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.
diff --git a/tools/glave/scripts/vk_generate.py b/tools/glave/scripts/vk_generate.py
index e96dc7c..bec34ed 100755
--- a/tools/glave/scripts/vk_generate.py
+++ b/tools/glave/scripts/vk_generate.py
@@ -1387,7 +1387,7 @@
return "\n".join(pid_enum)
# Interpret functions used on replay to read in packets and interpret their contents
- # This code gets generated into glvtrace_xgl_xgl_structs.h file
+ # This code gets generated into glv_vk_vk_structs.h file
def _generate_interp_funcs(self):
# Custom txt for given function and parameter. First check if param is NULL, then insert txt if not
# TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically
@@ -3341,8 +3341,8 @@
class GlaveTraceHeader(Subcommand):
def generate_header(self):
header_txt = []
- header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
- header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')
+ header_txt.append('#include "glv_vk_vk_structs.h"')
+ header_txt.append('#include "glv_vk_packet_id.h"\n')
header_txt.append('void AttachHooks();')
header_txt.append('void DetachHooks();')
header_txt.append('void InitTracer(void);\n')
@@ -3389,9 +3389,9 @@
header_txt.append('#include "glv_trace_packet_utils.h"')
header_txt.append('#include "glv_trace_packet_identifiers.h"')
header_txt.append('#include "glv_interconnect.h"')
- header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
- header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
- header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
+ header_txt.append('#include "glv_vk_vk_structs.h"')
+ header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+ header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
header_txt.append('#include "xgl_enum_string_helper.h"')
header_txt.append('#if defined(WIN32)')
header_txt.append('#define snprintf _snprintf')
@@ -3455,8 +3455,8 @@
header_txt.append('#include "glv_platform.h"')
header_txt.append('#include "glv_common.h"')
header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')
- header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
- header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+ header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
+ header_txt.append('#include "glv_vk_packet_id.h"')
header_txt.append('#ifdef WIN32')
header_txt.append('#include "mhook/mhook-lib/mhook.h"')
header_txt.append('#endif')
@@ -3510,8 +3510,8 @@
header_txt.append('#include "glv_common.h"')
header_txt.append('#include "glvtrace_xgl_xgl.h"')
header_txt.append('#include "glvtrace_xgl_xgldbg.h"')
- header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
- header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+ header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+ header_txt.append('#include "glv_vk_packet_id.h"')
header_txt.append('#ifdef WIN32')
header_txt.append('#include "mhook/mhook-lib/mhook.h"')
header_txt.append('#endif')
@@ -3581,10 +3581,10 @@
header_txt.append('#include <queue>')
header_txt.append('glvreplay_settings *g_pReplaySettings;')
header_txt.append('extern "C" {')
- header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')
- header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')
- header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')
- header_txt.append('#include "glvtrace_xgl_packet_id.h"')
+ header_txt.append('#include "glv_vk_vk_structs.h"')
+ header_txt.append('#include "glv_vk_vkdbg_structs.h"')
+ header_txt.append('#include "glv_vk_vkwsix11ext_structs.h"')
+ header_txt.append('#include "glv_vk_packet_id.h"')
header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')
header_txt.append('#define APP_NAME "glvreplay_xgl"')
header_txt.append('#define IDI_ICON 101\n')
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
index 589cf66..89d5fa9 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
@@ -20,15 +20,15 @@
file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
-add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
DEPENDS ${SRC_DIR}/../scripts/vk_generate.py
${SRC_DIR}/../../../xgl_helper.py
@@ -75,10 +75,10 @@
set(HDR_LIST
glvdebug_xgl_settings.h
glvdebug_xgl_qgroupframesproxymodel.h
- codegen/glvtrace_xgl_packet_id.h
- codegen/glvtrace_xgl_xgl_structs.h
- codegen/glvtrace_xgl_xglwsix11ext_structs.h
- codegen/glvtrace_xgl_xgldbg_structs.h
+ codegen/glv_vk_packet_id.h
+ codegen/glv_vk_vk_structs.h
+ codegen/glv_vk_vkwsix11ext_structs.h
+ codegen/glv_vk_vkdbg_structs.h
${SRC_DIR}/glvdebug/glvdebug_qgroupthreadsproxymodel.h
${SRC_DIR}/glvdebug/glvdebug_controller.h
${SRC_DIR}/glvreplay/glvreplay_factory.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
#include "glv_trace_packet_utils.h"
#include "glv_trace_packet_identifiers.h"
#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
#include "xgl_enum_string_helper.h"
#if defined(WIN32)
#define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
index ef9fcd3..1322edf 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_string_helper.h
@@ -3,16 +3,28 @@
#include <xgl.h>
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
default:
- return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+ case XGL_LINEAR_TILING:
+ return "XGL_LINEAR_TILING";
+ case XGL_OPTIMAL_TILING:
+ return "XGL_OPTIMAL_TILING";
+ default:
+ return "Unhandled XGL_IMAGE_TILING";
}
}
@@ -31,234 +43,48 @@
}
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ return "XGL_IMAGE_FORMAT_CLASS_D16";
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ return "XGL_IMAGE_FORMAT_CLASS_D24";
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ return "XGL_IMAGE_FORMAT_CLASS_D32";
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return "XGL_IMAGE_FORMAT_CLASS_S8";
default:
- return "Unhandled XGL_MEMORY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
- {
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
- default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
- }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
- default:
- return "Unhandled XGL_CULL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
- switch ((XGL_IMAGE_LAYOUT)input_value)
- {
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
- default:
- return "Unhandled XGL_IMAGE_LAYOUT";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
- default:
- return "Unhandled XGL_MEMORY_PRIORITY";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- return "XGL_QUERY_OCCLUSION";
- case XGL_QUERY_PIPELINE_STATISTICS:
- return "XGL_QUERY_PIPELINE_STATISTICS";
- default:
- return "Unhandled XGL_QUERY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
- default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
- default:
- return "Unhandled XGL_VALIDATION_LEVEL";
- }
-}
-
-
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
- switch ((XGL_STATE_BIND_POINT)input_value)
- {
- case XGL_STATE_BIND_COLOR_BLEND:
- return "XGL_STATE_BIND_COLOR_BLEND";
- case XGL_STATE_BIND_DEPTH_STENCIL:
- return "XGL_STATE_BIND_DEPTH_STENCIL";
- case XGL_STATE_BIND_RASTER:
- return "XGL_STATE_BIND_RASTER";
- case XGL_STATE_BIND_VIEWPORT:
- return "XGL_STATE_BIND_VIEWPORT";
- default:
- return "Unhandled XGL_STATE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
- {
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return "XGL_BUFFER_CREATE_SPARSE_BIT";
- default:
- return "Unhandled XGL_BUFFER_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
- default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
- {
- case XGL_BUFFER_VIEW_RAW:
- return "XGL_BUFFER_VIEW_RAW";
- case XGL_BUFFER_VIEW_STRUCTURED:
- return "XGL_BUFFER_VIEW_STRUCTURED";
- case XGL_BUFFER_VIEW_TYPED:
- return "XGL_BUFFER_VIEW_TYPED";
- default:
- return "Unhandled XGL_BUFFER_VIEW_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+ return "Unhandled XGL_IMAGE_FORMAT_CLASS";
}
}
@@ -293,74 +119,72 @@
}
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ case XGL_IMAGE_VIEW_1D:
+ return "XGL_IMAGE_VIEW_1D";
+ case XGL_IMAGE_VIEW_2D:
+ return "XGL_IMAGE_VIEW_2D";
+ case XGL_IMAGE_VIEW_3D:
+ return "XGL_IMAGE_VIEW_3D";
+ case XGL_IMAGE_VIEW_CUBE:
+ return "XGL_IMAGE_VIEW_CUBE";
default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ return "Unhandled XGL_IMAGE_VIEW_TYPE";
}
}
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
}
}
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+ case XGL_QUERY_OCCLUSION:
+ return "XGL_QUERY_OCCLUSION";
+ case XGL_QUERY_PIPELINE_STATISTICS:
+ return "XGL_QUERY_PIPELINE_STATISTICS";
default:
- return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+ return "Unhandled XGL_QUERY_TYPE";
}
}
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- return "XGL_MEMORY_PROPERTY_GPU_ONLY";
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
default:
- return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
}
}
@@ -391,124 +215,262 @@
}
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
{
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- return "XGL_PIPELINE_BIND_POINT_COMPUTE";
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
default:
- return "Unhandled XGL_PIPELINE_BIND_POINT";
+ return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
}
}
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
default:
- return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
}
}
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
+ return "Unhandled XGL_IMAGE_ASPECT";
}
}
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return "XGL_BUFFER_CREATE_SPARSE_BIT";
default:
- return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+ return "Unhandled XGL_BUFFER_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- return "XGL_CHANNEL_SWIZZLE_A";
- case XGL_CHANNEL_SWIZZLE_B:
- return "XGL_CHANNEL_SWIZZLE_B";
- case XGL_CHANNEL_SWIZZLE_G:
- return "XGL_CHANNEL_SWIZZLE_G";
- case XGL_CHANNEL_SWIZZLE_ONE:
- return "XGL_CHANNEL_SWIZZLE_ONE";
- case XGL_CHANNEL_SWIZZLE_R:
- return "XGL_CHANNEL_SWIZZLE_R";
- case XGL_CHANNEL_SWIZZLE_ZERO:
- return "XGL_CHANNEL_SWIZZLE_ZERO";
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
default:
- return "Unhandled XGL_CHANNEL_SWIZZLE";
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
}
}
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_FACE_ORIENTATION)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- return "XGL_TEX_ADDRESS_CLAMP";
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- return "XGL_TEX_ADDRESS_CLAMP_BORDER";
- case XGL_TEX_ADDRESS_MIRROR:
- return "XGL_TEX_ADDRESS_MIRROR";
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- return "XGL_TEX_ADDRESS_MIRROR_ONCE";
- case XGL_TEX_ADDRESS_WRAP:
- return "XGL_TEX_ADDRESS_WRAP";
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
default:
- return "Unhandled XGL_TEX_ADDRESS";
+ return "Unhandled XGL_FACE_ORIENTATION";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_FILTER";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ return "XGL_BUFFER_VIEW_RAW";
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ return "XGL_BUFFER_VIEW_STRUCTURED";
+ case XGL_BUFFER_VIEW_TYPED:
+ return "XGL_BUFFER_VIEW_TYPED";
+ default:
+ return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ default:
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
+ default:
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+ default:
+ return "Unhandled XGL_QUEUE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ default:
+ return "Unhandled XGL_COORDINATE_ORIGIN";
+ }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
+ default:
+ return "Unhandled XGL_FILL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+ default:
+ return "Unhandled XGL_WAIT_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
+ default:
+ return "Unhandled XGL_STENCIL_OP";
}
}
@@ -551,428 +513,52 @@
}
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ switch ((XGL_BLEND_FUNC)input_value)
{
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+ return "Unhandled XGL_BLEND_FUNC";
}
}
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
default:
- return "Unhandled XGL_QUEUE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- return "XGL_IMAGE_VIEW_1D";
- case XGL_IMAGE_VIEW_2D:
- return "XGL_IMAGE_VIEW_2D";
- case XGL_IMAGE_VIEW_3D:
- return "XGL_IMAGE_VIEW_3D";
- case XGL_IMAGE_VIEW_CUBE:
- return "XGL_IMAGE_VIEW_CUBE";
- default:
- return "Unhandled XGL_IMAGE_VIEW_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
- default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return "XGL_MEMORY_REF_READ_ONLY_BIT";
- default:
- return "Unhandled XGL_MEMORY_REF_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
- switch ((XGL_STRUCTURE_TYPE)input_value)
- {
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
- default:
- return "Unhandled XGL_STRUCTURE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
-{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
- {
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
- case XGL_ATTACHMENT_STORE_OP_STORE:
- return "XGL_ATTACHMENT_STORE_OP_STORE";
- default:
- return "Unhandled XGL_ATTACHMENT_STORE_OP";
- }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return "XGL_WAIT_EVENT_TOP_OF_PIPE";
- default:
- return "Unhandled XGL_WAIT_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
- switch ((XGL_DEPTH_MODE)input_value)
- {
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
- default:
- return "Unhandled XGL_DEPTH_MODE";
- }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
- default:
- return "Unhandled XGL_FILL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
- default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
- }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_TOP_OF_PIPE:
- return "XGL_SET_EVENT_TOP_OF_PIPE";
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- return "XGL_SET_EVENT_TRANSFER_COMPLETE";
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
- default:
- return "Unhandled XGL_SET_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
- default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
- switch ((XGL_IMAGE_ASPECT)input_value)
- {
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
- default:
- return "Unhandled XGL_IMAGE_ASPECT";
- }
-}
-
-
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
- default:
- return "Unhandled XGL_OBJECT_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- return "XGL_INDEX_16";
- case XGL_INDEX_32:
- return "XGL_INDEX_32";
- case XGL_INDEX_8:
- return "XGL_INDEX_8";
- default:
- return "Unhandled XGL_INDEX_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
- switch ((XGL_IMAGE_TILING)input_value)
- {
- case XGL_LINEAR_TILING:
- return "XGL_LINEAR_TILING";
- case XGL_OPTIMAL_TILING:
- return "XGL_OPTIMAL_TILING";
- default:
- return "Unhandled XGL_IMAGE_TILING";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
- switch ((XGL_QUEUE_TYPE)input_value)
- {
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
- default:
- return "Unhandled XGL_QUEUE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
- {
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
- default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
}
}
@@ -1001,104 +587,336 @@
}
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_COPY_BIT:
- return "XGL_MEMORY_INPUT_COPY_BIT";
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- return "XGL_MEMORY_INPUT_CPU_READ_BIT";
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
- return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
default:
- return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
}
}
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_RESULT)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ return "XGL_ERROR_BAD_PIPELINE_DATA";
+ case XGL_ERROR_BAD_SHADER_CODE:
+ return "XGL_ERROR_BAD_SHADER_CODE";
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+ case XGL_ERROR_DEVICE_LOST:
+ return "XGL_ERROR_DEVICE_LOST";
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ return "XGL_ERROR_INITIALIZATION_FAILED";
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ return "XGL_ERROR_INVALID_ALIGNMENT";
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case XGL_ERROR_INVALID_EXTENSION:
+ return "XGL_ERROR_INVALID_EXTENSION";
+ case XGL_ERROR_INVALID_FLAGS:
+ return "XGL_ERROR_INVALID_FLAGS";
+ case XGL_ERROR_INVALID_FORMAT:
+ return "XGL_ERROR_INVALID_FORMAT";
+ case XGL_ERROR_INVALID_HANDLE:
+ return "XGL_ERROR_INVALID_HANDLE";
+ case XGL_ERROR_INVALID_IMAGE:
+ return "XGL_ERROR_INVALID_IMAGE";
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ return "XGL_ERROR_INVALID_MEMORY_SIZE";
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ return "XGL_ERROR_INVALID_OBJECT_TYPE";
+ case XGL_ERROR_INVALID_ORDINAL:
+ return "XGL_ERROR_INVALID_ORDINAL";
+ case XGL_ERROR_INVALID_POINTER:
+ return "XGL_ERROR_INVALID_POINTER";
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ return "XGL_ERROR_INVALID_QUEUE_TYPE";
+ case XGL_ERROR_INVALID_VALUE:
+ return "XGL_ERROR_INVALID_VALUE";
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ return "XGL_ERROR_MEMORY_MAP_FAILED";
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ return "XGL_ERROR_MEMORY_NOT_BOUND";
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+ case XGL_ERROR_NOT_MAPPABLE:
+ return "XGL_ERROR_NOT_MAPPABLE";
+ case XGL_ERROR_NOT_SHAREABLE:
+ return "XGL_ERROR_NOT_SHAREABLE";
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+ case XGL_ERROR_OUT_OF_MEMORY:
+ return "XGL_ERROR_OUT_OF_MEMORY";
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ case XGL_ERROR_UNAVAILABLE:
+ return "XGL_ERROR_UNAVAILABLE";
+ case XGL_ERROR_UNKNOWN:
+ return "XGL_ERROR_UNKNOWN";
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
+ return "Unhandled XGL_RESULT";
}
}
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_SET_EVENT)input_value)
{
- case XGL_LOGIC_OP_AND:
- return "XGL_LOGIC_OP_AND";
- case XGL_LOGIC_OP_AND_INVERTED:
- return "XGL_LOGIC_OP_AND_INVERTED";
- case XGL_LOGIC_OP_AND_REVERSE:
- return "XGL_LOGIC_OP_AND_REVERSE";
- case XGL_LOGIC_OP_CLEAR:
- return "XGL_LOGIC_OP_CLEAR";
- case XGL_LOGIC_OP_COPY:
- return "XGL_LOGIC_OP_COPY";
- case XGL_LOGIC_OP_COPY_INVERTED:
- return "XGL_LOGIC_OP_COPY_INVERTED";
- case XGL_LOGIC_OP_EQUIV:
- return "XGL_LOGIC_OP_EQUIV";
- case XGL_LOGIC_OP_INVERT:
- return "XGL_LOGIC_OP_INVERT";
- case XGL_LOGIC_OP_NAND:
- return "XGL_LOGIC_OP_NAND";
- case XGL_LOGIC_OP_NOOP:
- return "XGL_LOGIC_OP_NOOP";
- case XGL_LOGIC_OP_NOR:
- return "XGL_LOGIC_OP_NOR";
- case XGL_LOGIC_OP_OR:
- return "XGL_LOGIC_OP_OR";
- case XGL_LOGIC_OP_OR_INVERTED:
- return "XGL_LOGIC_OP_OR_INVERTED";
- case XGL_LOGIC_OP_OR_REVERSE:
- return "XGL_LOGIC_OP_OR_REVERSE";
- case XGL_LOGIC_OP_SET:
- return "XGL_LOGIC_OP_SET";
- case XGL_LOGIC_OP_XOR:
- return "XGL_LOGIC_OP_XOR";
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ return "XGL_SET_EVENT_TOP_OF_PIPE";
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
default:
- return "Unhandled XGL_LOGIC_OP";
+ return "Unhandled XGL_SET_EVENT";
}
}
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- return "XGL_MEMORY_OUTPUT_COPY_BIT";
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
default:
- return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ return "Unhandled XGL_STATE_BIND_POINT";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ default:
+ return "Unhandled XGL_IMAGE_LAYOUT";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+ switch ((XGL_MEMORY_TYPE)input_value)
+ {
+ case XGL_MEMORY_TYPE_BUFFER:
+ return "XGL_MEMORY_TYPE_BUFFER";
+ case XGL_MEMORY_TYPE_IMAGE:
+ return "XGL_MEMORY_TYPE_IMAGE";
+ case XGL_MEMORY_TYPE_OTHER:
+ return "XGL_MEMORY_TYPE_OTHER";
+ default:
+ return "Unhandled XGL_MEMORY_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+ default:
+ return "Unhandled XGL_CULL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ default:
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ default:
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ {
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+{
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
+ {
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
+ default:
+ return "Unhandled XGL_TIMESTAMP_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+ default:
+ return "Unhandled XGL_IMAGE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ {
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
+ default:
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
}
}
@@ -1151,50 +969,160 @@
}
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- return "XGL_GPU_TYPE_DISCRETE";
- case XGL_GPU_TYPE_INTEGRATED:
- return "XGL_GPU_TYPE_INTEGRATED";
- case XGL_GPU_TYPE_OTHER:
- return "XGL_GPU_TYPE_OTHER";
- case XGL_GPU_TYPE_VIRTUAL:
- return "XGL_GPU_TYPE_VIRTUAL";
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
default:
- return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
}
}
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
- case XGL_IMAGE_USAGE_GENERAL:
- return "XGL_IMAGE_USAGE_GENERAL";
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- return "XGL_IMAGE_USAGE_IMAGE_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- return "XGL_IMAGE_USAGE_TEXTURE_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
default:
- return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+ return "Unhandled XGL_VALIDATION_LEVEL";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE";
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+ case XGL_ATTACHMENT_STORE_OP_STORE:
+ return "XGL_ATTACHMENT_STORE_OP_STORE";
+ default:
+ return "Unhandled XGL_ATTACHMENT_STORE_OP";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
+ default:
+ return "Unhandled XGL_INDEX_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+ default:
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
}
}
@@ -1543,164 +1471,366 @@
}
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
default:
- return "Unhandled XGL_TEX_FILTER";
+ return "Unhandled XGL_TEX_ADDRESS";
}
}
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
{
- switch ((XGL_BLEND_FUNC)input_value)
+ switch ((XGL_MEMORY_PRIORITY)input_value)
{
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
default:
- return "Unhandled XGL_BLEND_FUNC";
+ return "Unhandled XGL_MEMORY_PRIORITY";
}
}
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
{
- switch ((XGL_FACE_ORIENTATION)input_value)
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
{
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
default:
- return "Unhandled XGL_FACE_ORIENTATION";
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_QUEUE_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
- case XGL_IMAGE_FORMAT_CLASS_D16:
- return "XGL_IMAGE_FORMAT_CLASS_D16";
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- return "XGL_IMAGE_FORMAT_CLASS_D16S8";
- case XGL_IMAGE_FORMAT_CLASS_D24:
- return "XGL_IMAGE_FORMAT_CLASS_D24";
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- return "XGL_IMAGE_FORMAT_CLASS_D24S8";
- case XGL_IMAGE_FORMAT_CLASS_D32:
- return "XGL_IMAGE_FORMAT_CLASS_D32";
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- return "XGL_IMAGE_FORMAT_CLASS_D32S8";
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return "XGL_IMAGE_FORMAT_CLASS_S8";
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ return "XGL_MEMORY_INPUT_COPY_BIT";
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
default:
- return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+ return "Unhandled XGL_MEMORY_INPUT_FLAGS";
}
}
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+ default:
+ return "Unhandled XGL_STRUCTURE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+ switch ((XGL_LOGIC_OP)input_value)
+ {
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
+ default:
+ return "Unhandled XGL_LOGIC_OP";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ default:
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ {
+ case XGL_CHANNEL_SWIZZLE_A:
+ return "XGL_CHANNEL_SWIZZLE_A";
+ case XGL_CHANNEL_SWIZZLE_B:
+ return "XGL_CHANNEL_SWIZZLE_B";
+ case XGL_CHANNEL_SWIZZLE_G:
+ return "XGL_CHANNEL_SWIZZLE_G";
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ return "XGL_CHANNEL_SWIZZLE_ONE";
+ case XGL_CHANNEL_SWIZZLE_R:
+ return "XGL_CHANNEL_SWIZZLE_R";
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return "XGL_CHANNEL_SWIZZLE_ZERO";
+ default:
+ return "Unhandled XGL_CHANNEL_SWIZZLE";
+ }
+}
+
+
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+{
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ {
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+ default:
+ return "Unhandled XGL_PIPELINE_BIND_POINT";
}
}
@@ -1719,164 +1849,34 @@
}
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_RESULT)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_ERROR_BAD_PIPELINE_DATA:
- return "XGL_ERROR_BAD_PIPELINE_DATA";
- case XGL_ERROR_BAD_SHADER_CODE:
- return "XGL_ERROR_BAD_SHADER_CODE";
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- return "XGL_ERROR_DEVICE_ALREADY_CREATED";
- case XGL_ERROR_DEVICE_LOST:
- return "XGL_ERROR_DEVICE_LOST";
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- return "XGL_ERROR_INCOMPATIBLE_DEVICE";
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- return "XGL_ERROR_INCOMPATIBLE_DRIVER";
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- return "XGL_ERROR_INCOMPATIBLE_QUEUE";
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case XGL_ERROR_INITIALIZATION_FAILED:
- return "XGL_ERROR_INITIALIZATION_FAILED";
- case XGL_ERROR_INVALID_ALIGNMENT:
- return "XGL_ERROR_INVALID_ALIGNMENT";
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case XGL_ERROR_INVALID_EXTENSION:
- return "XGL_ERROR_INVALID_EXTENSION";
- case XGL_ERROR_INVALID_FLAGS:
- return "XGL_ERROR_INVALID_FLAGS";
- case XGL_ERROR_INVALID_FORMAT:
- return "XGL_ERROR_INVALID_FORMAT";
- case XGL_ERROR_INVALID_HANDLE:
- return "XGL_ERROR_INVALID_HANDLE";
- case XGL_ERROR_INVALID_IMAGE:
- return "XGL_ERROR_INVALID_IMAGE";
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- return "XGL_ERROR_INVALID_MEMORY_SIZE";
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- return "XGL_ERROR_INVALID_OBJECT_TYPE";
- case XGL_ERROR_INVALID_ORDINAL:
- return "XGL_ERROR_INVALID_ORDINAL";
- case XGL_ERROR_INVALID_POINTER:
- return "XGL_ERROR_INVALID_POINTER";
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- return "XGL_ERROR_INVALID_QUEUE_TYPE";
- case XGL_ERROR_INVALID_VALUE:
- return "XGL_ERROR_INVALID_VALUE";
- case XGL_ERROR_MEMORY_MAP_FAILED:
- return "XGL_ERROR_MEMORY_MAP_FAILED";
- case XGL_ERROR_MEMORY_NOT_BOUND:
- return "XGL_ERROR_MEMORY_NOT_BOUND";
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- return "XGL_ERROR_MEMORY_UNMAP_FAILED";
- case XGL_ERROR_NOT_MAPPABLE:
- return "XGL_ERROR_NOT_MAPPABLE";
- case XGL_ERROR_NOT_SHAREABLE:
- return "XGL_ERROR_NOT_SHAREABLE";
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- return "XGL_ERROR_OUT_OF_GPU_MEMORY";
- case XGL_ERROR_OUT_OF_MEMORY:
- return "XGL_ERROR_OUT_OF_MEMORY";
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
- case XGL_ERROR_UNAVAILABLE:
- return "XGL_ERROR_UNAVAILABLE";
- case XGL_ERROR_UNKNOWN:
- return "XGL_ERROR_UNKNOWN";
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case XGL_EVENT_RESET:
- return "XGL_EVENT_RESET";
- case XGL_EVENT_SET:
- return "XGL_EVENT_SET";
- case XGL_NOT_READY:
- return "XGL_NOT_READY";
- case XGL_SUCCESS:
- return "XGL_SUCCESS";
- case XGL_TIMEOUT:
- return "XGL_TIMEOUT";
- case XGL_UNSUPPORTED:
- return "XGL_UNSUPPORTED";
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
default:
- return "Unhandled XGL_RESULT";
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
}
}
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
- {
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- return "XGL_SYSTEM_ALLOC_API_OBJECT";
- case XGL_SYSTEM_ALLOC_DEBUG:
- return "XGL_SYSTEM_ALLOC_DEBUG";
- case XGL_SYSTEM_ALLOC_INTERNAL:
- return "XGL_SYSTEM_ALLOC_INTERNAL";
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
- default:
- return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
- switch ((XGL_STENCIL_OP)input_value)
- {
- case XGL_STENCIL_OP_DEC_CLAMP:
- return "XGL_STENCIL_OP_DEC_CLAMP";
- case XGL_STENCIL_OP_DEC_WRAP:
- return "XGL_STENCIL_OP_DEC_WRAP";
- case XGL_STENCIL_OP_INC_CLAMP:
- return "XGL_STENCIL_OP_INC_CLAMP";
- case XGL_STENCIL_OP_INC_WRAP:
- return "XGL_STENCIL_OP_INC_WRAP";
- case XGL_STENCIL_OP_INVERT:
- return "XGL_STENCIL_OP_INVERT";
- case XGL_STENCIL_OP_KEEP:
- return "XGL_STENCIL_OP_KEEP";
- case XGL_STENCIL_OP_REPLACE:
- return "XGL_STENCIL_OP_REPLACE";
- case XGL_STENCIL_OP_ZERO:
- return "XGL_STENCIL_OP_ZERO";
- default:
- return "Unhandled XGL_STENCIL_OP";
- }
-}
-
-
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
- {
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
- default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
}
}
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
index d9fa7e4..36d35e6 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,12 +3,24 @@
#include <xgl.h>
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+ case XGL_LINEAR_TILING:
+ case XGL_OPTIMAL_TILING:
return 1;
default:
return 0;
@@ -29,193 +41,28 @@
}
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
- {
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
- switch ((XGL_IMAGE_LAYOUT)input_value)
- {
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- case XGL_QUERY_PIPELINE_STATISTICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
- switch ((XGL_STATE_BIND_POINT)input_value)
- {
- case XGL_STATE_BIND_COLOR_BLEND:
- case XGL_STATE_BIND_DEPTH_STENCIL:
- case XGL_STATE_BIND_RASTER:
- case XGL_STATE_BIND_VIEWPORT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
- {
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
- {
- case XGL_BUFFER_VIEW_RAW:
- case XGL_BUFFER_VIEW_STRUCTURED:
- case XGL_BUFFER_VIEW_TYPED:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ case XGL_IMAGE_FORMAT_CLASS_S8:
return 1;
default:
return 0;
@@ -244,11 +91,14 @@
}
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
+ case XGL_IMAGE_VIEW_1D:
+ case XGL_IMAGE_VIEW_2D:
+ case XGL_IMAGE_VIEW_3D:
+ case XGL_IMAGE_VIEW_CUBE:
return 1;
default:
return 0;
@@ -256,15 +106,14 @@
}
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
return 1;
default:
return 0;
@@ -272,13 +121,12 @@
}
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ case XGL_QUERY_OCCLUSION:
+ case XGL_QUERY_PIPELINE_STATISTICS:
return 1;
default:
return 0;
@@ -286,17 +134,15 @@
}
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
return 1;
default:
return 0;
@@ -323,12 +169,13 @@
}
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
{
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
return 1;
default:
return 0;
@@ -336,14 +183,13 @@
}
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
return 1;
default:
return 0;
@@ -351,22 +197,13 @@
}
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
return 1;
default:
return 0;
@@ -374,12 +211,12 @@
}
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
@@ -387,16 +224,17 @@
}
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- case XGL_CHANNEL_SWIZZLE_B:
- case XGL_CHANNEL_SWIZZLE_G:
- case XGL_CHANNEL_SWIZZLE_ONE:
- case XGL_CHANNEL_SWIZZLE_R:
- case XGL_CHANNEL_SWIZZLE_ZERO:
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
return 1;
default:
return 0;
@@ -404,15 +242,152 @@
}
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_FACE_ORIENTATION)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- case XGL_TEX_ADDRESS_MIRROR:
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- case XGL_TEX_ADDRESS_WRAP:
+ case XGL_FRONT_FACE_CCW:
+ case XGL_FRONT_FACE_CW:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ case XGL_BUFFER_VIEW_TYPED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
return 1;
default:
return 0;
@@ -445,12 +420,15 @@
}
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ switch ((XGL_BLEND_FUNC)input_value)
{
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ case XGL_BLEND_FUNC_ADD:
+ case XGL_BLEND_FUNC_MAX:
+ case XGL_BLEND_FUNC_MIN:
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ case XGL_BLEND_FUNC_SUBTRACT:
return 1;
default:
return 0;
@@ -458,319 +436,20 @@
}
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- case XGL_IMAGE_VIEW_2D:
- case XGL_IMAGE_VIEW_3D:
- case XGL_IMAGE_VIEW_CUBE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
- switch ((XGL_STRUCTURE_TYPE)input_value)
- {
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
-{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
- {
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- case XGL_ATTACHMENT_STORE_OP_STORE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
- switch ((XGL_DEPTH_MODE)input_value)
- {
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
- switch ((XGL_IMAGE_ASPECT)input_value)
- {
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- case XGL_INDEX_32:
- case XGL_INDEX_8:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
- switch ((XGL_IMAGE_TILING)input_value)
- {
- case XGL_LINEAR_TILING:
- case XGL_OPTIMAL_TILING:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
- switch ((XGL_QUEUE_TYPE)input_value)
- {
- case XGL_QUEUE_TYPE_COMPUTE:
- case XGL_QUEUE_TYPE_DMA:
- case XGL_QUEUE_TYPE_GRAPHICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
- {
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ case XGL_IMAGE_USAGE_GENERAL:
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
return 1;
default:
return 0;
@@ -796,19 +475,13 @@
}
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_COPY_BIT:
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
return 1;
default:
return 0;
@@ -816,11 +489,50 @@
}
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_RESULT)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ case XGL_ERROR_BAD_SHADER_CODE:
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ case XGL_ERROR_DEVICE_LOST:
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ case XGL_ERROR_INVALID_EXTENSION:
+ case XGL_ERROR_INVALID_FLAGS:
+ case XGL_ERROR_INVALID_FORMAT:
+ case XGL_ERROR_INVALID_HANDLE:
+ case XGL_ERROR_INVALID_IMAGE:
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ case XGL_ERROR_INVALID_ORDINAL:
+ case XGL_ERROR_INVALID_POINTER:
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ case XGL_ERROR_INVALID_VALUE:
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ case XGL_ERROR_NOT_MAPPABLE:
+ case XGL_ERROR_NOT_SHAREABLE:
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ case XGL_ERROR_OUT_OF_MEMORY:
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ case XGL_ERROR_UNAVAILABLE:
+ case XGL_ERROR_UNKNOWN:
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ case XGL_EVENT_RESET:
+ case XGL_EVENT_SET:
+ case XGL_NOT_READY:
+ case XGL_SUCCESS:
+ case XGL_TIMEOUT:
+ case XGL_UNSUPPORTED:
return 1;
default:
return 0;
@@ -828,26 +540,17 @@
}
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_SET_EVENT)input_value)
{
- case XGL_LOGIC_OP_AND:
- case XGL_LOGIC_OP_AND_INVERTED:
- case XGL_LOGIC_OP_AND_REVERSE:
- case XGL_LOGIC_OP_CLEAR:
- case XGL_LOGIC_OP_COPY:
- case XGL_LOGIC_OP_COPY_INVERTED:
- case XGL_LOGIC_OP_EQUIV:
- case XGL_LOGIC_OP_INVERT:
- case XGL_LOGIC_OP_NAND:
- case XGL_LOGIC_OP_NOOP:
- case XGL_LOGIC_OP_NOR:
- case XGL_LOGIC_OP_OR:
- case XGL_LOGIC_OP_OR_INVERTED:
- case XGL_LOGIC_OP_OR_REVERSE:
- case XGL_LOGIC_OP_SET:
- case XGL_LOGIC_OP_XOR:
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
return 1;
default:
return 0;
@@ -855,15 +558,173 @@
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ case XGL_STATE_BIND_COLOR_BLEND:
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ case XGL_STATE_BIND_RASTER:
+ case XGL_STATE_BIND_VIEWPORT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+ switch ((XGL_MEMORY_TYPE)input_value)
+ {
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ {
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+{
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
+ {
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ case XGL_IMAGE_2D:
+ case XGL_IMAGE_3D:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ {
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
return 1;
default:
return 0;
@@ -901,14 +762,23 @@
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
+ case XGL_TOPOLOGY_LINE_LIST:
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ case XGL_TOPOLOGY_LINE_STRIP:
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ case XGL_TOPOLOGY_PATCH:
+ case XGL_TOPOLOGY_POINT_LIST:
+ case XGL_TOPOLOGY_QUAD_LIST:
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ case XGL_TOPOLOGY_RECT_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
return 1;
default:
return 0;
@@ -916,20 +786,96 @@
}
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- case XGL_IMAGE_USAGE_GENERAL:
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ case XGL_ATTACHMENT_STORE_OP_STORE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
return 1;
default:
return 0;
@@ -1115,12 +1061,15 @@
}
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- case XGL_TEX_FILTER_NEAREST:
+ case XGL_TEX_ADDRESS_CLAMP:
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ case XGL_TEX_ADDRESS_MIRROR:
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ case XGL_TEX_ADDRESS_WRAP:
return 1;
default:
return 0;
@@ -1128,23 +1077,12 @@
}
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_TOPOLOGY_LINE_LIST:
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- case XGL_TOPOLOGY_LINE_STRIP:
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- case XGL_TOPOLOGY_PATCH:
- case XGL_TOPOLOGY_POINT_LIST:
- case XGL_TOPOLOGY_QUAD_LIST:
- case XGL_TOPOLOGY_QUAD_STRIP:
- case XGL_TOPOLOGY_RECT_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
return 1;
default:
return 0;
@@ -1152,15 +1090,16 @@
}
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
{
- switch ((XGL_BLEND_FUNC)input_value)
+ switch ((XGL_MEMORY_PRIORITY)input_value)
{
- case XGL_BLEND_FUNC_ADD:
- case XGL_BLEND_FUNC_MAX:
- case XGL_BLEND_FUNC_MIN:
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- case XGL_BLEND_FUNC_SUBTRACT:
+ case XGL_MEMORY_PRIORITY_HIGH:
+ case XGL_MEMORY_PRIORITY_LOW:
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
return 1;
default:
return 0;
@@ -1168,12 +1107,14 @@
}
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
{
- switch ((XGL_FACE_ORIENTATION)input_value)
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
{
- case XGL_FRONT_FACE_CCW:
- case XGL_FRONT_FACE_CW:
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
return 1;
default:
return 0;
@@ -1181,13 +1122,14 @@
}
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_IMAGE_1D:
- case XGL_IMAGE_2D:
- case XGL_IMAGE_3D:
+ case XGL_QUEUE_COMPUTE_BIT:
+ case XGL_QUEUE_DMA_BIT:
+ case XGL_QUEUE_EXTENDED_BIT:
+ case XGL_QUEUE_GRAPHICS_BIT:
return 1;
default:
return 0;
@@ -1195,28 +1137,19 @@
}
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- case XGL_IMAGE_FORMAT_CLASS_D16:
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- case XGL_IMAGE_FORMAT_CLASS_D24:
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- case XGL_IMAGE_FORMAT_CLASS_D32:
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- case XGL_IMAGE_FORMAT_CLASS_S8:
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
return 1;
default:
return 0;
@@ -1224,13 +1157,163 @@
}
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+ switch ((XGL_LOGIC_OP)input_value)
+ {
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ {
+ case XGL_CHANNEL_SWIZZLE_A:
+ case XGL_CHANNEL_SWIZZLE_B:
+ case XGL_CHANNEL_SWIZZLE_G:
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ case XGL_CHANNEL_SWIZZLE_R:
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+{
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ {
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
return 1;
default:
return 0;
@@ -1251,50 +1334,14 @@
}
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_RESULT)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_ERROR_BAD_PIPELINE_DATA:
- case XGL_ERROR_BAD_SHADER_CODE:
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- case XGL_ERROR_DEVICE_LOST:
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- case XGL_ERROR_INITIALIZATION_FAILED:
- case XGL_ERROR_INVALID_ALIGNMENT:
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- case XGL_ERROR_INVALID_EXTENSION:
- case XGL_ERROR_INVALID_FLAGS:
- case XGL_ERROR_INVALID_FORMAT:
- case XGL_ERROR_INVALID_HANDLE:
- case XGL_ERROR_INVALID_IMAGE:
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- case XGL_ERROR_INVALID_ORDINAL:
- case XGL_ERROR_INVALID_POINTER:
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- case XGL_ERROR_INVALID_VALUE:
- case XGL_ERROR_MEMORY_MAP_FAILED:
- case XGL_ERROR_MEMORY_NOT_BOUND:
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- case XGL_ERROR_NOT_MAPPABLE:
- case XGL_ERROR_NOT_SHAREABLE:
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- case XGL_ERROR_OUT_OF_MEMORY:
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- case XGL_ERROR_UNAVAILABLE:
- case XGL_ERROR_UNKNOWN:
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- case XGL_EVENT_RESET:
- case XGL_EVENT_SET:
- case XGL_NOT_READY:
- case XGL_SUCCESS:
- case XGL_TIMEOUT:
- case XGL_UNSUPPORTED:
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
return 1;
default:
return 0;
@@ -1302,59 +1349,12 @@
}
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
- {
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
- switch ((XGL_STENCIL_OP)input_value)
- {
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
- {
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
return 1;
default:
return 0;
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
index ac5f673..c3e12a2 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qcontroller.cpp
@@ -23,7 +23,7 @@
*************************************************************************/
extern "C" {
#include "glv_trace_packet_utils.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
}
#include "glvdebug_xgl_settings.h"
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
index 69f6896..1c448f4 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/glvdebug_xgl_qgroupframesproxymodel.h
@@ -25,7 +25,7 @@
#ifndef GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H
#define GLVDEBUG_XGL_QGROUPFRAMESPROXYMODEL_H
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
#include "glvdebug_QTraceFileModel.h"
#include <QAbstractProxyModel>
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
index c7a1caf..cf5e85a 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
@@ -9,17 +9,17 @@
file(MAKE_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/codegen)
-add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
+add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvreplay_xgl_replay.cpp
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-h > glvreplay_xgl_replay.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-replay-c > glvreplay_xgl_replay.cpp
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
@@ -52,10 +52,10 @@
)
set (HDR_LIST
- codegen/glvtrace_xgl_packet_id.h
- codegen/glvtrace_xgl_xgl_structs.h
- codegen/glvtrace_xgl_xglwsix11ext_structs.h
- codegen/glvtrace_xgl_xgldbg_structs.h
+ codegen/glv_vk_packet_id.h
+ codegen/glv_vk_vk_structs.h
+ codegen/glv_vk_vkwsix11ext_structs.h
+ codegen/glv_vk_vkdbg_structs.h
codegen/xgl_enum_string_helper.h
glvreplay_xgl.h
glvreplay_xgl_settings.h
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
copy from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
copy to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
#include "glv_trace_packet_utils.h"
#include "glv_trace_packet_identifiers.h"
#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
#include "xgl_enum_string_helper.h"
#if defined(WIN32)
#define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
index a4ea29a..99c71bb 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.cpp
@@ -36,10 +36,10 @@
#include <queue>
glvreplay_settings *g_pReplaySettings;
extern "C" {
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
+#include "glv_vk_packet_id.h"
#include "xgl_enum_string_helper.h"
}
@@ -295,6 +295,28 @@
void xglDisplay::process_event()
{
}
+
+void objMemory::setCount(const uint32_t num)
+{
+ m_numAllocations = num;
+}
+
+void objMemory::setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num)
+{
+ if (m_numAllocations != num && m_numAllocations != 0)
+ glv_LogError("objMemory::setReqs, internal mismatch on number of allocations");
+ if (m_pMemReqs == NULL && pReqs != NULL)
+ {
+ m_pMemReqs = (XGL_MEMORY_REQUIREMENTS *) glv_malloc(num * sizeof(XGL_MEMORY_REQUIREMENTS));
+ if (m_pMemReqs == NULL)
+ {
+ glv_LogError("objMemory::setReqs out of memory");
+ return;
+ }
+ memcpy(m_pMemReqs, pReqs, num);
+ }
+}
+
xglReplay::xglReplay(glvreplay_settings *pReplaySettings)
{
g_pReplaySettings = pReplaySettings;
@@ -302,6 +324,7 @@
m_pDSDump = NULL;
m_pCBDump = NULL;
m_pGlvSnapshotPrint = NULL;
+ m_adjustForGPU = false;
if (g_pReplaySettings && g_pReplaySettings->screenshotList) {
process_screenshot_list(g_pReplaySettings->screenshotList);
}
@@ -856,12 +879,12 @@
case GLV_TPI_XGL_xglAllocMemory:
{
struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(packet->pBody);
- XGL_GPU_MEMORY local_pMem;
- replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_pMem);
+ struct gpuMemObj local_mem;
+ replayResult = m_xglFuncs.real_xglAllocMemory(remap(pPacket->device), pPacket->pAllocInfo, &local_mem.replayGpuMem);
if (replayResult == XGL_SUCCESS)
{
- add_to_map(pPacket->pMem, &local_pMem);
- add_entry_to_mapData(local_pMem, pPacket->pAllocInfo->allocationSize);
+ add_to_map(pPacket->pMem, &local_mem);
+ add_entry_to_mapData(local_mem.replayGpuMem, pPacket->pAllocInfo->allocationSize);
}
CHECK_RETURN_VALUE(xglAllocMemory);
break;
@@ -869,11 +892,11 @@
case GLV_TPI_XGL_xglFreeMemory:
{
struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(packet->pBody);
- XGL_GPU_MEMORY handle = remap(pPacket->mem);
- replayResult = m_xglFuncs.real_xglFreeMemory(handle);
+ XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
+ replayResult = m_xglFuncs.real_xglFreeMemory(local_mem);
if (replayResult == XGL_SUCCESS)
{
- rm_entry_from_mapData(handle);
+ rm_entry_from_mapData(local_mem);
rm_from_map(pPacket->mem);
}
CHECK_RETURN_VALUE(xglFreeMemory);
@@ -889,32 +912,30 @@
case GLV_TPI_XGL_xglMapMemory:
{
struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(packet->pBody);
- XGL_GPU_MEMORY handle = remap(pPacket->mem);
+ XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
void* pData;
- replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);
+ replayResult = m_xglFuncs.real_xglMapMemory(local_mem, pPacket->flags, &pData);
if (replayResult == XGL_SUCCESS)
- add_mapping_to_mapData(handle, pData);
+ add_mapping_to_mapData(local_mem, pData);
CHECK_RETURN_VALUE(xglMapMemory);
break;
}
case GLV_TPI_XGL_xglUnmapMemory:
{
struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(packet->pBody);
- XGL_GPU_MEMORY handle = remap(pPacket->mem);
- rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer
- replayResult = m_xglFuncs.real_xglUnmapMemory(handle);
+ XGL_GPU_MEMORY local_mem = remap(pPacket->mem);
+ rm_mapping_from_mapData(local_mem, pPacket->pData); // copies data from packet into memory buffer
+ replayResult = m_xglFuncs.real_xglUnmapMemory(local_mem);
CHECK_RETURN_VALUE(xglUnmapMemory);
break;
}
case GLV_TPI_XGL_xglPinSystemMemory:
{
struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(packet->pBody);
- XGL_GPU_MEMORY local_pMem;
- replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_pMem);
+ struct gpuMemObj local_mem;
+ replayResult = m_xglFuncs.real_xglPinSystemMemory(remap(pPacket->device), pPacket->pSysMem, pPacket->memSize, &local_mem.replayGpuMem);
if (replayResult == XGL_SUCCESS)
- {
- add_to_map(pPacket->pMem, &local_pMem);
- }
+ add_to_map(pPacket->pMem, &local_mem);
CHECK_RETURN_VALUE(xglPinSystemMemory);
break;
}
@@ -992,16 +1013,55 @@
pData = glv_malloc(*pPacket->pDataSize);
memcpy(pData, pPacket->pData, *pPacket->pDataSize);
}
+ // TODO only search for object once rather than at remap() and init_objMemXXX()
replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);
if (replayResult == XGL_SUCCESS)
{
if (size != *pPacket->pDataSize && pData != NULL)
{
glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\n", size, *pPacket->pDataSize);
- }
- else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)
+ } else if (pData != NULL)
{
- glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\n");
+ switch (pPacket->infoType)
+ {
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ {
+ uint32_t traceCount = *((uint32_t *) pPacket->pData);
+ uint32_t replayCount = *((uint32_t *) pData);
+ if (traceCount != replayCount)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_ALLOCATION_COUNT) mismatch: trace count %u, replay count %u\n", traceCount, replayCount);
+ if (m_adjustForGPU)
+ init_objMemCount(pPacket->object, replayCount);
+ break;
+ }
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *traceReqs = (XGL_MEMORY_REQUIREMENTS *) pPacket->pData;
+ XGL_MEMORY_REQUIREMENTS *replayReqs = (XGL_MEMORY_REQUIREMENTS *) pData;
+ unsigned int num = size / sizeof(XGL_MEMORY_REQUIREMENTS);
+ for (unsigned int i = 0; i < num; i++)
+ {
+ if (traceReqs->size != replayReqs->size)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace size %u, replay size %u\n", traceReqs->size, replayReqs->size);
+ if (traceReqs->alignment != replayReqs->alignment)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace alignment %u, replay aligmnent %u\n", traceReqs->alignment, replayReqs->alignment);
+ if (traceReqs->granularity != replayReqs->granularity)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace granularity %u, replay granularity %u\n", traceReqs->granularity, replayReqs->granularity);
+ if (traceReqs->memProps != replayReqs->memProps)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memProps %u, replay memProps %u\n", traceReqs->memProps, replayReqs->memProps);
+ if (traceReqs->memType != replayReqs->memType)
+ glv_LogWarn("xglGetObjectInfo(INFO_TYPE_MEMORY_REQUIREMENTS) mismatch: trace memType %u, replay memType %u\n", traceReqs->memType, replayReqs->memType);
+ traceReqs++;
+ replayReqs++;
+ }
+ if (m_adjustForGPU)
+ init_objMemReqs(pPacket->object, replayReqs - num, num);
+ break;
+ }
+ default:
+ if (memcmp(pData, pPacket->pData, size) != 0)
+ glv_LogWarn("xglGetObjectInfo() mismatch on *pData: between trace and replay *pDataSize %u\n", size);
+ }
}
}
glv_free(pData);
@@ -1174,11 +1234,11 @@
case GLV_TPI_XGL_xglCreateBuffer:
{
struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(packet->pBody);
- XGL_BUFFER local_pBuffer;
- replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_pBuffer);
+ struct bufferObj local_bufferObj;
+ replayResult = m_xglFuncs.real_xglCreateBuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_bufferObj.replayBuffer);
if (replayResult == XGL_SUCCESS)
{
- add_to_map(pPacket->pBuffer, &local_pBuffer);
+ add_to_map(pPacket->pBuffer, &local_bufferObj);
}
CHECK_RETURN_VALUE(xglCreateBuffer);
break;
@@ -1201,11 +1261,11 @@
case GLV_TPI_XGL_xglCreateImage:
{
struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(packet->pBody);
- XGL_IMAGE local_pImage;
- replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_pImage);
+ struct imageObj local_imageObj;
+ replayResult = m_xglFuncs.real_xglCreateImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imageObj.replayImage);
if (replayResult == XGL_SUCCESS)
{
- add_to_map(pPacket->pImage, &local_pImage);
+ add_to_map(pPacket->pImage, &local_imageObj);
}
CHECK_RETURN_VALUE(xglCreateImage);
break;
@@ -2164,19 +2224,19 @@
{
struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(packet->pBody);
#if defined(PLATFORM_LINUX) || defined(XCB_NVIDIA)
- XGL_IMAGE img;
- XGL_GPU_MEMORY mem;
+ struct imageObj local_imgObj;
+ struct gpuMemObj local_mem;
m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);
m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);
- replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);
+ replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &local_imgObj.replayImage, &local_mem.replayGpuMem);
if (replayResult == XGL_SUCCESS)
{
if (pPacket->pImage != NULL)
- add_to_map(pPacket->pImage, &img);
+ add_to_map(pPacket->pImage, &local_imgObj);
if(pPacket->pMem != NULL)
- add_to_map(pPacket->pMem, &mem);
- m_display->imageHandles.push_back(img);
- m_display->imageMemory.push_back(mem);
+ add_to_map(pPacket->pMem, &local_mem);
+ m_display->imageHandles.push_back(local_imgObj.replayImage);
+ m_display->imageMemory.push_back(local_mem.replayGpuMem);
}
#elif defined(WIN32)
//TBD
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
index d35a8af..df55449 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvreplay_xgl_replay.h
@@ -105,6 +105,18 @@
XGL_GPU_SIZE size;
void *pData;
} XGLAllocInfo;
+
+class objMemory {
+public:
+ objMemory() : m_numAllocations(0), m_pMemReqs(NULL) {}
+ ~objMemory() { free(m_pMemReqs);}
+ void setCount(const uint32_t num);
+ void setReqs(const XGL_MEMORY_REQUIREMENTS *pReqs, const uint32_t num);
+private:
+ uint32_t m_numAllocations;
+ XGL_MEMORY_REQUIREMENTS *m_pMemReqs;
+};
+
struct xglFuncs {
void init_funcs(void * libHandle);
void *m_libHandle;
@@ -806,6 +818,7 @@
};
std::vector<struct validationMsg> m_validationMsgs;
std::vector<int> m_screenshotFrames;
+ // memory mapping functions for app writes into mapped memory
std::map<XGL_GPU_MEMORY, XGLAllocInfo> m_mapData;
void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)
{
@@ -856,19 +869,63 @@
info.pData = NULL;
}
- /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;
- void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)
+ bool m_adjustForGPU; // true if replay adjusts behavior based on GPU
+ struct imageObj {
+ objMemory imageMem;
+ XGL_IMAGE replayImage;
+ };
+
+ struct bufferObj {
+ objMemory bufferMem;
+ XGL_BUFFER replayBuffer;
+ };
+
+ struct gpuMemObj {
+ objMemory gpuMem;
+ XGL_GPU_MEMORY replayGpuMem;
+ };
+
+ void init_objMemCount(const XGL_BASE_OBJECT& object, const uint32_t &num)
{
- assert(pTraceGpu != NULL);
- assert(pReplayGpu != NULL);
- m_gpus[*pTraceGpu] = *pReplayGpu;
+ XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
+ std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);
+ if (it != m_images.end())
+ {
+ objMemory obj = it->second.imageMem;
+ obj.setCount(num);
+ return;
+ }
+ XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
+ std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);
+ if (itb != m_buffers.end())
+ {
+ objMemory obj = itb->second.bufferMem;
+ obj.setCount(num);
+ return;
+ }
+ return;
}
- XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)
+ void init_objMemReqs(const XGL_BASE_OBJECT& object, const XGL_MEMORY_REQUIREMENTS *pMemReqs, const unsigned int num)
{
- std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);
- return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;
- }*/
+ XGL_IMAGE img = static_cast <XGL_IMAGE> (object);
+ std::map<XGL_IMAGE, struct imageObj>::const_iterator it = m_images.find(img);
+ if (it != m_images.end())
+ {
+ objMemory obj = it->second.imageMem;
+ obj.setReqs(pMemReqs, num);
+ return;
+ }
+ XGL_BUFFER buf = static_cast <XGL_BUFFER> (object);
+ std::map<XGL_BUFFER, struct bufferObj>::const_iterator itb = m_buffers.find(buf);
+ if (itb != m_buffers.end())
+ {
+ objMemory obj = itb->second.bufferMem;
+ obj.setReqs(pMemReqs, num);
+ return;
+ }
+ return;
+ }
void clear_all_map_handles()
{
@@ -902,6 +959,7 @@
m_samplers.clear();
m_shaders.clear();
}
+
std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW> m_bufferViews;
void add_to_map(XGL_BUFFER_VIEW* pTraceVal, XGL_BUFFER_VIEW* pReplayVal)
{
@@ -909,31 +967,37 @@
assert(pReplayVal != NULL);
m_bufferViews[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_BUFFER_VIEW& key)
{
m_bufferViews.erase(key);
}
+
XGL_BUFFER_VIEW remap(const XGL_BUFFER_VIEW& value)
{
std::map<XGL_BUFFER_VIEW, XGL_BUFFER_VIEW>::const_iterator q = m_bufferViews.find(value);
return (q == m_bufferViews.end()) ? XGL_NULL_HANDLE : q->second;
}
- std::map<XGL_BUFFER, XGL_BUFFER> m_buffers;
- void add_to_map(XGL_BUFFER* pTraceVal, XGL_BUFFER* pReplayVal)
+
+ std::map<XGL_BUFFER, struct bufferObj> m_buffers;
+ void add_to_map(XGL_BUFFER* pTraceVal, struct bufferObj* pReplayVal)
{
assert(pTraceVal != NULL);
assert(pReplayVal != NULL);
m_buffers[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_BUFFER& key)
{
m_buffers.erase(key);
}
+
XGL_BUFFER remap(const XGL_BUFFER& value)
{
- std::map<XGL_BUFFER, XGL_BUFFER>::const_iterator q = m_buffers.find(value);
- return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second;
+ std::map<XGL_BUFFER, struct bufferObj>::const_iterator q = m_buffers.find(value);
+ return (q == m_buffers.end()) ? XGL_NULL_HANDLE : q->second.replayBuffer;
}
+
std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER> m_cmdBuffers;
void add_to_map(XGL_CMD_BUFFER* pTraceVal, XGL_CMD_BUFFER* pReplayVal)
{
@@ -941,15 +1005,18 @@
assert(pReplayVal != NULL);
m_cmdBuffers[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_CMD_BUFFER& key)
{
m_cmdBuffers.erase(key);
}
+
XGL_CMD_BUFFER remap(const XGL_CMD_BUFFER& value)
{
std::map<XGL_CMD_BUFFER, XGL_CMD_BUFFER>::const_iterator q = m_cmdBuffers.find(value);
return (q == m_cmdBuffers.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW> m_colorAttachmentViews;
void add_to_map(XGL_COLOR_ATTACHMENT_VIEW* pTraceVal, XGL_COLOR_ATTACHMENT_VIEW* pReplayVal)
{
@@ -957,15 +1024,18 @@
assert(pReplayVal != NULL);
m_colorAttachmentViews[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_COLOR_ATTACHMENT_VIEW& key)
{
m_colorAttachmentViews.erase(key);
}
+
XGL_COLOR_ATTACHMENT_VIEW remap(const XGL_COLOR_ATTACHMENT_VIEW& value)
{
std::map<XGL_COLOR_ATTACHMENT_VIEW, XGL_COLOR_ATTACHMENT_VIEW>::const_iterator q = m_colorAttachmentViews.find(value);
return (q == m_colorAttachmentViews.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW> m_depthStencilViews;
void add_to_map(XGL_DEPTH_STENCIL_VIEW* pTraceVal, XGL_DEPTH_STENCIL_VIEW* pReplayVal)
{
@@ -973,15 +1043,18 @@
assert(pReplayVal != NULL);
m_depthStencilViews[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DEPTH_STENCIL_VIEW& key)
{
m_depthStencilViews.erase(key);
}
+
XGL_DEPTH_STENCIL_VIEW remap(const XGL_DEPTH_STENCIL_VIEW& value)
{
std::map<XGL_DEPTH_STENCIL_VIEW, XGL_DEPTH_STENCIL_VIEW>::const_iterator q = m_depthStencilViews.find(value);
return (q == m_depthStencilViews.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION> m_descriptorRegions;
void add_to_map(XGL_DESCRIPTOR_REGION* pTraceVal, XGL_DESCRIPTOR_REGION* pReplayVal)
{
@@ -989,15 +1062,18 @@
assert(pReplayVal != NULL);
m_descriptorRegions[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DESCRIPTOR_REGION& key)
{
m_descriptorRegions.erase(key);
}
+
XGL_DESCRIPTOR_REGION remap(const XGL_DESCRIPTOR_REGION& value)
{
std::map<XGL_DESCRIPTOR_REGION, XGL_DESCRIPTOR_REGION>::const_iterator q = m_descriptorRegions.find(value);
return (q == m_descriptorRegions.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT> m_descriptorSetLayouts;
void add_to_map(XGL_DESCRIPTOR_SET_LAYOUT* pTraceVal, XGL_DESCRIPTOR_SET_LAYOUT* pReplayVal)
{
@@ -1005,15 +1081,18 @@
assert(pReplayVal != NULL);
m_descriptorSetLayouts[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DESCRIPTOR_SET_LAYOUT& key)
{
m_descriptorSetLayouts.erase(key);
}
+
XGL_DESCRIPTOR_SET_LAYOUT remap(const XGL_DESCRIPTOR_SET_LAYOUT& value)
{
std::map<XGL_DESCRIPTOR_SET_LAYOUT, XGL_DESCRIPTOR_SET_LAYOUT>::const_iterator q = m_descriptorSetLayouts.find(value);
return (q == m_descriptorSetLayouts.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET> m_descriptorSets;
void add_to_map(XGL_DESCRIPTOR_SET* pTraceVal, XGL_DESCRIPTOR_SET* pReplayVal)
{
@@ -1021,15 +1100,18 @@
assert(pReplayVal != NULL);
m_descriptorSets[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DESCRIPTOR_SET& key)
{
m_descriptorSets.erase(key);
}
+
XGL_DESCRIPTOR_SET remap(const XGL_DESCRIPTOR_SET& value)
{
std::map<XGL_DESCRIPTOR_SET, XGL_DESCRIPTOR_SET>::const_iterator q = m_descriptorSets.find(value);
return (q == m_descriptorSets.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DEVICE, XGL_DEVICE> m_devices;
void add_to_map(XGL_DEVICE* pTraceVal, XGL_DEVICE* pReplayVal)
{
@@ -1037,15 +1119,18 @@
assert(pReplayVal != NULL);
m_devices[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DEVICE& key)
{
m_devices.erase(key);
}
+
XGL_DEVICE remap(const XGL_DEVICE& value)
{
std::map<XGL_DEVICE, XGL_DEVICE>::const_iterator q = m_devices.find(value);
return (q == m_devices.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT> m_dynamicCbStateObjects;
void add_to_map(XGL_DYNAMIC_CB_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_CB_STATE_OBJECT* pReplayVal)
{
@@ -1053,15 +1138,18 @@
assert(pReplayVal != NULL);
m_dynamicCbStateObjects[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DYNAMIC_CB_STATE_OBJECT& key)
{
m_dynamicCbStateObjects.erase(key);
}
+
XGL_DYNAMIC_CB_STATE_OBJECT remap(const XGL_DYNAMIC_CB_STATE_OBJECT& value)
{
std::map<XGL_DYNAMIC_CB_STATE_OBJECT, XGL_DYNAMIC_CB_STATE_OBJECT>::const_iterator q = m_dynamicCbStateObjects.find(value);
return (q == m_dynamicCbStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT> m_dynamicDsStateObjects;
void add_to_map(XGL_DYNAMIC_DS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_DS_STATE_OBJECT* pReplayVal)
{
@@ -1069,15 +1157,18 @@
assert(pReplayVal != NULL);
m_dynamicDsStateObjects[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DYNAMIC_DS_STATE_OBJECT& key)
{
m_dynamicDsStateObjects.erase(key);
}
+
XGL_DYNAMIC_DS_STATE_OBJECT remap(const XGL_DYNAMIC_DS_STATE_OBJECT& value)
{
std::map<XGL_DYNAMIC_DS_STATE_OBJECT, XGL_DYNAMIC_DS_STATE_OBJECT>::const_iterator q = m_dynamicDsStateObjects.find(value);
return (q == m_dynamicDsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT> m_dynamicRsStateObjects;
void add_to_map(XGL_DYNAMIC_RS_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_RS_STATE_OBJECT* pReplayVal)
{
@@ -1085,15 +1176,18 @@
assert(pReplayVal != NULL);
m_dynamicRsStateObjects[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DYNAMIC_RS_STATE_OBJECT& key)
{
m_dynamicRsStateObjects.erase(key);
}
+
XGL_DYNAMIC_RS_STATE_OBJECT remap(const XGL_DYNAMIC_RS_STATE_OBJECT& value)
{
std::map<XGL_DYNAMIC_RS_STATE_OBJECT, XGL_DYNAMIC_RS_STATE_OBJECT>::const_iterator q = m_dynamicRsStateObjects.find(value);
return (q == m_dynamicRsStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT> m_dynamicVpStateObjects;
void add_to_map(XGL_DYNAMIC_VP_STATE_OBJECT* pTraceVal, XGL_DYNAMIC_VP_STATE_OBJECT* pReplayVal)
{
@@ -1101,15 +1195,18 @@
assert(pReplayVal != NULL);
m_dynamicVpStateObjects[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_DYNAMIC_VP_STATE_OBJECT& key)
{
m_dynamicVpStateObjects.erase(key);
}
+
XGL_DYNAMIC_VP_STATE_OBJECT remap(const XGL_DYNAMIC_VP_STATE_OBJECT& value)
{
std::map<XGL_DYNAMIC_VP_STATE_OBJECT, XGL_DYNAMIC_VP_STATE_OBJECT>::const_iterator q = m_dynamicVpStateObjects.find(value);
return (q == m_dynamicVpStateObjects.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_EVENT, XGL_EVENT> m_events;
void add_to_map(XGL_EVENT* pTraceVal, XGL_EVENT* pReplayVal)
{
@@ -1117,15 +1214,18 @@
assert(pReplayVal != NULL);
m_events[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_EVENT& key)
{
m_events.erase(key);
}
+
XGL_EVENT remap(const XGL_EVENT& value)
{
std::map<XGL_EVENT, XGL_EVENT>::const_iterator q = m_events.find(value);
return (q == m_events.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_FENCE, XGL_FENCE> m_fences;
void add_to_map(XGL_FENCE* pTraceVal, XGL_FENCE* pReplayVal)
{
@@ -1133,15 +1233,18 @@
assert(pReplayVal != NULL);
m_fences[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_FENCE& key)
{
m_fences.erase(key);
}
+
XGL_FENCE remap(const XGL_FENCE& value)
{
std::map<XGL_FENCE, XGL_FENCE>::const_iterator q = m_fences.find(value);
return (q == m_fences.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER> m_framebuffers;
void add_to_map(XGL_FRAMEBUFFER* pTraceVal, XGL_FRAMEBUFFER* pReplayVal)
{
@@ -1149,31 +1252,37 @@
assert(pReplayVal != NULL);
m_framebuffers[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_FRAMEBUFFER& key)
{
m_framebuffers.erase(key);
}
+
XGL_FRAMEBUFFER remap(const XGL_FRAMEBUFFER& value)
{
std::map<XGL_FRAMEBUFFER, XGL_FRAMEBUFFER>::const_iterator q = m_framebuffers.find(value);
return (q == m_framebuffers.end()) ? XGL_NULL_HANDLE : q->second;
}
- std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY> m_gpuMemorys;
- void add_to_map(XGL_GPU_MEMORY* pTraceVal, XGL_GPU_MEMORY* pReplayVal)
+
+ std::map<XGL_GPU_MEMORY, struct gpuMemObj> m_gpuMemorys;
+ void add_to_map(XGL_GPU_MEMORY* pTraceVal, struct gpuMemObj* pReplayVal)
{
assert(pTraceVal != NULL);
assert(pReplayVal != NULL);
m_gpuMemorys[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_GPU_MEMORY& key)
{
m_gpuMemorys.erase(key);
}
+
XGL_GPU_MEMORY remap(const XGL_GPU_MEMORY& value)
{
- std::map<XGL_GPU_MEMORY, XGL_GPU_MEMORY>::const_iterator q = m_gpuMemorys.find(value);
- return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second;
+ std::map<XGL_GPU_MEMORY, struct gpuMemObj>::const_iterator q = m_gpuMemorys.find(value);
+ return (q == m_gpuMemorys.end()) ? XGL_NULL_HANDLE : q->second.replayGpuMem;
}
+
std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW> m_imageViews;
void add_to_map(XGL_IMAGE_VIEW* pTraceVal, XGL_IMAGE_VIEW* pReplayVal)
{
@@ -1181,31 +1290,37 @@
assert(pReplayVal != NULL);
m_imageViews[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_IMAGE_VIEW& key)
{
m_imageViews.erase(key);
}
+
XGL_IMAGE_VIEW remap(const XGL_IMAGE_VIEW& value)
{
std::map<XGL_IMAGE_VIEW, XGL_IMAGE_VIEW>::const_iterator q = m_imageViews.find(value);
return (q == m_imageViews.end()) ? XGL_NULL_HANDLE : q->second;
}
- std::map<XGL_IMAGE, XGL_IMAGE> m_images;
- void add_to_map(XGL_IMAGE* pTraceVal, XGL_IMAGE* pReplayVal)
+
+ std::map<XGL_IMAGE, struct imageObj> m_images;
+ void add_to_map(XGL_IMAGE* pTraceVal, struct imageObj* pReplayVal)
{
assert(pTraceVal != NULL);
assert(pReplayVal != NULL);
m_images[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_IMAGE& key)
{
m_images.erase(key);
}
+
XGL_IMAGE remap(const XGL_IMAGE& value)
{
- std::map<XGL_IMAGE, XGL_IMAGE>::const_iterator q = m_images.find(value);
- return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second;
+ std::map<XGL_IMAGE, struct imageObj>::const_iterator q = m_images.find(value);
+ return (q == m_images.end()) ? XGL_NULL_HANDLE : q->second.replayImage;
}
+
std::map<XGL_INSTANCE, XGL_INSTANCE> m_instances;
void add_to_map(XGL_INSTANCE* pTraceVal, XGL_INSTANCE* pReplayVal)
{
@@ -1213,15 +1328,18 @@
assert(pReplayVal != NULL);
m_instances[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_INSTANCE& key)
{
m_instances.erase(key);
}
+
XGL_INSTANCE remap(const XGL_INSTANCE& value)
{
std::map<XGL_INSTANCE, XGL_INSTANCE>::const_iterator q = m_instances.find(value);
return (q == m_instances.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_physicalGpus;
void add_to_map(XGL_PHYSICAL_GPU* pTraceVal, XGL_PHYSICAL_GPU* pReplayVal)
{
@@ -1229,15 +1347,18 @@
assert(pReplayVal != NULL);
m_physicalGpus[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_PHYSICAL_GPU& key)
{
m_physicalGpus.erase(key);
}
+
XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& value)
{
std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_physicalGpus.find(value);
return (q == m_physicalGpus.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA> m_pipelineDeltas;
void add_to_map(XGL_PIPELINE_DELTA* pTraceVal, XGL_PIPELINE_DELTA* pReplayVal)
{
@@ -1245,15 +1366,18 @@
assert(pReplayVal != NULL);
m_pipelineDeltas[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_PIPELINE_DELTA& key)
{
m_pipelineDeltas.erase(key);
}
+
XGL_PIPELINE_DELTA remap(const XGL_PIPELINE_DELTA& value)
{
std::map<XGL_PIPELINE_DELTA, XGL_PIPELINE_DELTA>::const_iterator q = m_pipelineDeltas.find(value);
return (q == m_pipelineDeltas.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_PIPELINE, XGL_PIPELINE> m_pipelines;
void add_to_map(XGL_PIPELINE* pTraceVal, XGL_PIPELINE* pReplayVal)
{
@@ -1261,15 +1385,18 @@
assert(pReplayVal != NULL);
m_pipelines[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_PIPELINE& key)
{
m_pipelines.erase(key);
}
+
XGL_PIPELINE remap(const XGL_PIPELINE& value)
{
std::map<XGL_PIPELINE, XGL_PIPELINE>::const_iterator q = m_pipelines.find(value);
return (q == m_pipelines.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_QUERY_POOL, XGL_QUERY_POOL> m_queryPools;
void add_to_map(XGL_QUERY_POOL* pTraceVal, XGL_QUERY_POOL* pReplayVal)
{
@@ -1277,15 +1404,18 @@
assert(pReplayVal != NULL);
m_queryPools[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_QUERY_POOL& key)
{
m_queryPools.erase(key);
}
+
XGL_QUERY_POOL remap(const XGL_QUERY_POOL& value)
{
std::map<XGL_QUERY_POOL, XGL_QUERY_POOL>::const_iterator q = m_queryPools.find(value);
return (q == m_queryPools.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE> m_queueSemaphores;
void add_to_map(XGL_QUEUE_SEMAPHORE* pTraceVal, XGL_QUEUE_SEMAPHORE* pReplayVal)
{
@@ -1293,15 +1423,18 @@
assert(pReplayVal != NULL);
m_queueSemaphores[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_QUEUE_SEMAPHORE& key)
{
m_queueSemaphores.erase(key);
}
+
XGL_QUEUE_SEMAPHORE remap(const XGL_QUEUE_SEMAPHORE& value)
{
std::map<XGL_QUEUE_SEMAPHORE, XGL_QUEUE_SEMAPHORE>::const_iterator q = m_queueSemaphores.find(value);
return (q == m_queueSemaphores.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_QUEUE, XGL_QUEUE> m_queues;
void add_to_map(XGL_QUEUE* pTraceVal, XGL_QUEUE* pReplayVal)
{
@@ -1309,15 +1442,18 @@
assert(pReplayVal != NULL);
m_queues[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_QUEUE& key)
{
m_queues.erase(key);
}
+
XGL_QUEUE remap(const XGL_QUEUE& value)
{
std::map<XGL_QUEUE, XGL_QUEUE>::const_iterator q = m_queues.find(value);
return (q == m_queues.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_RENDER_PASS, XGL_RENDER_PASS> m_renderPasss;
void add_to_map(XGL_RENDER_PASS* pTraceVal, XGL_RENDER_PASS* pReplayVal)
{
@@ -1325,15 +1461,18 @@
assert(pReplayVal != NULL);
m_renderPasss[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_RENDER_PASS& key)
{
m_renderPasss.erase(key);
}
+
XGL_RENDER_PASS remap(const XGL_RENDER_PASS& value)
{
std::map<XGL_RENDER_PASS, XGL_RENDER_PASS>::const_iterator q = m_renderPasss.find(value);
return (q == m_renderPasss.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_SAMPLER, XGL_SAMPLER> m_samplers;
void add_to_map(XGL_SAMPLER* pTraceVal, XGL_SAMPLER* pReplayVal)
{
@@ -1341,15 +1480,18 @@
assert(pReplayVal != NULL);
m_samplers[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_SAMPLER& key)
{
m_samplers.erase(key);
}
+
XGL_SAMPLER remap(const XGL_SAMPLER& value)
{
std::map<XGL_SAMPLER, XGL_SAMPLER>::const_iterator q = m_samplers.find(value);
return (q == m_samplers.end()) ? XGL_NULL_HANDLE : q->second;
}
+
std::map<XGL_SHADER, XGL_SHADER> m_shaders;
void add_to_map(XGL_SHADER* pTraceVal, XGL_SHADER* pReplayVal)
{
@@ -1357,15 +1499,18 @@
assert(pReplayVal != NULL);
m_shaders[*pTraceVal] = *pReplayVal;
}
+
void rm_from_map(const XGL_SHADER& key)
{
m_shaders.erase(key);
}
+
XGL_SHADER remap(const XGL_SHADER& value)
{
std::map<XGL_SHADER, XGL_SHADER>::const_iterator q = m_shaders.find(value);
return (q == m_shaders.end()) ? XGL_NULL_HANDLE : q->second;
}
+
XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)
{
XGL_DYNAMIC_STATE_OBJECT obj;
@@ -1386,6 +1531,7 @@
rm_from_map(static_cast <XGL_DYNAMIC_CB_STATE_OBJECT> (state));
rm_from_map(static_cast <XGL_DYNAMIC_DS_STATE_OBJECT> (state));
}
+
XGL_OBJECT remap(const XGL_OBJECT& object)
{
XGL_OBJECT obj;
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h
deleted file mode 100644
index d1dded3..0000000
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/glvtrace_xgl_packet_id.h
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* THIS FILE IS GENERATED. DO NOT EDIT. */
-
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#pragma once
-
-#include "glv_trace_packet_utils.h"
-#include "glv_trace_packet_identifiers.h"
-#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "xgl_enum_string_helper.h"
-#if defined(WIN32)
-#define snprintf _snprintf
-#endif
-#define SEND_ENTRYPOINT_ID(entrypoint) ;
-//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\n");
-
-#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;
-//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);
-
-#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \
- pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);
-
-#define FINISH_TRACE_PACKET() \
- glv_finalize_trace_packet(pHeader); \
- glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \
- glv_delete_trace_packet(&pHeader);
-
-enum GLV_TRACE_PACKET_ID_XGL
-{
- GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,
- GLV_TPI_XGL_xglCreateInstance,
- GLV_TPI_XGL_xglDestroyInstance,
- GLV_TPI_XGL_xglEnumerateGpus,
- GLV_TPI_XGL_xglGetGpuInfo,
- GLV_TPI_XGL_xglGetProcAddr,
- GLV_TPI_XGL_xglCreateDevice,
- GLV_TPI_XGL_xglDestroyDevice,
- GLV_TPI_XGL_xglGetExtensionSupport,
- GLV_TPI_XGL_xglEnumerateLayers,
- GLV_TPI_XGL_xglGetDeviceQueue,
- GLV_TPI_XGL_xglQueueSubmit,
- GLV_TPI_XGL_xglQueueSetGlobalMemReferences,
- GLV_TPI_XGL_xglQueueWaitIdle,
- GLV_TPI_XGL_xglDeviceWaitIdle,
- GLV_TPI_XGL_xglAllocMemory,
- GLV_TPI_XGL_xglFreeMemory,
- GLV_TPI_XGL_xglSetMemoryPriority,
- GLV_TPI_XGL_xglMapMemory,
- GLV_TPI_XGL_xglUnmapMemory,
- GLV_TPI_XGL_xglPinSystemMemory,
- GLV_TPI_XGL_xglGetMultiGpuCompatibility,
- GLV_TPI_XGL_xglOpenSharedMemory,
- GLV_TPI_XGL_xglOpenSharedQueueSemaphore,
- GLV_TPI_XGL_xglOpenPeerMemory,
- GLV_TPI_XGL_xglOpenPeerImage,
- GLV_TPI_XGL_xglDestroyObject,
- GLV_TPI_XGL_xglGetObjectInfo,
- GLV_TPI_XGL_xglBindObjectMemory,
- GLV_TPI_XGL_xglBindObjectMemoryRange,
- GLV_TPI_XGL_xglBindImageMemoryRange,
- GLV_TPI_XGL_xglCreateFence,
- GLV_TPI_XGL_xglGetFenceStatus,
- GLV_TPI_XGL_xglWaitForFences,
- GLV_TPI_XGL_xglCreateQueueSemaphore,
- GLV_TPI_XGL_xglSignalQueueSemaphore,
- GLV_TPI_XGL_xglWaitQueueSemaphore,
- GLV_TPI_XGL_xglCreateEvent,
- GLV_TPI_XGL_xglGetEventStatus,
- GLV_TPI_XGL_xglSetEvent,
- GLV_TPI_XGL_xglResetEvent,
- GLV_TPI_XGL_xglCreateQueryPool,
- GLV_TPI_XGL_xglGetQueryPoolResults,
- GLV_TPI_XGL_xglGetFormatInfo,
- GLV_TPI_XGL_xglCreateBuffer,
- GLV_TPI_XGL_xglCreateBufferView,
- GLV_TPI_XGL_xglCreateImage,
- GLV_TPI_XGL_xglSetFastClearColor,
- GLV_TPI_XGL_xglSetFastClearDepth,
- GLV_TPI_XGL_xglGetImageSubresourceInfo,
- GLV_TPI_XGL_xglCreateImageView,
- GLV_TPI_XGL_xglCreateColorAttachmentView,
- GLV_TPI_XGL_xglCreateDepthStencilView,
- GLV_TPI_XGL_xglCreateShader,
- GLV_TPI_XGL_xglCreateGraphicsPipeline,
- GLV_TPI_XGL_xglCreateComputePipeline,
- GLV_TPI_XGL_xglStorePipeline,
- GLV_TPI_XGL_xglLoadPipeline,
- GLV_TPI_XGL_xglCreatePipelineDelta,
- GLV_TPI_XGL_xglCreateSampler,
- GLV_TPI_XGL_xglCreateDescriptorSetLayout,
- GLV_TPI_XGL_xglBeginDescriptorRegionUpdate,
- GLV_TPI_XGL_xglEndDescriptorRegionUpdate,
- GLV_TPI_XGL_xglCreateDescriptorRegion,
- GLV_TPI_XGL_xglClearDescriptorRegion,
- GLV_TPI_XGL_xglAllocDescriptorSets,
- GLV_TPI_XGL_xglClearDescriptorSets,
- GLV_TPI_XGL_xglUpdateDescriptors,
- GLV_TPI_XGL_xglCreateDynamicViewportState,
- GLV_TPI_XGL_xglCreateDynamicRasterState,
- GLV_TPI_XGL_xglCreateDynamicColorBlendState,
- GLV_TPI_XGL_xglCreateDynamicDepthStencilState,
- GLV_TPI_XGL_xglCreateCommandBuffer,
- GLV_TPI_XGL_xglBeginCommandBuffer,
- GLV_TPI_XGL_xglEndCommandBuffer,
- GLV_TPI_XGL_xglResetCommandBuffer,
- GLV_TPI_XGL_xglCmdBindPipeline,
- GLV_TPI_XGL_xglCmdBindPipelineDelta,
- GLV_TPI_XGL_xglCmdBindDynamicStateObject,
- GLV_TPI_XGL_xglCmdBindDescriptorSet,
- GLV_TPI_XGL_xglCmdBindVertexBuffer,
- GLV_TPI_XGL_xglCmdBindIndexBuffer,
- GLV_TPI_XGL_xglCmdDraw,
- GLV_TPI_XGL_xglCmdDrawIndexed,
- GLV_TPI_XGL_xglCmdDrawIndirect,
- GLV_TPI_XGL_xglCmdDrawIndexedIndirect,
- GLV_TPI_XGL_xglCmdDispatch,
- GLV_TPI_XGL_xglCmdDispatchIndirect,
- GLV_TPI_XGL_xglCmdCopyBuffer,
- GLV_TPI_XGL_xglCmdCopyImage,
- GLV_TPI_XGL_xglCmdCopyBufferToImage,
- GLV_TPI_XGL_xglCmdCopyImageToBuffer,
- GLV_TPI_XGL_xglCmdCloneImageData,
- GLV_TPI_XGL_xglCmdUpdateBuffer,
- GLV_TPI_XGL_xglCmdFillBuffer,
- GLV_TPI_XGL_xglCmdClearColorImage,
- GLV_TPI_XGL_xglCmdClearColorImageRaw,
- GLV_TPI_XGL_xglCmdClearDepthStencil,
- GLV_TPI_XGL_xglCmdResolveImage,
- GLV_TPI_XGL_xglCmdSetEvent,
- GLV_TPI_XGL_xglCmdResetEvent,
- GLV_TPI_XGL_xglCmdWaitEvents,
- GLV_TPI_XGL_xglCmdPipelineBarrier,
- GLV_TPI_XGL_xglCmdBeginQuery,
- GLV_TPI_XGL_xglCmdEndQuery,
- GLV_TPI_XGL_xglCmdResetQueryPool,
- GLV_TPI_XGL_xglCmdWriteTimestamp,
- GLV_TPI_XGL_xglCmdInitAtomicCounters,
- GLV_TPI_XGL_xglCmdLoadAtomicCounters,
- GLV_TPI_XGL_xglCmdSaveAtomicCounters,
- GLV_TPI_XGL_xglCreateFramebuffer,
- GLV_TPI_XGL_xglCreateRenderPass,
- GLV_TPI_XGL_xglCmdBeginRenderPass,
- GLV_TPI_XGL_xglCmdEndRenderPass,
- GLV_TPI_XGL_xglDbgSetValidationLevel,
- GLV_TPI_XGL_xglDbgRegisterMsgCallback,
- GLV_TPI_XGL_xglDbgUnregisterMsgCallback,
- GLV_TPI_XGL_xglDbgSetMessageFilter,
- GLV_TPI_XGL_xglDbgSetObjectTag,
- GLV_TPI_XGL_xglDbgSetGlobalOption,
- GLV_TPI_XGL_xglDbgSetDeviceOption,
- GLV_TPI_XGL_xglCmdDbgMarkerBegin,
- GLV_TPI_XGL_xglCmdDbgMarkerEnd,
- GLV_TPI_XGL_xglWsiX11AssociateConnection,
- GLV_TPI_XGL_xglWsiX11GetMSC,
- GLV_TPI_XGL_xglWsiX11CreatePresentableImage,
- GLV_TPI_XGL_xglWsiX11QueuePresent,
-};
-
-static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)
-{
- static char str[1024];
- switch(id) {
- case GLV_TPI_XGL_xglApiVersion:
- {
- struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);
- snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);
- return str;
- }
- case GLV_TPI_XGL_xglCreateInstance:
- {
- struct_xglCreateInstance* pPacket = (struct_xglCreateInstance*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateInstance(pAppInfo = %p, pAllocCb = %p, pInstance = %p)", (void*)(pPacket->pAppInfo), (void*)(pPacket->pAllocCb), (void*)pPacket->pInstance);
- return str;
- }
- case GLV_TPI_XGL_xglDestroyInstance:
- {
- struct_xglDestroyInstance* pPacket = (struct_xglDestroyInstance*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyInstance(instance = %p)", (void*)(pPacket->instance));
- return str;
- }
- case GLV_TPI_XGL_xglEnumerateGpus:
- {
- struct_xglEnumerateGpus* pPacket = (struct_xglEnumerateGpus*)(pHeader->pBody);
- snprintf(str, 1024, "xglEnumerateGpus(instance = %p, maxGpus = %i, *pGpuCount = %i, pGpus = %p)", (void*)(pPacket->instance), pPacket->maxGpus, (pPacket->pGpuCount == NULL) ? 0 : *(pPacket->pGpuCount), (void*)(pPacket->pGpus));
- return str;
- }
- case GLV_TPI_XGL_xglGetGpuInfo:
- {
- struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetGpuInfo(gpu = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->gpu), string_XGL_PHYSICAL_GPU_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglGetProcAddr:
- {
- struct_xglGetProcAddr* pPacket = (struct_xglGetProcAddr*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetProcAddr(gpu = %p, pName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pName));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDevice:
- {
- struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pCreateInfo), (void*)pPacket->pDevice);
- return str;
- }
- case GLV_TPI_XGL_xglDestroyDevice:
- {
- struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyDevice(device = %p)", (void*)(pPacket->device));
- return str;
- }
- case GLV_TPI_XGL_xglGetExtensionSupport:
- {
- struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetExtensionSupport(gpu = %p, pExtName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pExtName));
- return str;
- }
- case GLV_TPI_XGL_xglEnumerateLayers:
- {
- struct_xglEnumerateLayers* pPacket = (struct_xglEnumerateLayers*)(pHeader->pBody);
- snprintf(str, 1024, "xglEnumerateLayers(gpu = %p, maxLayerCount = %zu, maxStringSize = %zu, *pOutLayerCount = %zu, pOutLayers = %p, pReserved = %p)", (void*)(pPacket->gpu), pPacket->maxLayerCount, pPacket->maxStringSize, (pPacket->pOutLayerCount == NULL) ? 0 : *(pPacket->pOutLayerCount), (void*)(pPacket->pOutLayers), (void*)(pPacket->pReserved));
- return str;
- }
- case GLV_TPI_XGL_xglGetDeviceQueue:
- {
- struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetDeviceQueue(device = %p, queueType = %s, queueIndex = %i, pQueue = %p)", (void*)(pPacket->device), string_XGL_QUEUE_TYPE(pPacket->queueType), pPacket->queueIndex, (void*)(pPacket->pQueue));
- return str;
- }
- case GLV_TPI_XGL_xglQueueSubmit:
- {
- struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p)", (void*)(pPacket->queue), pPacket->cmdBufferCount, (void*)(pPacket->pCmdBuffers), pPacket->memRefCount, (void*)(pPacket->pMemRefs), (void*)(pPacket->fence));
- return str;
- }
- case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
- {
- struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p)", (void*)(pPacket->queue), pPacket->memRefCount, (void*)(pPacket->pMemRefs));
- return str;
- }
- case GLV_TPI_XGL_xglQueueWaitIdle:
- {
- struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueWaitIdle(queue = %p)", (void*)(pPacket->queue));
- return str;
- }
- case GLV_TPI_XGL_xglDeviceWaitIdle:
- {
- struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)(pHeader->pBody);
- snprintf(str, 1024, "xglDeviceWaitIdle(device = %p)", (void*)(pPacket->device));
- return str;
- }
- case GLV_TPI_XGL_xglAllocMemory:
- {
- struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pAllocInfo), (void*)pPacket->pMem);
- return str;
- }
- case GLV_TPI_XGL_xglFreeMemory:
- {
- struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglFreeMemory(mem = %p)", (void*)(pPacket->mem));
- return str;
- }
- case GLV_TPI_XGL_xglSetMemoryPriority:
- {
- struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetMemoryPriority(mem = %p, priority = %p)", (void*)(pPacket->mem), (void*)(pPacket->priority));
- return str;
- }
- case GLV_TPI_XGL_xglMapMemory:
- {
- struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglMapMemory(mem = %p, flags = %i, ppData = %p)", (void*)(pPacket->mem), pPacket->flags, (void*)pPacket->ppData);
- return str;
- }
- case GLV_TPI_XGL_xglUnmapMemory:
- {
- struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglUnmapMemory(mem = %p)", (void*)(pPacket->mem));
- return str;
- }
- case GLV_TPI_XGL_xglPinSystemMemory:
- {
- struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %zu, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pSysMem), pPacket->memSize, (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
- {
- struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p)", (void*)(pPacket->gpu0), (void*)(pPacket->gpu1), (void*)(pPacket->pInfo));
- return str;
- }
- case GLV_TPI_XGL_xglOpenSharedMemory:
- {
- struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
- {
- struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pSemaphore));
- return str;
- }
- case GLV_TPI_XGL_xglOpenPeerMemory:
- {
- struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglOpenPeerImage:
- {
- struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pImage), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglDestroyObject:
- {
- struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyObject(object = %p)", (void*)(pPacket->object));
- return str;
- }
- case GLV_TPI_XGL_xglGetObjectInfo:
- {
- struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetObjectInfo(object = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->object), string_XGL_OBJECT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglBindObjectMemory:
- {
- struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindObjectMemory(object = %p, allocationIdx = %i, mem = %p, offset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->mem), (void*)(pPacket->offset));
- return str;
- }
- case GLV_TPI_XGL_xglBindObjectMemoryRange:
- {
- struct_xglBindObjectMemoryRange* pPacket = (struct_xglBindObjectMemoryRange*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindObjectMemoryRange(object = %p, allocationIdx = %i, rangeOffset = %p, rangeSize = %p, mem = %p, memOffset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->rangeOffset), (void*)(pPacket->rangeSize), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
- return str;
- }
- case GLV_TPI_XGL_xglBindImageMemoryRange:
- {
- struct_xglBindImageMemoryRange* pPacket = (struct_xglBindImageMemoryRange*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindImageMemoryRange(image = %p, allocationIdx = %i, bindInfo = %p, mem = %p, memOffset = %p)", (void*)(pPacket->image), pPacket->allocationIdx, (void*)(pPacket->bindInfo), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCreateFence:
- {
- struct_xglCreateFence* pPacket = (struct_xglCreateFence*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFence);
- return str;
- }
- case GLV_TPI_XGL_xglGetFenceStatus:
- {
- struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetFenceStatus(fence = %p)", (void*)(pPacket->fence));
- return str;
- }
- case GLV_TPI_XGL_xglWaitForFences:
- {
- struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)(pHeader->pBody);
- snprintf(str, 1024, "xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu)", (void*)(pPacket->device), pPacket->fenceCount, (void*)(pPacket->pFences), pPacket->waitAll, pPacket->timeout);
- return str;
- }
- case GLV_TPI_XGL_xglCreateQueueSemaphore:
- {
- struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSemaphore);
- return str;
- }
- case GLV_TPI_XGL_xglSignalQueueSemaphore:
- {
- struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglSignalQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
- return str;
- }
- case GLV_TPI_XGL_xglWaitQueueSemaphore:
- {
- struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglWaitQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
- return str;
- }
- case GLV_TPI_XGL_xglCreateEvent:
- {
- struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pEvent);
- return str;
- }
- case GLV_TPI_XGL_xglGetEventStatus:
- {
- struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetEventStatus(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglSetEvent:
- {
- struct_xglSetEvent* pPacket = (struct_xglSetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetEvent(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglResetEvent:
- {
- struct_xglResetEvent* pPacket = (struct_xglResetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglResetEvent(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglCreateQueryPool:
- {
- struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pQueryPool);
- return str;
- }
- case GLV_TPI_XGL_xglGetQueryPoolResults:
- {
- struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, *pDataSize = %zu, pData = %p)", (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglGetFormatInfo:
- {
- struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetFormatInfo(device = %p, format = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->format), string_XGL_FORMAT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCreateBuffer:
- {
- struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateBuffer(device = %p, pCreateInfo = %p, pBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pBuffer);
- return str;
- }
- case GLV_TPI_XGL_xglCreateBufferView:
- {
- struct_xglCreateBufferView* pPacket = (struct_xglCreateBufferView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateBufferView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateImage:
- {
- struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pImage);
- return str;
- }
- case GLV_TPI_XGL_xglSetFastClearColor:
- {
- struct_xglSetFastClearColor* pPacket = (struct_xglSetFastClearColor*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetFastClearColor(image = %p, color = [%f, %f, %f, %f])", (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3]);
- return str;
- }
- case GLV_TPI_XGL_xglSetFastClearDepth:
- {
- struct_xglSetFastClearDepth* pPacket = (struct_xglSetFastClearDepth*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetFastClearDepth(image = %p, depth = %f)", (void*)(pPacket->image), pPacket->depth);
- return str;
- }
- case GLV_TPI_XGL_xglGetImageSubresourceInfo:
- {
- struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->image), (void*)(pPacket->pSubresource), string_XGL_SUBRESOURCE_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCreateImageView:
- {
- struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateColorAttachmentView:
- {
- struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDepthStencilView:
- {
- struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateShader:
- {
- struct_xglCreateShader* pPacket = (struct_xglCreateShader*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pShader);
- return str;
- }
- case GLV_TPI_XGL_xglCreateGraphicsPipeline:
- {
- struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
- return str;
- }
- case GLV_TPI_XGL_xglCreateComputePipeline:
- {
- struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
- return str;
- }
- case GLV_TPI_XGL_xglStorePipeline:
- {
- struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglStorePipeline(pipeline = %p, *pDataSize = %zu, pData = %p)", (void*)(pPacket->pipeline), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglLoadPipeline:
- {
- struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglLoadPipeline(device = %p, dataSize = %zu, pData = %p, pPipeline = %p)", (void*)(pPacket->device), pPacket->dataSize, (void*)(pPacket->pData), (void*)(pPacket->pPipeline));
- return str;
- }
- case GLV_TPI_XGL_xglCreatePipelineDelta:
- {
- struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p)", (void*)(pPacket->device), (void*)(pPacket->p1), (void*)(pPacket->p2), (void*)pPacket->delta);
- return str;
- }
- case GLV_TPI_XGL_xglCreateSampler:
- {
- struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSampler);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
- {
- struct_xglCreateDescriptorSetLayout* pPacket = (struct_xglCreateDescriptorSetLayout*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDescriptorSetLayout(device = %p, stageFlags = %i, *pSetBindPoints = %i, priorSetLayout = %p, pSetLayoutInfoList = %p, pSetLayout = %p)", (void*)(pPacket->device), pPacket->stageFlags, (pPacket->pSetBindPoints == NULL) ? 0 : *(pPacket->pSetBindPoints), (void*)(pPacket->priorSetLayout), (void*)(pPacket->pSetLayoutInfoList), (void*)pPacket->pSetLayout);
- return str;
- }
- case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
- {
- struct_xglBeginDescriptorRegionUpdate* pPacket = (struct_xglBeginDescriptorRegionUpdate*)(pHeader->pBody);
- snprintf(str, 1024, "xglBeginDescriptorRegionUpdate(device = %p, updateMode = %p)", (void*)(pPacket->device), (void*)(pPacket->updateMode));
- return str;
- }
- case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
- {
- struct_xglEndDescriptorRegionUpdate* pPacket = (struct_xglEndDescriptorRegionUpdate*)(pHeader->pBody);
- snprintf(str, 1024, "xglEndDescriptorRegionUpdate(device = %p, cmd = %p)", (void*)(pPacket->device), (void*)(pPacket->cmd));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDescriptorRegion:
- {
- struct_xglCreateDescriptorRegion* pPacket = (struct_xglCreateDescriptorRegion*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDescriptorRegion(device = %p, regionUsage = %p, maxSets = %i, pCreateInfo = %p, pDescriptorRegion = %p)", (void*)(pPacket->device), (void*)(pPacket->regionUsage), pPacket->maxSets, (void*)(pPacket->pCreateInfo), (void*)pPacket->pDescriptorRegion);
- return str;
- }
- case GLV_TPI_XGL_xglClearDescriptorRegion:
- {
- struct_xglClearDescriptorRegion* pPacket = (struct_xglClearDescriptorRegion*)(pHeader->pBody);
- snprintf(str, 1024, "xglClearDescriptorRegion(descriptorRegion = %p)", (void*)(pPacket->descriptorRegion));
- return str;
- }
- case GLV_TPI_XGL_xglAllocDescriptorSets:
- {
- struct_xglAllocDescriptorSets* pPacket = (struct_xglAllocDescriptorSets*)(pHeader->pBody);
- snprintf(str, 1024, "xglAllocDescriptorSets(descriptorRegion = %p, setUsage = %p, count = %i, pSetLayouts = %p, pDescriptorSets = %p, *pCount = %i)", (void*)(pPacket->descriptorRegion), (void*)(pPacket->setUsage), pPacket->count, (void*)(pPacket->pSetLayouts), (void*)(pPacket->pDescriptorSets), (pPacket->pCount == NULL) ? 0 : *(pPacket->pCount));
- return str;
- }
- case GLV_TPI_XGL_xglClearDescriptorSets:
- {
- struct_xglClearDescriptorSets* pPacket = (struct_xglClearDescriptorSets*)(pHeader->pBody);
- snprintf(str, 1024, "xglClearDescriptorSets(descriptorRegion = %p, count = %i, pDescriptorSets = %p)", (void*)(pPacket->descriptorRegion), pPacket->count, (void*)(pPacket->pDescriptorSets));
- return str;
- }
- case GLV_TPI_XGL_xglUpdateDescriptors:
- {
- struct_xglUpdateDescriptors* pPacket = (struct_xglUpdateDescriptors*)(pHeader->pBody);
- snprintf(str, 1024, "xglUpdateDescriptors(descriptorSet = %p, pUpdateChain = %p)", (void*)(pPacket->descriptorSet), (void*)(pPacket->pUpdateChain));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicViewportState:
- {
- struct_xglCreateDynamicViewportState* pPacket = (struct_xglCreateDynamicViewportState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicViewportState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicRasterState:
- {
- struct_xglCreateDynamicRasterState* pPacket = (struct_xglCreateDynamicRasterState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicRasterState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
- {
- struct_xglCreateDynamicColorBlendState* pPacket = (struct_xglCreateDynamicColorBlendState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicColorBlendState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
- {
- struct_xglCreateDynamicDepthStencilState* pPacket = (struct_xglCreateDynamicDepthStencilState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicDepthStencilState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateCommandBuffer:
- {
- struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pCmdBuffer);
- return str;
- }
- case GLV_TPI_XGL_xglBeginCommandBuffer:
- {
- struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglBeginCommandBuffer(cmdBuffer = %p, pBeginInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBeginInfo));
- return str;
- }
- case GLV_TPI_XGL_xglEndCommandBuffer:
- {
- struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglEndCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglResetCommandBuffer:
- {
- struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglResetCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindPipeline:
- {
- struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindPipeline(cmdBuffer = %p, pipelineBindPoint = %p, pipeline = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->pipeline));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindPipelineDelta:
- {
- struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindPipelineDelta(cmdBuffer = %p, pipelineBindPoint = %p, delta = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->delta));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
- {
- struct_xglCmdBindDynamicStateObject* pPacket = (struct_xglCmdBindDynamicStateObject*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindDynamicStateObject(cmdBuffer = %p, stateBindPoint = %p, state = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->stateBindPoint), (void*)(pPacket->state));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindDescriptorSet:
- {
- struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindDescriptorSet(cmdBuffer = %p, pipelineBindPoint = %p, descriptorSet = %p, *pUserData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->descriptorSet), (pPacket->pUserData == NULL) ? 0 : *(pPacket->pUserData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindVertexBuffer:
- {
- struct_xglCmdBindVertexBuffer* pPacket = (struct_xglCmdBindVertexBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindVertexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, binding = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->binding);
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindIndexBuffer:
- {
- struct_xglCmdBindIndexBuffer* pPacket = (struct_xglCmdBindIndexBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindIndexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, indexType = %s)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), string_XGL_INDEX_TYPE(pPacket->indexType));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDraw:
- {
- struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDraw(cmdBuffer = %p, firstVertex = %i, vertexCount = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexed:
- {
- struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndexed(cmdBuffer = %p, firstIndex = %i, indexCount = %i, vertexOffset = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndirect:
- {
- struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
- {
- struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndexedIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDispatch:
- {
- struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDispatch(cmdBuffer = %p, x = %i, y = %i, z = %i)", (void*)(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDispatchIndirect:
- {
- struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDispatchIndirect(cmdBuffer = %p, buffer = %p, offset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyBuffer:
- {
- struct_xglCmdCopyBuffer* pPacket = (struct_xglCmdCopyBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyBuffer(cmdBuffer = %p, srcBuffer = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyImage:
- {
- struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyImage(cmdBuffer = %p, srcImage = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyBufferToImage:
- {
- struct_xglCmdCopyBufferToImage* pPacket = (struct_xglCmdCopyBufferToImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyBufferToImage(cmdBuffer = %p, srcBuffer = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
- {
- struct_xglCmdCopyImageToBuffer* pPacket = (struct_xglCmdCopyImageToBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyImageToBuffer(cmdBuffer = %p, srcImage = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCloneImageData:
- {
- struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCloneImageData(cmdBuffer = %p, srcImage = %p, srcImageLayout = %p, destImage = %p, destImageLayout = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->srcImageLayout), (void*)(pPacket->destImage), (void*)(pPacket->destImageLayout));
- return str;
- }
- case GLV_TPI_XGL_xglCmdUpdateBuffer:
- {
- struct_xglCmdUpdateBuffer* pPacket = (struct_xglCmdUpdateBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdUpdateBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, dataSize = %p, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->dataSize), (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdFillBuffer:
- {
- struct_xglCmdFillBuffer* pPacket = (struct_xglCmdFillBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdFillBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, fillSize = %p, data = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->fillSize), pPacket->data);
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearColorImage:
- {
- struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearColorImage(cmdBuffer = %p, image = %p, color = [%f, %f, %f, %f], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearColorImageRaw:
- {
- struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearColorImageRaw(cmdBuffer = %p, image = %p, color = [%i, %i, %i, %i], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearDepthStencil:
- {
- struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearDepthStencil(cmdBuffer = %p, image = %p, depth = %f, stencil = %i, rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdResolveImage:
- {
- struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResolveImage(cmdBuffer = %p, srcImage = %p, destImage = %p, rectCount = %i, pRects = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->rectCount, (void*)(pPacket->pRects));
- return str;
- }
- case GLV_TPI_XGL_xglCmdSetEvent:
- {
- struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdSetEvent(cmdBuffer = %p, event = %p, pipeEvent = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event), (void*)(pPacket->pipeEvent));
- return str;
- }
- case GLV_TPI_XGL_xglCmdResetEvent:
- {
- struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResetEvent(cmdBuffer = %p, event = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglCmdWaitEvents:
- {
- struct_xglCmdWaitEvents* pPacket = (struct_xglCmdWaitEvents*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdWaitEvents(cmdBuffer = %p, pWaitInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pWaitInfo));
- return str;
- }
- case GLV_TPI_XGL_xglCmdPipelineBarrier:
- {
- struct_xglCmdPipelineBarrier* pPacket = (struct_xglCmdPipelineBarrier*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdPipelineBarrier(cmdBuffer = %p, pBarrier = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBarrier));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBeginQuery:
- {
- struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBeginQuery(cmdBuffer = %p, queryPool = %p, slot = %i, flags = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot, pPacket->flags);
- return str;
- }
- case GLV_TPI_XGL_xglCmdEndQuery:
- {
- struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdEndQuery(cmdBuffer = %p, queryPool = %p, slot = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot);
- return str;
- }
- case GLV_TPI_XGL_xglCmdResetQueryPool:
- {
- struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResetQueryPool(cmdBuffer = %p, queryPool = %p, startQuery = %i, queryCount = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdWriteTimestamp:
- {
- struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %s, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), string_XGL_TIMESTAMP_TYPE(pPacket->timestampType), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdInitAtomicCounters:
- {
- struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdInitAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
- {
- struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdLoadAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, srcBuffer = %p, srcOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->srcBuffer), (void*)(pPacket->srcOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
- {
- struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdSaveAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCreateFramebuffer:
- {
- struct_xglCreateFramebuffer* pPacket = (struct_xglCreateFramebuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateFramebuffer(device = %p, pCreateInfo = %p, pFramebuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFramebuffer);
- return str;
- }
- case GLV_TPI_XGL_xglCreateRenderPass:
- {
- struct_xglCreateRenderPass* pPacket = (struct_xglCreateRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateRenderPass(device = %p, pCreateInfo = %p, pRenderPass = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pRenderPass);
- return str;
- }
- case GLV_TPI_XGL_xglCmdBeginRenderPass:
- {
- struct_xglCmdBeginRenderPass* pPacket = (struct_xglCmdBeginRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBeginRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
- return str;
- }
- case GLV_TPI_XGL_xglCmdEndRenderPass:
- {
- struct_xglCmdEndRenderPass* pPacket = (struct_xglCmdEndRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdEndRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetValidationLevel:
- {
- struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetValidationLevel(device = %p, validationLevel = %p)", (void*)(pPacket->device), (void*)(pPacket->validationLevel));
- return str;
- }
- case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
- {
- struct_xglDbgRegisterMsgCallback* pPacket = (struct_xglDbgRegisterMsgCallback*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p)", (void*)(pPacket->pfnMsgCallback), (void*)(pPacket->pUserData));
- return str;
- }
- case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
- {
- struct_xglDbgUnregisterMsgCallback* pPacket = (struct_xglDbgUnregisterMsgCallback*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgUnregisterMsgCallback(pfnMsgCallback = %p)", (void*)(pPacket->pfnMsgCallback));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetMessageFilter:
- {
- struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p)", (void*)(pPacket->device), pPacket->msgCode, (void*)(pPacket->filter));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetObjectTag:
- {
- struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetObjectTag(object = %p, tagSize = %zu, pTag = %p)", (void*)(pPacket->object), pPacket->tagSize, (void*)(pPacket->pTag));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetGlobalOption:
- {
- struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetGlobalOption(dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetDeviceOption:
- {
- struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
- {
- struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDbgMarkerBegin(cmdBuffer = %p, pMarker = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pMarker));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
- {
- struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDbgMarkerEnd(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11AssociateConnection:
- {
- struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pConnectionInfo));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11GetMSC:
- {
- struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11GetMSC(device = %p, window = %i, crtc = %u, *pMsc = %lu)", (void*)(pPacket->device), pPacket->window, pPacket->crtc, (pPacket->pMsc == NULL) ? 0 : *(pPacket->pMsc));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
- {
- struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)(pPacket->pImage), (void*)pPacket->pMem);
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11QueuePresent:
- {
- struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p)", (void*)(pPacket->queue), (void*)(pPacket->pPresentInfo), (void*)(pPacket->fence));
- return str;
- }
- default:
- return NULL;
- }
-};
-
-static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)
-{
- if (pHeader == NULL)
- {
- return NULL;
- }
- switch (pHeader->packet_id)
- {
- case GLV_TPI_XGL_xglApiVersion:
- {
- return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;
- }
- case GLV_TPI_XGL_xglCreateInstance:
- {
- return interpret_body_as_xglCreateInstance(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyInstance:
- {
- return interpret_body_as_xglDestroyInstance(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEnumerateGpus:
- {
- return interpret_body_as_xglEnumerateGpus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetGpuInfo:
- {
- return interpret_body_as_xglGetGpuInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetProcAddr:
- {
- return interpret_body_as_xglGetProcAddr(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDevice:
- {
- return interpret_body_as_xglCreateDevice(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyDevice:
- {
- return interpret_body_as_xglDestroyDevice(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetExtensionSupport:
- {
- return interpret_body_as_xglGetExtensionSupport(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEnumerateLayers:
- {
- return interpret_body_as_xglEnumerateLayers(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetDeviceQueue:
- {
- return interpret_body_as_xglGetDeviceQueue(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueSubmit:
- {
- return interpret_body_as_xglQueueSubmit(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
- {
- return interpret_body_as_xglQueueSetGlobalMemReferences(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueWaitIdle:
- {
- return interpret_body_as_xglQueueWaitIdle(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDeviceWaitIdle:
- {
- return interpret_body_as_xglDeviceWaitIdle(pHeader)->header;
- }
- case GLV_TPI_XGL_xglAllocMemory:
- {
- return interpret_body_as_xglAllocMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglFreeMemory:
- {
- return interpret_body_as_xglFreeMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetMemoryPriority:
- {
- return interpret_body_as_xglSetMemoryPriority(pHeader)->header;
- }
- case GLV_TPI_XGL_xglMapMemory:
- {
- return interpret_body_as_xglMapMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglUnmapMemory:
- {
- return interpret_body_as_xglUnmapMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglPinSystemMemory:
- {
- return interpret_body_as_xglPinSystemMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
- {
- return interpret_body_as_xglGetMultiGpuCompatibility(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenSharedMemory:
- {
- return interpret_body_as_xglOpenSharedMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
- {
- return interpret_body_as_xglOpenSharedQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenPeerMemory:
- {
- return interpret_body_as_xglOpenPeerMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenPeerImage:
- {
- return interpret_body_as_xglOpenPeerImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyObject:
- {
- return interpret_body_as_xglDestroyObject(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetObjectInfo:
- {
- return interpret_body_as_xglGetObjectInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindObjectMemory:
- {
- return interpret_body_as_xglBindObjectMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindObjectMemoryRange:
- {
- return interpret_body_as_xglBindObjectMemoryRange(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindImageMemoryRange:
- {
- return interpret_body_as_xglBindImageMemoryRange(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateFence:
- {
- return interpret_body_as_xglCreateFence(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetFenceStatus:
- {
- return interpret_body_as_xglGetFenceStatus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglWaitForFences:
- {
- return interpret_body_as_xglWaitForFences(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateQueueSemaphore:
- {
- return interpret_body_as_xglCreateQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSignalQueueSemaphore:
- {
- return interpret_body_as_xglSignalQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglWaitQueueSemaphore:
- {
- return interpret_body_as_xglWaitQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateEvent:
- {
- return interpret_body_as_xglCreateEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetEventStatus:
- {
- return interpret_body_as_xglGetEventStatus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetEvent:
- {
- return interpret_body_as_xglSetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglResetEvent:
- {
- return interpret_body_as_xglResetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateQueryPool:
- {
- return interpret_body_as_xglCreateQueryPool(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetQueryPoolResults:
- {
- return interpret_body_as_xglGetQueryPoolResults(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetFormatInfo:
- {
- return interpret_body_as_xglGetFormatInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateBuffer:
- {
- return interpret_body_as_xglCreateBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateBufferView:
- {
- return interpret_body_as_xglCreateBufferView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateImage:
- {
- return interpret_body_as_xglCreateImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetFastClearColor:
- {
- return interpret_body_as_xglSetFastClearColor(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetFastClearDepth:
- {
- return interpret_body_as_xglSetFastClearDepth(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetImageSubresourceInfo:
- {
- return interpret_body_as_xglGetImageSubresourceInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateImageView:
- {
- return interpret_body_as_xglCreateImageView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateColorAttachmentView:
- {
- return interpret_body_as_xglCreateColorAttachmentView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDepthStencilView:
- {
- return interpret_body_as_xglCreateDepthStencilView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateShader:
- {
- return interpret_body_as_xglCreateShader(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateGraphicsPipeline:
- {
- return interpret_body_as_xglCreateGraphicsPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateComputePipeline:
- {
- return interpret_body_as_xglCreateComputePipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglStorePipeline:
- {
- return interpret_body_as_xglStorePipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglLoadPipeline:
- {
- return interpret_body_as_xglLoadPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreatePipelineDelta:
- {
- return interpret_body_as_xglCreatePipelineDelta(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateSampler:
- {
- return interpret_body_as_xglCreateSampler(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
- {
- return interpret_body_as_xglCreateDescriptorSetLayout(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
- {
- return interpret_body_as_xglBeginDescriptorRegionUpdate(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
- {
- return interpret_body_as_xglEndDescriptorRegionUpdate(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDescriptorRegion:
- {
- return interpret_body_as_xglCreateDescriptorRegion(pHeader)->header;
- }
- case GLV_TPI_XGL_xglClearDescriptorRegion:
- {
- return interpret_body_as_xglClearDescriptorRegion(pHeader)->header;
- }
- case GLV_TPI_XGL_xglAllocDescriptorSets:
- {
- return interpret_body_as_xglAllocDescriptorSets(pHeader)->header;
- }
- case GLV_TPI_XGL_xglClearDescriptorSets:
- {
- return interpret_body_as_xglClearDescriptorSets(pHeader)->header;
- }
- case GLV_TPI_XGL_xglUpdateDescriptors:
- {
- return interpret_body_as_xglUpdateDescriptors(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicViewportState:
- {
- return interpret_body_as_xglCreateDynamicViewportState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicRasterState:
- {
- return interpret_body_as_xglCreateDynamicRasterState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
- {
- return interpret_body_as_xglCreateDynamicColorBlendState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
- {
- return interpret_body_as_xglCreateDynamicDepthStencilState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateCommandBuffer:
- {
- return interpret_body_as_xglCreateCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBeginCommandBuffer:
- {
- return interpret_body_as_xglBeginCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEndCommandBuffer:
- {
- return interpret_body_as_xglEndCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglResetCommandBuffer:
- {
- return interpret_body_as_xglResetCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindPipeline:
- {
- return interpret_body_as_xglCmdBindPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindPipelineDelta:
- {
- return interpret_body_as_xglCmdBindPipelineDelta(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
- {
- return interpret_body_as_xglCmdBindDynamicStateObject(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindDescriptorSet:
- {
- return interpret_body_as_xglCmdBindDescriptorSet(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindVertexBuffer:
- {
- return interpret_body_as_xglCmdBindVertexBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindIndexBuffer:
- {
- return interpret_body_as_xglCmdBindIndexBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDraw:
- {
- return interpret_body_as_xglCmdDraw(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexed:
- {
- return interpret_body_as_xglCmdDrawIndexed(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndirect:
- {
- return interpret_body_as_xglCmdDrawIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
- {
- return interpret_body_as_xglCmdDrawIndexedIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDispatch:
- {
- return interpret_body_as_xglCmdDispatch(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDispatchIndirect:
- {
- return interpret_body_as_xglCmdDispatchIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyBuffer:
- {
- return interpret_body_as_xglCmdCopyBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyImage:
- {
- return interpret_body_as_xglCmdCopyImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyBufferToImage:
- {
- return interpret_body_as_xglCmdCopyBufferToImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
- {
- return interpret_body_as_xglCmdCopyImageToBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCloneImageData:
- {
- return interpret_body_as_xglCmdCloneImageData(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdUpdateBuffer:
- {
- return interpret_body_as_xglCmdUpdateBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdFillBuffer:
- {
- return interpret_body_as_xglCmdFillBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearColorImage:
- {
- return interpret_body_as_xglCmdClearColorImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearColorImageRaw:
- {
- return interpret_body_as_xglCmdClearColorImageRaw(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearDepthStencil:
- {
- return interpret_body_as_xglCmdClearDepthStencil(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResolveImage:
- {
- return interpret_body_as_xglCmdResolveImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdSetEvent:
- {
- return interpret_body_as_xglCmdSetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResetEvent:
- {
- return interpret_body_as_xglCmdResetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdWaitEvents:
- {
- return interpret_body_as_xglCmdWaitEvents(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdPipelineBarrier:
- {
- return interpret_body_as_xglCmdPipelineBarrier(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBeginQuery:
- {
- return interpret_body_as_xglCmdBeginQuery(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdEndQuery:
- {
- return interpret_body_as_xglCmdEndQuery(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResetQueryPool:
- {
- return interpret_body_as_xglCmdResetQueryPool(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdWriteTimestamp:
- {
- return interpret_body_as_xglCmdWriteTimestamp(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdInitAtomicCounters:
- {
- return interpret_body_as_xglCmdInitAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
- {
- return interpret_body_as_xglCmdLoadAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
- {
- return interpret_body_as_xglCmdSaveAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateFramebuffer:
- {
- return interpret_body_as_xglCreateFramebuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateRenderPass:
- {
- return interpret_body_as_xglCreateRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBeginRenderPass:
- {
- return interpret_body_as_xglCmdBeginRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdEndRenderPass:
- {
- return interpret_body_as_xglCmdEndRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDbgSetValidationLevel:
- {
- return interpret_body_as_xglDbgSetValidationLevel(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
- {
- return interpret_body_as_xglDbgRegisterMsgCallback(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
- {
- return interpret_body_as_xglDbgUnregisterMsgCallback(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetMessageFilter:
- {
- return interpret_body_as_xglDbgSetMessageFilter(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetObjectTag:
- {
- return interpret_body_as_xglDbgSetObjectTag(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetGlobalOption:
- {
- return interpret_body_as_xglDbgSetGlobalOption(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetDeviceOption:
- {
- return interpret_body_as_xglDbgSetDeviceOption(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
- {
- return interpret_body_as_xglCmdDbgMarkerBegin(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
- {
- return interpret_body_as_xglCmdDbgMarkerEnd(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11AssociateConnection:
- {
- return interpret_body_as_xglWsiX11AssociateConnection(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11GetMSC:
- {
- return interpret_body_as_xglWsiX11GetMSC(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
- {
- return interpret_body_as_xglWsiX11CreatePresentableImage(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11QueuePresent:
- {
- return interpret_body_as_xglWsiX11QueuePresent(pHeader)->pHeader;
- }
- default:
- return NULL;
- }
- return NULL;
-}
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
index 0c581ef..d68bb20 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_string_helper.h
@@ -3,70 +3,16 @@
#include <xgl.h>
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
- }
-}
-
-
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
- switch ((XGL_BLEND_FUNC)input_value)
- {
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
- default:
- return "Unhandled XGL_BLEND_FUNC";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return "XGL_MEMORY_REF_READ_ONLY_BIT";
- default:
- return "Unhandled XGL_MEMORY_REF_FLAGS";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
@@ -89,180 +35,40 @@
}
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- return "XGL_MEMORY_OUTPUT_COPY_BIT";
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
default:
- return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ return "Unhandled XGL_PIPELINE_BIND_POINT";
}
}
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
}
}
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_STATE_BIND_POINT)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_STATE_BIND_COLOR_BLEND:
- return "XGL_STATE_BIND_COLOR_BLEND";
- case XGL_STATE_BIND_DEPTH_STENCIL:
- return "XGL_STATE_BIND_DEPTH_STENCIL";
- case XGL_STATE_BIND_RASTER:
- return "XGL_STATE_BIND_RASTER";
- case XGL_STATE_BIND_VIEWPORT:
- return "XGL_STATE_BIND_VIEWPORT";
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
default:
- return "Unhandled XGL_STATE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
- switch ((XGL_LOGIC_OP)input_value)
- {
- case XGL_LOGIC_OP_AND:
- return "XGL_LOGIC_OP_AND";
- case XGL_LOGIC_OP_AND_INVERTED:
- return "XGL_LOGIC_OP_AND_INVERTED";
- case XGL_LOGIC_OP_AND_REVERSE:
- return "XGL_LOGIC_OP_AND_REVERSE";
- case XGL_LOGIC_OP_CLEAR:
- return "XGL_LOGIC_OP_CLEAR";
- case XGL_LOGIC_OP_COPY:
- return "XGL_LOGIC_OP_COPY";
- case XGL_LOGIC_OP_COPY_INVERTED:
- return "XGL_LOGIC_OP_COPY_INVERTED";
- case XGL_LOGIC_OP_EQUIV:
- return "XGL_LOGIC_OP_EQUIV";
- case XGL_LOGIC_OP_INVERT:
- return "XGL_LOGIC_OP_INVERT";
- case XGL_LOGIC_OP_NAND:
- return "XGL_LOGIC_OP_NAND";
- case XGL_LOGIC_OP_NOOP:
- return "XGL_LOGIC_OP_NOOP";
- case XGL_LOGIC_OP_NOR:
- return "XGL_LOGIC_OP_NOR";
- case XGL_LOGIC_OP_OR:
- return "XGL_LOGIC_OP_OR";
- case XGL_LOGIC_OP_OR_INVERTED:
- return "XGL_LOGIC_OP_OR_INVERTED";
- case XGL_LOGIC_OP_OR_REVERSE:
- return "XGL_LOGIC_OP_OR_REVERSE";
- case XGL_LOGIC_OP_SET:
- return "XGL_LOGIC_OP_SET";
- case XGL_LOGIC_OP_XOR:
- return "XGL_LOGIC_OP_XOR";
- default:
- return "Unhandled XGL_LOGIC_OP";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
- default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
- switch ((XGL_MEMORY_TYPE)input_value)
- {
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
- default:
- return "Unhandled XGL_MEMORY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
- default:
- return "Unhandled XGL_MEMORY_PRIORITY";
+ return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
}
}
@@ -283,16 +89,16 @@
}
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ case XGL_QUERY_OCCLUSION:
+ return "XGL_QUERY_OCCLUSION";
+ case XGL_QUERY_PIPELINE_STATISTICS:
+ return "XGL_QUERY_PIPELINE_STATISTICS";
default:
- return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+ return "Unhandled XGL_QUERY_TYPE";
}
}
@@ -313,52 +119,30 @@
}
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
default:
- return "Unhandled XGL_QUEUE_TYPE";
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- return "XGL_SYSTEM_ALLOC_API_OBJECT";
- case XGL_SYSTEM_ALLOC_DEBUG:
- return "XGL_SYSTEM_ALLOC_DEBUG";
- case XGL_SYSTEM_ALLOC_INTERNAL:
- return "XGL_SYSTEM_ALLOC_INTERNAL";
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
default:
- return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
- switch ((XGL_DEPTH_MODE)input_value)
- {
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
- default:
- return "Unhandled XGL_DEPTH_MODE";
+ return "Unhandled XGL_TIMESTAMP_TYPE";
}
}
@@ -377,176 +161,100 @@
}
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
- case XGL_IMAGE_USAGE_GENERAL:
- return "XGL_IMAGE_USAGE_GENERAL";
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- return "XGL_IMAGE_USAGE_IMAGE_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- return "XGL_IMAGE_USAGE_TEXTURE_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
default:
- return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+ return "Unhandled XGL_IMAGE_ASPECT";
}
}
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- return "XGL_GPU_TYPE_DISCRETE";
- case XGL_GPU_TYPE_INTEGRATED:
- return "XGL_GPU_TYPE_INTEGRATED";
- case XGL_GPU_TYPE_OTHER:
- return "XGL_GPU_TYPE_OTHER";
- case XGL_GPU_TYPE_VIRTUAL:
- return "XGL_GPU_TYPE_VIRTUAL";
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
default:
- return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
}
}
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- return "XGL_STENCIL_OP_DEC_CLAMP";
- case XGL_STENCIL_OP_DEC_WRAP:
- return "XGL_STENCIL_OP_DEC_WRAP";
- case XGL_STENCIL_OP_INC_CLAMP:
- return "XGL_STENCIL_OP_INC_CLAMP";
- case XGL_STENCIL_OP_INC_WRAP:
- return "XGL_STENCIL_OP_INC_WRAP";
- case XGL_STENCIL_OP_INVERT:
- return "XGL_STENCIL_OP_INVERT";
- case XGL_STENCIL_OP_KEEP:
- return "XGL_STENCIL_OP_KEEP";
- case XGL_STENCIL_OP_REPLACE:
- return "XGL_STENCIL_OP_REPLACE";
- case XGL_STENCIL_OP_ZERO:
- return "XGL_STENCIL_OP_ZERO";
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
default:
- return "Unhandled XGL_STENCIL_OP";
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
}
}
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ case XGL_BUFFER_USAGE_GENERAL:
+ return "XGL_BUFFER_USAGE_GENERAL";
+ case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
+ case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
+ case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
+ case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
+ case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+ return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
+ case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
- default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
- default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
- default:
- return "Unhandled XGL_OBJECT_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
- default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
+ return "Unhandled XGL_BUFFER_USAGE_FLAGS";
}
}
@@ -671,158 +379,20 @@
}
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- return "XGL_PROVOKING_VERTEX_FIRST";
- case XGL_PROVOKING_VERTEX_LAST:
- return "XGL_PROVOKING_VERTEX_LAST";
- default:
- return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
- switch ((XGL_TEX_FILTER)input_value)
- {
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
- default:
- return "Unhandled XGL_TEX_FILTER";
- }
-}
-
-
-static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
-{
- switch ((XGL_BLEND)input_value)
- {
- case XGL_BLEND_CONSTANT_ALPHA:
- return "XGL_BLEND_CONSTANT_ALPHA";
- case XGL_BLEND_CONSTANT_COLOR:
- return "XGL_BLEND_CONSTANT_COLOR";
- case XGL_BLEND_DEST_ALPHA:
- return "XGL_BLEND_DEST_ALPHA";
- case XGL_BLEND_DEST_COLOR:
- return "XGL_BLEND_DEST_COLOR";
- case XGL_BLEND_ONE:
- return "XGL_BLEND_ONE";
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
- case XGL_BLEND_SRC1_ALPHA:
- return "XGL_BLEND_SRC1_ALPHA";
- case XGL_BLEND_SRC1_COLOR:
- return "XGL_BLEND_SRC1_COLOR";
- case XGL_BLEND_SRC_ALPHA:
- return "XGL_BLEND_SRC_ALPHA";
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- return "XGL_BLEND_SRC_ALPHA_SATURATE";
- case XGL_BLEND_SRC_COLOR:
- return "XGL_BLEND_SRC_COLOR";
- case XGL_BLEND_ZERO:
- return "XGL_BLEND_ZERO";
- default:
- return "Unhandled XGL_BLEND";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
- default:
- return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
- default:
- return "Unhandled XGL_CULL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
- {
- case XGL_BUFFER_VIEW_RAW:
- return "XGL_BUFFER_VIEW_RAW";
- case XGL_BUFFER_VIEW_STRUCTURED:
- return "XGL_BUFFER_VIEW_STRUCTURED";
- case XGL_BUFFER_VIEW_TYPED:
- return "XGL_BUFFER_VIEW_TYPED";
- default:
- return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ return "Unhandled XGL_STATE_BIND_POINT";
}
}
@@ -917,194 +487,20 @@
}
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
- switch ((XGL_TEX_ADDRESS)input_value)
- {
- case XGL_TEX_ADDRESS_CLAMP:
- return "XGL_TEX_ADDRESS_CLAMP";
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- return "XGL_TEX_ADDRESS_CLAMP_BORDER";
- case XGL_TEX_ADDRESS_MIRROR:
- return "XGL_TEX_ADDRESS_MIRROR";
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- return "XGL_TEX_ADDRESS_MIRROR_ONCE";
- case XGL_TEX_ADDRESS_WRAP:
- return "XGL_TEX_ADDRESS_WRAP";
- default:
- return "Unhandled XGL_TEX_ADDRESS";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
- default:
- return "Unhandled XGL_QUEUE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- return "XGL_QUERY_OCCLUSION";
- case XGL_QUERY_PIPELINE_STATISTICS:
- return "XGL_QUERY_PIPELINE_STATISTICS";
- default:
- return "Unhandled XGL_QUERY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
- switch ((XGL_IMAGE_LAYOUT)input_value)
- {
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
- default:
- return "Unhandled XGL_IMAGE_LAYOUT";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
- default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
- default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
- {
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
- default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
- }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
- default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
- }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
- default:
- return "Unhandled XGL_VALIDATION_LEVEL";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
- default:
- return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
}
}
@@ -1123,84 +519,6 @@
}
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
- {
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return "XGL_BUFFER_CREATE_SPARSE_BIT";
- default:
- return "Unhandled XGL_BUFFER_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_TOP_OF_PIPE:
- return "XGL_SET_EVENT_TOP_OF_PIPE";
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- return "XGL_SET_EVENT_TRANSFER_COMPLETE";
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
- default:
- return "Unhandled XGL_SET_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
-{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
- {
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- return "XGL_PIPELINE_BIND_POINT_COMPUTE";
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
- default:
- return "Unhandled XGL_PIPELINE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
- switch ((XGL_COMPARE_FUNC)input_value)
- {
- case XGL_COMPARE_ALWAYS:
- return "XGL_COMPARE_ALWAYS";
- case XGL_COMPARE_EQUAL:
- return "XGL_COMPARE_EQUAL";
- case XGL_COMPARE_GREATER:
- return "XGL_COMPARE_GREATER";
- case XGL_COMPARE_GREATER_EQUAL:
- return "XGL_COMPARE_GREATER_EQUAL";
- case XGL_COMPARE_LESS:
- return "XGL_COMPARE_LESS";
- case XGL_COMPARE_LESS_EQUAL:
- return "XGL_COMPARE_LESS_EQUAL";
- case XGL_COMPARE_NEVER:
- return "XGL_COMPARE_NEVER";
- case XGL_COMPARE_NOT_EQUAL:
- return "XGL_COMPARE_NOT_EQUAL";
- default:
- return "Unhandled XGL_COMPARE_FUNC";
- }
-}
-
-
static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
@@ -1247,18 +565,224 @@
}
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
default:
- return "Unhandled XGL_FILL_MODE";
+ return "Unhandled XGL_TEX_ADDRESS";
+ }
+}
+
+
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ default:
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ default:
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
+ default:
+ return "Unhandled XGL_STENCIL_OP";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ return "XGL_BUFFER_VIEW_RAW";
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ return "XGL_BUFFER_VIEW_STRUCTURED";
+ case XGL_BUFFER_VIEW_TYPED:
+ return "XGL_BUFFER_VIEW_TYPED";
+ default:
+ return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
+ default:
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
+ default:
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+{
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ {
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
+ case XGL_FORMAT_CONVERSION_BIT:
+ return "XGL_FORMAT_CONVERSION_BIT";
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ return "XGL_FORMAT_IMAGE_COPY_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
+ default:
+ return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ default:
+ return "Unhandled XGL_COORDINATE_ORIGIN";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
+ default:
+ return "Unhandled XGL_MEMORY_PRIORITY";
}
}
@@ -1287,6 +811,534 @@
}
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
+{
+ switch ((XGL_BLEND)input_value)
+ {
+ case XGL_BLEND_CONSTANT_ALPHA:
+ return "XGL_BLEND_CONSTANT_ALPHA";
+ case XGL_BLEND_CONSTANT_COLOR:
+ return "XGL_BLEND_CONSTANT_COLOR";
+ case XGL_BLEND_DEST_ALPHA:
+ return "XGL_BLEND_DEST_ALPHA";
+ case XGL_BLEND_DEST_COLOR:
+ return "XGL_BLEND_DEST_COLOR";
+ case XGL_BLEND_ONE:
+ return "XGL_BLEND_ONE";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
+ case XGL_BLEND_SRC1_ALPHA:
+ return "XGL_BLEND_SRC1_ALPHA";
+ case XGL_BLEND_SRC1_COLOR:
+ return "XGL_BLEND_SRC1_COLOR";
+ case XGL_BLEND_SRC_ALPHA:
+ return "XGL_BLEND_SRC_ALPHA";
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ return "XGL_BLEND_SRC_ALPHA_SATURATE";
+ case XGL_BLEND_SRC_COLOR:
+ return "XGL_BLEND_SRC_COLOR";
+ case XGL_BLEND_ZERO:
+ return "XGL_BLEND_ZERO";
+ default:
+ return "Unhandled XGL_BLEND";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return "XGL_BUFFER_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+ default:
+ return "Unhandled XGL_FACE_ORIENTATION";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+ default:
+ return "Unhandled XGL_IMAGE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+ switch ((XGL_MEMORY_TYPE)input_value)
+ {
+ case XGL_MEMORY_TYPE_BUFFER:
+ return "XGL_MEMORY_TYPE_BUFFER";
+ case XGL_MEMORY_TYPE_IMAGE:
+ return "XGL_MEMORY_TYPE_IMAGE";
+ case XGL_MEMORY_TYPE_OTHER:
+ return "XGL_MEMORY_TYPE_OTHER";
+ default:
+ return "Unhandled XGL_MEMORY_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ {
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+ default:
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
+ default:
+ return "Unhandled XGL_BLEND_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
+ default:
+ return "Unhandled XGL_FILL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ default:
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+ default:
+ return "Unhandled XGL_QUEUE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE";
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_FILTER";
+ }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ return "XGL_SET_EVENT_TOP_OF_PIPE";
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
+ default:
+ return "Unhandled XGL_SET_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
+ default:
+ return "Unhandled XGL_COMPARE_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ default:
+ return "Unhandled XGL_IMAGE_LAYOUT";
+ }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ {
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ return "XGL_SHADER_STAGE_FLAGS_ALL";
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ default:
+ return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ {
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
+ default:
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+ }
+}
+
+
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ {
+ case XGL_CHANNEL_SWIZZLE_A:
+ return "XGL_CHANNEL_SWIZZLE_A";
+ case XGL_CHANNEL_SWIZZLE_B:
+ return "XGL_CHANNEL_SWIZZLE_B";
+ case XGL_CHANNEL_SWIZZLE_G:
+ return "XGL_CHANNEL_SWIZZLE_G";
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ return "XGL_CHANNEL_SWIZZLE_ONE";
+ case XGL_CHANNEL_SWIZZLE_R:
+ return "XGL_CHANNEL_SWIZZLE_R";
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return "XGL_CHANNEL_SWIZZLE_ZERO";
+ default:
+ return "Unhandled XGL_CHANNEL_SWIZZLE";
+ }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
+ default:
+ return "Unhandled XGL_INDEX_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ {
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ default:
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ }
+}
+
+
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+ default:
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+ default:
+ return "Unhandled XGL_CULL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ default:
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ default:
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
+ }
+}
+
+
static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
{
switch ((XGL_FORMAT)input_value)
@@ -1631,160 +1683,172 @@
}
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_FACE_ORIENTATION)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
default:
- return "Unhandled XGL_FACE_ORIENTATION";
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
}
}
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_QUEUE_FLAGS";
}
}
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ return "Unhandled XGL_LOGIC_OP";
}
}
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- return "XGL_CHANNEL_SWIZZLE_A";
- case XGL_CHANNEL_SWIZZLE_B:
- return "XGL_CHANNEL_SWIZZLE_B";
- case XGL_CHANNEL_SWIZZLE_G:
- return "XGL_CHANNEL_SWIZZLE_G";
- case XGL_CHANNEL_SWIZZLE_ONE:
- return "XGL_CHANNEL_SWIZZLE_ONE";
- case XGL_CHANNEL_SWIZZLE_R:
- return "XGL_CHANNEL_SWIZZLE_R";
- case XGL_CHANNEL_SWIZZLE_ZERO:
- return "XGL_CHANNEL_SWIZZLE_ZERO";
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
default:
- return "Unhandled XGL_CHANNEL_SWIZZLE";
+ return "Unhandled XGL_VALIDATION_LEVEL";
}
}
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- return "XGL_SHADER_STAGE_FLAGS_ALL";
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
default:
- return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
default:
- return "Unhandled XGL_IMAGE_ASPECT";
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
}
}
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_BUFFER_USAGE_GENERAL:
- return "XGL_BUFFER_USAGE_GENERAL";
- case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
- case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
- case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
- case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
- case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
- return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
- case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
default:
- return "Unhandled XGL_BUFFER_USAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
- default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
}
}
@@ -1816,67 +1880,3 @@
}
}
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- return "XGL_INDEX_16";
- case XGL_INDEX_32:
- return "XGL_INDEX_32";
- case XGL_INDEX_8:
- return "XGL_INDEX_8";
- default:
- return "Unhandled XGL_INDEX_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
- {
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
- default:
- return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
-{
- switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
- {
- case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
- return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
- case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
- return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
- case XGL_FORMAT_CONVERSION_BIT:
- return "XGL_FORMAT_CONVERSION_BIT";
- case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
- return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
- case XGL_FORMAT_IMAGE_COPY_BIT:
- return "XGL_FORMAT_IMAGE_COPY_BIT";
- case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
- return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
- case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
- return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
- case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
- return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
- case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
- return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
- case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
- return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
- default:
- return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
- }
-}
-
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
index b45590b..e80a1d1 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,51 +3,12 @@
#include <xgl.h>
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_TOPOLOGY_LINE_LIST:
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- case XGL_TOPOLOGY_LINE_STRIP:
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- case XGL_TOPOLOGY_PATCH:
- case XGL_TOPOLOGY_POINT_LIST:
- case XGL_TOPOLOGY_QUAD_LIST:
- case XGL_TOPOLOGY_QUAD_STRIP:
- case XGL_TOPOLOGY_RECT_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
- switch ((XGL_BLEND_FUNC)input_value)
- {
- case XGL_BLEND_FUNC_ADD:
- case XGL_BLEND_FUNC_MAX:
- case XGL_BLEND_FUNC_MIN:
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- case XGL_BLEND_FUNC_SUBTRACT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
return 1;
default:
return 0;
@@ -70,15 +31,12 @@
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
return 1;
default:
return 0;
@@ -86,12 +44,11 @@
}
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
return 1;
default:
return 0;
@@ -99,107 +56,11 @@
}
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_STATE_BIND_POINT)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_STATE_BIND_COLOR_BLEND:
- case XGL_STATE_BIND_DEPTH_STENCIL:
- case XGL_STATE_BIND_RASTER:
- case XGL_STATE_BIND_VIEWPORT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
- switch ((XGL_LOGIC_OP)input_value)
- {
- case XGL_LOGIC_OP_AND:
- case XGL_LOGIC_OP_AND_INVERTED:
- case XGL_LOGIC_OP_AND_REVERSE:
- case XGL_LOGIC_OP_CLEAR:
- case XGL_LOGIC_OP_COPY:
- case XGL_LOGIC_OP_COPY_INVERTED:
- case XGL_LOGIC_OP_EQUIV:
- case XGL_LOGIC_OP_INVERT:
- case XGL_LOGIC_OP_NAND:
- case XGL_LOGIC_OP_NOOP:
- case XGL_LOGIC_OP_NOR:
- case XGL_LOGIC_OP_OR:
- case XGL_LOGIC_OP_OR_INVERTED:
- case XGL_LOGIC_OP_OR_REVERSE:
- case XGL_LOGIC_OP_SET:
- case XGL_LOGIC_OP_XOR:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
- switch ((XGL_MEMORY_TYPE)input_value)
- {
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
return 1;
default:
return 0;
@@ -221,12 +82,12 @@
}
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ case XGL_QUERY_OCCLUSION:
+ case XGL_QUERY_PIPELINE_STATISTICS:
return 1;
default:
return 0;
@@ -248,13 +109,12 @@
}
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- case XGL_QUEUE_TYPE_DMA:
- case XGL_QUEUE_TYPE_GRAPHICS:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
return 1;
default:
return 0;
@@ -262,28 +122,12 @@
}
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
- switch ((XGL_DEPTH_MODE)input_value)
- {
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
return 1;
default:
return 0;
@@ -304,20 +148,13 @@
}
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- case XGL_IMAGE_USAGE_GENERAL:
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
return 1;
default:
return 0;
@@ -325,14 +162,12 @@
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
return 1;
default:
return 0;
@@ -340,18 +175,11 @@
}
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
return 1;
default:
return 0;
@@ -359,13 +187,14 @@
}
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
return 1;
default:
return 0;
@@ -373,71 +202,24 @@
}
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
+ case XGL_BUFFER_USAGE_GENERAL:
+ case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+ case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+ case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+ case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+ case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
return 1;
default:
return 0;
@@ -511,125 +293,14 @@
}
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- case XGL_PROVOKING_VERTEX_LAST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
- switch ((XGL_TEX_FILTER)input_value)
- {
- case XGL_TEX_FILTER_LINEAR:
- case XGL_TEX_FILTER_NEAREST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
-{
- switch ((XGL_BLEND)input_value)
- {
- case XGL_BLEND_CONSTANT_ALPHA:
- case XGL_BLEND_CONSTANT_COLOR:
- case XGL_BLEND_DEST_ALPHA:
- case XGL_BLEND_DEST_COLOR:
- case XGL_BLEND_ONE:
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- case XGL_BLEND_SRC1_ALPHA:
- case XGL_BLEND_SRC1_COLOR:
- case XGL_BLEND_SRC_ALPHA:
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- case XGL_BLEND_SRC_COLOR:
- case XGL_BLEND_ZERO:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
- {
- case XGL_BUFFER_VIEW_RAW:
- case XGL_BUFFER_VIEW_STRUCTURED:
- case XGL_BUFFER_VIEW_TYPED:
+ case XGL_STATE_BIND_COLOR_BLEND:
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ case XGL_STATE_BIND_RASTER:
+ case XGL_STATE_BIND_VIEWPORT:
return 1;
default:
return 0;
@@ -688,161 +359,14 @@
}
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
- switch ((XGL_TEX_ADDRESS)input_value)
- {
- case XGL_TEX_ADDRESS_CLAMP:
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- case XGL_TEX_ADDRESS_MIRROR:
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- case XGL_TEX_ADDRESS_WRAP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- case XGL_QUERY_PIPELINE_STATISTICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
- switch ((XGL_IMAGE_LAYOUT)input_value)
- {
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
-{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
- {
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
return 1;
default:
return 0;
@@ -863,69 +387,6 @@
}
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
- {
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
-{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
- {
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
- switch ((XGL_COMPARE_FUNC)input_value)
- {
- case XGL_COMPARE_ALWAYS:
- case XGL_COMPARE_EQUAL:
- case XGL_COMPARE_GREATER:
- case XGL_COMPARE_GREATER_EQUAL:
- case XGL_COMPARE_LESS:
- case XGL_COMPARE_LESS_EQUAL:
- case XGL_COMPARE_NEVER:
- case XGL_COMPARE_NOT_EQUAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
@@ -955,13 +416,176 @@
}
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
+ case XGL_TEX_ADDRESS_CLAMP:
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ case XGL_TEX_ADDRESS_MIRROR:
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ case XGL_TEX_ADDRESS_WRAP:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+ case XGL_TOPOLOGY_LINE_LIST:
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ case XGL_TOPOLOGY_LINE_STRIP:
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ case XGL_TOPOLOGY_PATCH:
+ case XGL_TOPOLOGY_POINT_LIST:
+ case XGL_TOPOLOGY_QUAD_LIST:
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ case XGL_TOPOLOGY_RECT_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ case XGL_BUFFER_VIEW_TYPED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ case XGL_PROVOKING_VERTEX_LAST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+{
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ {
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ case XGL_FORMAT_CONVERSION_BIT:
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ case XGL_MEMORY_PRIORITY_LOW:
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
return 1;
default:
return 0;
@@ -987,6 +611,432 @@
}
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+{
+ switch ((XGL_BLEND)input_value)
+ {
+ case XGL_BLEND_CONSTANT_ALPHA:
+ case XGL_BLEND_CONSTANT_COLOR:
+ case XGL_BLEND_DEST_ALPHA:
+ case XGL_BLEND_DEST_COLOR:
+ case XGL_BLEND_ONE:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ case XGL_BLEND_SRC1_ALPHA:
+ case XGL_BLEND_SRC1_COLOR:
+ case XGL_BLEND_SRC_ALPHA:
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ case XGL_BLEND_SRC_COLOR:
+ case XGL_BLEND_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ case XGL_FRONT_FACE_CW:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ case XGL_IMAGE_2D:
+ case XGL_IMAGE_3D:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+ switch ((XGL_MEMORY_TYPE)input_value)
+ {
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ {
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+ case XGL_BLEND_FUNC_ADD:
+ case XGL_BLEND_FUNC_MAX:
+ case XGL_BLEND_FUNC_MIN:
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ case XGL_COMPARE_EQUAL:
+ case XGL_COMPARE_GREATER:
+ case XGL_COMPARE_GREATER_EQUAL:
+ case XGL_COMPARE_LESS:
+ case XGL_COMPARE_LESS_EQUAL:
+ case XGL_COMPARE_NEVER:
+ case XGL_COMPARE_NOT_EQUAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ {
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+{
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ {
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+{
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ {
+ case XGL_CHANNEL_SWIZZLE_A:
+ case XGL_CHANNEL_SWIZZLE_B:
+ case XGL_CHANNEL_SWIZZLE_G:
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ case XGL_CHANNEL_SWIZZLE_R:
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ {
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
{
switch ((XGL_FORMAT)input_value)
@@ -1165,12 +1215,13 @@
}
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_FACE_ORIENTATION)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_FRONT_FACE_CCW:
- case XGL_FRONT_FACE_CW:
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
return 1;
default:
return 0;
@@ -1178,13 +1229,14 @@
}
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_IMAGE_1D:
- case XGL_IMAGE_2D:
- case XGL_IMAGE_3D:
+ case XGL_QUEUE_COMPUTE_BIT:
+ case XGL_QUEUE_DMA_BIT:
+ case XGL_QUEUE_EXTENDED_BIT:
+ case XGL_QUEUE_GRAPHICS_BIT:
return 1;
default:
return 0;
@@ -1192,13 +1244,26 @@
}
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
return 1;
default:
return 0;
@@ -1206,16 +1271,15 @@
}
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- case XGL_CHANNEL_SWIZZLE_B:
- case XGL_CHANNEL_SWIZZLE_G:
- case XGL_CHANNEL_SWIZZLE_ONE:
- case XGL_CHANNEL_SWIZZLE_R:
- case XGL_CHANNEL_SWIZZLE_ZERO:
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
return 1;
default:
return 0;
@@ -1223,17 +1287,20 @@
}
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ case XGL_IMAGE_USAGE_GENERAL:
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
return 1;
default:
return 0;
@@ -1241,13 +1308,15 @@
}
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
return 1;
default:
return 0;
@@ -1255,36 +1324,17 @@
}
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_BUFFER_USAGE_GENERAL:
- case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
- case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
- case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
- case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
- case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
- case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
- case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
- case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
return 1;
default:
return 0;
@@ -1311,53 +1361,3 @@
}
}
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- case XGL_INDEX_32:
- case XGL_INDEX_8:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
- {
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
-{
- switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
- {
- case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
- case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
- case XGL_FORMAT_CONVERSION_BIT:
- case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
- case XGL_FORMAT_IMAGE_COPY_BIT:
- case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
- case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
- case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
- case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
- case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
index c05acdd..c3c1cdb 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/glvreplay_xgl.cpp
@@ -27,7 +27,7 @@
extern "C"
{
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
}
ApiReplay* g_pReplayer = NULL;
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
index 5de203d..7cc11d7 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
@@ -11,26 +11,26 @@
add_custom_command(OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl.c
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_packet_id.h
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgl_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_packet_id.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vk_structs.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext.c
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xglwsix11ext_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkwsix11ext_structs.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg.c
- ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glvtrace_xgl_xgldbg_structs.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/codegen/glv_vk_vkdbg_structs.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_struct_size_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/codegen/xgl_enum_string_helper.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-h > glvtrace_xgl_xgl.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-trace-c > glvtrace_xgl_xgl.c
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glvtrace_xgl_packet_id.h
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glvtrace_xgl_xgl_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-packet-id > glv_vk_packet_id.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-core-structs > glv_vk_vk_structs.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-h > glvtrace_xgl_xglwsix11ext.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-c > glvtrace_xgl_xglwsix11ext.c
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glvtrace_xgl_xglwsix11ext_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-wsi-trace-structs > glv_vk_vkwsix11ext_structs.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-h > glvtrace_xgl_xgldbg.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-c > glvtrace_xgl_xgldbg.c
- COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glvtrace_xgl_xgldbg_structs.h
+ COMMAND ${PYTHON_CMD} ${SRC_DIR}/../scripts/vk_generate.py glave-dbg-trace-structs > glv_vk_vkdbg_structs.h
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_struct_wrappers ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
COMMAND ${PYTHON_CMD} ${SRC_DIR}/../../../xgl_helper.py --gen_enum_string_helper ${SRC_DIR}/../../../include/xgl.h --abs_out_dir ${CMAKE_CURRENT_SOURCE_DIR}/codegen
DEPENDS ${SRC_DIR}/../../../xgl_helper.py
@@ -48,13 +48,13 @@
set_source_files_properties( ${SRC_LIST} PROPERTIES LANGUAGE C)
set (HDR_LIST
- codegen/glvtrace_xgl_packet_id.h
+ codegen/glv_vk_packet_id.h
codegen/glvtrace_xgl_xgl.h
- codegen/glvtrace_xgl_xgl_structs.h
+ codegen/glv_vk_vk_structs.h
codegen/glvtrace_xgl_xgldbg.h
- codegen/glvtrace_xgl_xgldbg_structs.h
+ codegen/glv_vk_vkdbg_structs.h
codegen/glvtrace_xgl_xglwsix11ext.h
- codegen/glvtrace_xgl_xglwsix11ext_structs.h
+ codegen/glv_vk_vkwsix11ext_structs.h
codegen/xgl_struct_size_helper.h
codegen/xgl_enum_string_helper.h
)
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
similarity index 99%
copy from tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
copy to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
index d1dded3..d774f98 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/codegen/glvtrace_xgl_packet_id.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_packet_id.h
@@ -29,9 +29,9 @@
#include "glv_trace_packet_utils.h"
#include "glv_trace_packet_identifiers.h"
#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_vkwsix11ext_structs.h"
#include "xgl_enum_string_helper.h"
#if defined(WIN32)
#define snprintf _snprintf
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vk_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkdbg_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h
similarity index 100%
rename from tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext_structs.h
rename to tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glv_vk_vkwsix11ext_structs.h
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h
deleted file mode 100644
index d1dded3..0000000
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_packet_id.h
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* THIS FILE IS GENERATED. DO NOT EDIT. */
-
-/*
- * XGL
- *
- * Copyright (C) 2014 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- */
-
-#pragma once
-
-#include "glv_trace_packet_utils.h"
-#include "glv_trace_packet_identifiers.h"
-#include "glv_interconnect.h"
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "xgl_enum_string_helper.h"
-#if defined(WIN32)
-#define snprintf _snprintf
-#endif
-#define SEND_ENTRYPOINT_ID(entrypoint) ;
-//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\n");
-
-#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;
-//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);
-
-#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \
- pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);
-
-#define FINISH_TRACE_PACKET() \
- glv_finalize_trace_packet(pHeader); \
- glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \
- glv_delete_trace_packet(&pHeader);
-
-enum GLV_TRACE_PACKET_ID_XGL
-{
- GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,
- GLV_TPI_XGL_xglCreateInstance,
- GLV_TPI_XGL_xglDestroyInstance,
- GLV_TPI_XGL_xglEnumerateGpus,
- GLV_TPI_XGL_xglGetGpuInfo,
- GLV_TPI_XGL_xglGetProcAddr,
- GLV_TPI_XGL_xglCreateDevice,
- GLV_TPI_XGL_xglDestroyDevice,
- GLV_TPI_XGL_xglGetExtensionSupport,
- GLV_TPI_XGL_xglEnumerateLayers,
- GLV_TPI_XGL_xglGetDeviceQueue,
- GLV_TPI_XGL_xglQueueSubmit,
- GLV_TPI_XGL_xglQueueSetGlobalMemReferences,
- GLV_TPI_XGL_xglQueueWaitIdle,
- GLV_TPI_XGL_xglDeviceWaitIdle,
- GLV_TPI_XGL_xglAllocMemory,
- GLV_TPI_XGL_xglFreeMemory,
- GLV_TPI_XGL_xglSetMemoryPriority,
- GLV_TPI_XGL_xglMapMemory,
- GLV_TPI_XGL_xglUnmapMemory,
- GLV_TPI_XGL_xglPinSystemMemory,
- GLV_TPI_XGL_xglGetMultiGpuCompatibility,
- GLV_TPI_XGL_xglOpenSharedMemory,
- GLV_TPI_XGL_xglOpenSharedQueueSemaphore,
- GLV_TPI_XGL_xglOpenPeerMemory,
- GLV_TPI_XGL_xglOpenPeerImage,
- GLV_TPI_XGL_xglDestroyObject,
- GLV_TPI_XGL_xglGetObjectInfo,
- GLV_TPI_XGL_xglBindObjectMemory,
- GLV_TPI_XGL_xglBindObjectMemoryRange,
- GLV_TPI_XGL_xglBindImageMemoryRange,
- GLV_TPI_XGL_xglCreateFence,
- GLV_TPI_XGL_xglGetFenceStatus,
- GLV_TPI_XGL_xglWaitForFences,
- GLV_TPI_XGL_xglCreateQueueSemaphore,
- GLV_TPI_XGL_xglSignalQueueSemaphore,
- GLV_TPI_XGL_xglWaitQueueSemaphore,
- GLV_TPI_XGL_xglCreateEvent,
- GLV_TPI_XGL_xglGetEventStatus,
- GLV_TPI_XGL_xglSetEvent,
- GLV_TPI_XGL_xglResetEvent,
- GLV_TPI_XGL_xglCreateQueryPool,
- GLV_TPI_XGL_xglGetQueryPoolResults,
- GLV_TPI_XGL_xglGetFormatInfo,
- GLV_TPI_XGL_xglCreateBuffer,
- GLV_TPI_XGL_xglCreateBufferView,
- GLV_TPI_XGL_xglCreateImage,
- GLV_TPI_XGL_xglSetFastClearColor,
- GLV_TPI_XGL_xglSetFastClearDepth,
- GLV_TPI_XGL_xglGetImageSubresourceInfo,
- GLV_TPI_XGL_xglCreateImageView,
- GLV_TPI_XGL_xglCreateColorAttachmentView,
- GLV_TPI_XGL_xglCreateDepthStencilView,
- GLV_TPI_XGL_xglCreateShader,
- GLV_TPI_XGL_xglCreateGraphicsPipeline,
- GLV_TPI_XGL_xglCreateComputePipeline,
- GLV_TPI_XGL_xglStorePipeline,
- GLV_TPI_XGL_xglLoadPipeline,
- GLV_TPI_XGL_xglCreatePipelineDelta,
- GLV_TPI_XGL_xglCreateSampler,
- GLV_TPI_XGL_xglCreateDescriptorSetLayout,
- GLV_TPI_XGL_xglBeginDescriptorRegionUpdate,
- GLV_TPI_XGL_xglEndDescriptorRegionUpdate,
- GLV_TPI_XGL_xglCreateDescriptorRegion,
- GLV_TPI_XGL_xglClearDescriptorRegion,
- GLV_TPI_XGL_xglAllocDescriptorSets,
- GLV_TPI_XGL_xglClearDescriptorSets,
- GLV_TPI_XGL_xglUpdateDescriptors,
- GLV_TPI_XGL_xglCreateDynamicViewportState,
- GLV_TPI_XGL_xglCreateDynamicRasterState,
- GLV_TPI_XGL_xglCreateDynamicColorBlendState,
- GLV_TPI_XGL_xglCreateDynamicDepthStencilState,
- GLV_TPI_XGL_xglCreateCommandBuffer,
- GLV_TPI_XGL_xglBeginCommandBuffer,
- GLV_TPI_XGL_xglEndCommandBuffer,
- GLV_TPI_XGL_xglResetCommandBuffer,
- GLV_TPI_XGL_xglCmdBindPipeline,
- GLV_TPI_XGL_xglCmdBindPipelineDelta,
- GLV_TPI_XGL_xglCmdBindDynamicStateObject,
- GLV_TPI_XGL_xglCmdBindDescriptorSet,
- GLV_TPI_XGL_xglCmdBindVertexBuffer,
- GLV_TPI_XGL_xglCmdBindIndexBuffer,
- GLV_TPI_XGL_xglCmdDraw,
- GLV_TPI_XGL_xglCmdDrawIndexed,
- GLV_TPI_XGL_xglCmdDrawIndirect,
- GLV_TPI_XGL_xglCmdDrawIndexedIndirect,
- GLV_TPI_XGL_xglCmdDispatch,
- GLV_TPI_XGL_xglCmdDispatchIndirect,
- GLV_TPI_XGL_xglCmdCopyBuffer,
- GLV_TPI_XGL_xglCmdCopyImage,
- GLV_TPI_XGL_xglCmdCopyBufferToImage,
- GLV_TPI_XGL_xglCmdCopyImageToBuffer,
- GLV_TPI_XGL_xglCmdCloneImageData,
- GLV_TPI_XGL_xglCmdUpdateBuffer,
- GLV_TPI_XGL_xglCmdFillBuffer,
- GLV_TPI_XGL_xglCmdClearColorImage,
- GLV_TPI_XGL_xglCmdClearColorImageRaw,
- GLV_TPI_XGL_xglCmdClearDepthStencil,
- GLV_TPI_XGL_xglCmdResolveImage,
- GLV_TPI_XGL_xglCmdSetEvent,
- GLV_TPI_XGL_xglCmdResetEvent,
- GLV_TPI_XGL_xglCmdWaitEvents,
- GLV_TPI_XGL_xglCmdPipelineBarrier,
- GLV_TPI_XGL_xglCmdBeginQuery,
- GLV_TPI_XGL_xglCmdEndQuery,
- GLV_TPI_XGL_xglCmdResetQueryPool,
- GLV_TPI_XGL_xglCmdWriteTimestamp,
- GLV_TPI_XGL_xglCmdInitAtomicCounters,
- GLV_TPI_XGL_xglCmdLoadAtomicCounters,
- GLV_TPI_XGL_xglCmdSaveAtomicCounters,
- GLV_TPI_XGL_xglCreateFramebuffer,
- GLV_TPI_XGL_xglCreateRenderPass,
- GLV_TPI_XGL_xglCmdBeginRenderPass,
- GLV_TPI_XGL_xglCmdEndRenderPass,
- GLV_TPI_XGL_xglDbgSetValidationLevel,
- GLV_TPI_XGL_xglDbgRegisterMsgCallback,
- GLV_TPI_XGL_xglDbgUnregisterMsgCallback,
- GLV_TPI_XGL_xglDbgSetMessageFilter,
- GLV_TPI_XGL_xglDbgSetObjectTag,
- GLV_TPI_XGL_xglDbgSetGlobalOption,
- GLV_TPI_XGL_xglDbgSetDeviceOption,
- GLV_TPI_XGL_xglCmdDbgMarkerBegin,
- GLV_TPI_XGL_xglCmdDbgMarkerEnd,
- GLV_TPI_XGL_xglWsiX11AssociateConnection,
- GLV_TPI_XGL_xglWsiX11GetMSC,
- GLV_TPI_XGL_xglWsiX11CreatePresentableImage,
- GLV_TPI_XGL_xglWsiX11QueuePresent,
-};
-
-static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)
-{
- static char str[1024];
- switch(id) {
- case GLV_TPI_XGL_xglApiVersion:
- {
- struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);
- snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);
- return str;
- }
- case GLV_TPI_XGL_xglCreateInstance:
- {
- struct_xglCreateInstance* pPacket = (struct_xglCreateInstance*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateInstance(pAppInfo = %p, pAllocCb = %p, pInstance = %p)", (void*)(pPacket->pAppInfo), (void*)(pPacket->pAllocCb), (void*)pPacket->pInstance);
- return str;
- }
- case GLV_TPI_XGL_xglDestroyInstance:
- {
- struct_xglDestroyInstance* pPacket = (struct_xglDestroyInstance*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyInstance(instance = %p)", (void*)(pPacket->instance));
- return str;
- }
- case GLV_TPI_XGL_xglEnumerateGpus:
- {
- struct_xglEnumerateGpus* pPacket = (struct_xglEnumerateGpus*)(pHeader->pBody);
- snprintf(str, 1024, "xglEnumerateGpus(instance = %p, maxGpus = %i, *pGpuCount = %i, pGpus = %p)", (void*)(pPacket->instance), pPacket->maxGpus, (pPacket->pGpuCount == NULL) ? 0 : *(pPacket->pGpuCount), (void*)(pPacket->pGpus));
- return str;
- }
- case GLV_TPI_XGL_xglGetGpuInfo:
- {
- struct_xglGetGpuInfo* pPacket = (struct_xglGetGpuInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetGpuInfo(gpu = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->gpu), string_XGL_PHYSICAL_GPU_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglGetProcAddr:
- {
- struct_xglGetProcAddr* pPacket = (struct_xglGetProcAddr*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetProcAddr(gpu = %p, pName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pName));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDevice:
- {
- struct_xglCreateDevice* pPacket = (struct_xglCreateDevice*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDevice(gpu = %p, pCreateInfo = %p, pDevice = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pCreateInfo), (void*)pPacket->pDevice);
- return str;
- }
- case GLV_TPI_XGL_xglDestroyDevice:
- {
- struct_xglDestroyDevice* pPacket = (struct_xglDestroyDevice*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyDevice(device = %p)", (void*)(pPacket->device));
- return str;
- }
- case GLV_TPI_XGL_xglGetExtensionSupport:
- {
- struct_xglGetExtensionSupport* pPacket = (struct_xglGetExtensionSupport*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetExtensionSupport(gpu = %p, pExtName = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pExtName));
- return str;
- }
- case GLV_TPI_XGL_xglEnumerateLayers:
- {
- struct_xglEnumerateLayers* pPacket = (struct_xglEnumerateLayers*)(pHeader->pBody);
- snprintf(str, 1024, "xglEnumerateLayers(gpu = %p, maxLayerCount = %zu, maxStringSize = %zu, *pOutLayerCount = %zu, pOutLayers = %p, pReserved = %p)", (void*)(pPacket->gpu), pPacket->maxLayerCount, pPacket->maxStringSize, (pPacket->pOutLayerCount == NULL) ? 0 : *(pPacket->pOutLayerCount), (void*)(pPacket->pOutLayers), (void*)(pPacket->pReserved));
- return str;
- }
- case GLV_TPI_XGL_xglGetDeviceQueue:
- {
- struct_xglGetDeviceQueue* pPacket = (struct_xglGetDeviceQueue*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetDeviceQueue(device = %p, queueType = %s, queueIndex = %i, pQueue = %p)", (void*)(pPacket->device), string_XGL_QUEUE_TYPE(pPacket->queueType), pPacket->queueIndex, (void*)(pPacket->pQueue));
- return str;
- }
- case GLV_TPI_XGL_xglQueueSubmit:
- {
- struct_xglQueueSubmit* pPacket = (struct_xglQueueSubmit*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueSubmit(queue = %p, cmdBufferCount = %i, pCmdBuffers = %p, memRefCount = %i, pMemRefs = %p, fence = %p)", (void*)(pPacket->queue), pPacket->cmdBufferCount, (void*)(pPacket->pCmdBuffers), pPacket->memRefCount, (void*)(pPacket->pMemRefs), (void*)(pPacket->fence));
- return str;
- }
- case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
- {
- struct_xglQueueSetGlobalMemReferences* pPacket = (struct_xglQueueSetGlobalMemReferences*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueSetGlobalMemReferences(queue = %p, memRefCount = %i, pMemRefs = %p)", (void*)(pPacket->queue), pPacket->memRefCount, (void*)(pPacket->pMemRefs));
- return str;
- }
- case GLV_TPI_XGL_xglQueueWaitIdle:
- {
- struct_xglQueueWaitIdle* pPacket = (struct_xglQueueWaitIdle*)(pHeader->pBody);
- snprintf(str, 1024, "xglQueueWaitIdle(queue = %p)", (void*)(pPacket->queue));
- return str;
- }
- case GLV_TPI_XGL_xglDeviceWaitIdle:
- {
- struct_xglDeviceWaitIdle* pPacket = (struct_xglDeviceWaitIdle*)(pHeader->pBody);
- snprintf(str, 1024, "xglDeviceWaitIdle(device = %p)", (void*)(pPacket->device));
- return str;
- }
- case GLV_TPI_XGL_xglAllocMemory:
- {
- struct_xglAllocMemory* pPacket = (struct_xglAllocMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglAllocMemory(device = %p, pAllocInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pAllocInfo), (void*)pPacket->pMem);
- return str;
- }
- case GLV_TPI_XGL_xglFreeMemory:
- {
- struct_xglFreeMemory* pPacket = (struct_xglFreeMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglFreeMemory(mem = %p)", (void*)(pPacket->mem));
- return str;
- }
- case GLV_TPI_XGL_xglSetMemoryPriority:
- {
- struct_xglSetMemoryPriority* pPacket = (struct_xglSetMemoryPriority*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetMemoryPriority(mem = %p, priority = %p)", (void*)(pPacket->mem), (void*)(pPacket->priority));
- return str;
- }
- case GLV_TPI_XGL_xglMapMemory:
- {
- struct_xglMapMemory* pPacket = (struct_xglMapMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglMapMemory(mem = %p, flags = %i, ppData = %p)", (void*)(pPacket->mem), pPacket->flags, (void*)pPacket->ppData);
- return str;
- }
- case GLV_TPI_XGL_xglUnmapMemory:
- {
- struct_xglUnmapMemory* pPacket = (struct_xglUnmapMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglUnmapMemory(mem = %p)", (void*)(pPacket->mem));
- return str;
- }
- case GLV_TPI_XGL_xglPinSystemMemory:
- {
- struct_xglPinSystemMemory* pPacket = (struct_xglPinSystemMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglPinSystemMemory(device = %p, pSysMem = %p, memSize = %zu, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pSysMem), pPacket->memSize, (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
- {
- struct_xglGetMultiGpuCompatibility* pPacket = (struct_xglGetMultiGpuCompatibility*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetMultiGpuCompatibility(gpu0 = %p, gpu1 = %p, pInfo = %p)", (void*)(pPacket->gpu0), (void*)(pPacket->gpu1), (void*)(pPacket->pInfo));
- return str;
- }
- case GLV_TPI_XGL_xglOpenSharedMemory:
- {
- struct_xglOpenSharedMemory* pPacket = (struct_xglOpenSharedMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenSharedMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
- {
- struct_xglOpenSharedQueueSemaphore* pPacket = (struct_xglOpenSharedQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenSharedQueueSemaphore(device = %p, pOpenInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pSemaphore));
- return str;
- }
- case GLV_TPI_XGL_xglOpenPeerMemory:
- {
- struct_xglOpenPeerMemory* pPacket = (struct_xglOpenPeerMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenPeerMemory(device = %p, pOpenInfo = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglOpenPeerImage:
- {
- struct_xglOpenPeerImage* pPacket = (struct_xglOpenPeerImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglOpenPeerImage(device = %p, pOpenInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pOpenInfo), (void*)(pPacket->pImage), (void*)(pPacket->pMem));
- return str;
- }
- case GLV_TPI_XGL_xglDestroyObject:
- {
- struct_xglDestroyObject* pPacket = (struct_xglDestroyObject*)(pHeader->pBody);
- snprintf(str, 1024, "xglDestroyObject(object = %p)", (void*)(pPacket->object));
- return str;
- }
- case GLV_TPI_XGL_xglGetObjectInfo:
- {
- struct_xglGetObjectInfo* pPacket = (struct_xglGetObjectInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetObjectInfo(object = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->object), string_XGL_OBJECT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglBindObjectMemory:
- {
- struct_xglBindObjectMemory* pPacket = (struct_xglBindObjectMemory*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindObjectMemory(object = %p, allocationIdx = %i, mem = %p, offset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->mem), (void*)(pPacket->offset));
- return str;
- }
- case GLV_TPI_XGL_xglBindObjectMemoryRange:
- {
- struct_xglBindObjectMemoryRange* pPacket = (struct_xglBindObjectMemoryRange*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindObjectMemoryRange(object = %p, allocationIdx = %i, rangeOffset = %p, rangeSize = %p, mem = %p, memOffset = %p)", (void*)(pPacket->object), pPacket->allocationIdx, (void*)(pPacket->rangeOffset), (void*)(pPacket->rangeSize), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
- return str;
- }
- case GLV_TPI_XGL_xglBindImageMemoryRange:
- {
- struct_xglBindImageMemoryRange* pPacket = (struct_xglBindImageMemoryRange*)(pHeader->pBody);
- snprintf(str, 1024, "xglBindImageMemoryRange(image = %p, allocationIdx = %i, bindInfo = %p, mem = %p, memOffset = %p)", (void*)(pPacket->image), pPacket->allocationIdx, (void*)(pPacket->bindInfo), (void*)(pPacket->mem), (void*)(pPacket->memOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCreateFence:
- {
- struct_xglCreateFence* pPacket = (struct_xglCreateFence*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateFence(device = %p, pCreateInfo = %p, pFence = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFence);
- return str;
- }
- case GLV_TPI_XGL_xglGetFenceStatus:
- {
- struct_xglGetFenceStatus* pPacket = (struct_xglGetFenceStatus*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetFenceStatus(fence = %p)", (void*)(pPacket->fence));
- return str;
- }
- case GLV_TPI_XGL_xglWaitForFences:
- {
- struct_xglWaitForFences* pPacket = (struct_xglWaitForFences*)(pHeader->pBody);
- snprintf(str, 1024, "xglWaitForFences(device = %p, fenceCount = %i, pFences = %p, waitAll = %u, timeout = %lu)", (void*)(pPacket->device), pPacket->fenceCount, (void*)(pPacket->pFences), pPacket->waitAll, pPacket->timeout);
- return str;
- }
- case GLV_TPI_XGL_xglCreateQueueSemaphore:
- {
- struct_xglCreateQueueSemaphore* pPacket = (struct_xglCreateQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateQueueSemaphore(device = %p, pCreateInfo = %p, pSemaphore = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSemaphore);
- return str;
- }
- case GLV_TPI_XGL_xglSignalQueueSemaphore:
- {
- struct_xglSignalQueueSemaphore* pPacket = (struct_xglSignalQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglSignalQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
- return str;
- }
- case GLV_TPI_XGL_xglWaitQueueSemaphore:
- {
- struct_xglWaitQueueSemaphore* pPacket = (struct_xglWaitQueueSemaphore*)(pHeader->pBody);
- snprintf(str, 1024, "xglWaitQueueSemaphore(queue = %p, semaphore = %p)", (void*)(pPacket->queue), (void*)(pPacket->semaphore));
- return str;
- }
- case GLV_TPI_XGL_xglCreateEvent:
- {
- struct_xglCreateEvent* pPacket = (struct_xglCreateEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateEvent(device = %p, pCreateInfo = %p, pEvent = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pEvent);
- return str;
- }
- case GLV_TPI_XGL_xglGetEventStatus:
- {
- struct_xglGetEventStatus* pPacket = (struct_xglGetEventStatus*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetEventStatus(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglSetEvent:
- {
- struct_xglSetEvent* pPacket = (struct_xglSetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetEvent(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglResetEvent:
- {
- struct_xglResetEvent* pPacket = (struct_xglResetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglResetEvent(event = %p)", (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglCreateQueryPool:
- {
- struct_xglCreateQueryPool* pPacket = (struct_xglCreateQueryPool*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateQueryPool(device = %p, pCreateInfo = %p, pQueryPool = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pQueryPool);
- return str;
- }
- case GLV_TPI_XGL_xglGetQueryPoolResults:
- {
- struct_xglGetQueryPoolResults* pPacket = (struct_xglGetQueryPoolResults*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetQueryPoolResults(queryPool = %p, startQuery = %i, queryCount = %i, *pDataSize = %zu, pData = %p)", (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount, (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglGetFormatInfo:
- {
- struct_xglGetFormatInfo* pPacket = (struct_xglGetFormatInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetFormatInfo(device = %p, format = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->format), string_XGL_FORMAT_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCreateBuffer:
- {
- struct_xglCreateBuffer* pPacket = (struct_xglCreateBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateBuffer(device = %p, pCreateInfo = %p, pBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pBuffer);
- return str;
- }
- case GLV_TPI_XGL_xglCreateBufferView:
- {
- struct_xglCreateBufferView* pPacket = (struct_xglCreateBufferView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateBufferView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateImage:
- {
- struct_xglCreateImage* pPacket = (struct_xglCreateImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateImage(device = %p, pCreateInfo = %p, pImage = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pImage);
- return str;
- }
- case GLV_TPI_XGL_xglSetFastClearColor:
- {
- struct_xglSetFastClearColor* pPacket = (struct_xglSetFastClearColor*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetFastClearColor(image = %p, color = [%f, %f, %f, %f])", (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3]);
- return str;
- }
- case GLV_TPI_XGL_xglSetFastClearDepth:
- {
- struct_xglSetFastClearDepth* pPacket = (struct_xglSetFastClearDepth*)(pHeader->pBody);
- snprintf(str, 1024, "xglSetFastClearDepth(image = %p, depth = %f)", (void*)(pPacket->image), pPacket->depth);
- return str;
- }
- case GLV_TPI_XGL_xglGetImageSubresourceInfo:
- {
- struct_xglGetImageSubresourceInfo* pPacket = (struct_xglGetImageSubresourceInfo*)(pHeader->pBody);
- snprintf(str, 1024, "xglGetImageSubresourceInfo(image = %p, pSubresource = %p, infoType = %s, *pDataSize = %zu, pData = %p)", (void*)(pPacket->image), (void*)(pPacket->pSubresource), string_XGL_SUBRESOURCE_INFO_TYPE(pPacket->infoType), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCreateImageView:
- {
- struct_xglCreateImageView* pPacket = (struct_xglCreateImageView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateImageView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateColorAttachmentView:
- {
- struct_xglCreateColorAttachmentView* pPacket = (struct_xglCreateColorAttachmentView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateColorAttachmentView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDepthStencilView:
- {
- struct_xglCreateDepthStencilView* pPacket = (struct_xglCreateDepthStencilView*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDepthStencilView(device = %p, pCreateInfo = %p, pView = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pView);
- return str;
- }
- case GLV_TPI_XGL_xglCreateShader:
- {
- struct_xglCreateShader* pPacket = (struct_xglCreateShader*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateShader(device = %p, pCreateInfo = %p, pShader = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pShader);
- return str;
- }
- case GLV_TPI_XGL_xglCreateGraphicsPipeline:
- {
- struct_xglCreateGraphicsPipeline* pPacket = (struct_xglCreateGraphicsPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateGraphicsPipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
- return str;
- }
- case GLV_TPI_XGL_xglCreateComputePipeline:
- {
- struct_xglCreateComputePipeline* pPacket = (struct_xglCreateComputePipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateComputePipeline(device = %p, pCreateInfo = %p, pPipeline = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pPipeline);
- return str;
- }
- case GLV_TPI_XGL_xglStorePipeline:
- {
- struct_xglStorePipeline* pPacket = (struct_xglStorePipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglStorePipeline(pipeline = %p, *pDataSize = %zu, pData = %p)", (void*)(pPacket->pipeline), (pPacket->pDataSize == NULL) ? 0 : *(pPacket->pDataSize), (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglLoadPipeline:
- {
- struct_xglLoadPipeline* pPacket = (struct_xglLoadPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglLoadPipeline(device = %p, dataSize = %zu, pData = %p, pPipeline = %p)", (void*)(pPacket->device), pPacket->dataSize, (void*)(pPacket->pData), (void*)(pPacket->pPipeline));
- return str;
- }
- case GLV_TPI_XGL_xglCreatePipelineDelta:
- {
- struct_xglCreatePipelineDelta* pPacket = (struct_xglCreatePipelineDelta*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreatePipelineDelta(device = %p, p1 = %p, p2 = %p, delta = %p)", (void*)(pPacket->device), (void*)(pPacket->p1), (void*)(pPacket->p2), (void*)pPacket->delta);
- return str;
- }
- case GLV_TPI_XGL_xglCreateSampler:
- {
- struct_xglCreateSampler* pPacket = (struct_xglCreateSampler*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateSampler(device = %p, pCreateInfo = %p, pSampler = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pSampler);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
- {
- struct_xglCreateDescriptorSetLayout* pPacket = (struct_xglCreateDescriptorSetLayout*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDescriptorSetLayout(device = %p, stageFlags = %i, *pSetBindPoints = %i, priorSetLayout = %p, pSetLayoutInfoList = %p, pSetLayout = %p)", (void*)(pPacket->device), pPacket->stageFlags, (pPacket->pSetBindPoints == NULL) ? 0 : *(pPacket->pSetBindPoints), (void*)(pPacket->priorSetLayout), (void*)(pPacket->pSetLayoutInfoList), (void*)pPacket->pSetLayout);
- return str;
- }
- case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
- {
- struct_xglBeginDescriptorRegionUpdate* pPacket = (struct_xglBeginDescriptorRegionUpdate*)(pHeader->pBody);
- snprintf(str, 1024, "xglBeginDescriptorRegionUpdate(device = %p, updateMode = %p)", (void*)(pPacket->device), (void*)(pPacket->updateMode));
- return str;
- }
- case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
- {
- struct_xglEndDescriptorRegionUpdate* pPacket = (struct_xglEndDescriptorRegionUpdate*)(pHeader->pBody);
- snprintf(str, 1024, "xglEndDescriptorRegionUpdate(device = %p, cmd = %p)", (void*)(pPacket->device), (void*)(pPacket->cmd));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDescriptorRegion:
- {
- struct_xglCreateDescriptorRegion* pPacket = (struct_xglCreateDescriptorRegion*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDescriptorRegion(device = %p, regionUsage = %p, maxSets = %i, pCreateInfo = %p, pDescriptorRegion = %p)", (void*)(pPacket->device), (void*)(pPacket->regionUsage), pPacket->maxSets, (void*)(pPacket->pCreateInfo), (void*)pPacket->pDescriptorRegion);
- return str;
- }
- case GLV_TPI_XGL_xglClearDescriptorRegion:
- {
- struct_xglClearDescriptorRegion* pPacket = (struct_xglClearDescriptorRegion*)(pHeader->pBody);
- snprintf(str, 1024, "xglClearDescriptorRegion(descriptorRegion = %p)", (void*)(pPacket->descriptorRegion));
- return str;
- }
- case GLV_TPI_XGL_xglAllocDescriptorSets:
- {
- struct_xglAllocDescriptorSets* pPacket = (struct_xglAllocDescriptorSets*)(pHeader->pBody);
- snprintf(str, 1024, "xglAllocDescriptorSets(descriptorRegion = %p, setUsage = %p, count = %i, pSetLayouts = %p, pDescriptorSets = %p, *pCount = %i)", (void*)(pPacket->descriptorRegion), (void*)(pPacket->setUsage), pPacket->count, (void*)(pPacket->pSetLayouts), (void*)(pPacket->pDescriptorSets), (pPacket->pCount == NULL) ? 0 : *(pPacket->pCount));
- return str;
- }
- case GLV_TPI_XGL_xglClearDescriptorSets:
- {
- struct_xglClearDescriptorSets* pPacket = (struct_xglClearDescriptorSets*)(pHeader->pBody);
- snprintf(str, 1024, "xglClearDescriptorSets(descriptorRegion = %p, count = %i, pDescriptorSets = %p)", (void*)(pPacket->descriptorRegion), pPacket->count, (void*)(pPacket->pDescriptorSets));
- return str;
- }
- case GLV_TPI_XGL_xglUpdateDescriptors:
- {
- struct_xglUpdateDescriptors* pPacket = (struct_xglUpdateDescriptors*)(pHeader->pBody);
- snprintf(str, 1024, "xglUpdateDescriptors(descriptorSet = %p, pUpdateChain = %p)", (void*)(pPacket->descriptorSet), (void*)(pPacket->pUpdateChain));
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicViewportState:
- {
- struct_xglCreateDynamicViewportState* pPacket = (struct_xglCreateDynamicViewportState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicViewportState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicRasterState:
- {
- struct_xglCreateDynamicRasterState* pPacket = (struct_xglCreateDynamicRasterState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicRasterState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
- {
- struct_xglCreateDynamicColorBlendState* pPacket = (struct_xglCreateDynamicColorBlendState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicColorBlendState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
- {
- struct_xglCreateDynamicDepthStencilState* pPacket = (struct_xglCreateDynamicDepthStencilState*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateDynamicDepthStencilState(device = %p, pCreateInfo = %p, pState = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pState);
- return str;
- }
- case GLV_TPI_XGL_xglCreateCommandBuffer:
- {
- struct_xglCreateCommandBuffer* pPacket = (struct_xglCreateCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateCommandBuffer(device = %p, pCreateInfo = %p, pCmdBuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pCmdBuffer);
- return str;
- }
- case GLV_TPI_XGL_xglBeginCommandBuffer:
- {
- struct_xglBeginCommandBuffer* pPacket = (struct_xglBeginCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglBeginCommandBuffer(cmdBuffer = %p, pBeginInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBeginInfo));
- return str;
- }
- case GLV_TPI_XGL_xglEndCommandBuffer:
- {
- struct_xglEndCommandBuffer* pPacket = (struct_xglEndCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglEndCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglResetCommandBuffer:
- {
- struct_xglResetCommandBuffer* pPacket = (struct_xglResetCommandBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglResetCommandBuffer(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindPipeline:
- {
- struct_xglCmdBindPipeline* pPacket = (struct_xglCmdBindPipeline*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindPipeline(cmdBuffer = %p, pipelineBindPoint = %p, pipeline = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->pipeline));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindPipelineDelta:
- {
- struct_xglCmdBindPipelineDelta* pPacket = (struct_xglCmdBindPipelineDelta*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindPipelineDelta(cmdBuffer = %p, pipelineBindPoint = %p, delta = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->delta));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
- {
- struct_xglCmdBindDynamicStateObject* pPacket = (struct_xglCmdBindDynamicStateObject*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindDynamicStateObject(cmdBuffer = %p, stateBindPoint = %p, state = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->stateBindPoint), (void*)(pPacket->state));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindDescriptorSet:
- {
- struct_xglCmdBindDescriptorSet* pPacket = (struct_xglCmdBindDescriptorSet*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindDescriptorSet(cmdBuffer = %p, pipelineBindPoint = %p, descriptorSet = %p, *pUserData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), (void*)(pPacket->descriptorSet), (pPacket->pUserData == NULL) ? 0 : *(pPacket->pUserData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindVertexBuffer:
- {
- struct_xglCmdBindVertexBuffer* pPacket = (struct_xglCmdBindVertexBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindVertexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, binding = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->binding);
- return str;
- }
- case GLV_TPI_XGL_xglCmdBindIndexBuffer:
- {
- struct_xglCmdBindIndexBuffer* pPacket = (struct_xglCmdBindIndexBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBindIndexBuffer(cmdBuffer = %p, buffer = %p, offset = %p, indexType = %s)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), string_XGL_INDEX_TYPE(pPacket->indexType));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDraw:
- {
- struct_xglCmdDraw* pPacket = (struct_xglCmdDraw*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDraw(cmdBuffer = %p, firstVertex = %i, vertexCount = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstVertex, pPacket->vertexCount, pPacket->firstInstance, pPacket->instanceCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexed:
- {
- struct_xglCmdDrawIndexed* pPacket = (struct_xglCmdDrawIndexed*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndexed(cmdBuffer = %p, firstIndex = %i, indexCount = %i, vertexOffset = %i, firstInstance = %i, instanceCount = %i)", (void*)(pPacket->cmdBuffer), pPacket->firstIndex, pPacket->indexCount, pPacket->vertexOffset, pPacket->firstInstance, pPacket->instanceCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndirect:
- {
- struct_xglCmdDrawIndirect* pPacket = (struct_xglCmdDrawIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
- {
- struct_xglCmdDrawIndexedIndirect* pPacket = (struct_xglCmdDrawIndexedIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDrawIndexedIndirect(cmdBuffer = %p, buffer = %p, offset = %p, count = %i, stride = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset), pPacket->count, pPacket->stride);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDispatch:
- {
- struct_xglCmdDispatch* pPacket = (struct_xglCmdDispatch*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDispatch(cmdBuffer = %p, x = %i, y = %i, z = %i)", (void*)(pPacket->cmdBuffer), pPacket->x, pPacket->y, pPacket->z);
- return str;
- }
- case GLV_TPI_XGL_xglCmdDispatchIndirect:
- {
- struct_xglCmdDispatchIndirect* pPacket = (struct_xglCmdDispatchIndirect*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDispatchIndirect(cmdBuffer = %p, buffer = %p, offset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->buffer), (void*)(pPacket->offset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyBuffer:
- {
- struct_xglCmdCopyBuffer* pPacket = (struct_xglCmdCopyBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyBuffer(cmdBuffer = %p, srcBuffer = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyImage:
- {
- struct_xglCmdCopyImage* pPacket = (struct_xglCmdCopyImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyImage(cmdBuffer = %p, srcImage = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyBufferToImage:
- {
- struct_xglCmdCopyBufferToImage* pPacket = (struct_xglCmdCopyBufferToImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyBufferToImage(cmdBuffer = %p, srcBuffer = %p, destImage = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcBuffer), (void*)(pPacket->destImage), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
- {
- struct_xglCmdCopyImageToBuffer* pPacket = (struct_xglCmdCopyImageToBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCopyImageToBuffer(cmdBuffer = %p, srcImage = %p, destBuffer = %p, regionCount = %i, pRegions = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destBuffer), pPacket->regionCount, (void*)(pPacket->pRegions));
- return str;
- }
- case GLV_TPI_XGL_xglCmdCloneImageData:
- {
- struct_xglCmdCloneImageData* pPacket = (struct_xglCmdCloneImageData*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdCloneImageData(cmdBuffer = %p, srcImage = %p, srcImageLayout = %p, destImage = %p, destImageLayout = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->srcImageLayout), (void*)(pPacket->destImage), (void*)(pPacket->destImageLayout));
- return str;
- }
- case GLV_TPI_XGL_xglCmdUpdateBuffer:
- {
- struct_xglCmdUpdateBuffer* pPacket = (struct_xglCmdUpdateBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdUpdateBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, dataSize = %p, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->dataSize), (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdFillBuffer:
- {
- struct_xglCmdFillBuffer* pPacket = (struct_xglCmdFillBuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdFillBuffer(cmdBuffer = %p, destBuffer = %p, destOffset = %p, fillSize = %p, data = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset), (void*)(pPacket->fillSize), pPacket->data);
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearColorImage:
- {
- struct_xglCmdClearColorImage* pPacket = (struct_xglCmdClearColorImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearColorImage(cmdBuffer = %p, image = %p, color = [%f, %f, %f, %f], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearColorImageRaw:
- {
- struct_xglCmdClearColorImageRaw* pPacket = (struct_xglCmdClearColorImageRaw*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearColorImageRaw(cmdBuffer = %p, image = %p, color = [%i, %i, %i, %i], rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->color[0], pPacket->color[1], pPacket->color[2], pPacket->color[3], pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdClearDepthStencil:
- {
- struct_xglCmdClearDepthStencil* pPacket = (struct_xglCmdClearDepthStencil*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdClearDepthStencil(cmdBuffer = %p, image = %p, depth = %f, stencil = %i, rangeCount = %i, pRanges = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->image), pPacket->depth, pPacket->stencil, pPacket->rangeCount, (void*)(pPacket->pRanges));
- return str;
- }
- case GLV_TPI_XGL_xglCmdResolveImage:
- {
- struct_xglCmdResolveImage* pPacket = (struct_xglCmdResolveImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResolveImage(cmdBuffer = %p, srcImage = %p, destImage = %p, rectCount = %i, pRects = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->srcImage), (void*)(pPacket->destImage), pPacket->rectCount, (void*)(pPacket->pRects));
- return str;
- }
- case GLV_TPI_XGL_xglCmdSetEvent:
- {
- struct_xglCmdSetEvent* pPacket = (struct_xglCmdSetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdSetEvent(cmdBuffer = %p, event = %p, pipeEvent = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event), (void*)(pPacket->pipeEvent));
- return str;
- }
- case GLV_TPI_XGL_xglCmdResetEvent:
- {
- struct_xglCmdResetEvent* pPacket = (struct_xglCmdResetEvent*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResetEvent(cmdBuffer = %p, event = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->event));
- return str;
- }
- case GLV_TPI_XGL_xglCmdWaitEvents:
- {
- struct_xglCmdWaitEvents* pPacket = (struct_xglCmdWaitEvents*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdWaitEvents(cmdBuffer = %p, pWaitInfo = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pWaitInfo));
- return str;
- }
- case GLV_TPI_XGL_xglCmdPipelineBarrier:
- {
- struct_xglCmdPipelineBarrier* pPacket = (struct_xglCmdPipelineBarrier*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdPipelineBarrier(cmdBuffer = %p, pBarrier = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pBarrier));
- return str;
- }
- case GLV_TPI_XGL_xglCmdBeginQuery:
- {
- struct_xglCmdBeginQuery* pPacket = (struct_xglCmdBeginQuery*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBeginQuery(cmdBuffer = %p, queryPool = %p, slot = %i, flags = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot, pPacket->flags);
- return str;
- }
- case GLV_TPI_XGL_xglCmdEndQuery:
- {
- struct_xglCmdEndQuery* pPacket = (struct_xglCmdEndQuery*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdEndQuery(cmdBuffer = %p, queryPool = %p, slot = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->slot);
- return str;
- }
- case GLV_TPI_XGL_xglCmdResetQueryPool:
- {
- struct_xglCmdResetQueryPool* pPacket = (struct_xglCmdResetQueryPool*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdResetQueryPool(cmdBuffer = %p, queryPool = %p, startQuery = %i, queryCount = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->queryPool), pPacket->startQuery, pPacket->queryCount);
- return str;
- }
- case GLV_TPI_XGL_xglCmdWriteTimestamp:
- {
- struct_xglCmdWriteTimestamp* pPacket = (struct_xglCmdWriteTimestamp*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdWriteTimestamp(cmdBuffer = %p, timestampType = %s, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), string_XGL_TIMESTAMP_TYPE(pPacket->timestampType), (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdInitAtomicCounters:
- {
- struct_xglCmdInitAtomicCounters* pPacket = (struct_xglCmdInitAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdInitAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, *pData = %i)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (pPacket->pData == NULL) ? 0 : *(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
- {
- struct_xglCmdLoadAtomicCounters* pPacket = (struct_xglCmdLoadAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdLoadAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, srcBuffer = %p, srcOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->srcBuffer), (void*)(pPacket->srcOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
- {
- struct_xglCmdSaveAtomicCounters* pPacket = (struct_xglCmdSaveAtomicCounters*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdSaveAtomicCounters(cmdBuffer = %p, pipelineBindPoint = %p, startCounter = %i, counterCount = %i, destBuffer = %p, destOffset = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pipelineBindPoint), pPacket->startCounter, pPacket->counterCount, (void*)(pPacket->destBuffer), (void*)(pPacket->destOffset));
- return str;
- }
- case GLV_TPI_XGL_xglCreateFramebuffer:
- {
- struct_xglCreateFramebuffer* pPacket = (struct_xglCreateFramebuffer*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateFramebuffer(device = %p, pCreateInfo = %p, pFramebuffer = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pFramebuffer);
- return str;
- }
- case GLV_TPI_XGL_xglCreateRenderPass:
- {
- struct_xglCreateRenderPass* pPacket = (struct_xglCreateRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCreateRenderPass(device = %p, pCreateInfo = %p, pRenderPass = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)pPacket->pRenderPass);
- return str;
- }
- case GLV_TPI_XGL_xglCmdBeginRenderPass:
- {
- struct_xglCmdBeginRenderPass* pPacket = (struct_xglCmdBeginRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdBeginRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
- return str;
- }
- case GLV_TPI_XGL_xglCmdEndRenderPass:
- {
- struct_xglCmdEndRenderPass* pPacket = (struct_xglCmdEndRenderPass*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdEndRenderPass(cmdBuffer = %p, renderPass = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->renderPass));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetValidationLevel:
- {
- struct_xglDbgSetValidationLevel* pPacket = (struct_xglDbgSetValidationLevel*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetValidationLevel(device = %p, validationLevel = %p)", (void*)(pPacket->device), (void*)(pPacket->validationLevel));
- return str;
- }
- case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
- {
- struct_xglDbgRegisterMsgCallback* pPacket = (struct_xglDbgRegisterMsgCallback*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgRegisterMsgCallback(pfnMsgCallback = %p, pUserData = %p)", (void*)(pPacket->pfnMsgCallback), (void*)(pPacket->pUserData));
- return str;
- }
- case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
- {
- struct_xglDbgUnregisterMsgCallback* pPacket = (struct_xglDbgUnregisterMsgCallback*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgUnregisterMsgCallback(pfnMsgCallback = %p)", (void*)(pPacket->pfnMsgCallback));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetMessageFilter:
- {
- struct_xglDbgSetMessageFilter* pPacket = (struct_xglDbgSetMessageFilter*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetMessageFilter(device = %p, msgCode = %i, filter = %p)", (void*)(pPacket->device), pPacket->msgCode, (void*)(pPacket->filter));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetObjectTag:
- {
- struct_xglDbgSetObjectTag* pPacket = (struct_xglDbgSetObjectTag*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetObjectTag(object = %p, tagSize = %zu, pTag = %p)", (void*)(pPacket->object), pPacket->tagSize, (void*)(pPacket->pTag));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetGlobalOption:
- {
- struct_xglDbgSetGlobalOption* pPacket = (struct_xglDbgSetGlobalOption*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetGlobalOption(dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglDbgSetDeviceOption:
- {
- struct_xglDbgSetDeviceOption* pPacket = (struct_xglDbgSetDeviceOption*)(pHeader->pBody);
- snprintf(str, 1024, "xglDbgSetDeviceOption(device = %p, dbgOption = %p, dataSize = %zu, pData = %p)", (void*)(pPacket->device), (void*)(pPacket->dbgOption), pPacket->dataSize, (void*)(pPacket->pData));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
- {
- struct_xglCmdDbgMarkerBegin* pPacket = (struct_xglCmdDbgMarkerBegin*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDbgMarkerBegin(cmdBuffer = %p, pMarker = %p)", (void*)(pPacket->cmdBuffer), (void*)(pPacket->pMarker));
- return str;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
- {
- struct_xglCmdDbgMarkerEnd* pPacket = (struct_xglCmdDbgMarkerEnd*)(pHeader->pBody);
- snprintf(str, 1024, "xglCmdDbgMarkerEnd(cmdBuffer = %p)", (void*)(pPacket->cmdBuffer));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11AssociateConnection:
- {
- struct_xglWsiX11AssociateConnection* pPacket = (struct_xglWsiX11AssociateConnection*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11AssociateConnection(gpu = %p, pConnectionInfo = %p)", (void*)(pPacket->gpu), (void*)(pPacket->pConnectionInfo));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11GetMSC:
- {
- struct_xglWsiX11GetMSC* pPacket = (struct_xglWsiX11GetMSC*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11GetMSC(device = %p, window = %i, crtc = %u, *pMsc = %lu)", (void*)(pPacket->device), pPacket->window, pPacket->crtc, (pPacket->pMsc == NULL) ? 0 : *(pPacket->pMsc));
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
- {
- struct_xglWsiX11CreatePresentableImage* pPacket = (struct_xglWsiX11CreatePresentableImage*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11CreatePresentableImage(device = %p, pCreateInfo = %p, pImage = %p, pMem = %p)", (void*)(pPacket->device), (void*)(pPacket->pCreateInfo), (void*)(pPacket->pImage), (void*)pPacket->pMem);
- return str;
- }
- case GLV_TPI_XGL_xglWsiX11QueuePresent:
- {
- struct_xglWsiX11QueuePresent* pPacket = (struct_xglWsiX11QueuePresent*)(pHeader->pBody);
- snprintf(str, 1024, "xglWsiX11QueuePresent(queue = %p, pPresentInfo = %p, fence = %p)", (void*)(pPacket->queue), (void*)(pPacket->pPresentInfo), (void*)(pPacket->fence));
- return str;
- }
- default:
- return NULL;
- }
-};
-
-static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)
-{
- if (pHeader == NULL)
- {
- return NULL;
- }
- switch (pHeader->packet_id)
- {
- case GLV_TPI_XGL_xglApiVersion:
- {
- return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;
- }
- case GLV_TPI_XGL_xglCreateInstance:
- {
- return interpret_body_as_xglCreateInstance(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyInstance:
- {
- return interpret_body_as_xglDestroyInstance(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEnumerateGpus:
- {
- return interpret_body_as_xglEnumerateGpus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetGpuInfo:
- {
- return interpret_body_as_xglGetGpuInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetProcAddr:
- {
- return interpret_body_as_xglGetProcAddr(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDevice:
- {
- return interpret_body_as_xglCreateDevice(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyDevice:
- {
- return interpret_body_as_xglDestroyDevice(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetExtensionSupport:
- {
- return interpret_body_as_xglGetExtensionSupport(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEnumerateLayers:
- {
- return interpret_body_as_xglEnumerateLayers(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetDeviceQueue:
- {
- return interpret_body_as_xglGetDeviceQueue(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueSubmit:
- {
- return interpret_body_as_xglQueueSubmit(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueSetGlobalMemReferences:
- {
- return interpret_body_as_xglQueueSetGlobalMemReferences(pHeader)->header;
- }
- case GLV_TPI_XGL_xglQueueWaitIdle:
- {
- return interpret_body_as_xglQueueWaitIdle(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDeviceWaitIdle:
- {
- return interpret_body_as_xglDeviceWaitIdle(pHeader)->header;
- }
- case GLV_TPI_XGL_xglAllocMemory:
- {
- return interpret_body_as_xglAllocMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglFreeMemory:
- {
- return interpret_body_as_xglFreeMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetMemoryPriority:
- {
- return interpret_body_as_xglSetMemoryPriority(pHeader)->header;
- }
- case GLV_TPI_XGL_xglMapMemory:
- {
- return interpret_body_as_xglMapMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglUnmapMemory:
- {
- return interpret_body_as_xglUnmapMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglPinSystemMemory:
- {
- return interpret_body_as_xglPinSystemMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetMultiGpuCompatibility:
- {
- return interpret_body_as_xglGetMultiGpuCompatibility(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenSharedMemory:
- {
- return interpret_body_as_xglOpenSharedMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenSharedQueueSemaphore:
- {
- return interpret_body_as_xglOpenSharedQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenPeerMemory:
- {
- return interpret_body_as_xglOpenPeerMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglOpenPeerImage:
- {
- return interpret_body_as_xglOpenPeerImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDestroyObject:
- {
- return interpret_body_as_xglDestroyObject(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetObjectInfo:
- {
- return interpret_body_as_xglGetObjectInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindObjectMemory:
- {
- return interpret_body_as_xglBindObjectMemory(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindObjectMemoryRange:
- {
- return interpret_body_as_xglBindObjectMemoryRange(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBindImageMemoryRange:
- {
- return interpret_body_as_xglBindImageMemoryRange(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateFence:
- {
- return interpret_body_as_xglCreateFence(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetFenceStatus:
- {
- return interpret_body_as_xglGetFenceStatus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglWaitForFences:
- {
- return interpret_body_as_xglWaitForFences(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateQueueSemaphore:
- {
- return interpret_body_as_xglCreateQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSignalQueueSemaphore:
- {
- return interpret_body_as_xglSignalQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglWaitQueueSemaphore:
- {
- return interpret_body_as_xglWaitQueueSemaphore(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateEvent:
- {
- return interpret_body_as_xglCreateEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetEventStatus:
- {
- return interpret_body_as_xglGetEventStatus(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetEvent:
- {
- return interpret_body_as_xglSetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglResetEvent:
- {
- return interpret_body_as_xglResetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateQueryPool:
- {
- return interpret_body_as_xglCreateQueryPool(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetQueryPoolResults:
- {
- return interpret_body_as_xglGetQueryPoolResults(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetFormatInfo:
- {
- return interpret_body_as_xglGetFormatInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateBuffer:
- {
- return interpret_body_as_xglCreateBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateBufferView:
- {
- return interpret_body_as_xglCreateBufferView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateImage:
- {
- return interpret_body_as_xglCreateImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetFastClearColor:
- {
- return interpret_body_as_xglSetFastClearColor(pHeader)->header;
- }
- case GLV_TPI_XGL_xglSetFastClearDepth:
- {
- return interpret_body_as_xglSetFastClearDepth(pHeader)->header;
- }
- case GLV_TPI_XGL_xglGetImageSubresourceInfo:
- {
- return interpret_body_as_xglGetImageSubresourceInfo(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateImageView:
- {
- return interpret_body_as_xglCreateImageView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateColorAttachmentView:
- {
- return interpret_body_as_xglCreateColorAttachmentView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDepthStencilView:
- {
- return interpret_body_as_xglCreateDepthStencilView(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateShader:
- {
- return interpret_body_as_xglCreateShader(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateGraphicsPipeline:
- {
- return interpret_body_as_xglCreateGraphicsPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateComputePipeline:
- {
- return interpret_body_as_xglCreateComputePipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglStorePipeline:
- {
- return interpret_body_as_xglStorePipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglLoadPipeline:
- {
- return interpret_body_as_xglLoadPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreatePipelineDelta:
- {
- return interpret_body_as_xglCreatePipelineDelta(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateSampler:
- {
- return interpret_body_as_xglCreateSampler(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDescriptorSetLayout:
- {
- return interpret_body_as_xglCreateDescriptorSetLayout(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBeginDescriptorRegionUpdate:
- {
- return interpret_body_as_xglBeginDescriptorRegionUpdate(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEndDescriptorRegionUpdate:
- {
- return interpret_body_as_xglEndDescriptorRegionUpdate(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDescriptorRegion:
- {
- return interpret_body_as_xglCreateDescriptorRegion(pHeader)->header;
- }
- case GLV_TPI_XGL_xglClearDescriptorRegion:
- {
- return interpret_body_as_xglClearDescriptorRegion(pHeader)->header;
- }
- case GLV_TPI_XGL_xglAllocDescriptorSets:
- {
- return interpret_body_as_xglAllocDescriptorSets(pHeader)->header;
- }
- case GLV_TPI_XGL_xglClearDescriptorSets:
- {
- return interpret_body_as_xglClearDescriptorSets(pHeader)->header;
- }
- case GLV_TPI_XGL_xglUpdateDescriptors:
- {
- return interpret_body_as_xglUpdateDescriptors(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicViewportState:
- {
- return interpret_body_as_xglCreateDynamicViewportState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicRasterState:
- {
- return interpret_body_as_xglCreateDynamicRasterState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicColorBlendState:
- {
- return interpret_body_as_xglCreateDynamicColorBlendState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateDynamicDepthStencilState:
- {
- return interpret_body_as_xglCreateDynamicDepthStencilState(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateCommandBuffer:
- {
- return interpret_body_as_xglCreateCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglBeginCommandBuffer:
- {
- return interpret_body_as_xglBeginCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglEndCommandBuffer:
- {
- return interpret_body_as_xglEndCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglResetCommandBuffer:
- {
- return interpret_body_as_xglResetCommandBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindPipeline:
- {
- return interpret_body_as_xglCmdBindPipeline(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindPipelineDelta:
- {
- return interpret_body_as_xglCmdBindPipelineDelta(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindDynamicStateObject:
- {
- return interpret_body_as_xglCmdBindDynamicStateObject(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindDescriptorSet:
- {
- return interpret_body_as_xglCmdBindDescriptorSet(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindVertexBuffer:
- {
- return interpret_body_as_xglCmdBindVertexBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBindIndexBuffer:
- {
- return interpret_body_as_xglCmdBindIndexBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDraw:
- {
- return interpret_body_as_xglCmdDraw(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexed:
- {
- return interpret_body_as_xglCmdDrawIndexed(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndirect:
- {
- return interpret_body_as_xglCmdDrawIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDrawIndexedIndirect:
- {
- return interpret_body_as_xglCmdDrawIndexedIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDispatch:
- {
- return interpret_body_as_xglCmdDispatch(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdDispatchIndirect:
- {
- return interpret_body_as_xglCmdDispatchIndirect(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyBuffer:
- {
- return interpret_body_as_xglCmdCopyBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyImage:
- {
- return interpret_body_as_xglCmdCopyImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyBufferToImage:
- {
- return interpret_body_as_xglCmdCopyBufferToImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCopyImageToBuffer:
- {
- return interpret_body_as_xglCmdCopyImageToBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdCloneImageData:
- {
- return interpret_body_as_xglCmdCloneImageData(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdUpdateBuffer:
- {
- return interpret_body_as_xglCmdUpdateBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdFillBuffer:
- {
- return interpret_body_as_xglCmdFillBuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearColorImage:
- {
- return interpret_body_as_xglCmdClearColorImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearColorImageRaw:
- {
- return interpret_body_as_xglCmdClearColorImageRaw(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdClearDepthStencil:
- {
- return interpret_body_as_xglCmdClearDepthStencil(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResolveImage:
- {
- return interpret_body_as_xglCmdResolveImage(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdSetEvent:
- {
- return interpret_body_as_xglCmdSetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResetEvent:
- {
- return interpret_body_as_xglCmdResetEvent(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdWaitEvents:
- {
- return interpret_body_as_xglCmdWaitEvents(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdPipelineBarrier:
- {
- return interpret_body_as_xglCmdPipelineBarrier(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBeginQuery:
- {
- return interpret_body_as_xglCmdBeginQuery(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdEndQuery:
- {
- return interpret_body_as_xglCmdEndQuery(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdResetQueryPool:
- {
- return interpret_body_as_xglCmdResetQueryPool(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdWriteTimestamp:
- {
- return interpret_body_as_xglCmdWriteTimestamp(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdInitAtomicCounters:
- {
- return interpret_body_as_xglCmdInitAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdLoadAtomicCounters:
- {
- return interpret_body_as_xglCmdLoadAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdSaveAtomicCounters:
- {
- return interpret_body_as_xglCmdSaveAtomicCounters(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateFramebuffer:
- {
- return interpret_body_as_xglCreateFramebuffer(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCreateRenderPass:
- {
- return interpret_body_as_xglCreateRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdBeginRenderPass:
- {
- return interpret_body_as_xglCmdBeginRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglCmdEndRenderPass:
- {
- return interpret_body_as_xglCmdEndRenderPass(pHeader)->header;
- }
- case GLV_TPI_XGL_xglDbgSetValidationLevel:
- {
- return interpret_body_as_xglDbgSetValidationLevel(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgRegisterMsgCallback:
- {
- return interpret_body_as_xglDbgRegisterMsgCallback(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgUnregisterMsgCallback:
- {
- return interpret_body_as_xglDbgUnregisterMsgCallback(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetMessageFilter:
- {
- return interpret_body_as_xglDbgSetMessageFilter(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetObjectTag:
- {
- return interpret_body_as_xglDbgSetObjectTag(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetGlobalOption:
- {
- return interpret_body_as_xglDbgSetGlobalOption(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglDbgSetDeviceOption:
- {
- return interpret_body_as_xglDbgSetDeviceOption(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerBegin:
- {
- return interpret_body_as_xglCmdDbgMarkerBegin(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglCmdDbgMarkerEnd:
- {
- return interpret_body_as_xglCmdDbgMarkerEnd(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11AssociateConnection:
- {
- return interpret_body_as_xglWsiX11AssociateConnection(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11GetMSC:
- {
- return interpret_body_as_xglWsiX11GetMSC(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11CreatePresentableImage:
- {
- return interpret_body_as_xglWsiX11CreatePresentableImage(pHeader)->pHeader;
- }
- case GLV_TPI_XGL_xglWsiX11QueuePresent:
- {
- return interpret_body_as_xglWsiX11QueuePresent(pHeader)->pHeader;
- }
- default:
- return NULL;
- }
- return NULL;
-}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
index 6284559..4de693d 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgl.h
@@ -24,8 +24,8 @@
* DEALINGS IN THE SOFTWARE.
*/
-#include "glvtrace_xgl_xgl_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vk_structs.h"
+#include "glv_vk_packet_id.h"
void AttachHooks();
void DetachHooks();
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
index a298093..c0e9cc7 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xgldbg.c
@@ -28,8 +28,8 @@
#include "glv_common.h"
#include "glvtrace_xgl_xgl.h"
#include "glvtrace_xgl_xgldbg.h"
-#include "glvtrace_xgl_xgldbg_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vkdbg_structs.h"
+#include "glv_vk_packet_id.h"
#ifdef WIN32
#include "mhook/mhook-lib/mhook.h"
#endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
index 8328257..4a8da11 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/glvtrace_xgl_xglwsix11ext.c
@@ -27,8 +27,8 @@
#include "glv_platform.h"
#include "glv_common.h"
#include "glvtrace_xgl_xglwsix11ext.h"
-#include "glvtrace_xgl_xglwsix11ext_structs.h"
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_vkwsix11ext_structs.h"
+#include "glv_vk_packet_id.h"
#ifdef WIN32
#include "mhook/mhook-lib/mhook.h"
#endif
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
index b3a9606..a81bb7b 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_string_helper.h
@@ -3,64 +3,6 @@
#include <xgl.h>
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
- switch ((XGL_STENCIL_OP)input_value)
- {
- case XGL_STENCIL_OP_DEC_CLAMP:
- return "XGL_STENCIL_OP_DEC_CLAMP";
- case XGL_STENCIL_OP_DEC_WRAP:
- return "XGL_STENCIL_OP_DEC_WRAP";
- case XGL_STENCIL_OP_INC_CLAMP:
- return "XGL_STENCIL_OP_INC_CLAMP";
- case XGL_STENCIL_OP_INC_WRAP:
- return "XGL_STENCIL_OP_INC_WRAP";
- case XGL_STENCIL_OP_INVERT:
- return "XGL_STENCIL_OP_INVERT";
- case XGL_STENCIL_OP_KEEP:
- return "XGL_STENCIL_OP_KEEP";
- case XGL_STENCIL_OP_REPLACE:
- return "XGL_STENCIL_OP_REPLACE";
- case XGL_STENCIL_OP_ZERO:
- return "XGL_STENCIL_OP_ZERO";
- default:
- return "Unhandled XGL_STENCIL_OP";
- }
-}
-
-
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
- {
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- return "XGL_SYSTEM_ALLOC_API_OBJECT";
- case XGL_SYSTEM_ALLOC_DEBUG:
- return "XGL_SYSTEM_ALLOC_DEBUG";
- case XGL_SYSTEM_ALLOC_INTERNAL:
- return "XGL_SYSTEM_ALLOC_INTERNAL";
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
- default:
- return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return "XGL_MEMORY_REF_READ_ONLY_BIT";
- default:
- return "Unhandled XGL_MEMORY_REF_FLAGS";
- }
-}
-
-
static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
switch ((XGL_PIPELINE_BIND_POINT)input_value)
@@ -75,56 +17,52 @@
}
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- return "XGL_MEMORY_OUTPUT_COPY_BIT";
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
default:
- return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
}
}
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
- case XGL_ATTACHMENT_STORE_OP_STORE:
- return "XGL_ATTACHMENT_STORE_OP_STORE";
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
default:
- return "Unhandled XGL_ATTACHMENT_STORE_OP";
+ return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+ case XGL_MEMORY_TYPE_BUFFER:
+ return "XGL_MEMORY_TYPE_BUFFER";
+ case XGL_MEMORY_TYPE_IMAGE:
+ return "XGL_MEMORY_TYPE_IMAGE";
+ case XGL_MEMORY_TYPE_OTHER:
+ return "XGL_MEMORY_TYPE_OTHER";
default:
- return "Unhandled XGL_OBJECT_INFO_TYPE";
+ return "Unhandled XGL_MEMORY_TYPE";
}
}
@@ -151,950 +89,16 @@
}
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
- {
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
- default:
- return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
- {
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
- case XGL_IMAGE_USAGE_GENERAL:
- return "XGL_IMAGE_USAGE_GENERAL";
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- return "XGL_IMAGE_USAGE_IMAGE_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- return "XGL_IMAGE_USAGE_TEXTURE_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
- default:
- return "Unhandled XGL_IMAGE_USAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
-{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
- {
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
- case XGL_IMAGE_FORMAT_CLASS_D16:
- return "XGL_IMAGE_FORMAT_CLASS_D16";
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- return "XGL_IMAGE_FORMAT_CLASS_D16S8";
- case XGL_IMAGE_FORMAT_CLASS_D24:
- return "XGL_IMAGE_FORMAT_CLASS_D24";
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- return "XGL_IMAGE_FORMAT_CLASS_D24S8";
- case XGL_IMAGE_FORMAT_CLASS_D32:
- return "XGL_IMAGE_FORMAT_CLASS_D32";
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- return "XGL_IMAGE_FORMAT_CLASS_D32S8";
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return "XGL_IMAGE_FORMAT_CLASS_S8";
- default:
- return "Unhandled XGL_IMAGE_FORMAT_CLASS";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- return "XGL_QUERY_OCCLUSION";
- case XGL_QUERY_PIPELINE_STATISTICS:
- return "XGL_QUERY_PIPELINE_STATISTICS";
- default:
- return "Unhandled XGL_QUERY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
- switch ((XGL_STRUCTURE_TYPE)input_value)
- {
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
- default:
- return "Unhandled XGL_STRUCTURE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
- {
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
- default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_COPY_BIT:
- return "XGL_MEMORY_INPUT_COPY_BIT";
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- return "XGL_MEMORY_INPUT_CPU_READ_BIT";
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
- return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
- default:
- return "Unhandled XGL_MEMORY_INPUT_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
- switch ((XGL_IMAGE_ASPECT)input_value)
- {
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
- default:
- return "Unhandled XGL_IMAGE_ASPECT";
- }
-}
-
-
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
- default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
- switch ((XGL_COMPARE_FUNC)input_value)
- {
- case XGL_COMPARE_ALWAYS:
- return "XGL_COMPARE_ALWAYS";
- case XGL_COMPARE_EQUAL:
- return "XGL_COMPARE_EQUAL";
- case XGL_COMPARE_GREATER:
- return "XGL_COMPARE_GREATER";
- case XGL_COMPARE_GREATER_EQUAL:
- return "XGL_COMPARE_GREATER_EQUAL";
- case XGL_COMPARE_LESS:
- return "XGL_COMPARE_LESS";
- case XGL_COMPARE_LESS_EQUAL:
- return "XGL_COMPARE_LESS_EQUAL";
- case XGL_COMPARE_NEVER:
- return "XGL_COMPARE_NEVER";
- case XGL_COMPARE_NOT_EQUAL:
- return "XGL_COMPARE_NOT_EQUAL";
- default:
- return "Unhandled XGL_COMPARE_FUNC";
- }
-}
-
-
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
-{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
- {
- case XGL_SHADER_STAGE_FLAGS_ALL:
- return "XGL_SHADER_STAGE_FLAGS_ALL";
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
- default:
- return "Unhandled XGL_SHADER_STAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
- default:
- return "Unhandled XGL_FILL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
- default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
- }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return "XGL_WAIT_EVENT_TOP_OF_PIPE";
- default:
- return "Unhandled XGL_WAIT_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
- default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
- default:
- return "Unhandled XGL_MEMORY_PRIORITY";
- }
-}
-
-
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
- {
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
- default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
- {
- case XGL_GPU_TYPE_DISCRETE:
- return "XGL_GPU_TYPE_DISCRETE";
- case XGL_GPU_TYPE_INTEGRATED:
- return "XGL_GPU_TYPE_INTEGRATED";
- case XGL_GPU_TYPE_OTHER:
- return "XGL_GPU_TYPE_OTHER";
- case XGL_GPU_TYPE_VIRTUAL:
- return "XGL_GPU_TYPE_VIRTUAL";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
- {
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
- default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- return "XGL_IMAGE_VIEW_1D";
- case XGL_IMAGE_VIEW_2D:
- return "XGL_IMAGE_VIEW_2D";
- case XGL_IMAGE_VIEW_3D:
- return "XGL_IMAGE_VIEW_3D";
- case XGL_IMAGE_VIEW_CUBE:
- return "XGL_IMAGE_VIEW_CUBE";
- default:
- return "Unhandled XGL_IMAGE_VIEW_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
- default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
-{
- switch ((XGL_RESULT)input_value)
- {
- case XGL_ERROR_BAD_PIPELINE_DATA:
- return "XGL_ERROR_BAD_PIPELINE_DATA";
- case XGL_ERROR_BAD_SHADER_CODE:
- return "XGL_ERROR_BAD_SHADER_CODE";
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- return "XGL_ERROR_DEVICE_ALREADY_CREATED";
- case XGL_ERROR_DEVICE_LOST:
- return "XGL_ERROR_DEVICE_LOST";
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- return "XGL_ERROR_INCOMPATIBLE_DEVICE";
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- return "XGL_ERROR_INCOMPATIBLE_DRIVER";
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- return "XGL_ERROR_INCOMPATIBLE_QUEUE";
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case XGL_ERROR_INITIALIZATION_FAILED:
- return "XGL_ERROR_INITIALIZATION_FAILED";
- case XGL_ERROR_INVALID_ALIGNMENT:
- return "XGL_ERROR_INVALID_ALIGNMENT";
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case XGL_ERROR_INVALID_EXTENSION:
- return "XGL_ERROR_INVALID_EXTENSION";
- case XGL_ERROR_INVALID_FLAGS:
- return "XGL_ERROR_INVALID_FLAGS";
- case XGL_ERROR_INVALID_FORMAT:
- return "XGL_ERROR_INVALID_FORMAT";
- case XGL_ERROR_INVALID_HANDLE:
- return "XGL_ERROR_INVALID_HANDLE";
- case XGL_ERROR_INVALID_IMAGE:
- return "XGL_ERROR_INVALID_IMAGE";
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- return "XGL_ERROR_INVALID_MEMORY_SIZE";
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- return "XGL_ERROR_INVALID_OBJECT_TYPE";
- case XGL_ERROR_INVALID_ORDINAL:
- return "XGL_ERROR_INVALID_ORDINAL";
- case XGL_ERROR_INVALID_POINTER:
- return "XGL_ERROR_INVALID_POINTER";
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- return "XGL_ERROR_INVALID_QUEUE_TYPE";
- case XGL_ERROR_INVALID_VALUE:
- return "XGL_ERROR_INVALID_VALUE";
- case XGL_ERROR_MEMORY_MAP_FAILED:
- return "XGL_ERROR_MEMORY_MAP_FAILED";
- case XGL_ERROR_MEMORY_NOT_BOUND:
- return "XGL_ERROR_MEMORY_NOT_BOUND";
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- return "XGL_ERROR_MEMORY_UNMAP_FAILED";
- case XGL_ERROR_NOT_MAPPABLE:
- return "XGL_ERROR_NOT_MAPPABLE";
- case XGL_ERROR_NOT_SHAREABLE:
- return "XGL_ERROR_NOT_SHAREABLE";
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- return "XGL_ERROR_OUT_OF_GPU_MEMORY";
- case XGL_ERROR_OUT_OF_MEMORY:
- return "XGL_ERROR_OUT_OF_MEMORY";
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
- case XGL_ERROR_UNAVAILABLE:
- return "XGL_ERROR_UNAVAILABLE";
- case XGL_ERROR_UNKNOWN:
- return "XGL_ERROR_UNKNOWN";
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case XGL_EVENT_RESET:
- return "XGL_EVENT_RESET";
- case XGL_EVENT_SET:
- return "XGL_EVENT_SET";
- case XGL_NOT_READY:
- return "XGL_NOT_READY";
- case XGL_SUCCESS:
- return "XGL_SUCCESS";
- case XGL_TIMEOUT:
- return "XGL_TIMEOUT";
- case XGL_UNSUPPORTED:
- return "XGL_UNSUPPORTED";
- default:
- return "Unhandled XGL_RESULT";
- }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
- default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
- default:
- return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- return "XGL_INDEX_16";
- case XGL_INDEX_32:
- return "XGL_INDEX_32";
- case XGL_INDEX_8:
- return "XGL_INDEX_8";
- default:
- return "Unhandled XGL_INDEX_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
- default:
- return "Unhandled XGL_CULL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_TOP_OF_PIPE:
- return "XGL_SET_EVENT_TOP_OF_PIPE";
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- return "XGL_SET_EVENT_TRANSFER_COMPLETE";
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
- default:
- return "Unhandled XGL_SET_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
- {
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- return "XGL_MEMORY_PROPERTY_GPU_ONLY";
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
- default:
- return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
- {
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
- default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
- }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- return "XGL_PROVOKING_VERTEX_FIRST";
- case XGL_PROVOKING_VERTEX_LAST:
- return "XGL_PROVOKING_VERTEX_LAST";
- default:
- return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
- }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
- default:
- return "Unhandled XGL_VALIDATION_LEVEL";
- }
-}
-
-
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
- default:
- return "Unhandled XGL_FACE_ORIENTATION";
- }
-}
-
-
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
- {
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
- default:
- return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
- default:
- return "Unhandled XGL_QUEUE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
- default:
- return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
- default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
- default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
@@ -1443,48 +447,492 @@
}
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return "XGL_BUFFER_CREATE_SPARSE_BIT";
default:
- return "Unhandled XGL_DEPTH_MODE";
+ return "Unhandled XGL_BUFFER_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_BUFFER_VIEW_RAW:
- return "XGL_BUFFER_VIEW_RAW";
- case XGL_BUFFER_VIEW_STRUCTURED:
- return "XGL_BUFFER_VIEW_STRUCTURED";
- case XGL_BUFFER_VIEW_TYPED:
- return "XGL_BUFFER_VIEW_TYPED";
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
default:
- return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ default:
+ return "Unhandled XGL_COORDINATE_ORIGIN";
+ }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+ default:
+ return "Unhandled XGL_CULL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ return "XGL_SET_EVENT_TOP_OF_PIPE";
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
+ default:
+ return "Unhandled XGL_SET_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ return "XGL_MEMORY_INPUT_COPY_BIT";
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ {
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+ default:
+ return "Unhandled XGL_STRUCTURE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ default:
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+ default:
+ return "Unhandled XGL_WAIT_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+ switch ((XGL_QUEUE_FLAGS)input_value)
+ {
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
+ default:
+ return "Unhandled XGL_QUEUE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ {
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+ default:
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+ switch ((XGL_VALIDATION_LEVEL)input_value)
+ {
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
+ default:
+ return "Unhandled XGL_VALIDATION_LEVEL";
+ }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
+ default:
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ default:
+ return "Unhandled XGL_IMAGE_LAYOUT";
}
}
@@ -1537,6 +985,438 @@
}
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+ default:
+ return "Unhandled XGL_QUEUE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ {
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ return "XGL_SHADER_STAGE_FLAGS_ALL";
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ default:
+ return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ default:
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ }
+}
+
+
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+ default:
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+ case XGL_LINEAR_TILING:
+ return "XGL_LINEAR_TILING";
+ case XGL_OPTIMAL_TILING:
+ return "XGL_OPTIMAL_TILING";
+ default:
+ return "Unhandled XGL_IMAGE_TILING";
+ }
+}
+
+
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ {
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+ default:
+ return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+ }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ default:
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+ default:
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
+ default:
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ return "XGL_BUFFER_VIEW_RAW";
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ return "XGL_BUFFER_VIEW_STRUCTURED";
+ case XGL_BUFFER_VIEW_TYPED:
+ return "XGL_BUFFER_VIEW_TYPED";
+ default:
+ return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE";
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+ default:
+ return "Unhandled XGL_IMAGE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
+ default:
+ return "Unhandled XGL_BLEND_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+{
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ {
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ default:
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
+ default:
+ return "Unhandled XGL_MEMORY_PRIORITY";
+ }
+}
+
+
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+{
+ switch ((XGL_RESULT)input_value)
+ {
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ return "XGL_ERROR_BAD_PIPELINE_DATA";
+ case XGL_ERROR_BAD_SHADER_CODE:
+ return "XGL_ERROR_BAD_SHADER_CODE";
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+ case XGL_ERROR_DEVICE_LOST:
+ return "XGL_ERROR_DEVICE_LOST";
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ return "XGL_ERROR_INITIALIZATION_FAILED";
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ return "XGL_ERROR_INVALID_ALIGNMENT";
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case XGL_ERROR_INVALID_EXTENSION:
+ return "XGL_ERROR_INVALID_EXTENSION";
+ case XGL_ERROR_INVALID_FLAGS:
+ return "XGL_ERROR_INVALID_FLAGS";
+ case XGL_ERROR_INVALID_FORMAT:
+ return "XGL_ERROR_INVALID_FORMAT";
+ case XGL_ERROR_INVALID_HANDLE:
+ return "XGL_ERROR_INVALID_HANDLE";
+ case XGL_ERROR_INVALID_IMAGE:
+ return "XGL_ERROR_INVALID_IMAGE";
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ return "XGL_ERROR_INVALID_MEMORY_SIZE";
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ return "XGL_ERROR_INVALID_OBJECT_TYPE";
+ case XGL_ERROR_INVALID_ORDINAL:
+ return "XGL_ERROR_INVALID_ORDINAL";
+ case XGL_ERROR_INVALID_POINTER:
+ return "XGL_ERROR_INVALID_POINTER";
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ return "XGL_ERROR_INVALID_QUEUE_TYPE";
+ case XGL_ERROR_INVALID_VALUE:
+ return "XGL_ERROR_INVALID_VALUE";
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ return "XGL_ERROR_MEMORY_MAP_FAILED";
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ return "XGL_ERROR_MEMORY_NOT_BOUND";
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+ case XGL_ERROR_NOT_MAPPABLE:
+ return "XGL_ERROR_NOT_MAPPABLE";
+ case XGL_ERROR_NOT_SHAREABLE:
+ return "XGL_ERROR_NOT_SHAREABLE";
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+ case XGL_ERROR_OUT_OF_MEMORY:
+ return "XGL_ERROR_OUT_OF_MEMORY";
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ case XGL_ERROR_UNAVAILABLE:
+ return "XGL_ERROR_UNAVAILABLE";
+ case XGL_ERROR_UNKNOWN:
+ return "XGL_ERROR_UNKNOWN";
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
+ default:
+ return "Unhandled XGL_RESULT";
+ }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
+ default:
+ return "Unhandled XGL_FILL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_FILTER";
+ }
+}
+
+
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+{
+ switch ((XGL_QUERY_TYPE)input_value)
+ {
+ case XGL_QUERY_OCCLUSION:
+ return "XGL_QUERY_OCCLUSION";
+ case XGL_QUERY_PIPELINE_STATISTICS:
+ return "XGL_QUERY_PIPELINE_STATISTICS";
+ default:
+ return "Unhandled XGL_QUERY_TYPE";
+ }
+}
+
+
static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
@@ -1567,274 +1447,32 @@
}
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
default:
- return "Unhandled XGL_TEX_FILTER";
+ return "Unhandled XGL_TIMESTAMP_TYPE";
}
}
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
- }
-}
-
-
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
- switch ((XGL_BLEND_FUNC)input_value)
- {
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
- default:
- return "Unhandled XGL_BLEND_FUNC";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
-{
- switch ((XGL_IMAGE_LAYOUT)input_value)
- {
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
- default:
- return "Unhandled XGL_IMAGE_LAYOUT";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
- {
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return "XGL_BUFFER_CREATE_SPARSE_BIT";
- default:
- return "Unhandled XGL_BUFFER_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
-{
- switch ((XGL_MEMORY_TYPE)input_value)
- {
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
- default:
- return "Unhandled XGL_MEMORY_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
- switch ((XGL_QUEUE_TYPE)input_value)
- {
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
- default:
- return "Unhandled XGL_QUEUE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
-{
- switch ((XGL_IMAGE_TILING)input_value)
- {
- case XGL_LINEAR_TILING:
- return "XGL_LINEAR_TILING";
- case XGL_OPTIMAL_TILING:
- return "XGL_OPTIMAL_TILING";
- default:
- return "Unhandled XGL_IMAGE_TILING";
- }
-}
-
-
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
- {
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
- default:
- return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
-{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
- default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
- switch ((XGL_STATE_BIND_POINT)input_value)
- {
- case XGL_STATE_BIND_COLOR_BLEND:
- return "XGL_STATE_BIND_COLOR_BLEND";
- case XGL_STATE_BIND_DEPTH_STENCIL:
- return "XGL_STATE_BIND_DEPTH_STENCIL";
- case XGL_STATE_BIND_RASTER:
- return "XGL_STATE_BIND_RASTER";
- case XGL_STATE_BIND_VIEWPORT:
- return "XGL_STATE_BIND_VIEWPORT";
- default:
- return "Unhandled XGL_STATE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
- switch ((XGL_TEX_ADDRESS)input_value)
- {
- case XGL_TEX_ADDRESS_CLAMP:
- return "XGL_TEX_ADDRESS_CLAMP";
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- return "XGL_TEX_ADDRESS_CLAMP_BORDER";
- case XGL_TEX_ADDRESS_MIRROR:
- return "XGL_TEX_ADDRESS_MIRROR";
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- return "XGL_TEX_ADDRESS_MIRROR_ONCE";
- case XGL_TEX_ADDRESS_WRAP:
- return "XGL_TEX_ADDRESS_WRAP";
- default:
- return "Unhandled XGL_TEX_ADDRESS";
- }
-}
-
-
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
- {
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
- default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
- {
- case XGL_BUFFER_USAGE_GENERAL:
- return "XGL_BUFFER_USAGE_GENERAL";
- case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
- case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
- case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
- case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
- case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
- return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
- case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
- default:
- return "Unhandled XGL_BUFFER_USAGE_FLAGS";
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
}
}
@@ -1880,3 +1518,365 @@
}
}
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ default:
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+ switch ((XGL_IMAGE_ASPECT)input_value)
+ {
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
+ default:
+ return "Unhandled XGL_IMAGE_ASPECT";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ {
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ default:
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ {
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ return "XGL_IMAGE_FORMAT_CLASS_D16";
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ return "XGL_IMAGE_FORMAT_CLASS_D24";
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ return "XGL_IMAGE_FORMAT_CLASS_D32";
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return "XGL_IMAGE_FORMAT_CLASS_S8";
+ default:
+ return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+{
+ switch ((XGL_TEX_ADDRESS)input_value)
+ {
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
+ default:
+ return "Unhandled XGL_TEX_ADDRESS";
+ }
+}
+
+
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ {
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+ default:
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
+ default:
+ return "Unhandled XGL_INDEX_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
+ default:
+ return "Unhandled XGL_COMPARE_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+{
+ switch ((XGL_STATE_BIND_POINT)input_value)
+ {
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
+ default:
+ return "Unhandled XGL_STATE_BIND_POINT";
+ }
+}
+
+
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
+ default:
+ return "Unhandled XGL_STENCIL_OP";
+ }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
+ default:
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+ case XGL_ATTACHMENT_STORE_OP_STORE:
+ return "XGL_ATTACHMENT_STORE_OP_STORE";
+ default:
+ return "Unhandled XGL_ATTACHMENT_STORE_OP";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_USAGE_GENERAL:
+ return "XGL_BUFFER_USAGE_GENERAL";
+ case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
+ case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
+ case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
+ case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
+ case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+ return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
+ case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
+ default:
+ return "Unhandled XGL_BUFFER_USAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+{
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+ {
+ case XGL_IMAGE_VIEW_1D:
+ return "XGL_IMAGE_VIEW_1D";
+ case XGL_IMAGE_VIEW_2D:
+ return "XGL_IMAGE_VIEW_2D";
+ case XGL_IMAGE_VIEW_3D:
+ return "XGL_IMAGE_VIEW_3D";
+ case XGL_IMAGE_VIEW_CUBE:
+ return "XGL_IMAGE_VIEW_CUBE";
+ default:
+ return "Unhandled XGL_IMAGE_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ default:
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ default:
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+ default:
+ return "Unhandled XGL_FACE_ORIENTATION";
+ }
+}
+
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
index 27df254..4a0f032 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_enum_validate_helper.h
@@ -3,53 +3,6 @@
#include <xgl.h>
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
- switch ((XGL_STENCIL_OP)input_value)
- {
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
-{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
- {
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
-{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
- {
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
switch ((XGL_PIPELINE_BIND_POINT)input_value)
@@ -63,15 +16,16 @@
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
return 1;
default:
return 0;
@@ -79,13 +33,11 @@
}
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- case XGL_ATTACHMENT_STORE_OP_STORE:
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
return 1;
default:
return 0;
@@ -93,14 +45,13 @@
}
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
return 1;
default:
return 0;
@@ -125,719 +76,12 @@
}
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
- {
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
- {
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- case XGL_IMAGE_USAGE_GENERAL:
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
-{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
- {
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- case XGL_IMAGE_FORMAT_CLASS_D16:
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- case XGL_IMAGE_FORMAT_CLASS_D24:
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- case XGL_IMAGE_FORMAT_CLASS_D32:
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
-{
- switch ((XGL_QUERY_TYPE)input_value)
- {
- case XGL_QUERY_OCCLUSION:
- case XGL_QUERY_PIPELINE_STATISTICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
-{
- switch ((XGL_STRUCTURE_TYPE)input_value)
- {
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
- {
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_COPY_BIT:
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
- switch ((XGL_IMAGE_ASPECT)input_value)
- {
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
- switch ((XGL_COMPARE_FUNC)input_value)
- {
- case XGL_COMPARE_ALWAYS:
- case XGL_COMPARE_EQUAL:
- case XGL_COMPARE_GREATER:
- case XGL_COMPARE_GREATER_EQUAL:
- case XGL_COMPARE_LESS:
- case XGL_COMPARE_LESS_EQUAL:
- case XGL_COMPARE_NEVER:
- case XGL_COMPARE_NOT_EQUAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
-{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
- {
- case XGL_SHADER_STAGE_FLAGS_ALL:
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
- {
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
- {
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
- {
- case XGL_TOPOLOGY_LINE_LIST:
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- case XGL_TOPOLOGY_LINE_STRIP:
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- case XGL_TOPOLOGY_PATCH:
- case XGL_TOPOLOGY_POINT_LIST:
- case XGL_TOPOLOGY_QUAD_LIST:
- case XGL_TOPOLOGY_QUAD_STRIP:
- case XGL_TOPOLOGY_RECT_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- case XGL_IMAGE_VIEW_2D:
- case XGL_IMAGE_VIEW_3D:
- case XGL_IMAGE_VIEW_CUBE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
-{
- switch ((XGL_RESULT)input_value)
- {
- case XGL_ERROR_BAD_PIPELINE_DATA:
- case XGL_ERROR_BAD_SHADER_CODE:
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- case XGL_ERROR_DEVICE_LOST:
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- case XGL_ERROR_INITIALIZATION_FAILED:
- case XGL_ERROR_INVALID_ALIGNMENT:
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- case XGL_ERROR_INVALID_EXTENSION:
- case XGL_ERROR_INVALID_FLAGS:
- case XGL_ERROR_INVALID_FORMAT:
- case XGL_ERROR_INVALID_HANDLE:
- case XGL_ERROR_INVALID_IMAGE:
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- case XGL_ERROR_INVALID_ORDINAL:
- case XGL_ERROR_INVALID_POINTER:
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- case XGL_ERROR_INVALID_VALUE:
- case XGL_ERROR_MEMORY_MAP_FAILED:
- case XGL_ERROR_MEMORY_NOT_BOUND:
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- case XGL_ERROR_NOT_MAPPABLE:
- case XGL_ERROR_NOT_SHAREABLE:
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- case XGL_ERROR_OUT_OF_MEMORY:
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- case XGL_ERROR_UNAVAILABLE:
- case XGL_ERROR_UNKNOWN:
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- case XGL_EVENT_RESET:
- case XGL_EVENT_SET:
- case XGL_NOT_READY:
- case XGL_SUCCESS:
- case XGL_TIMEOUT:
- case XGL_UNSUPPORTED:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- case XGL_INDEX_32:
- case XGL_INDEX_8:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
- {
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
- {
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- case XGL_PROVOKING_VERTEX_LAST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- case XGL_FRONT_FACE_CW:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
- {
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
return 1;
default:
return 0;
@@ -1023,12 +267,12 @@
}
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
@@ -1036,13 +280,17 @@
}
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_BUFFER_VIEW_RAW:
- case XGL_BUFFER_VIEW_STRUCTURED:
- case XGL_BUFFER_VIEW_TYPED:
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
return 1;
default:
return 0;
@@ -1050,13 +298,339 @@
}
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_IMAGE_1D:
- case XGL_IMAGE_2D:
- case XGL_IMAGE_3D:
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ case XGL_IMAGE_USAGE_GENERAL:
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ {
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+ switch ((XGL_QUEUE_FLAGS)input_value)
+ {
+ case XGL_QUEUE_COMPUTE_BIT:
+ case XGL_QUEUE_DMA_BIT:
+ case XGL_QUEUE_EXTENDED_BIT:
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ {
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+ switch ((XGL_VALIDATION_LEVEL)input_value)
+ {
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
return 1;
default:
return 0;
@@ -1094,20 +668,13 @@
}
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
{
- switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ switch ((XGL_QUEUE_TYPE)input_value)
{
- case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
- case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
- case XGL_FORMAT_CONVERSION_BIT:
- case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
- case XGL_FORMAT_IMAGE_COPY_BIT:
- case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
- case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
- case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
- case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
- case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
return 1;
default:
return 0;
@@ -1115,12 +682,17 @@
}
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- case XGL_TEX_FILTER_NEAREST:
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
return 1;
default:
return 0;
@@ -1128,16 +700,155 @@
}
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
+ case XGL_TOPOLOGY_LINE_LIST:
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ case XGL_TOPOLOGY_LINE_STRIP:
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ case XGL_TOPOLOGY_PATCH:
+ case XGL_TOPOLOGY_POINT_LIST:
+ case XGL_TOPOLOGY_QUAD_LIST:
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ case XGL_TOPOLOGY_RECT_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+ case XGL_LINEAR_TILING:
+ case XGL_OPTIMAL_TILING:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ {
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ case XGL_PROVOKING_VERTEX_LAST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ case XGL_BUFFER_VIEW_TYPED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ case XGL_IMAGE_2D:
+ case XGL_IMAGE_3D:
return 1;
default:
return 0;
@@ -1161,18 +872,17 @@
}
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
return 1;
default:
return 0;
@@ -1180,12 +890,16 @@
}
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_MEMORY_PRIORITY)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
+ case XGL_MEMORY_PRIORITY_HIGH:
+ case XGL_MEMORY_PRIORITY_LOW:
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
return 1;
default:
return 0;
@@ -1193,13 +907,50 @@
}
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_RESULT)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ case XGL_ERROR_BAD_SHADER_CODE:
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ case XGL_ERROR_DEVICE_LOST:
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ case XGL_ERROR_INVALID_EXTENSION:
+ case XGL_ERROR_INVALID_FLAGS:
+ case XGL_ERROR_INVALID_FORMAT:
+ case XGL_ERROR_INVALID_HANDLE:
+ case XGL_ERROR_INVALID_IMAGE:
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ case XGL_ERROR_INVALID_ORDINAL:
+ case XGL_ERROR_INVALID_POINTER:
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ case XGL_ERROR_INVALID_VALUE:
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ case XGL_ERROR_NOT_MAPPABLE:
+ case XGL_ERROR_NOT_SHAREABLE:
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ case XGL_ERROR_OUT_OF_MEMORY:
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ case XGL_ERROR_UNAVAILABLE:
+ case XGL_ERROR_UNKNOWN:
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ case XGL_EVENT_RESET:
+ case XGL_EVENT_SET:
+ case XGL_NOT_READY:
+ case XGL_SUCCESS:
+ case XGL_TIMEOUT:
+ case XGL_UNSUPPORTED:
return 1;
default:
return 0;
@@ -1207,13 +958,13 @@
}
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_FILL_MODE)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- case XGL_QUEUE_TYPE_DMA:
- case XGL_QUEUE_TYPE_GRAPHICS:
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
return 1;
default:
return 0;
@@ -1221,12 +972,12 @@
}
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_TEX_FILTER)input_value)
{
- case XGL_LINEAR_TILING:
- case XGL_OPTIMAL_TILING:
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
return 1;
default:
return 0;
@@ -1234,14 +985,12 @@
}
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ case XGL_QUERY_OCCLUSION:
+ case XGL_QUERY_PIPELINE_STATISTICS:
return 1;
default:
return 0;
@@ -1249,11 +998,20 @@
}
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ case XGL_FORMAT_CONVERSION_BIT:
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
return 1;
default:
return 0;
@@ -1261,14 +1019,122 @@
}
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_STATE_BIND_POINT)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_STATE_BIND_COLOR_BLEND:
- case XGL_STATE_BIND_DEPTH_STENCIL:
- case XGL_STATE_BIND_RASTER:
- case XGL_STATE_BIND_VIEWPORT:
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+{
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ {
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+{
+ switch ((XGL_LOGIC_OP)input_value)
+ {
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+ switch ((XGL_IMAGE_ASPECT)input_value)
+ {
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ {
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ {
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ case XGL_IMAGE_FORMAT_CLASS_S8:
return 1;
default:
return 0;
@@ -1292,17 +1158,126 @@
}
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ case XGL_COMPARE_EQUAL:
+ case XGL_COMPARE_GREATER:
+ case XGL_COMPARE_GREATER_EQUAL:
+ case XGL_COMPARE_LESS:
+ case XGL_COMPARE_LESS_EQUAL:
+ case XGL_COMPARE_NEVER:
+ case XGL_COMPARE_NOT_EQUAL:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+{
+ switch ((XGL_STATE_BIND_POINT)input_value)
+ {
+ case XGL_STATE_BIND_COLOR_BLEND:
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ case XGL_STATE_BIND_RASTER:
+ case XGL_STATE_BIND_VIEWPORT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ case XGL_ATTACHMENT_STORE_OP_STORE:
return 1;
default:
return 0;
@@ -1335,26 +1310,51 @@
}
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_LOGIC_OP_AND:
- case XGL_LOGIC_OP_AND_INVERTED:
- case XGL_LOGIC_OP_AND_REVERSE:
- case XGL_LOGIC_OP_CLEAR:
- case XGL_LOGIC_OP_COPY:
- case XGL_LOGIC_OP_COPY_INVERTED:
- case XGL_LOGIC_OP_EQUIV:
- case XGL_LOGIC_OP_INVERT:
- case XGL_LOGIC_OP_NAND:
- case XGL_LOGIC_OP_NOOP:
- case XGL_LOGIC_OP_NOR:
- case XGL_LOGIC_OP_OR:
- case XGL_LOGIC_OP_OR_INVERTED:
- case XGL_LOGIC_OP_OR_REVERSE:
- case XGL_LOGIC_OP_SET:
- case XGL_LOGIC_OP_XOR:
+ case XGL_IMAGE_VIEW_1D:
+ case XGL_IMAGE_VIEW_2D:
+ case XGL_IMAGE_VIEW_3D:
+ case XGL_IMAGE_VIEW_CUBE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ case XGL_FRONT_FACE_CW:
return 1;
default:
return 0;
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
index 3ce093b..2c92755 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_size_helper.h
@@ -6,213 +6,122 @@
// Function Prototypes
size_t get_struct_chain_size(const void* pStruct);
size_t get_dynamic_struct_size(const void* pStruct);
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
-size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
-size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
+size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
+size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_FORMAT_PROPERTIES);
+ structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
- }
- return structSize;
-}
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
- }
- return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
- }
- return structSize;
-}
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
- }
- return structSize;
-}
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_UPDATE_AS_COPY);
- }
- return structSize;
-}
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_CLEAR_COLOR);
- }
- return structSize;
-}
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_EXTENT2D);
- }
- return structSize;
-}
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->colorAttachmentCount; i++) {
- structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
- }
- structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
- }
- return structSize;
-}
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_ALLOC_CALLBACKS);
- }
- return structSize;
-}
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
+ structSize = sizeof(XGL_APPLICATION_INFO);
+ structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
+ structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
}
return structSize;
}
@@ -225,11 +134,28 @@
}
return structSize;
}
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+ structSize = sizeof(XGL_UPDATE_SAMPLERS);
+ structSize += pStruct->count*sizeof(XGL_SAMPLER);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_STENCIL_OP_STATE);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
}
return structSize;
}
@@ -248,90 +174,6 @@
}
return structSize;
}
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_RESOLVE);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_FENCE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_BUFFER_COPY);
- }
- return structSize;
-}
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->attachmentCount; i++) {
- structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
- }
- }
- return structSize;
-}
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
- }
- return structSize;
-}
size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
{
size_t structSize = 0;
@@ -340,394 +182,6 @@
}
return structSize;
}
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
- structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
- }
- return structSize;
-}
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_EVENT_WAIT_INFO);
- structSize += pStruct->eventCount*sizeof(XGL_EVENT);
- structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
- }
- return structSize;
-}
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
- }
- }
- return structSize;
-}
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_MEMORY_OPEN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_BARRIER);
- structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
- structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
- }
- return structSize;
-}
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_MEMORY_BARRIER);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
- }
- return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_APPLICATION_INFO);
- structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
- structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
- }
- return structSize;
-}
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_COPY);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
- }
- return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
- }
- return structSize;
-}
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_CHANNEL_MAPPING);
- }
- return structSize;
-}
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
- structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
- }
- for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
- structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
- }
- }
- return structSize;
-}
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
- }
- return structSize;
-}
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
- structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
- structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
- uint32_t i = 0;
- for (i = 0; i < pStruct->colorAttachmentCount; i++) {
- structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
- }
- }
- return structSize;
-}
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_VIEWPORT);
- }
- return structSize;
-}
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_BUFFER_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_RECT);
- }
- return structSize;
-}
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
- }
- return structSize;
-}
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
- }
- return structSize;
-}
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
- }
- }
- return structSize;
-}
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_EVENT_CREATE_INFO);
- }
- return structSize;
-}
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_OFFSET2D);
- }
- return structSize;
-}
size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
{
size_t structSize = 0;
@@ -740,19 +194,11 @@
}
return structSize;
}
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_REF);
- }
- return structSize;
-}
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
-{
- size_t structSize = 0;
- if (pStruct) {
- structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
+ structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
}
return structSize;
}
@@ -771,11 +217,42 @@
}
return structSize;
}
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
+ structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+ structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
+ }
+ for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+ structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
+ }
}
return structSize;
}
@@ -788,47 +265,124 @@
}
return structSize;
}
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_OFFSET3D);
+ structSize = sizeof(XGL_MEMORY_REF);
}
return structSize;
}
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_LAYER_CREATE_INFO);
+ structSize = sizeof(XGL_FORMAT_PROPERTIES);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_ALLOC_CALLBACKS);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
uint32_t i = 0;
- for (i = 0; i < pStruct->layerCount; i++) {
- structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
+ for (i = 0; i < pStruct->attachmentCount; i++) {
+ structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
}
}
return structSize;
}
-size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+ structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
}
return structSize;
}
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+ structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_FENCE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+ structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
+ }
+ structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_EXTENT2D);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
}
return structSize;
}
@@ -840,6 +394,70 @@
}
return structSize;
}
+size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_OFFSET2D);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+ }
+ return structSize;
+}
size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
{
size_t structSize = 0;
@@ -852,35 +470,43 @@
}
return structSize;
}
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+ structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_EXTENT3D);
+ structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+ structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+ structSize = sizeof(XGL_RECT);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
}
return structSize;
}
@@ -892,11 +518,327 @@
}
return structSize;
}
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_STENCIL_OP_STATE);
+ structSize = sizeof(XGL_MEMORY_OPEN_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_UPDATE_AS_COPY);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_COPY);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_RESOLVE);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PIPELINE_BARRIER);
+ structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
+ structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
+ }
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
+ }
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_VIEWPORT);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_MEMORY_BARRIER);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_CHANNEL_MAPPING);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_CLEAR_COLOR);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_EVENT_WAIT_INFO);
+ structSize += pStruct->eventCount*sizeof(XGL_EVENT);
+ structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_EVENT_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_BUFFER_COPY);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
}
return structSize;
}
@@ -912,60 +854,118 @@
}
return structSize;
}
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+ structSize = sizeof(XGL_OFFSET3D);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
+ structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+ structSize = sizeof(XGL_EXTENT3D);
}
return structSize;
}
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+ structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
+ structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
}
return structSize;
}
-size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_SAMPLERS);
- structSize += pStruct->count*sizeof(XGL_SAMPLER);
+ structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
}
return structSize;
}
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+ structSize = sizeof(XGL_LAYER_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->layerCount; i++) {
+ structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
+ }
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_BUFFER_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
+ structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
+ structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+ structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
+ }
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
+ }
+ return structSize;
+}
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+{
+ size_t structSize = 0;
+ if (pStruct) {
+ structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
}
return structSize;
}
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
index b6568c4..7cf0102 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper.h
@@ -115,49 +115,7 @@
#define snprintf _snprintf
#endif // _WIN32
-char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
- return str;
-}
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -177,7 +135,264 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
+ return str;
+}
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
+ return str;
+}
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
+ return str;
+}
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pRequestedQueues) {
+ tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ return str;
+}
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pBufferViews) {
+ tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
+ return str;
+}
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pVertexBindingDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pVertexAttributeDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -196,45 +411,6 @@
snprintf(str, len, "%soffset = %p\n%ssize = %p\n%srowPitch = %p\n%sdepthPitch = %p\n", prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->rowPitch), prefix, (void*)(pStruct->depthPitch));
return str;
}
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
@@ -244,7 +420,53 @@
snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pViewports) {
+ tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pScissors) {
+ tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -264,7 +486,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -274,7 +496,176 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+ return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+ return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pAttachments) {
+ tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spAttachments (%p)\n%s", prefix, (void*)pStruct->pAttachments, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix, (void*)(pStruct->pAttachments));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ return str;
+}
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+ return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -283,13 +674,18 @@
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -299,15 +695,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
- return str;
-}
char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -354,43 +741,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
return str;
}
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
- return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
- return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
- return str;
-}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -408,59 +768,14 @@
}
else
stp_strs[0] = "";
- if (pStruct->pRequestedQueues) {
- tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[5];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[3] = (char*)malloc(len);
- snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[4] = (char*)malloc(len);
- snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -469,149 +784,55 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+ snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
return str;
}
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
return str;
}
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -631,7 +852,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -641,113 +862,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pAttachments) {
- tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spAttachments (%p)\n%s", prefix, (void*)pStruct->pAttachments, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix, (void*)(pStruct->pAttachments));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
return str;
}
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pImageView) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -767,7 +891,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -777,198 +901,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pTypeCount) {
- tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -999,165 +931,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1188,7 +961,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1206,13 +979,13 @@
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1222,7 +995,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1230,23 +1003,28 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pImageViews) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -1255,22 +1033,34 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
- return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -1311,7 +1101,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1331,7 +1121,135 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+ return str;
+}
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1382,7 +1300,57 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[5];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr);
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[3] = (char*)malloc(len);
+ snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[4] = (char*)malloc(len);
+ snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
+ for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ return str;
+}
+char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1402,7 +1370,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1446,352 +1414,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
- return str;
-}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
- return str;
-}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pViewports) {
- tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pScissors) {
- tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
- return str;
-}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
- if (pStruct->pColorLoadClearValues) {
- tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
- return str;
-}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1830,13 +1452,73 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+ return str;
+}
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
@@ -1877,6 +1559,135 @@
free(extra_indent);
return str;
}
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ return str;
+}
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pTypeCount) {
+ tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1907,6 +1718,314 @@
free(extra_indent);
return str;
}
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ return str;
+}
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+ return str;
+}
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1937,16 +2056,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+ snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
return str;
}
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1954,7 +2073,7 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
@@ -1964,18 +2083,10 @@
}
else
stp_strs[0] = "";
- if (pStruct->pBufferViews) {
- tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -1984,13 +2095,123 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+ return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pLinkConstBufferInfo) {
+ tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
return str;
}
char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
@@ -2023,62 +2244,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pVertexBindingDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pVertexAttributeDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
return str;
}
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2087,18 +2262,17 @@
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
+ if (pStruct->pImageView) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
+ snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
}
else
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
+ snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2108,13 +2282,13 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
return str;
}
char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
@@ -2147,7 +2321,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2155,7 +2329,7 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
@@ -2165,79 +2339,82 @@
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- return str;
-}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
- return str;
-}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
- return str;
-}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pImageViews) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
+ if (pStruct->pColorLoadClearValues) {
+ tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
}
else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -2246,34 +2423,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
- return str;
-}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
- return str;
-}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
- return str;
-}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2293,7 +2443,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2303,54 +2453,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+ snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
return str;
}
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
- return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pLinkConstBufferInfo) {
- tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2370,7 +2482,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2380,125 +2492,13 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
- return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
- return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
- return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
return str;
}
char* dynamic_display(const void* pStruct, const char* prefix)
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
index 435ef71..b792ea2 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_string_helper_no_addr.h
@@ -115,49 +115,7 @@
#define snprintf _snprintf
#endif // _WIN32
-char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
- return str;
-}
-char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -177,7 +135,264 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
+ return str;
+}
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
+ return str;
+}
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soriginalImage = addr\n", prefix);
+ return str;
+}
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pRequestedQueues) {
+ tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ return str;
+}
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pBufferViews) {
+ tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
+ return str;
+}
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pVertexBindingDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pVertexAttributeDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -196,45 +411,6 @@
snprintf(str, len, "%soffset = addr\n%ssize = addr\n%srowPitch = addr\n%sdepthPitch = addr\n", prefix, prefix, prefix, prefix);
return str;
}
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
@@ -244,7 +420,53 @@
snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pViewports) {
+ tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pScissors) {
+ tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -264,7 +486,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -274,7 +496,176 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+ return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+ return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pAttachments) {
+ tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spAttachments (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ return str;
+}
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+ return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -283,13 +674,18 @@
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -299,15 +695,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
- return str;
-}
char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -354,43 +741,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
return str;
}
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
- return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
- return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
- return str;
-}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -408,59 +768,14 @@
}
else
stp_strs[0] = "";
- if (pStruct->pRequestedQueues) {
- tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[5];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[3] = (char*)malloc(len);
- snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[4] = (char*)malloc(len);
- snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix);
- for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -469,149 +784,55 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthBias = %f\n%sdepthBiasClamp = %f\n%sslopeScaledDepthBias = %f\n%spointSize = %f\n%spointFadeThreshold = %f\n%slineWidth = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthBias), prefix, (pStruct->depthBiasClamp), prefix, (pStruct->slopeScaledDepthBias), prefix, (pStruct->pointSize), prefix, (pStruct->pointFadeThreshold), prefix, (pStruct->lineWidth));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+ snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
return str;
}
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
return str;
}
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -631,7 +852,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -641,113 +862,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pAttachments) {
- tmpStr = xgl_print_xgl_pipeline_cb_attachment_state(pStruct->pAttachments, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spAttachments (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%salphaToCoverageEnable = %s\n%slogicOpEnable = %s\n%slogicOp = %s\n%sattachmentCount = %u\n%spAttachments = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->alphaToCoverageEnable) ? "TRUE" : "FALSE", prefix, (pStruct->logicOpEnable) ? "TRUE" : "FALSE", prefix, string_XGL_LOGIC_OP(pStruct->logicOp), prefix, (pStruct->attachmentCount), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
return str;
}
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pImageView) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -767,7 +891,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -777,198 +901,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pTypeCount) {
- tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -999,165 +931,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1188,7 +961,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1206,13 +979,13 @@
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1222,7 +995,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1230,23 +1003,28 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pImageViews) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -1255,22 +1033,34 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
- return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
@@ -1311,7 +1101,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1331,7 +1121,135 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+ return str;
+}
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1382,7 +1300,57 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[5];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[3] = (char*)malloc(len);
+ snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[4] = (char*)malloc(len);
+ snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix);
+ for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ return str;
+}
+char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1402,7 +1370,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -1446,352 +1414,6 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
- return str;
-}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soriginalImage = addr\n", prefix);
- return str;
-}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pViewports) {
- tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pScissors) {
- tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
- return str;
-}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
- if (pStruct->pColorLoadClearValues) {
- tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
- return str;
-}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1830,13 +1452,73 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
+ return str;
+}
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
@@ -1877,6 +1559,135 @@
free(extra_indent);
return str;
}
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ return str;
+}
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ if (pStruct->pTypeCount) {
+ tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_viewport(const XGL_VIEWPORT* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1907,6 +1718,314 @@
free(extra_indent);
return str;
}
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ return str;
+}
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+ return str;
+}
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
@@ -1937,16 +2056,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+ snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
return str;
}
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -1954,7 +2073,7 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
@@ -1964,18 +2083,10 @@
}
else
stp_strs[0] = "";
- if (pStruct->pBufferViews) {
- tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -1984,13 +2095,123 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
+ snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+ return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pLinkConstBufferInfo) {
+ tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
return str;
}
char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
@@ -2023,62 +2244,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pVertexBindingDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pVertexAttributeDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
return str;
}
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2087,18 +2262,17 @@
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
+ if (pStruct->pImageView) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
+ snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
}
else
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
+ snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2108,13 +2282,13 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
return str;
}
char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
@@ -2147,7 +2321,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2155,7 +2329,7 @@
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
@@ -2165,79 +2339,82 @@
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[3];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- return str;
-}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
- return str;
-}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
- return str;
-}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pImageViews) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
+ if (pStruct->pColorLoadClearValues) {
+ tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
}
else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
@@ -2246,34 +2423,7 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
- return str;
-}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
- return str;
-}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
- return str;
-}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2293,7 +2443,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2303,54 +2453,16 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
+ snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
return str;
}
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
- return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pLinkConstBufferInfo) {
- tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
@@ -2370,7 +2482,7 @@
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
@@ -2380,125 +2492,13 @@
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
- return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
- return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
- return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
return str;
}
char* dynamic_display(const void* pStruct, const char* prefix)
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
index f72db36..e50bd3d 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_validate_helper.h
@@ -8,122 +8,188 @@
#include "xgl_enum_validate_helper.h"
// Function Prototypes
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
-uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
-uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
-uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
+uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
{
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
-{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
- return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
+ if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+{
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
+ return 0;
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
+ return 0;
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
+ return 0;
+ if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
+ return 0;
+ if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ return 0;
+ if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+{
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
+ return 0;
+ if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
@@ -133,10 +199,472 @@
{
return 1;
}
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
{
return 1;
}
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
+ return 0;
+ if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_LOGIC_OP(pStruct->logicOp))
+ return 0;
+ if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
+{
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->srcBlendColor))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->destBlendColor))
+ return 0;
+ if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
+ return 0;
+ if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+{
+ if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
+ return 0;
+ if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
+{
+ if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin))
+ return 0;
+ if (!validate_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex))
+ return 0;
+ if (!validate_XGL_FILL_MODE(pStruct->fillMode))
+ return 0;
+ if (!validate_XGL_CULL_MODE(pStruct->cullMode))
+ return 0;
+ if (!validate_XGL_FACE_ORIENTATION(pStruct->frontFace))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+ return 0;
+ if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ return 0;
+ if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_IMAGE_VIEW_TYPE(pStruct->viewType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
+{
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
+ return 0;
+ if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+{
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->srcOffset))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->destOffset))
+ return 0;
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+{
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
+ return 0;
+ if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+{
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
+ return 0;
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
+ return 0;
+ if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
+ return 0;
+ if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+{
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+{
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+{
+ if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+{
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
+ return 0;
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
+ return 0;
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
+ return 0;
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+{
+ if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
+ return 0;
+ return 1;
+}
uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
@@ -159,50 +687,28 @@
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
{
- if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
+ return 0;
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
- return 0;
- if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
-{
- if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
-{
return 1;
}
uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
@@ -211,30 +717,6 @@
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
- return 0;
- if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
-{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
- return 0;
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
- return 0;
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
- return 0;
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
- return 0;
- if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
- return 0;
- return 1;
-}
uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
@@ -243,13 +725,7 @@
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
@@ -259,196 +735,6 @@
{
return 1;
}
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
-{
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_LOGIC_OP(pStruct->logicOp))
- return 0;
- if (pStruct->pAttachments && !xgl_validate_xgl_pipeline_cb_attachment_state((const XGL_PIPELINE_CB_ATTACHMENT_STATE*)pStruct->pAttachments))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
-{
- if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
- return 0;
- if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
-{
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!validate_XGL_BLEND(pStruct->srcBlendColor))
- return 0;
- if (!validate_XGL_BLEND(pStruct->destBlendColor))
- return 0;
- if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
- return 0;
- if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
- return 0;
- if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
- return 0;
- if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin))
- return 0;
- if (!validate_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex))
- return 0;
- if (!validate_XGL_FILL_MODE(pStruct->fillMode))
- return 0;
- if (!validate_XGL_CULL_MODE(pStruct->cullMode))
- return 0;
- if (!validate_XGL_FACE_ORIENTATION(pStruct->frontFace))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
- return 0;
- return 1;
-}
uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
{
if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource))
@@ -459,48 +745,50 @@
return 0;
return 1;
}
+uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+{
+ if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
+{
+ if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
+ return 0;
+ if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
+{
+ if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
+ return 0;
+ return 1;
+}
uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
{
if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_IMAGE_VIEW_TYPE(pStruct->viewType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
- return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
-{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
- return 0;
- if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->srcOffset))
- return 0;
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
- return 0;
- if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->destOffset))
- return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
- return 0;
return 1;
}
uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
@@ -513,64 +801,10 @@
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
- return 0;
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
- return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
-{
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
- return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
- return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
- return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
- return 0;
- if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
-{
return 1;
}
uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
@@ -591,263 +825,29 @@
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
-{
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
- return 0;
- if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
- return 0;
- if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
- return 0;
- if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
-{
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
return 0;
- if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
- return 0;
- if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
- return 0;
return 1;
}
uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+ return 0;
+ if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
-{
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
-{
- if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
-{
- if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
- return 0;
- if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
-{
- if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
- return 0;
- if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
- return 0;
- if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
- return 0;
- if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
-{
- if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
- return 0;
- if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
-{
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
-{
- if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
- return 0;
- if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
\ No newline at end of file
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
index 8cbe8bd..90ba170 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.cpp
@@ -400,143 +400,585 @@
}
-// xgl_format_properties_struct_wrapper class definition
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_format_properties_struct_wrapper::display_single_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_format_properties_struct_wrapper::display_struct_members()
-{
- printf("%*s %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
- printf("%*s %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
-}
-
-// Output all struct elements, each on their own line
-void xgl_format_properties_struct_wrapper::display_txt()
-{
- printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_format_properties_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_buffer_image_copy_struct_wrapper class definition
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
-{
- printf("%*s %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
- printf("%*s %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
- printf("%*s %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
- printf("%*s %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_image_copy_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.imageExtent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.imageOffset) {
- xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.imageSubresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
- }
-}
-
-
-// xgl_peer_memory_open_info_struct_wrapper class definition
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+ printf("%*s %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
+ printf("%*s %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
+ printf("%*s %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
}
// Output all struct elements, each on their own line
-void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_application_info_struct_wrapper class definition
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_application_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_application_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
+ printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
+ printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
+ printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+}
+
+// Output all struct elements, each on their own line
+void xgl_application_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_application_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_link_const_buffer_struct_wrapper class definition
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_link_const_buffer_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_link_const_buffer_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
+ printf("%*s %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
+ printf("%*s %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
+}
+
+// Output all struct elements, each on their own line
+void xgl_link_const_buffer_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_link_const_buffer_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_update_samplers_struct_wrapper class definition
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_samplers_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_samplers_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ printf("%*s %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_samplers_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_samplers_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_stencil_op_state_struct_wrapper class definition
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_stencil_op_state_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_stencil_op_state_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
+ printf("%*s %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
+ printf("%*s %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
+ printf("%*s %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
+}
+
+// Output all struct elements, each on their own line
+void xgl_stencil_op_state_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_stencil_op_state_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_peer_image_open_info_struct_wrapper class definition
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_image_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_device_create_info_struct_wrapper class definition
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
+ uint32_t i;
+ for (i = 0; i<queueRecordCount; i++) {
+ printf("%*s %spRequestedQueues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pRequestedQueues)[i]);
+ }
+ printf("%*s %sextensionCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.extensionCount));
+ for (i = 0; i<extensionCount; i++) {
+ printf("%*s %sppEnabledExtensionNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppEnabledExtensionNames)[0]);
+ }
+ printf("%*s %smaxValidationLevel = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VALIDATION_LEVEL(m_struct.maxValidationLevel));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<queueRecordCount; i++) {
+ xgl_device_queue_create_info_struct_wrapper class0(&(m_struct.pRequestedQueues[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_buffer_memory_requirements_struct_wrapper class definition
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
+{
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_update_buffers_struct_wrapper class definition
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_buffers_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_buffers_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ printf("%*s %spBufferViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pBufferViews)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_buffers_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_buffers_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ xgl_buffer_view_attach_info_struct_wrapper class0(&(m_struct.pBufferViews[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_vertex_input_attribute_description_struct_wrapper class definition
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
+}
+
+// Output all struct elements, each on their own line
+void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
+ uint32_t i;
+ for (i = 0; i<bindingCount; i++) {
+ printf("%*s %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
+ }
+ printf("%*s %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
+ for (i = 0; i<attributeCount; i++) {
+ printf("%*s %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<attributeCount; i++) {
+ xgl_vertex_input_attribute_description_struct_wrapper class0(&(m_struct.pVertexAttributeDescriptions[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ for (i = 0; i<bindingCount; i++) {
+ xgl_vertex_input_binding_description_struct_wrapper class1(&(m_struct.pVertexBindingDescriptions[i]));
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_dynamic_rs_state_create_info_struct_wrapper class definition
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
+ printf("%*s %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
+ printf("%*s %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
+ printf("%*s %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
+ printf("%*s %spointFadeThreshold = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointFadeThreshold));
+ printf("%*s %slineWidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.lineWidth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -587,105 +1029,6 @@
}
-// xgl_physical_gpu_queue_properties_struct_wrapper class definition
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
-{
- printf("%*s %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
- printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
- printf("%*s %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
- printf("%*s %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
-}
-
-// Output all struct elements, each on their own line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_sampler_create_info_struct_wrapper class definition
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_sampler_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
- printf("%*s %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
- printf("%*s %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
- printf("%*s %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
- printf("%*s %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
- printf("%*s %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
- printf("%*s %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
- printf("%*s %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
- printf("%*s %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
- printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
- printf("%*s %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
- printf("%*s %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
-}
-
-// Output all struct elements, each on their own line
-void xgl_sampler_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
// xgl_draw_indexed_indirect_cmd_struct_wrapper class definition
xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -730,47 +1073,109 @@
}
-// xgl_update_as_copy_struct_wrapper class definition
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_as_copy_struct_wrapper::display_single_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_as_copy_struct_wrapper::display_struct_members()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
- printf("%*s %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ printf("%*s %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
+ uint32_t i;
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ printf("%*s %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
+ }
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ printf("%*s %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
+ }
}
// Output all struct elements, each on their own line
-void xgl_update_as_copy_struct_wrapper::display_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_as_copy_struct_wrapper::display_full_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ xgl_rect_struct_wrapper class0(&(m_struct.pScissors[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ xgl_viewport_struct_wrapper class1(&(m_struct.pViewports[i]));
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_shader_create_info_struct_wrapper class definition
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_shader_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_shader_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scodeSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.codeSize));
+ printf("%*s %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_shader_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_shader_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -778,93 +1183,521 @@
}
-// xgl_clear_color_struct_wrapper class definition
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_ref_struct_wrapper class definition
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
+xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_clear_color_struct_wrapper::display_single_txt()
+void xgl_memory_ref_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_struct_wrapper::display_struct_members()
+void xgl_memory_ref_struct_wrapper::display_struct_members()
{
- printf("%*s %scolor = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.color));
- printf("%*s %suseRawValue = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.useRawValue) ? "TRUE" : "FALSE");
+ printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_clear_color_struct_wrapper::display_txt()
+void xgl_memory_ref_struct_wrapper::display_txt()
{
- printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_struct_wrapper::display_full_txt()
+void xgl_memory_ref_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.color) {
- xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
+}
+
+
+// xgl_format_properties_struct_wrapper class definition
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_format_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_format_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
+ printf("%*s %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
+}
+
+// Output all struct elements, each on their own line
+void xgl_format_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_format_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_statistics_data_struct_wrapper class definition
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
+ printf("%*s %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
+ printf("%*s %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
+ printf("%*s %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
+ printf("%*s %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
+ printf("%*s %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
+ printf("%*s %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
+ printf("%*s %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
+ printf("%*s %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
+ printf("%*s %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
+ printf("%*s %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_alloc_callbacks_struct_wrapper class definition
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+{
+ printf("%*s %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
+ printf("%*s %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
+ printf("%*s %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+}
+
+// Output all struct elements, each on their own line
+void xgl_alloc_callbacks_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
+ printf("%*s %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
+ printf("%*s %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
+ printf("%*s %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
+ uint32_t i;
+ for (i = 0; i<attachmentCount; i++) {
+ printf("%*s %spAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pAttachments)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<attachmentCount; i++) {
+ xgl_pipeline_cb_attachment_state_struct_wrapper class0(&(m_struct.pAttachments[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_extent2d_struct_wrapper class definition
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_draw_indirect_cmd_struct_wrapper class definition
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
+xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_extent2d_struct_wrapper::display_single_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_extent2d_struct_wrapper::display_struct_members()
+void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
{
- printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
- printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
+ printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+ printf("%*s %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
+ printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
}
// Output all struct elements, each on their own line
-void xgl_extent2d_struct_wrapper::display_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
{
- printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent2d_struct_wrapper::display_full_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
+// xgl_color_attachment_view_create_info_struct_wrapper class definition
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+ printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.msaaResolveSubResource) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
+ printf("%*s %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
+ printf("%*s %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
+ printf("%*s %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
+ printf("%*s %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
+ printf("%*s %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
+ printf("%*s %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_vertex_input_binding_description_struct_wrapper class definition
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_vertex_input_binding_description_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sstrideInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.strideInBytes));
+ printf("%*s %sstepRate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VERTEX_INPUT_STEP_RATE(m_struct.stepRate));
+}
+
+// Output all struct elements, each on their own line
+void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.shader) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_fence_create_info_struct_wrapper class definition
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_fence_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_fence_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_fence_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_fence_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
// xgl_framebuffer_create_info_struct_wrapper class definition
xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -930,1127 +1763,186 @@
}
-// xgl_alloc_callbacks_struct_wrapper class definition
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_extent2d_struct_wrapper class definition
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+void xgl_extent2d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+void xgl_extent2d_struct_wrapper::display_struct_members()
{
- printf("%*s %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
- printf("%*s %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
- printf("%*s %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+ printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
}
// Output all struct elements, each on their own line
-void xgl_alloc_callbacks_struct_wrapper::display_txt()
+void xgl_extent2d_struct_wrapper::display_txt()
{
- printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+void xgl_extent2d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_memory_requirements_struct_wrapper class definition
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_compute_pipeline_create_info_struct_wrapper class definition
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_requirements_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
- printf("%*s %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
- printf("%*s %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
- printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
- printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_requirements_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_requirements_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_link_const_buffer_struct_wrapper class definition
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_link_const_buffer_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_link_const_buffer_struct_wrapper::display_struct_members()
-{
- printf("%*s %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
- printf("%*s %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
- printf("%*s %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
-}
-
-// Output all struct elements, each on their own line
-void xgl_link_const_buffer_struct_wrapper::display_txt()
-{
- printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_link_const_buffer_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_physical_gpu_properties_struct_wrapper class definition
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
-{
- printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
- printf("%*s %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
- printf("%*s %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
- printf("%*s %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
- printf("%*s %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
- uint32_t i;
- for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
- printf("%*s %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
- }
- printf("%*s %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
- printf("%*s %smaxInlineMemoryUpdateSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.maxInlineMemoryUpdateSize));
- printf("%*s %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
- printf("%*s %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
- printf("%*s %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
- printf("%*s %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
- printf("%*s %smaxDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDescriptorSets));
- printf("%*s %smaxViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxViewports));
- printf("%*s %smaxColorAttachments = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxColorAttachments));
-}
-
-// Output all struct elements, each on their own line
-void xgl_physical_gpu_properties_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_device_create_info_struct_wrapper class definition
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_device_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_device_create_info_struct_wrapper::display_struct_members()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
- uint32_t i;
- for (i = 0; i<queueRecordCount; i++) {
- printf("%*s %spRequestedQueues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pRequestedQueues)[i]);
- }
- printf("%*s %sextensionCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.extensionCount));
- for (i = 0; i<extensionCount; i++) {
- printf("%*s %sppEnabledExtensionNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppEnabledExtensionNames)[0]);
- }
- printf("%*s %smaxValidationLevel = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VALIDATION_LEVEL(m_struct.maxValidationLevel));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_device_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<queueRecordCount; i++) {
- xgl_device_queue_create_info_struct_wrapper class0(&(m_struct.pRequestedQueues[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_image_resolve_struct_wrapper class definition
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_resolve_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_resolve_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
- printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
- printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
- printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_resolve_struct_wrapper::display_txt()
-{
- printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_resolve_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent2d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.destOffset) {
- xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.destSubresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
- }
- if (&m_struct.srcOffset) {
- xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
- class3.set_indent(m_indent + 4);
- class3.display_full_txt();
- }
- if (&m_struct.srcSubresource) {
- xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
- class4.set_indent(m_indent + 4);
- class4.display_full_txt();
- }
-}
-
-
-// xgl_image_view_attach_info_struct_wrapper class definition
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_view_attach_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_fence_create_info_struct_wrapper class definition
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_fence_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_fence_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_fence_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_fence_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_dynamic_rs_state_create_info_struct_wrapper class definition
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
- printf("%*s %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
- printf("%*s %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
- printf("%*s %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
- printf("%*s %spointFadeThreshold = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointFadeThreshold));
- printf("%*s %slineWidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.lineWidth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_buffer_copy_struct_wrapper class definition
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_copy_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_copy_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
- printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
- printf("%*s %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_copy_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_copy_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_color_attachment_bind_info_struct_wrapper class definition
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_buffer_view_create_info_struct_wrapper class definition
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
- printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
- printf("%*s %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
- printf("%*s %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_view_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.channels) {
- xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_queue_semaphore_open_info_struct_wrapper class definition
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
-}
-
-// Output all struct elements, each on their own line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
- printf("%*s %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
- printf("%*s %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
- printf("%*s %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
- uint32_t i;
- for (i = 0; i<attachmentCount; i++) {
- printf("%*s %spAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pAttachments)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<attachmentCount; i++) {
- xgl_pipeline_cb_attachment_state_struct_wrapper class0(&(m_struct.pAttachments[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_dynamic_cb_state_create_info_struct_wrapper class definition
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- uint32_t i;
- for (i = 0; i<4; i++) {
- printf("%*s %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_buffer_memory_requirements_struct_wrapper class definition
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
-{
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_sampler_image_view_info_struct_wrapper class definition
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
- printf("%*s %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
-}
-
-// Output all struct elements, each on their own line
-void xgl_sampler_image_view_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pImageView) {
- xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
-}
-
-
-// xgl_descriptor_set_layout_create_info_struct_wrapper class definition
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- printf("%*s %sstageFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stageFlags));
- printf("%*s %simmutableSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.immutableSampler));
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_event_wait_info_struct_wrapper class definition
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_event_wait_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_event_wait_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
- uint32_t i;
- for (i = 0; i<eventCount; i++) {
- printf("%*s %spEvents[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pEvents)[i]);
- }
- printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
- printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
- for (i = 0; i<memBarrierCount; i++) {
- printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_event_wait_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_wait_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_descriptor_region_create_info_struct_wrapper class definition
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<count; i++) {
- xgl_descriptor_type_count_struct_wrapper class0(&(m_struct.pTypeCount[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_memory_alloc_info_struct_wrapper class definition
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
- printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
- printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
- printf("%*s %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_alloc_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_memory_open_info_struct_wrapper class definition
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_open_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_open_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_open_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_open_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_graphics_pipeline_create_info_struct_wrapper class definition
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
+ printf("%*s %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX));
+ printf("%*s %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY));
+ printf("%*s %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ));
}
// Output all struct elements, each on their own line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.cs) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_image_subresource_range_struct_wrapper class definition
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_range_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_range_struct_wrapper::display_struct_members()
+{
+ printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+ printf("%*s %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
+ printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_range_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_range_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
+ printf("%*s %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
+ printf("%*s %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2058,50 +1950,182 @@
}
-// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_offset2d_struct_wrapper class definition
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+void xgl_offset2d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+void xgl_offset2d_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+ printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+void xgl_offset2d_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+void xgl_offset2d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.shader) {
- xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
+}
+
+
+// xgl_queue_semaphore_create_info_struct_wrapper class definition
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
+}
+
+
+// xgl_clear_color_value_struct_wrapper class definition
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_clear_color_value_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_clear_color_value_struct_wrapper::display_struct_members()
+{
+ uint32_t i;
+ for (i = 0; i<4; i++) {
+ printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
+ }
+ for (i = 0; i<4; i++) {
+ printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_clear_color_value_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_clear_color_value_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_buffer_memory_barrier_struct_wrapper class definition
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+ printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+ printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
@@ -2157,297 +2181,6 @@
}
-// xgl_pipeline_barrier_struct_wrapper class definition
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
- uint32_t i;
- for (i = 0; i<eventCount; i++) {
- printf("%*s %spEvents[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_SET_EVENT(*m_struct.pEvents)[i]);
- }
- printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
- printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
- for (i = 0; i<memBarrierCount; i++) {
- printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_barrier_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_memory_barrier_struct_wrapper class definition
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_barrier_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_barrier_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
- printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_barrier_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_barrier_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
- printf("%*s %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
- printf("%*s %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
- printf("%*s %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
-{
- printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
- printf("%*s %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
- printf("%*s %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
- printf("%*s %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
- printf("%*s %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
- printf("%*s %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
- printf("%*s %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_cmd_buffer_create_info_struct_wrapper class definition
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_application_info_struct_wrapper class definition
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_application_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_application_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
- printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
- printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
- printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
- printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
-}
-
-// Output all struct elements, each on their own line
-void xgl_application_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_application_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
// xgl_pipeline_rs_state_create_info_struct_wrapper class definition
xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -2500,53 +2233,55 @@
}
-// xgl_color_attachment_view_create_info_struct_wrapper class definition
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_create_info_struct_wrapper class definition
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+void xgl_image_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+void xgl_image_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
- printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+void xgl_image_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+void xgl_image_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.msaaResolveSubResource) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
@@ -2556,145 +2291,105 @@
}
-// xgl_image_memory_bind_info_struct_wrapper class definition
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_images_struct_wrapper class definition
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+void xgl_update_images_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
+void xgl_update_images_struct_wrapper::display_struct_members()
{
- printf("%*s %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ printf("%*s %spImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pImageViews)[i]);
+ }
}
// Output all struct elements, each on their own line
-void xgl_image_memory_bind_info_struct_wrapper::display_txt()
+void xgl_update_images_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
+void xgl_update_images_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ xgl_image_view_attach_info_struct_wrapper class0(&(m_struct.pImageViews[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
}
- if (&m_struct.offset) {
- xgl_offset3d_struct_wrapper class1(&m_struct.offset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.subresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_image_subresource_struct_wrapper class definition
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_cmd_buffer_begin_info_struct_wrapper class definition
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+xgl_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_subresource_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
{
- printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_image_subresource_struct_wrapper::display_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
-}
-
-
-// xgl_draw_indirect_cmd_struct_wrapper class definition
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
-{
- printf("%*s %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
- printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
- printf("%*s %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
- printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
-}
-
-// Output all struct elements, each on their own line
-void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
@@ -2758,44 +2453,275 @@
}
-// xgl_cmd_buffer_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_graphics_pipeline_create_info_struct_wrapper class definition
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_struct_wrapper() {}
+xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
}
// Output all struct elements, each on their own line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_rect_struct_wrapper class definition
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_rect_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_rect_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_rect_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_rect_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.offset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.offset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+}
+
+
+// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
+}
+
+// Output all struct elements, each on their own line
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_device_queue_create_info_struct_wrapper class definition
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+ printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+}
+
+// Output all struct elements, each on their own line
+void xgl_device_queue_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_memory_open_info_struct_wrapper class definition
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_update_as_copy_struct_wrapper class definition
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_as_copy_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_as_copy_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
+ printf("%*s %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_as_copy_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_as_copy_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2872,46 +2798,159 @@
}
-// xgl_pipeline_vp_state_create_info_struct_wrapper class definition
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_resolve_struct_wrapper class definition
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_image_resolve_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
+void xgl_image_resolve_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %snumViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.numViewports));
- printf("%*s %sclipOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.clipOrigin));
- printf("%*s %sdepthMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DEPTH_MODE(m_struct.depthMode));
+ printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+ printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_image_resolve_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_image_resolve_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.destOffset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.destSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (&m_struct.srcOffset) {
+ xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
+ class3.set_indent(m_indent + 4);
+ class3.display_full_txt();
+ }
+ if (&m_struct.srcSubresource) {
+ xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+ class4.set_indent(m_indent + 4);
+ class4.display_full_txt();
+ }
+}
+
+
+// xgl_color_attachment_bind_info_struct_wrapper class definition
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_dynamic_ds_state_create_info_struct_wrapper class definition
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+ printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+ printf("%*s %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
+ printf("%*s %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
+ printf("%*s %sstencilFrontRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilFrontRef));
+ printf("%*s %sstencilBackRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilBackRef));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -2974,6 +3013,122 @@
}
+// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
+ printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
+ printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.back) {
+ xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.front) {
+ xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_barrier_struct_wrapper class definition
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
+ uint32_t i;
+ for (i = 0; i<eventCount; i++) {
+ printf("%*s %spEvents[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_SET_EVENT(*m_struct.pEvents)[i]);
+ }
+ printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
+ printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
+ for (i = 0; i<memBarrierCount; i++) {
+ printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_barrier_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
// xgl_physical_gpu_memory_properties_struct_wrapper class definition
xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_physical_gpu_memory_properties_struct_wrapper::xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3015,6 +3170,1214 @@
}
+// xgl_memory_alloc_image_info_struct_wrapper class definition
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_update_sampler_textures_struct_wrapper class definition
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ printf("%*s %spSamplerImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pSamplerImageViews)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_update_sampler_textures_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ xgl_sampler_image_view_info_struct_wrapper class0(&(m_struct.pSamplerImageViews[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_peer_memory_open_info_struct_wrapper class definition
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_descriptor_type_count_struct_wrapper class definition
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
+{
+ printf("%*s %stype = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.type));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_type_count_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_dispatch_indirect_cmd_struct_wrapper class definition
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sx = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+ printf("%*s %sz = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_descriptor_region_create_info_struct_wrapper class definition
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ printf("%*s %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<count; i++) {
+ xgl_descriptor_type_count_struct_wrapper class0(&(m_struct.pTypeCount[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_viewport_struct_wrapper class definition
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_viewport_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_viewport_struct_wrapper::display_struct_members()
+{
+ printf("%*s %soriginX = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originX));
+ printf("%*s %soriginY = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originY));
+ printf("%*s %swidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+ printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+}
+
+// Output all struct elements, each on their own line
+void xgl_viewport_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_viewport_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_depth_stencil_view_create_info_struct_wrapper class definition
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+ printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.msaaResolveSubResource) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_query_pool_create_info_struct_wrapper class definition
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
+ printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
+}
+
+// Output all struct elements, each on their own line
+void xgl_query_pool_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_cmd_buffer_create_info_struct_wrapper class definition
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_depth_stencil_bind_info_struct_wrapper class definition
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_memory_requirements_struct_wrapper class definition
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_requirements_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_requirements_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+ printf("%*s %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
+ printf("%*s %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
+ printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+ printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_requirements_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_requirements_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_queue_semaphore_open_info_struct_wrapper class definition
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
+}
+
+// Output all struct elements, each on their own line
+void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_memory_barrier_struct_wrapper class definition
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_barrier_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_barrier_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+ printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_barrier_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_barrier_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_physical_gpu_performance_struct_wrapper class definition
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+{
+ printf("%*s %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
+ printf("%*s %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
+ printf("%*s %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
+ printf("%*s %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
+ printf("%*s %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_performance_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_channel_mapping_struct_wrapper class definition
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_channel_mapping_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_channel_mapping_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
+ printf("%*s %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
+ printf("%*s %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
+ printf("%*s %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
+}
+
+// Output all struct elements, each on their own line
+void xgl_channel_mapping_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_channel_mapping_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_clear_color_struct_wrapper class definition
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_clear_color_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_clear_color_struct_wrapper::display_struct_members()
+{
+ printf("%*s %scolor = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.color));
+ printf("%*s %suseRawValue = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.useRawValue) ? "TRUE" : "FALSE");
+}
+
+// Output all struct elements, each on their own line
+void xgl_clear_color_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_clear_color_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.color) {
+ xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+}
+
+
+// xgl_dynamic_cb_state_create_info_struct_wrapper class definition
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ uint32_t i;
+ for (i = 0; i<4; i++) {
+ printf("%*s %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_buffer_view_create_info_struct_wrapper class definition
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+ printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
+ printf("%*s %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+ printf("%*s %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_view_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.channels) {
+ xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_sampler_create_info_struct_wrapper class definition
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_sampler_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_sampler_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
+ printf("%*s %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
+ printf("%*s %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
+ printf("%*s %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
+ printf("%*s %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
+ printf("%*s %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
+ printf("%*s %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
+ printf("%*s %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
+ printf("%*s %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
+ printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+ printf("%*s %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
+ printf("%*s %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
+}
+
+// Output all struct elements, each on their own line
+void xgl_sampler_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_sampler_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_event_wait_info_struct_wrapper class definition
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_event_wait_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_event_wait_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
+ uint32_t i;
+ for (i = 0; i<eventCount; i++) {
+ printf("%*s %spEvents[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pEvents)[i]);
+ }
+ printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
+ printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
+ for (i = 0; i<memBarrierCount; i++) {
+ printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_event_wait_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_event_wait_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_buffer_image_copy_struct_wrapper class definition
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
+ printf("%*s %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
+ printf("%*s %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
+ printf("%*s %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_image_copy_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.imageExtent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.imageOffset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.imageSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+}
+
+
+// xgl_event_create_info_struct_wrapper class definition
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_event_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_event_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_event_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_event_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_physical_gpu_properties_struct_wrapper class definition
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+ printf("%*s %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
+ printf("%*s %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
+ printf("%*s %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
+ printf("%*s %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
+ uint32_t i;
+ for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
+ printf("%*s %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
+ }
+ printf("%*s %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
+ printf("%*s %smaxInlineMemoryUpdateSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.maxInlineMemoryUpdateSize));
+ printf("%*s %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
+ printf("%*s %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
+ printf("%*s %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
+ printf("%*s %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
+ printf("%*s %smaxDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDescriptorSets));
+ printf("%*s %smaxViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxViewports));
+ printf("%*s %smaxColorAttachments = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxColorAttachments));
+}
+
+// Output all struct elements, each on their own line
+void xgl_physical_gpu_properties_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_image_view_attach_info_struct_wrapper class definition
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_view_attach_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
// xgl_memory_alloc_buffer_info_struct_wrapper class definition
xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3060,251 +4423,559 @@
}
-// xgl_compute_pipeline_create_info_struct_wrapper class definition
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_copy_struct_wrapper class definition
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
+xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
+void xgl_buffer_copy_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
+void xgl_buffer_copy_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
- printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
- printf("%*s %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX));
- printf("%*s %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY));
- printf("%*s %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
+ printf("%*s %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
}
// Output all struct elements, each on their own line
-void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_buffer_copy_struct_wrapper::display_txt()
{
- printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_buffer_copy_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.cs) {
- xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+}
+
+
+// xgl_image_memory_bind_info_struct_wrapper class definition
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_memory_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
+ if (&m_struct.offset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.offset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.subresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
}
}
-// xgl_channel_mapping_struct_wrapper class definition
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_memory_requirements_struct_wrapper class definition
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
+xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_channel_mapping_struct_wrapper::display_single_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_channel_mapping_struct_wrapper::display_struct_members()
+void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
{
- printf("%*s %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
- printf("%*s %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
- printf("%*s %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
- printf("%*s %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
}
// Output all struct elements, each on their own line
-void xgl_channel_mapping_struct_wrapper::display_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_txt()
{
- printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_channel_mapping_struct_wrapper::display_full_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_peer_image_open_info_struct_wrapper class definition
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_shader_struct_wrapper class definition
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_shader_struct_wrapper::display_struct_members()
{
- printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
-}
-
-// Output all struct elements, each on their own line
-void xgl_peer_image_open_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
+ printf("%*s %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
+ printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
+ printf("%*s %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
uint32_t i;
- for (i = 0; i<viewportAndScissorCount; i++) {
- printf("%*s %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
- }
- for (i = 0; i<viewportAndScissorCount; i++) {
- printf("%*s %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
+ for (i = 0; i<linkConstBufferCount; i++) {
+ printf("%*s %spLinkConstBufferInfo[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pLinkConstBufferInfo)[i]);
}
}
// Output all struct elements, each on their own line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_shader_struct_wrapper::display_txt()
{
- printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
uint32_t i;
- for (i = 0; i<viewportAndScissorCount; i++) {
- xgl_rect_struct_wrapper class0(&(m_struct.pScissors[i]));
+ for (i = 0; i<linkConstBufferCount; i++) {
+ xgl_link_const_buffer_struct_wrapper class0(&(m_struct.pLinkConstBufferInfo[i]));
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
- for (i = 0; i<viewportAndScissorCount; i++) {
- xgl_viewport_struct_wrapper class1(&(m_struct.pViewports[i]));
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
+}
+
+
+// xgl_offset3d_struct_wrapper class definition
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_offset3d_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_offset3d_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+ printf("%*s %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+}
+
+// Output all struct elements, each on their own line
+void xgl_offset3d_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_offset3d_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_buffer_view_attach_info_struct_wrapper class definition
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_physical_gpu_performance_struct_wrapper class definition
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_extent3d_struct_wrapper class definition
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+void xgl_extent3d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+void xgl_extent3d_struct_wrapper::display_struct_members()
{
- printf("%*s %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
- printf("%*s %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
- printf("%*s %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
- printf("%*s %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
- printf("%*s %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
+ printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
}
// Output all struct elements, each on their own line
-void xgl_physical_gpu_performance_struct_wrapper::display_txt()
+void xgl_extent3d_struct_wrapper::display_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+void xgl_extent3d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
+// xgl_sampler_image_view_info_struct_wrapper class definition
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
+ printf("%*s %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
+}
+
+// Output all struct elements, each on their own line
+void xgl_sampler_image_view_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pImageView) {
+ xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+}
+
+
+// xgl_image_subresource_struct_wrapper class definition
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_image_subresource_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_image_subresource_struct_wrapper::display_struct_members()
+{
+ printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+}
+
+// Output all struct elements, each on their own line
+void xgl_image_subresource_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_image_subresource_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_layer_create_info_struct_wrapper class definition
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_layer_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_layer_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
+ uint32_t i;
+ for (i = 0; i<layerCount; i++) {
+ printf("%*s %sppActiveLayerNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppActiveLayerNames)[0]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_layer_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_layer_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_pipeline_vp_state_create_info_struct_wrapper class definition
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %snumViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.numViewports));
+ printf("%*s %sclipOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.clipOrigin));
+ printf("%*s %sdepthMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DEPTH_MODE(m_struct.depthMode));
+}
+
+// Output all struct elements, each on their own line
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
+// xgl_buffer_create_info_struct_wrapper class definition
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_create_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+}
+
+// Output all struct elements, each on their own line
+void xgl_buffer_create_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_buffer_create_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
+}
+
+
// xgl_render_pass_create_info_struct_wrapper class definition
xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
@@ -3379,785 +5050,48 @@
}
-// xgl_viewport_struct_wrapper class definition
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_descriptor_set_layout_create_info_struct_wrapper class definition
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_viewport_struct_wrapper::xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_viewport_struct_wrapper::~xgl_viewport_struct_wrapper() {}
+xgl_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_viewport_struct_wrapper::display_single_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_VIEWPORT = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_viewport_struct_wrapper::display_struct_members()
-{
- printf("%*s %soriginX = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originX));
- printf("%*s %soriginY = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.originY));
- printf("%*s %swidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
- printf("%*s %sheight = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
- printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
- printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_viewport_struct_wrapper::display_txt()
-{
- printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_viewport_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_VIEWPORT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_dynamic_ds_state_create_info_struct_wrapper class definition
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
- printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
- printf("%*s %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
- printf("%*s %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
- printf("%*s %sstencilFrontRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilFrontRef));
- printf("%*s %sstencilBackRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilBackRef));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_buffer_create_info_struct_wrapper class definition
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
-}
-
-// Output all struct elements, each on their own line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_rect_struct_wrapper class definition
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_rect_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_rect_struct_wrapper::display_struct_members()
-{
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_rect_struct_wrapper::display_txt()
-{
- printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_rect_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent2d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.offset) {
- xgl_offset2d_struct_wrapper class1(&m_struct.offset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
-}
-
-
-// xgl_buffer_memory_barrier_struct_wrapper class definition
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
- printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
- printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
- printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
- printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
- printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
- printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
- printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
- printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.back) {
- xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.front) {
- xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_descriptor_type_count_struct_wrapper class definition
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
-{
- printf("%*s %stype = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.type));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
-}
-
-// Output all struct elements, each on their own line
-void xgl_descriptor_type_count_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_update_sampler_textures_struct_wrapper class definition
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spSamplerImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pSamplerImageViews)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_sampler_textures_struct_wrapper::display_txt()
-{
- printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<count; i++) {
- xgl_sampler_image_view_info_struct_wrapper class0(&(m_struct.pSamplerImageViews[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_query_pool_create_info_struct_wrapper class definition
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
- printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
-}
-
-// Output all struct elements, each on their own line
-void xgl_query_pool_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_event_create_info_struct_wrapper class definition
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_event_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_event_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_event_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_offset2d_struct_wrapper class definition
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_offset2d_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_offset2d_struct_wrapper::display_struct_members()
-{
- printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
- printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
-}
-
-// Output all struct elements, each on their own line
-void xgl_offset2d_struct_wrapper::display_txt()
-{
- printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset2d_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_update_buffers_struct_wrapper class definition
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_buffers_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_buffers_struct_wrapper::display_struct_members()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spBufferViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pBufferViews)[i]);
- }
+ printf("%*s %sstageFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stageFlags));
+ printf("%*s %simmutableSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.immutableSampler));
}
// Output all struct elements, each on their own line
-void xgl_update_buffers_struct_wrapper::display_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_buffers_struct_wrapper::display_full_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; i<count; i++) {
- xgl_buffer_view_attach_info_struct_wrapper class0(&(m_struct.pBufferViews[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_memory_ref_struct_wrapper class definition
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_ref_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_ref_struct_wrapper::display_struct_members()
-{
- printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_ref_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_ref_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_buffer_view_attach_info_struct_wrapper class definition
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
-}
-
-// Output all struct elements, each on their own line
-void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
- uint32_t i;
- for (i = 0; i<bindingCount; i++) {
- printf("%*s %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
- }
- printf("%*s %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
- for (i = 0; i<attributeCount; i++) {
- printf("%*s %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<attributeCount; i++) {
- xgl_vertex_input_attribute_description_struct_wrapper class0(&(m_struct.pVertexAttributeDescriptions[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- for (i = 0; i<bindingCount; i++) {
- xgl_vertex_input_binding_description_struct_wrapper class1(&(m_struct.pVertexBindingDescriptions[i]));
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
@@ -4204,46 +5138,47 @@
}
-// xgl_shader_create_info_struct_wrapper class definition
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_alloc_info_struct_wrapper class definition
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_shader_create_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_shader_create_info_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scodeSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.codeSize));
- printf("%*s %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
+ printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+ printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
+ printf("%*s %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
}
// Output all struct elements, each on their own line
-void xgl_shader_create_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_shader_create_info_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
@@ -4251,981 +5186,46 @@
}
-// xgl_offset3d_struct_wrapper class definition
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_physical_gpu_queue_properties_struct_wrapper class definition
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_offset3d_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_offset3d_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
{
- printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
- printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
- printf("%*s %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
-}
-
-// Output all struct elements, each on their own line
-void xgl_offset3d_struct_wrapper::display_txt()
-{
- printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset3d_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_layer_create_info_struct_wrapper class definition
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_layer_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_layer_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
- uint32_t i;
- for (i = 0; i<layerCount; i++) {
- printf("%*s %sppActiveLayerNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppActiveLayerNames)[0]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_layer_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_layer_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_depth_stencil_view_create_info_struct_wrapper class definition
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
- printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.msaaResolveSubResource) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_depth_stencil_bind_info_struct_wrapper class definition
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
-}
-
-// Output all struct elements, each on their own line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_image_memory_requirements_struct_wrapper class definition
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
-{
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_memory_requirements_struct_wrapper::display_txt()
-{
- printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_image_subresource_range_struct_wrapper class definition
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_subresource_range_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_range_struct_wrapper::display_struct_members()
-{
- printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
- printf("%*s %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
- printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_subresource_range_struct_wrapper::display_txt()
-{
- printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_range_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_update_images_struct_wrapper class definition
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_images_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_images_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pImageViews)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_images_struct_wrapper::display_txt()
-{
- printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_images_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<count; i++) {
- xgl_image_view_attach_info_struct_wrapper class0(&(m_struct.pImageViews[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_dispatch_indirect_cmd_struct_wrapper class definition
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_struct_members()
-{
- printf("%*s %sx = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
- printf("%*s %sy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
- printf("%*s %sz = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
-}
-
-// Output all struct elements, each on their own line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
-{
- printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_extent3d_struct_wrapper class definition
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_extent3d_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_extent3d_struct_wrapper::display_struct_members()
-{
- printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
- printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
- printf("%*s %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
-}
-
-// Output all struct elements, each on their own line
-void xgl_extent3d_struct_wrapper::display_txt()
-{
- printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent3d_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_clear_color_value_struct_wrapper class definition
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_clear_color_value_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_value_struct_wrapper::display_struct_members()
-{
- uint32_t i;
- for (i = 0; i<4; i++) {
- printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
- }
- for (i = 0; i<4; i++) {
- printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_clear_color_value_struct_wrapper::display_txt()
-{
- printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_value_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_memory_alloc_image_info_struct_wrapper class definition
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
-}
-
-// Output all struct elements, each on their own line
-void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_device_queue_create_info_struct_wrapper class definition
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+ printf("%*s %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+ printf("%*s %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
+ printf("%*s %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
}
// Output all struct elements, each on their own line
-void xgl_device_queue_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
{
- printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-
-// xgl_stencil_op_state_struct_wrapper class definition
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_stencil_op_state_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_stencil_op_state_struct_wrapper::display_struct_members()
-{
- printf("%*s %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
- printf("%*s %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
- printf("%*s %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
- printf("%*s %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
-}
-
-// Output all struct elements, each on their own line
-void xgl_stencil_op_state_struct_wrapper::display_txt()
-{
- printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_stencil_op_state_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_pipeline_shader_struct_wrapper class definition
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_struct_wrapper::display_struct_members()
-{
- printf("%*s %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
- printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
- printf("%*s %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
- uint32_t i;
- for (i = 0; i<linkConstBufferCount; i++) {
- printf("%*s %spLinkConstBufferInfo[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pLinkConstBufferInfo)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_shader_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- uint32_t i;
- for (i = 0; i<linkConstBufferCount; i++) {
- xgl_link_const_buffer_struct_wrapper class0(&(m_struct.pLinkConstBufferInfo[i]));
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
-}
-
-
-// xgl_queue_semaphore_create_info_struct_wrapper class definition
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_statistics_data_struct_wrapper class definition
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
-{
- printf("%*s %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
- printf("%*s %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
- printf("%*s %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
- printf("%*s %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
- printf("%*s %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
- printf("%*s %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
- printf("%*s %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
- printf("%*s %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
- printf("%*s %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
- printf("%*s %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
- printf("%*s %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_vertex_input_attribute_description_struct_wrapper class definition
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
-{
- printf("%*s %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
-}
-
-// Output all struct elements, each on their own line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
-{
- printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_vertex_input_binding_description_struct_wrapper class definition
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_vertex_input_binding_description_struct_wrapper::display_struct_members()
-{
- printf("%*s %sstrideInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.strideInBytes));
- printf("%*s %sstepRate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VERTEX_INPUT_STEP_RATE(m_struct.stepRate));
-}
-
-// Output all struct elements, each on their own line
-void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
-{
- printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-
-// xgl_update_samplers_struct_wrapper class definition
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_update_samplers_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_update_samplers_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
- }
-}
-
-// Output all struct elements, each on their own line
-void xgl_update_samplers_struct_wrapper::display_txt()
-{
- printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_samplers_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_image_create_info_struct_wrapper class definition
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_image_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_image_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
- printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
- printf("%*s %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
-
-// Output all struct elements, each on their own line
-void xgl_image_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
-
-// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
-{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
- printf("%*s %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
- printf("%*s %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
-}
-
-// Output all struct elements, each on their own line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
-{
- printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
-}
-
//any footer info for class
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
index 3439d04..ac2fe0c 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/codegen/xgl_struct_wrappers.h
@@ -7,80 +7,14 @@
#include <stdlib.h>
//class declaration
-class xgl_format_properties_struct_wrapper
+class xgl_pipeline_ia_state_create_info_struct_wrapper
{
public:
- xgl_format_properties_struct_wrapper();
- xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
- xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
+ xgl_pipeline_ia_state_create_info_struct_wrapper();
+ xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_format_properties_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
- void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
- XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
- void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
-
-
-private:
- XGL_FORMAT_PROPERTIES m_struct;
- const XGL_FORMAT_PROPERTIES* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_image_copy_struct_wrapper
-{
-public:
- xgl_buffer_image_copy_struct_wrapper();
- xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
- xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
-
- virtual ~xgl_buffer_image_copy_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
- void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
- void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
- XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
- void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
- XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
- void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
-
-
-private:
- XGL_BUFFER_IMAGE_COPY m_struct;
- const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_peer_memory_open_info_struct_wrapper
-{
-public:
- xgl_peer_memory_open_info_struct_wrapper();
- xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
- xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
-
- virtual ~xgl_peer_memory_open_info_struct_wrapper();
+ virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -90,13 +24,399 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
- void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+ XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
+ void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
+ bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
+ void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
+ bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
+ void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
+ uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
+ void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
private:
- XGL_PEER_MEMORY_OPEN_INFO m_struct;
- const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+ XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_application_info_struct_wrapper
+{
+public:
+ xgl_application_info_struct_wrapper();
+ xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
+ xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
+
+ virtual ~xgl_application_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ const char* get_pAppName() { return m_struct.pAppName; }
+ uint32_t get_appVersion() { return m_struct.appVersion; }
+ void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
+ const char* get_pEngineName() { return m_struct.pEngineName; }
+ uint32_t get_engineVersion() { return m_struct.engineVersion; }
+ void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
+ uint32_t get_apiVersion() { return m_struct.apiVersion; }
+ void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
+
+
+private:
+ XGL_APPLICATION_INFO m_struct;
+ const XGL_APPLICATION_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_link_const_buffer_struct_wrapper
+{
+public:
+ xgl_link_const_buffer_struct_wrapper();
+ xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
+ xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
+
+ virtual ~xgl_link_const_buffer_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_bufferId() { return m_struct.bufferId; }
+ void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
+ size_t get_bufferSize() { return m_struct.bufferSize; }
+ void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
+ const void* get_pBufferData() { return m_struct.pBufferData; }
+
+
+private:
+ XGL_LINK_CONST_BUFFER m_struct;
+ const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_samplers_struct_wrapper
+{
+public:
+ xgl_update_samplers_struct_wrapper();
+ xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
+ xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
+
+ virtual ~xgl_update_samplers_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_UPDATE_SAMPLERS m_struct;
+ const XGL_UPDATE_SAMPLERS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_stencil_op_state_struct_wrapper
+{
+public:
+ xgl_stencil_op_state_struct_wrapper();
+ xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
+ xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
+
+ virtual ~xgl_stencil_op_state_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
+ void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
+ XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
+ void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
+ XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
+ void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
+ XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
+ void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
+
+
+private:
+ XGL_STENCIL_OP_STATE m_struct;
+ const XGL_STENCIL_OP_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_image_open_info_struct_wrapper
+{
+public:
+ xgl_peer_image_open_info_struct_wrapper();
+ xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+ xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_peer_image_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
+ void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
+
+
+private:
+ XGL_PEER_IMAGE_OPEN_INFO m_struct;
+ const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_create_info_struct_wrapper
+{
+public:
+ xgl_device_create_info_struct_wrapper();
+ xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
+ xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_device_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
+ void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
+ uint32_t get_extensionCount() { return m_struct.extensionCount; }
+ void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
+ XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
+ void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_DEVICE_CREATE_INFO m_struct;
+ const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_memory_requirements_struct_wrapper
+{
+public:
+ xgl_buffer_memory_requirements_struct_wrapper();
+ xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+
+ virtual ~xgl_buffer_memory_requirements_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+
+
+private:
+ XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
+ const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_buffers_struct_wrapper
+{
+public:
+ xgl_update_buffers_struct_wrapper();
+ xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
+ xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
+
+ virtual ~xgl_update_buffers_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_UPDATE_BUFFERS m_struct;
+ const XGL_UPDATE_BUFFERS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_vertex_input_attribute_description_struct_wrapper
+{
+public:
+ xgl_vertex_input_attribute_description_struct_wrapper();
+ xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+ xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+
+ virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_binding() { return m_struct.binding; }
+ void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
+ void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
+
+
+private:
+ XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
+ const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_vertex_input_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_vertex_input_create_info_struct_wrapper();
+ xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+ xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_bindingCount() { return m_struct.bindingCount; }
+ void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
+ uint32_t get_attributeCount() { return m_struct.attributeCount; }
+ void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
+
+
+private:
+ XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
+ const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_rs_state_create_info_struct_wrapper
+{
+public:
+ xgl_dynamic_rs_state_create_info_struct_wrapper();
+ xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ float get_depthBias() { return m_struct.depthBias; }
+ void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
+ float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
+ void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
+ float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
+ void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
+ float get_pointSize() { return m_struct.pointSize; }
+ void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
+ float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
+ void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
+ float get_lineWidth() { return m_struct.lineWidth; }
+ void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
+
+
+private:
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -140,33 +460,2226 @@
//class declaration
-class xgl_physical_gpu_queue_properties_struct_wrapper
+class xgl_draw_indexed_indirect_cmd_struct_wrapper
{
public:
- xgl_physical_gpu_queue_properties_struct_wrapper();
- xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
- xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+ xgl_draw_indexed_indirect_cmd_struct_wrapper();
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
- virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
+ virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
- void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
- uint32_t get_queueCount() { return m_struct.queueCount; }
- void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
- uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
- void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
- bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
- void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
+ uint32_t get_indexCount() { return m_struct.indexCount; }
+ void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
+ uint32_t get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+ uint32_t get_firstIndex() { return m_struct.firstIndex; }
+ void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
+ int32_t get_vertexOffset() { return m_struct.vertexOffset; }
+ void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
+ uint32_t get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
private:
- XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
- const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
+ XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_vp_state_create_info_struct_wrapper
+{
+public:
+ xgl_dynamic_vp_state_create_info_struct_wrapper();
+ xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
+ void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
+
+
+private:
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_shader_create_info_struct_wrapper
+{
+public:
+ xgl_shader_create_info_struct_wrapper();
+ xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
+ xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_shader_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ size_t get_codeSize() { return m_struct.codeSize; }
+ void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
+ const void* get_pCode() { return m_struct.pCode; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_SHADER_CREATE_INFO m_struct;
+ const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_ref_struct_wrapper
+{
+public:
+ xgl_memory_ref_struct_wrapper();
+ xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
+ xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
+
+ virtual ~xgl_memory_ref_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+ void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_MEMORY_REF m_struct;
+ const XGL_MEMORY_REF* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_format_properties_struct_wrapper
+{
+public:
+ xgl_format_properties_struct_wrapper();
+ xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
+ xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
+
+ virtual ~xgl_format_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
+ void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
+ XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
+ void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
+
+
+private:
+ XGL_FORMAT_PROPERTIES m_struct;
+ const XGL_FORMAT_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_statistics_data_struct_wrapper
+{
+public:
+ xgl_pipeline_statistics_data_struct_wrapper();
+ xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+ xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+
+ virtual ~xgl_pipeline_statistics_data_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
+ void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
+ uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
+ void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
+ uint64_t get_cInvocations() { return m_struct.cInvocations; }
+ void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
+ uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
+ void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
+ uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
+ void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
+ uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
+ void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
+ uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
+ void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
+ uint64_t get_iaVertices() { return m_struct.iaVertices; }
+ void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
+ uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
+ void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
+ uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
+ void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
+ uint64_t get_csInvocations() { return m_struct.csInvocations; }
+ void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
+
+
+private:
+ XGL_PIPELINE_STATISTICS_DATA m_struct;
+ const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_alloc_callbacks_struct_wrapper
+{
+public:
+ xgl_alloc_callbacks_struct_wrapper();
+ xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
+ xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
+
+ virtual ~xgl_alloc_callbacks_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ void* get_pUserData() { return m_struct.pUserData; }
+ void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
+ XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
+ void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
+ XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
+ void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
+
+
+private:
+ XGL_ALLOC_CALLBACKS m_struct;
+ const XGL_ALLOC_CALLBACKS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_cb_state_create_info_struct_wrapper();
+ xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
+ void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
+ bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
+ void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
+ XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
+ void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
+ uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
+ void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
+
+
+private:
+ XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_draw_indirect_cmd_struct_wrapper
+{
+public:
+ xgl_draw_indirect_cmd_struct_wrapper();
+ xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
+ xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+
+ virtual ~xgl_draw_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_vertexCount() { return m_struct.vertexCount; }
+ void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
+ uint32_t get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+ uint32_t get_firstVertex() { return m_struct.firstVertex; }
+ void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
+ uint32_t get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
+
+
+private:
+ XGL_DRAW_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_view_create_info_struct_wrapper
+{
+public:
+ xgl_color_attachment_view_create_info_struct_wrapper();
+ xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+ xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ uint32_t get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+ void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+ void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+
+
+private:
+ XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_cb_attachment_state_struct_wrapper
+{
+public:
+ xgl_pipeline_cb_attachment_state_struct_wrapper();
+ xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+ xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+
+ virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ bool32_t get_blendEnable() { return m_struct.blendEnable; }
+ void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
+ void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
+ XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
+ void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
+ XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
+ void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
+ XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
+ void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
+ XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
+ void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
+ XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
+ void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
+ uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
+ void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
+
+
+private:
+ XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
+ const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_vertex_input_binding_description_struct_wrapper
+{
+public:
+ xgl_vertex_input_binding_description_struct_wrapper();
+ xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+ xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+
+ virtual ~xgl_vertex_input_binding_description_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
+ void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
+ XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
+ void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
+
+
+private:
+ XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
+ const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_stage_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_shader_stage_create_info_struct_wrapper();
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
+
+
+private:
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_fence_create_info_struct_wrapper
+{
+public:
+ xgl_fence_create_info_struct_wrapper();
+ xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
+ xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_fence_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_FENCE_CREATE_INFO m_struct;
+ const XGL_FENCE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_framebuffer_create_info_struct_wrapper
+{
+public:
+ xgl_framebuffer_create_info_struct_wrapper();
+ xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+ xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_framebuffer_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
+ void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
+ const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
+ uint32_t get_sampleCount() { return m_struct.sampleCount; }
+ void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
+ uint32_t get_width() { return m_struct.width; }
+ void set_width(uint32_t inValue) { m_struct.width = inValue; }
+ uint32_t get_height() { return m_struct.height; }
+ void set_height(uint32_t inValue) { m_struct.height = inValue; }
+ uint32_t get_layers() { return m_struct.layers; }
+ void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
+
+
+private:
+ XGL_FRAMEBUFFER_CREATE_INFO m_struct;
+ const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent2d_struct_wrapper
+{
+public:
+ xgl_extent2d_struct_wrapper();
+ xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
+ xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+
+ virtual ~xgl_extent2d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ int32_t get_width() { return m_struct.width; }
+ void set_width(int32_t inValue) { m_struct.width = inValue; }
+ int32_t get_height() { return m_struct.height; }
+ void set_height(int32_t inValue) { m_struct.height = inValue; }
+
+
+private:
+ XGL_EXTENT2D m_struct;
+ const XGL_EXTENT2D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_compute_pipeline_create_info_struct_wrapper
+{
+public:
+ xgl_compute_pipeline_create_info_struct_wrapper();
+ xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
+ void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+ void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
+ uint32_t get_localSizeX() { return m_struct.localSizeX; }
+ void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
+ uint32_t get_localSizeY() { return m_struct.localSizeY; }
+ void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
+ uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
+ void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
+
+
+private:
+ XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_subresource_range_struct_wrapper
+{
+public:
+ xgl_image_subresource_range_struct_wrapper();
+ xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+ xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+
+ virtual ~xgl_image_subresource_range_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+ void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+ uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
+ void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
+ uint32_t get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+
+
+private:
+ XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_tess_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_tess_state_create_info_struct_wrapper();
+ xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
+ void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
+ float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
+ void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
+ float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
+ void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
+
+
+private:
+ XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset2d_struct_wrapper
+{
+public:
+ xgl_offset2d_struct_wrapper();
+ xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
+ xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
+
+ virtual ~xgl_offset2d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ int32_t get_x() { return m_struct.x; }
+ void set_x(int32_t inValue) { m_struct.x = inValue; }
+ int32_t get_y() { return m_struct.y; }
+ void set_y(int32_t inValue) { m_struct.y = inValue; }
+
+
+private:
+ XGL_OFFSET2D m_struct;
+ const XGL_OFFSET2D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_create_info_struct_wrapper
+{
+public:
+ xgl_queue_semaphore_create_info_struct_wrapper();
+ xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+ xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_initialCount() { return m_struct.initialCount; }
+ void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_clear_color_value_struct_wrapper
+{
+public:
+ xgl_clear_color_value_struct_wrapper();
+ xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
+ xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
+
+ virtual ~xgl_clear_color_value_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+
+
+private:
+ XGL_CLEAR_COLOR_VALUE m_struct;
+ const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_memory_barrier_struct_wrapper
+{
+public:
+ xgl_buffer_memory_barrier_struct_wrapper();
+ xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+ xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+
+ virtual ~xgl_buffer_memory_barrier_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+ void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+ XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+ void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+ XGL_BUFFER get_buffer() { return m_struct.buffer; }
+ void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+
+
+private:
+ XGL_BUFFER_MEMORY_BARRIER m_struct;
+ const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_ms_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_ms_state_create_info_struct_wrapper();
+ xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+ bool32_t get_multisampleEnable() { return m_struct.multisampleEnable; }
+ void set_multisampleEnable(bool32_t inValue) { m_struct.multisampleEnable = inValue; }
+ bool32_t get_sampleShadingEnable() { return m_struct.sampleShadingEnable; }
+ void set_sampleShadingEnable(bool32_t inValue) { m_struct.sampleShadingEnable = inValue; }
+ float get_minSampleShading() { return m_struct.minSampleShading; }
+ void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; }
+ XGL_SAMPLE_MASK get_sampleMask() { return m_struct.sampleMask; }
+ void set_sampleMask(XGL_SAMPLE_MASK inValue) { m_struct.sampleMask = inValue; }
+
+
+private:
+ XGL_PIPELINE_MS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_MS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_rs_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_rs_state_create_info_struct_wrapper();
+ xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
+ void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
+ bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
+ void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
+ bool32_t get_programPointSize() { return m_struct.programPointSize; }
+ void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
+ XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
+ void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
+ XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
+ void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
+ XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
+ void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
+ XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
+ void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
+ XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
+ void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
+
+
+private:
+ XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_create_info_struct_wrapper
+{
+public:
+ xgl_image_create_info_struct_wrapper();
+ xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
+ xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_image_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
+ void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+ uint32_t get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+ XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
+ void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_IMAGE_CREATE_INFO m_struct;
+ const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_images_struct_wrapper
+{
+public:
+ xgl_update_images_struct_wrapper();
+ xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
+ xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
+
+ virtual ~xgl_update_images_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_UPDATE_IMAGES m_struct;
+ const XGL_UPDATE_IMAGES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_begin_info_struct_wrapper
+{
+public:
+ xgl_cmd_buffer_begin_info_struct_wrapper();
+ xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+ xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+
+ virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_CMD_BUFFER_BEGIN_INFO m_struct;
+ const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_view_create_info_struct_wrapper
+{
+public:
+ xgl_image_view_create_info_struct_wrapper();
+ xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+ xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_image_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+ void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+ void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+ void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+ float get_minLod() { return m_struct.minLod; }
+ void set_minLod(float inValue) { m_struct.minLod = inValue; }
+
+
+private:
+ XGL_IMAGE_VIEW_CREATE_INFO m_struct;
+ const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_graphics_pipeline_create_info_struct_wrapper
+{
+public:
+ xgl_graphics_pipeline_create_info_struct_wrapper();
+ xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+ void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
+
+
+private:
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_rect_struct_wrapper
+{
+public:
+ xgl_rect_struct_wrapper();
+ xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
+ xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
+
+ virtual ~xgl_rect_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_OFFSET2D get_offset() { return m_struct.offset; }
+ void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_RECT m_struct;
+ const XGL_RECT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
+{
+public:
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+
+ virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
+ void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
+
+
+private:
+ XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
+ const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_device_queue_create_info_struct_wrapper
+{
+public:
+ xgl_device_queue_create_info_struct_wrapper();
+ xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+ xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_device_queue_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
+ void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
+ uint32_t get_queueCount() { return m_struct.queueCount; }
+ void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+
+
+private:
+ XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
+ const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_open_info_struct_wrapper
+{
+public:
+ xgl_memory_open_info_struct_wrapper();
+ xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
+ xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_memory_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
+ void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
+
+
+private:
+ XGL_MEMORY_OPEN_INFO m_struct;
+ const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_as_copy_struct_wrapper
+{
+public:
+ xgl_update_as_copy_struct_wrapper();
+ xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
+ xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
+
+ virtual ~xgl_update_as_copy_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
+ void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
+ uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
+ void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_UPDATE_AS_COPY m_struct;
+ const XGL_UPDATE_AS_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_copy_struct_wrapper
+{
+public:
+ xgl_image_copy_struct_wrapper();
+ xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
+ xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
+
+ virtual ~xgl_image_copy_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_IMAGE_COPY m_struct;
+ const XGL_IMAGE_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_resolve_struct_wrapper
+{
+public:
+ xgl_image_resolve_struct_wrapper();
+ xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
+ xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
+
+ virtual ~xgl_image_resolve_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_IMAGE_RESOLVE m_struct;
+ const XGL_IMAGE_RESOLVE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_color_attachment_bind_info_struct_wrapper
+{
+public:
+ xgl_color_attachment_bind_info_struct_wrapper();
+ xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+ xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+
+ virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+ void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+
+
+private:
+ XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_ds_state_create_info_struct_wrapper
+{
+public:
+ xgl_dynamic_ds_state_create_info_struct_wrapper();
+ xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ float get_minDepth() { return m_struct.minDepth; }
+ void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
+ float get_maxDepth() { return m_struct.maxDepth; }
+ void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
+ uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
+ void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
+ uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
+ void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
+ uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
+ void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
+ uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
+ void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
+
+
+private:
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_memory_barrier_struct_wrapper
+{
+public:
+ xgl_image_memory_barrier_struct_wrapper();
+ xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+ xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+
+ virtual ~xgl_image_memory_barrier_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+ void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+ XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+ void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+ XGL_IMAGE_LAYOUT get_oldLayout() { return m_struct.oldLayout; }
+ void set_oldLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.oldLayout = inValue; }
+ XGL_IMAGE_LAYOUT get_newLayout() { return m_struct.newLayout; }
+ void set_newLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.newLayout = inValue; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+ void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+
+
+private:
+ XGL_IMAGE_MEMORY_BARRIER m_struct;
+ const XGL_IMAGE_MEMORY_BARRIER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_ds_state_create_info_struct_wrapper
+{
+public:
+ xgl_pipeline_ds_state_create_info_struct_wrapper();
+ xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
+ void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
+ bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
+ void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
+ XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
+ void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
+ bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
+ void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
+ bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
+ void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
+ XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
+ void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
+ XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
+ void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
+
+
+private:
+ XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_barrier_struct_wrapper
+{
+public:
+ xgl_pipeline_barrier_struct_wrapper();
+ xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
+ xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
+
+ virtual ~xgl_pipeline_barrier_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_eventCount() { return m_struct.eventCount; }
+ void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+ XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+ void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+ uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+ void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
+
+
+private:
+ XGL_PIPELINE_BARRIER m_struct;
+ const XGL_PIPELINE_BARRIER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_memory_properties_struct_wrapper
+{
+public:
+ xgl_physical_gpu_memory_properties_struct_wrapper();
+ xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+ xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+
+ virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
+ void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
+ bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
+ void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_alloc_image_info_struct_wrapper
+{
+public:
+ xgl_memory_alloc_image_info_struct_wrapper();
+ xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+ xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+
+ virtual ~xgl_memory_alloc_image_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
+ void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+
+
+private:
+ XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
+ const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_sampler_textures_struct_wrapper
+{
+public:
+ xgl_update_sampler_textures_struct_wrapper();
+ xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+ xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+
+ virtual ~xgl_update_sampler_textures_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_UPDATE_SAMPLER_TEXTURES m_struct;
+ const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_peer_memory_open_info_struct_wrapper
+{
+public:
+ xgl_peer_memory_open_info_struct_wrapper();
+ xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+ xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_peer_memory_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
+ void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+
+
+private:
+ XGL_PEER_MEMORY_OPEN_INFO m_struct;
+ const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_type_count_struct_wrapper
+{
+public:
+ xgl_descriptor_type_count_struct_wrapper();
+ xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+ xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+
+ virtual ~xgl_descriptor_type_count_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
+ void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_DESCRIPTOR_TYPE_COUNT m_struct;
+ const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dispatch_indirect_cmd_struct_wrapper
+{
+public:
+ xgl_dispatch_indirect_cmd_struct_wrapper();
+ xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+ xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+
+ virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_x() { return m_struct.x; }
+ void set_x(uint32_t inValue) { m_struct.x = inValue; }
+ uint32_t get_y() { return m_struct.y; }
+ void set_y(uint32_t inValue) { m_struct.y = inValue; }
+ uint32_t get_z() { return m_struct.z; }
+ void set_z(uint32_t inValue) { m_struct.z = inValue; }
+
+
+private:
+ XGL_DISPATCH_INDIRECT_CMD m_struct;
+ const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_region_create_info_struct_wrapper
+{
+public:
+ xgl_descriptor_region_create_info_struct_wrapper();
+ xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+ xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_descriptor_region_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+
+
+private:
+ XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_viewport_struct_wrapper
+{
+public:
+ xgl_viewport_struct_wrapper();
+ xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
+ xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+
+ virtual ~xgl_viewport_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ float get_originX() { return m_struct.originX; }
+ void set_originX(float inValue) { m_struct.originX = inValue; }
+ float get_originY() { return m_struct.originY; }
+ void set_originY(float inValue) { m_struct.originY = inValue; }
+ float get_width() { return m_struct.width; }
+ void set_width(float inValue) { m_struct.width = inValue; }
+ float get_height() { return m_struct.height; }
+ void set_height(float inValue) { m_struct.height = inValue; }
+ float get_minDepth() { return m_struct.minDepth; }
+ void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
+ float get_maxDepth() { return m_struct.maxDepth; }
+ void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
+
+
+private:
+ XGL_VIEWPORT m_struct;
+ const XGL_VIEWPORT* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_view_create_info_struct_wrapper
+{
+public:
+ xgl_depth_stencil_view_create_info_struct_wrapper();
+ xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+ xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ uint32_t get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+ void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+ void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_query_pool_create_info_struct_wrapper
+{
+public:
+ xgl_query_pool_create_info_struct_wrapper();
+ xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+ xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_query_pool_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
+ void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
+ uint32_t get_slots() { return m_struct.slots; }
+ void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
+
+
+private:
+ XGL_QUERY_POOL_CREATE_INFO m_struct;
+ const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_cmd_buffer_create_info_struct_wrapper
+{
+public:
+ xgl_cmd_buffer_create_info_struct_wrapper();
+ xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+ xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
+ void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+
+
+private:
+ XGL_CMD_BUFFER_CREATE_INFO m_struct;
+ const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_depth_stencil_bind_info_struct_wrapper
+{
+public:
+ xgl_depth_stencil_bind_info_struct_wrapper();
+ xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+ xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+
+ virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+ void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+
+
+private:
+ XGL_DEPTH_STENCIL_BIND_INFO m_struct;
+ const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_requirements_struct_wrapper
+{
+public:
+ xgl_memory_requirements_struct_wrapper();
+ xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
+
+ virtual ~xgl_memory_requirements_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
+ void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
+ XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
+ void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
+ XGL_FLAGS get_memProps() { return m_struct.memProps; }
+ void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+ XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+ void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+
+
+private:
+ XGL_MEMORY_REQUIREMENTS m_struct;
+ const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_queue_semaphore_open_info_struct_wrapper
+{
+public:
+ xgl_queue_semaphore_open_info_struct_wrapper();
+ xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+ xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+
+ virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
+ void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
+
+
+private:
+ XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_memory_barrier_struct_wrapper
+{
+public:
+ xgl_memory_barrier_struct_wrapper();
+ xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
+ xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
+
+ virtual ~xgl_memory_barrier_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+ void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+ XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+ void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+
+
+private:
+ XGL_MEMORY_BARRIER m_struct;
+ const XGL_MEMORY_BARRIER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_physical_gpu_performance_struct_wrapper
+{
+public:
+ xgl_physical_gpu_performance_struct_wrapper();
+ xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+ xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+
+ virtual ~xgl_physical_gpu_performance_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ float get_maxGpuClock() { return m_struct.maxGpuClock; }
+ void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
+ float get_aluPerClock() { return m_struct.aluPerClock; }
+ void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
+ float get_texPerClock() { return m_struct.texPerClock; }
+ void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
+ float get_primsPerClock() { return m_struct.primsPerClock; }
+ void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
+ float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
+ void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
+
+
+private:
+ XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
+ const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_channel_mapping_struct_wrapper
+{
+public:
+ xgl_channel_mapping_struct_wrapper();
+ xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
+ xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
+
+ virtual ~xgl_channel_mapping_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
+ void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
+ XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
+ void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
+ XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
+ void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
+ XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
+ void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
+
+
+private:
+ XGL_CHANNEL_MAPPING m_struct;
+ const XGL_CHANNEL_MAPPING* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_clear_color_struct_wrapper
+{
+public:
+ xgl_clear_color_struct_wrapper();
+ xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
+ xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
+
+ virtual ~xgl_clear_color_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
+ void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
+ bool32_t get_useRawValue() { return m_struct.useRawValue; }
+ void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
+
+
+private:
+ XGL_CLEAR_COLOR m_struct;
+ const XGL_CLEAR_COLOR* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_dynamic_cb_state_create_info_struct_wrapper
+{
+public:
+ xgl_dynamic_cb_state_create_info_struct_wrapper();
+ xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+
+
+private:
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_view_create_info_struct_wrapper
+{
+public:
+ xgl_buffer_view_create_info_struct_wrapper();
+ xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+ xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_buffer_view_create_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_BUFFER get_buffer() { return m_struct.buffer; }
+ void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+ XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+ void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+ XGL_GPU_SIZE get_stride() { return m_struct.stride; }
+ void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+ void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_range() { return m_struct.range; }
+ void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
+
+
+private:
+ XGL_BUFFER_VIEW_CREATE_INFO m_struct;
+ const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -229,51 +2742,14 @@
//class declaration
-class xgl_draw_indexed_indirect_cmd_struct_wrapper
+class xgl_event_wait_info_struct_wrapper
{
public:
- xgl_draw_indexed_indirect_cmd_struct_wrapper();
- xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
- xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+ xgl_event_wait_info_struct_wrapper();
+ xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
+ xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
- virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_indexCount() { return m_struct.indexCount; }
- void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
- uint32_t get_instanceCount() { return m_struct.instanceCount; }
- void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
- uint32_t get_firstIndex() { return m_struct.firstIndex; }
- void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
- int32_t get_vertexOffset() { return m_struct.vertexOffset; }
- void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
- uint32_t get_firstInstance() { return m_struct.firstInstance; }
- void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
-
-
-private:
- XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
- const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_as_copy_struct_wrapper
-{
-public:
- xgl_update_as_copy_struct_wrapper();
- xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
- xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
-
- virtual ~xgl_update_as_copy_struct_wrapper();
+ virtual ~xgl_event_wait_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -283,19 +2759,17 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
- void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
- uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
- void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ uint32_t get_eventCount() { return m_struct.eventCount; }
+ void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+ XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+ void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+ uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+ void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
private:
- XGL_UPDATE_AS_COPY m_struct;
- const XGL_UPDATE_AS_COPY* m_origStructAddr;
+ XGL_EVENT_WAIT_INFO m_struct;
+ const XGL_EVENT_WAIT_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -304,29 +2778,33 @@
//class declaration
-class xgl_clear_color_struct_wrapper
+class xgl_buffer_image_copy_struct_wrapper
{
public:
- xgl_clear_color_struct_wrapper();
- xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
- xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
+ xgl_buffer_image_copy_struct_wrapper();
+ xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
+ xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
- virtual ~xgl_clear_color_struct_wrapper();
+ virtual ~xgl_buffer_image_copy_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
- void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
- bool32_t get_useRawValue() { return m_struct.useRawValue; }
- void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
+ XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
+ void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
+ void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
+ XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
+ void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
+ XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
+ void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
private:
- XGL_CLEAR_COLOR m_struct;
- const XGL_CLEAR_COLOR* m_origStructAddr;
+ XGL_BUFFER_IMAGE_COPY m_struct;
+ const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -335,45 +2813,14 @@
//class declaration
-class xgl_extent2d_struct_wrapper
+class xgl_event_create_info_struct_wrapper
{
public:
- xgl_extent2d_struct_wrapper();
- xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
- xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+ xgl_event_create_info_struct_wrapper();
+ xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
+ xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
- virtual ~xgl_extent2d_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_width() { return m_struct.width; }
- void set_width(int32_t inValue) { m_struct.width = inValue; }
- int32_t get_height() { return m_struct.height; }
- void set_height(int32_t inValue) { m_struct.height = inValue; }
-
-
-private:
- XGL_EXTENT2D m_struct;
- const XGL_EXTENT2D* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_framebuffer_create_info_struct_wrapper
-{
-public:
- xgl_framebuffer_create_info_struct_wrapper();
- xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
- xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
-
- virtual ~xgl_framebuffer_create_info_struct_wrapper();
+ virtual ~xgl_event_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -383,124 +2830,13 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
- void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
- const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
- uint32_t get_sampleCount() { return m_struct.sampleCount; }
- void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
- uint32_t get_width() { return m_struct.width; }
- void set_width(uint32_t inValue) { m_struct.width = inValue; }
- uint32_t get_height() { return m_struct.height; }
- void set_height(uint32_t inValue) { m_struct.height = inValue; }
- uint32_t get_layers() { return m_struct.layers; }
- void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_FRAMEBUFFER_CREATE_INFO m_struct;
- const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_alloc_callbacks_struct_wrapper
-{
-public:
- xgl_alloc_callbacks_struct_wrapper();
- xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
- xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
-
- virtual ~xgl_alloc_callbacks_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- void* get_pUserData() { return m_struct.pUserData; }
- void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
- XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
- void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
- XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
- void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
-
-
-private:
- XGL_ALLOC_CALLBACKS m_struct;
- const XGL_ALLOC_CALLBACKS* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_requirements_struct_wrapper
-{
-public:
- xgl_memory_requirements_struct_wrapper();
- xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
- xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
-
- virtual ~xgl_memory_requirements_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
- XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
- void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
- XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
- void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
- XGL_FLAGS get_memProps() { return m_struct.memProps; }
- void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
- XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
- void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
-
-
-private:
- XGL_MEMORY_REQUIREMENTS m_struct;
- const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_link_const_buffer_struct_wrapper
-{
-public:
- xgl_link_const_buffer_struct_wrapper();
- xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
- xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
-
- virtual ~xgl_link_const_buffer_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_bufferId() { return m_struct.bufferId; }
- void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
- size_t get_bufferSize() { return m_struct.bufferSize; }
- void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
- const void* get_pBufferData() { return m_struct.pBufferData; }
-
-
-private:
- XGL_LINK_CONST_BUFFER m_struct;
- const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+ XGL_EVENT_CREATE_INFO m_struct;
+ const XGL_EVENT_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -564,81 +2900,6 @@
//class declaration
-class xgl_device_create_info_struct_wrapper
-{
-public:
- xgl_device_create_info_struct_wrapper();
- xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
- xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_device_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
- void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
- uint32_t get_extensionCount() { return m_struct.extensionCount; }
- void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
- XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
- void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_DEVICE_CREATE_INFO m_struct;
- const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_resolve_struct_wrapper
-{
-public:
- xgl_image_resolve_struct_wrapper();
- xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
- xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
-
- virtual ~xgl_image_resolve_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
- void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
- XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
- void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
- void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
- XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
- void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
- XGL_EXTENT2D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
-
-
-private:
- XGL_IMAGE_RESOLVE m_struct;
- const XGL_IMAGE_RESOLVE* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
class xgl_image_view_attach_info_struct_wrapper
{
public:
@@ -673,14 +2934,14 @@
//class declaration
-class xgl_fence_create_info_struct_wrapper
+class xgl_memory_alloc_buffer_info_struct_wrapper
{
public:
- xgl_fence_create_info_struct_wrapper();
- xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
- xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+ xgl_memory_alloc_buffer_info_struct_wrapper();
+ xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
+ xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
- virtual ~xgl_fence_create_info_struct_wrapper();
+ virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -690,55 +2951,13 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
private:
- XGL_FENCE_CREATE_INFO m_struct;
- const XGL_FENCE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_rs_state_create_info_struct_wrapper
-{
-public:
- xgl_dynamic_rs_state_create_info_struct_wrapper();
- xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- float get_depthBias() { return m_struct.depthBias; }
- void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
- float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
- void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
- float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
- void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
- float get_pointSize() { return m_struct.pointSize; }
- void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
- float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
- void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
- float get_lineWidth() { return m_struct.lineWidth; }
- void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
-
-
-private:
- XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
+ const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -780,29 +2999,31 @@
//class declaration
-class xgl_color_attachment_bind_info_struct_wrapper
+class xgl_image_memory_bind_info_struct_wrapper
{
public:
- xgl_color_attachment_bind_info_struct_wrapper();
- xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
- xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+ xgl_image_memory_bind_info_struct_wrapper();
+ xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
+ xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
- virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+ virtual ~xgl_image_memory_bind_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
- XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
- void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
+ void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
+ XGL_OFFSET3D get_offset() { return m_struct.offset; }
+ void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
private:
- XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
- const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+ XGL_IMAGE_MEMORY_BIND_INFO m_struct;
+ const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -811,158 +3032,14 @@
//class declaration
-class xgl_buffer_view_create_info_struct_wrapper
+class xgl_image_memory_requirements_struct_wrapper
{
public:
- xgl_buffer_view_create_info_struct_wrapper();
- xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
- xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+ xgl_image_memory_requirements_struct_wrapper();
+ xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
- virtual ~xgl_buffer_view_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_BUFFER get_buffer() { return m_struct.buffer; }
- void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
- XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
- void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
- XGL_GPU_SIZE get_stride() { return m_struct.stride; }
- void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
- void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
- XGL_GPU_SIZE get_offset() { return m_struct.offset; }
- void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
- XGL_GPU_SIZE get_range() { return m_struct.range; }
- void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
-
-
-private:
- XGL_BUFFER_VIEW_CREATE_INFO m_struct;
- const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_queue_semaphore_open_info_struct_wrapper
-{
-public:
- xgl_queue_semaphore_open_info_struct_wrapper();
- xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
- xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
-
- virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
- void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
-
-
-private:
- XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
- const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_cb_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_cb_state_create_info_struct_wrapper();
- xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
- void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
- bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
- void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
- XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
- void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
- uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
- void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
-
-
-private:
- XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_cb_state_create_info_struct_wrapper
-{
-public:
- xgl_dynamic_cb_state_create_info_struct_wrapper();
- xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
-
-
-private:
- XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_memory_requirements_struct_wrapper
-{
-public:
- xgl_buffer_memory_requirements_struct_wrapper();
- xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
- xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
-
- virtual ~xgl_buffer_memory_requirements_struct_wrapper();
+ virtual ~xgl_image_memory_requirements_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -971,11 +3048,146 @@
void set_indent(uint32_t indent) { m_indent = indent; }
XGL_FLAGS get_usage() { return m_struct.usage; }
void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
+ void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
private:
- XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
- const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
+ XGL_IMAGE_MEMORY_REQUIREMENTS m_struct;
+ const XGL_IMAGE_MEMORY_REQUIREMENTS* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_pipeline_shader_struct_wrapper
+{
+public:
+ xgl_pipeline_shader_struct_wrapper();
+ xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
+ xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
+
+ virtual ~xgl_pipeline_shader_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
+ void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
+ XGL_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
+ uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
+ void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
+
+
+private:
+ XGL_PIPELINE_SHADER m_struct;
+ const XGL_PIPELINE_SHADER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_offset3d_struct_wrapper
+{
+public:
+ xgl_offset3d_struct_wrapper();
+ xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
+ xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+
+ virtual ~xgl_offset3d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ int32_t get_x() { return m_struct.x; }
+ void set_x(int32_t inValue) { m_struct.x = inValue; }
+ int32_t get_y() { return m_struct.y; }
+ void set_y(int32_t inValue) { m_struct.y = inValue; }
+ int32_t get_z() { return m_struct.z; }
+ void set_z(int32_t inValue) { m_struct.z = inValue; }
+
+
+private:
+ XGL_OFFSET3D m_struct;
+ const XGL_OFFSET3D* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_buffer_view_attach_info_struct_wrapper
+{
+public:
+ xgl_buffer_view_attach_info_struct_wrapper();
+ xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+ xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+
+ virtual ~xgl_buffer_view_attach_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_BUFFER_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
+
+
+private:
+ XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
+ const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_extent3d_struct_wrapper
+{
+public:
+ xgl_extent3d_struct_wrapper();
+ xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
+ xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
+
+ virtual ~xgl_extent3d_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ int32_t get_width() { return m_struct.width; }
+ void set_width(int32_t inValue) { m_struct.width = inValue; }
+ int32_t get_height() { return m_struct.height; }
+ void set_height(int32_t inValue) { m_struct.height = inValue; }
+ int32_t get_depth() { return m_struct.depth; }
+ void set_depth(int32_t inValue) { m_struct.depth = inValue; }
+
+
+private:
+ XGL_EXTENT3D m_struct;
+ const XGL_EXTENT3D* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -1014,636 +3226,6 @@
//class declaration
-class xgl_descriptor_set_layout_create_info_struct_wrapper
-{
-public:
- xgl_descriptor_set_layout_create_info_struct_wrapper();
- xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
- xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
-
- virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
- XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
- void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
- XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
- void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
-
-
-private:
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
- const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_event_wait_info_struct_wrapper
-{
-public:
- xgl_event_wait_info_struct_wrapper();
- xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
- xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
-
- virtual ~xgl_event_wait_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_eventCount() { return m_struct.eventCount; }
- void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
- XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
- void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
- uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
- void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
-
-
-private:
- XGL_EVENT_WAIT_INFO m_struct;
- const XGL_EVENT_WAIT_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_descriptor_region_create_info_struct_wrapper
-{
-public:
- xgl_descriptor_region_create_info_struct_wrapper();
- xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
- xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
-
- virtual ~xgl_descriptor_region_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
- XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
- const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_info_struct_wrapper
-{
-public:
- xgl_memory_alloc_info_struct_wrapper();
- xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
- xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
-
- virtual ~xgl_memory_alloc_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
- void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
- XGL_FLAGS get_memProps() { return m_struct.memProps; }
- void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
- XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
- void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
- XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
- void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
-
-
-private:
- XGL_MEMORY_ALLOC_INFO m_struct;
- const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_open_info_struct_wrapper
-{
-public:
- xgl_memory_open_info_struct_wrapper();
- xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
- xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
-
- virtual ~xgl_memory_open_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
- void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
-
-
-private:
- XGL_MEMORY_OPEN_INFO m_struct;
- const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_graphics_pipeline_create_info_struct_wrapper
-{
-public:
- xgl_graphics_pipeline_create_info_struct_wrapper();
- xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
- xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
- XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
- void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
-
-
-private:
- XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_shader_stage_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_shader_stage_create_info_struct_wrapper();
- xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
- xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
- void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
-
-
-private:
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
- const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ms_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_ms_state_create_info_struct_wrapper();
- xgl_pipeline_ms_state_create_info_struct_wrapper(XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_ms_state_create_info_struct_wrapper(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_ms_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
- bool32_t get_multisampleEnable() { return m_struct.multisampleEnable; }
- void set_multisampleEnable(bool32_t inValue) { m_struct.multisampleEnable = inValue; }
- bool32_t get_sampleShadingEnable() { return m_struct.sampleShadingEnable; }
- void set_sampleShadingEnable(bool32_t inValue) { m_struct.sampleShadingEnable = inValue; }
- float get_minSampleShading() { return m_struct.minSampleShading; }
- void set_minSampleShading(float inValue) { m_struct.minSampleShading = inValue; }
- XGL_SAMPLE_MASK get_sampleMask() { return m_struct.sampleMask; }
- void set_sampleMask(XGL_SAMPLE_MASK inValue) { m_struct.sampleMask = inValue; }
-
-
-private:
- XGL_PIPELINE_MS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_MS_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_barrier_struct_wrapper
-{
-public:
- xgl_pipeline_barrier_struct_wrapper();
- xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
- xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
-
- virtual ~xgl_pipeline_barrier_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_eventCount() { return m_struct.eventCount; }
- void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
- XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
- void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
- uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
- void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
-
-
-private:
- XGL_PIPELINE_BARRIER m_struct;
- const XGL_PIPELINE_BARRIER* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_barrier_struct_wrapper
-{
-public:
- xgl_memory_barrier_struct_wrapper();
- xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
- xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
-
- virtual ~xgl_memory_barrier_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
- void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
- XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
- void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
-
-
-private:
- XGL_MEMORY_BARRIER m_struct;
- const XGL_MEMORY_BARRIER* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ia_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_ia_state_create_info_struct_wrapper();
- xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
- void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
- bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
- void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
- bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
- void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
- uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
- void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
-
-
-private:
- XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_cb_attachment_state_struct_wrapper
-{
-public:
- xgl_pipeline_cb_attachment_state_struct_wrapper();
- xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
- xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
-
- virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- bool32_t get_blendEnable() { return m_struct.blendEnable; }
- void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
- void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
- XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
- void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
- XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
- void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
- XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
- void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
- XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
- void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
- XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
- void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
- uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
- void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
-
-
-private:
- XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
- const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_create_info_struct_wrapper
-{
-public:
- xgl_cmd_buffer_create_info_struct_wrapper();
- xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
- xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
-
- virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
- void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_CMD_BUFFER_CREATE_INFO m_struct;
- const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_application_info_struct_wrapper
-{
-public:
- xgl_application_info_struct_wrapper();
- xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
- xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
-
- virtual ~xgl_application_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- const char* get_pAppName() { return m_struct.pAppName; }
- uint32_t get_appVersion() { return m_struct.appVersion; }
- void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
- const char* get_pEngineName() { return m_struct.pEngineName; }
- uint32_t get_engineVersion() { return m_struct.engineVersion; }
- void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
- uint32_t get_apiVersion() { return m_struct.apiVersion; }
- void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
-
-
-private:
- XGL_APPLICATION_INFO m_struct;
- const XGL_APPLICATION_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_rs_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_rs_state_create_info_struct_wrapper();
- xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
- void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
- bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
- void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
- bool32_t get_programPointSize() { return m_struct.programPointSize; }
- void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
- XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
- void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
- XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
- void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
- XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
- void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
- XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
- void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
- XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
- void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
-
-
-private:
- XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_color_attachment_view_create_info_struct_wrapper
-{
-public:
- xgl_color_attachment_view_create_info_struct_wrapper();
- xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
- xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
-
- virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- uint32_t get_mipLevel() { return m_struct.mipLevel; }
- void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
- void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
- void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
-
-
-private:
- XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_memory_bind_info_struct_wrapper
-{
-public:
- xgl_image_memory_bind_info_struct_wrapper();
- xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
- xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
-
- virtual ~xgl_image_memory_bind_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
- void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
- XGL_OFFSET3D get_offset() { return m_struct.offset; }
- void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
-
-
-private:
- XGL_IMAGE_MEMORY_BIND_INFO m_struct;
- const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
class xgl_image_subresource_struct_wrapper
{
public:
@@ -1677,49 +3259,14 @@
//class declaration
-class xgl_draw_indirect_cmd_struct_wrapper
+class xgl_layer_create_info_struct_wrapper
{
public:
- xgl_draw_indirect_cmd_struct_wrapper();
- xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
- xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+ xgl_layer_create_info_struct_wrapper();
+ xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
+ xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
- virtual ~xgl_draw_indirect_cmd_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_vertexCount() { return m_struct.vertexCount; }
- void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
- uint32_t get_instanceCount() { return m_struct.instanceCount; }
- void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
- uint32_t get_firstVertex() { return m_struct.firstVertex; }
- void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
- uint32_t get_firstInstance() { return m_struct.firstInstance; }
- void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
-
-
-private:
- XGL_DRAW_INDIRECT_CMD m_struct;
- const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_view_create_info_struct_wrapper
-{
-public:
- xgl_image_view_create_info_struct_wrapper();
- xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
- xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
-
- virtual ~xgl_image_view_create_info_struct_wrapper();
+ virtual ~xgl_layer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -1729,92 +3276,13 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
- void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
- void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
- void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
- float get_minLod() { return m_struct.minLod; }
- void set_minLod(float inValue) { m_struct.minLod = inValue; }
+ uint32_t get_layerCount() { return m_struct.layerCount; }
+ void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
private:
- XGL_IMAGE_VIEW_CREATE_INFO m_struct;
- const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_begin_info_struct_wrapper
-{
-public:
- xgl_cmd_buffer_begin_info_struct_wrapper();
- xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
- xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
-
- virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_CMD_BUFFER_BEGIN_INFO m_struct;
- const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_copy_struct_wrapper
-{
-public:
- xgl_image_copy_struct_wrapper();
- xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
- xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
-
- virtual ~xgl_image_copy_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
- void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
- XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
- void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
- void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
- XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
- void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
-
-
-private:
- XGL_IMAGE_COPY m_struct;
- const XGL_IMAGE_COPY* m_origStructAddr;
+ XGL_LAYER_CREATE_INFO m_struct;
+ const XGL_LAYER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -1859,14 +3327,14 @@
//class declaration
-class xgl_image_memory_barrier_struct_wrapper
+class xgl_buffer_create_info_struct_wrapper
{
public:
- xgl_image_memory_barrier_struct_wrapper();
- xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct);
- xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct);
+ xgl_buffer_create_info_struct_wrapper();
+ xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
+ xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
- virtual ~xgl_image_memory_barrier_struct_wrapper();
+ virtual ~xgl_buffer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -1876,261 +3344,17 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
- void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
- XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
- void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
- XGL_IMAGE_LAYOUT get_oldLayout() { return m_struct.oldLayout; }
- void set_oldLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.oldLayout = inValue; }
- XGL_IMAGE_LAYOUT get_newLayout() { return m_struct.newLayout; }
- void set_newLayout(XGL_IMAGE_LAYOUT inValue) { m_struct.newLayout = inValue; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
- void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
-
-
-private:
- XGL_IMAGE_MEMORY_BARRIER m_struct;
- const XGL_IMAGE_MEMORY_BARRIER* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_physical_gpu_memory_properties_struct_wrapper
-{
-public:
- xgl_physical_gpu_memory_properties_struct_wrapper();
- xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
- xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
-
- virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
- void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
- bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
- void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
-
-
-private:
- XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
- const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_buffer_info_struct_wrapper
-{
-public:
- xgl_memory_alloc_buffer_info_struct_wrapper();
- xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
- xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
-
- virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
XGL_FLAGS get_usage() { return m_struct.usage; }
void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
-
-
-private:
- XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
- const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_compute_pipeline_create_info_struct_wrapper
-{
-public:
- xgl_compute_pipeline_create_info_struct_wrapper();
- xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
- xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
- void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
XGL_FLAGS get_flags() { return m_struct.flags; }
void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
- XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
- void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
- uint32_t get_localSizeX() { return m_struct.localSizeX; }
- void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
- uint32_t get_localSizeY() { return m_struct.localSizeY; }
- void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
- uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
- void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
private:
- XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
- const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_channel_mapping_struct_wrapper
-{
-public:
- xgl_channel_mapping_struct_wrapper();
- xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
- xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
-
- virtual ~xgl_channel_mapping_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
- void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
- XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
- void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
- XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
- void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
- XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
- void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
-
-
-private:
- XGL_CHANNEL_MAPPING m_struct;
- const XGL_CHANNEL_MAPPING* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_peer_image_open_info_struct_wrapper
-{
-public:
- xgl_peer_image_open_info_struct_wrapper();
- xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
- xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
-
- virtual ~xgl_peer_image_open_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
- void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
-
-
-private:
- XGL_PEER_IMAGE_OPEN_INFO m_struct;
- const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_vp_state_create_info_struct_wrapper
-{
-public:
- xgl_dynamic_vp_state_create_info_struct_wrapper();
- xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
- void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
-
-
-private:
- XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_physical_gpu_performance_struct_wrapper
-{
-public:
- xgl_physical_gpu_performance_struct_wrapper();
- xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
- xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
-
- virtual ~xgl_physical_gpu_performance_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- float get_maxGpuClock() { return m_struct.maxGpuClock; }
- void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
- float get_aluPerClock() { return m_struct.aluPerClock; }
- void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
- float get_texPerClock() { return m_struct.texPerClock; }
- void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
- float get_primsPerClock() { return m_struct.primsPerClock; }
- void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
- float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
- void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
-
-
-private:
- XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
- const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+ XGL_BUFFER_CREATE_INFO m_struct;
+ const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -2187,442 +3411,14 @@
//class declaration
-class xgl_viewport_struct_wrapper
+class xgl_descriptor_set_layout_create_info_struct_wrapper
{
public:
- xgl_viewport_struct_wrapper();
- xgl_viewport_struct_wrapper(XGL_VIEWPORT* pInStruct);
- xgl_viewport_struct_wrapper(const XGL_VIEWPORT* pInStruct);
+ xgl_descriptor_set_layout_create_info_struct_wrapper();
+ xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
+ xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
- virtual ~xgl_viewport_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- float get_originX() { return m_struct.originX; }
- void set_originX(float inValue) { m_struct.originX = inValue; }
- float get_originY() { return m_struct.originY; }
- void set_originY(float inValue) { m_struct.originY = inValue; }
- float get_width() { return m_struct.width; }
- void set_width(float inValue) { m_struct.width = inValue; }
- float get_height() { return m_struct.height; }
- void set_height(float inValue) { m_struct.height = inValue; }
- float get_minDepth() { return m_struct.minDepth; }
- void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
- float get_maxDepth() { return m_struct.maxDepth; }
- void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
-
-
-private:
- XGL_VIEWPORT m_struct;
- const XGL_VIEWPORT* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dynamic_ds_state_create_info_struct_wrapper
-{
-public:
- xgl_dynamic_ds_state_create_info_struct_wrapper();
- xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- float get_minDepth() { return m_struct.minDepth; }
- void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
- float get_maxDepth() { return m_struct.maxDepth; }
- void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
- uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
- void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
- uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
- void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
- uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
- void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
- uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
- void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
-
-
-private:
- XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_create_info_struct_wrapper
-{
-public:
- xgl_buffer_create_info_struct_wrapper();
- xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
- xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
-
- virtual ~xgl_buffer_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_BUFFER_CREATE_INFO m_struct;
- const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
-{
-public:
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
-
- virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
- void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
-
-
-private:
- XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
- const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_rect_struct_wrapper
-{
-public:
- xgl_rect_struct_wrapper();
- xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
- xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
-
- virtual ~xgl_rect_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_OFFSET2D get_offset() { return m_struct.offset; }
- void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
- XGL_EXTENT2D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
-
-
-private:
- XGL_RECT m_struct;
- const XGL_RECT* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_memory_barrier_struct_wrapper
-{
-public:
- xgl_buffer_memory_barrier_struct_wrapper();
- xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
- xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
-
- virtual ~xgl_buffer_memory_barrier_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
- void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
- XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
- void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
- XGL_BUFFER get_buffer() { return m_struct.buffer; }
- void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
- XGL_GPU_SIZE get_offset() { return m_struct.offset; }
- void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
-
-
-private:
- XGL_BUFFER_MEMORY_BARRIER m_struct;
- const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_ds_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_ds_state_create_info_struct_wrapper();
- xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
- void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
- bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
- void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
- XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
- void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
- bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
- void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
- bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
- void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
- XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
- void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
- XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
- void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
-
-
-private:
- XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_descriptor_type_count_struct_wrapper
-{
-public:
- xgl_descriptor_type_count_struct_wrapper();
- xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
- xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
-
- virtual ~xgl_descriptor_type_count_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
- void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
- XGL_DESCRIPTOR_TYPE_COUNT m_struct;
- const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_sampler_textures_struct_wrapper
-{
-public:
- xgl_update_sampler_textures_struct_wrapper();
- xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
- xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
-
- virtual ~xgl_update_sampler_textures_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
- XGL_UPDATE_SAMPLER_TEXTURES m_struct;
- const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_query_pool_create_info_struct_wrapper
-{
-public:
- xgl_query_pool_create_info_struct_wrapper();
- xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
- xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
-
- virtual ~xgl_query_pool_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
- void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
- uint32_t get_slots() { return m_struct.slots; }
- void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
-
-
-private:
- XGL_QUERY_POOL_CREATE_INFO m_struct;
- const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_event_create_info_struct_wrapper
-{
-public:
- xgl_event_create_info_struct_wrapper();
- xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
- xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
-
- virtual ~xgl_event_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_EVENT_CREATE_INFO m_struct;
- const XGL_EVENT_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_offset2d_struct_wrapper
-{
-public:
- xgl_offset2d_struct_wrapper();
- xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
- xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
-
- virtual ~xgl_offset2d_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_x() { return m_struct.x; }
- void set_x(int32_t inValue) { m_struct.x = inValue; }
- int32_t get_y() { return m_struct.y; }
- void set_y(int32_t inValue) { m_struct.y = inValue; }
-
-
-private:
- XGL_OFFSET2D m_struct;
- const XGL_OFFSET2D* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_buffers_struct_wrapper
-{
-public:
- xgl_update_buffers_struct_wrapper();
- xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
- xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
-
- virtual ~xgl_update_buffers_struct_wrapper();
+ virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -2634,112 +3430,17 @@
const void* get_pNext() { return m_struct.pNext; }
XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
uint32_t get_count() { return m_struct.count; }
void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
+ void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
+ XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
+ void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
private:
- XGL_UPDATE_BUFFERS m_struct;
- const XGL_UPDATE_BUFFERS* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_ref_struct_wrapper
-{
-public:
- xgl_memory_ref_struct_wrapper();
- xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
- xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
-
- virtual ~xgl_memory_ref_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
- void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_MEMORY_REF m_struct;
- const XGL_MEMORY_REF* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_buffer_view_attach_info_struct_wrapper
-{
-public:
- xgl_buffer_view_attach_info_struct_wrapper();
- xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
- xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
-
- virtual ~xgl_buffer_view_attach_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_BUFFER_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
-
-
-private:
- XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
- const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_vertex_input_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_vertex_input_create_info_struct_wrapper();
- xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
- xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_bindingCount() { return m_struct.bindingCount; }
- void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
- uint32_t get_attributeCount() { return m_struct.attributeCount; }
- void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
-
-
-private:
- XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
- const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+ XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -2777,14 +3478,14 @@
//class declaration
-class xgl_shader_create_info_struct_wrapper
+class xgl_memory_alloc_info_struct_wrapper
{
public:
- xgl_shader_create_info_struct_wrapper();
- xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
- xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+ xgl_memory_alloc_info_struct_wrapper();
+ xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
+ xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
- virtual ~xgl_shader_create_info_struct_wrapper();
+ virtual ~xgl_memory_alloc_info_struct_wrapper();
void display_txt();
void display_single_txt();
@@ -2794,16 +3495,19 @@
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- size_t get_codeSize() { return m_struct.codeSize; }
- void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
- const void* get_pCode() { return m_struct.pCode; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
+ void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
+ XGL_FLAGS get_memProps() { return m_struct.memProps; }
+ void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+ XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+ void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+ XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
+ void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
private:
- XGL_SHADER_CREATE_INFO m_struct;
- const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+ XGL_MEMORY_ALLOC_INFO m_struct;
+ const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
@@ -2812,737 +3516,33 @@
//class declaration
-class xgl_offset3d_struct_wrapper
+class xgl_physical_gpu_queue_properties_struct_wrapper
{
public:
- xgl_offset3d_struct_wrapper();
- xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
- xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+ xgl_physical_gpu_queue_properties_struct_wrapper();
+ xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+ xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
- virtual ~xgl_offset3d_struct_wrapper();
+ virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_x() { return m_struct.x; }
- void set_x(int32_t inValue) { m_struct.x = inValue; }
- int32_t get_y() { return m_struct.y; }
- void set_y(int32_t inValue) { m_struct.y = inValue; }
- int32_t get_z() { return m_struct.z; }
- void set_z(int32_t inValue) { m_struct.z = inValue; }
-
-
-private:
- XGL_OFFSET3D m_struct;
- const XGL_OFFSET3D* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_layer_create_info_struct_wrapper
-{
-public:
- xgl_layer_create_info_struct_wrapper();
- xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
- xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
-
- virtual ~xgl_layer_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_layerCount() { return m_struct.layerCount; }
- void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
-
-
-private:
- XGL_LAYER_CREATE_INFO m_struct;
- const XGL_LAYER_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_depth_stencil_view_create_info_struct_wrapper
-{
-public:
- xgl_depth_stencil_view_create_info_struct_wrapper();
- xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
- xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
-
- virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- uint32_t get_mipLevel() { return m_struct.mipLevel; }
- void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
- void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
- void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_depth_stencil_bind_info_struct_wrapper
-{
-public:
- xgl_depth_stencil_bind_info_struct_wrapper();
- xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
- xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
-
- virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
- XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
- void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
-
-
-private:
- XGL_DEPTH_STENCIL_BIND_INFO m_struct;
- const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_memory_requirements_struct_wrapper
-{
-public:
- xgl_image_memory_requirements_struct_wrapper();
- xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
- xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct);
-
- virtual ~xgl_image_memory_requirements_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
- void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-
-
-private:
- XGL_IMAGE_MEMORY_REQUIREMENTS m_struct;
- const XGL_IMAGE_MEMORY_REQUIREMENTS* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_subresource_range_struct_wrapper
-{
-public:
- xgl_image_subresource_range_struct_wrapper();
- xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
- xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
-
- virtual ~xgl_image_subresource_range_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
- void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
- uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
- void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
- uint32_t get_mipLevels() { return m_struct.mipLevels; }
- void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
-
-
-private:
- XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
- const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_images_struct_wrapper
-{
-public:
- xgl_update_images_struct_wrapper();
- xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
- xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
-
- virtual ~xgl_update_images_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
- XGL_UPDATE_IMAGES m_struct;
- const XGL_UPDATE_IMAGES* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_dispatch_indirect_cmd_struct_wrapper
-{
-public:
- xgl_dispatch_indirect_cmd_struct_wrapper();
- xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
- xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
-
- virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_x() { return m_struct.x; }
- void set_x(uint32_t inValue) { m_struct.x = inValue; }
- uint32_t get_y() { return m_struct.y; }
- void set_y(uint32_t inValue) { m_struct.y = inValue; }
- uint32_t get_z() { return m_struct.z; }
- void set_z(uint32_t inValue) { m_struct.z = inValue; }
-
-
-private:
- XGL_DISPATCH_INDIRECT_CMD m_struct;
- const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_extent3d_struct_wrapper
-{
-public:
- xgl_extent3d_struct_wrapper();
- xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct);
- xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct);
-
- virtual ~xgl_extent3d_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_width() { return m_struct.width; }
- void set_width(int32_t inValue) { m_struct.width = inValue; }
- int32_t get_height() { return m_struct.height; }
- void set_height(int32_t inValue) { m_struct.height = inValue; }
- int32_t get_depth() { return m_struct.depth; }
- void set_depth(int32_t inValue) { m_struct.depth = inValue; }
-
-
-private:
- XGL_EXTENT3D m_struct;
- const XGL_EXTENT3D* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_clear_color_value_struct_wrapper
-{
-public:
- xgl_clear_color_value_struct_wrapper();
- xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
- xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
-
- virtual ~xgl_clear_color_value_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
-
-
-private:
- XGL_CLEAR_COLOR_VALUE m_struct;
- const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_memory_alloc_image_info_struct_wrapper
-{
-public:
- xgl_memory_alloc_image_info_struct_wrapper();
- xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
- xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
-
- virtual ~xgl_memory_alloc_image_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
- void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
-
-
-private:
- XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
- const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_device_queue_create_info_struct_wrapper
-{
-public:
- xgl_device_queue_create_info_struct_wrapper();
- xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
- xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_device_queue_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
- void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
+ XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
+ void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
uint32_t get_queueCount() { return m_struct.queueCount; }
void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+ uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
+ void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
+ bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
+ void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
private:
- XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
- const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_stencil_op_state_struct_wrapper
-{
-public:
- xgl_stencil_op_state_struct_wrapper();
- xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
- xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
-
- virtual ~xgl_stencil_op_state_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
- void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
- XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
- void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
- XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
- void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
- XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
- void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
-
-
-private:
- XGL_STENCIL_OP_STATE m_struct;
- const XGL_STENCIL_OP_STATE* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_shader_struct_wrapper
-{
-public:
- xgl_pipeline_shader_struct_wrapper();
- xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
- xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
-
- virtual ~xgl_pipeline_shader_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
- void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
- XGL_SHADER get_shader() { return m_struct.shader; }
- void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
- uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
- void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
-
-
-private:
- XGL_PIPELINE_SHADER m_struct;
- const XGL_PIPELINE_SHADER* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_queue_semaphore_create_info_struct_wrapper
-{
-public:
- xgl_queue_semaphore_create_info_struct_wrapper();
- xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
- xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_initialCount() { return m_struct.initialCount; }
- void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
- const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_statistics_data_struct_wrapper
-{
-public:
- xgl_pipeline_statistics_data_struct_wrapper();
- xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
- xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
-
- virtual ~xgl_pipeline_statistics_data_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
- void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
- uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
- void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
- uint64_t get_cInvocations() { return m_struct.cInvocations; }
- void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
- uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
- void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
- uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
- void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
- uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
- void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
- uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
- void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
- uint64_t get_iaVertices() { return m_struct.iaVertices; }
- void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
- uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
- void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
- uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
- void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
- uint64_t get_csInvocations() { return m_struct.csInvocations; }
- void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
-
-
-private:
- XGL_PIPELINE_STATISTICS_DATA m_struct;
- const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_vertex_input_attribute_description_struct_wrapper
-{
-public:
- xgl_vertex_input_attribute_description_struct_wrapper();
- xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
- xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
-
- virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_binding() { return m_struct.binding; }
- void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
- void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
-
-
-private:
- XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
- const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_vertex_input_binding_description_struct_wrapper
-{
-public:
- xgl_vertex_input_binding_description_struct_wrapper();
- xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
- xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
-
- virtual ~xgl_vertex_input_binding_description_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
- void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
- XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
- void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
-
-
-private:
- XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
- const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_update_samplers_struct_wrapper
-{
-public:
- xgl_update_samplers_struct_wrapper();
- xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
- xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
-
- virtual ~xgl_update_samplers_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
-
-
-private:
- XGL_UPDATE_SAMPLERS m_struct;
- const XGL_UPDATE_SAMPLERS* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_image_create_info_struct_wrapper
-{
-public:
- xgl_image_create_info_struct_wrapper();
- xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
- xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_image_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
- void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
- uint32_t get_mipLevels() { return m_struct.mipLevels; }
- void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
- XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
- void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_IMAGE_CREATE_INFO m_struct;
- const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_tess_state_create_info_struct_wrapper
-{
-public:
- xgl_pipeline_tess_state_create_info_struct_wrapper();
- xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
- void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
- float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
- void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
- float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
- void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
-
-
-private:
- XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();