* 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.
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
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')
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')
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')
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')
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')
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
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
#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
#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_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ switch ((XGL_IMAGE_TILING)input_value)
{
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+ case XGL_LINEAR_TILING:
+ return "XGL_LINEAR_TILING";
+ case XGL_OPTIMAL_TILING:
+ return "XGL_OPTIMAL_TILING";
default:
- return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+ return "Unhandled XGL_IMAGE_TILING";
}
}
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
default:
- return "Unhandled XGL_MEMORY_TYPE";
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ return "XGL_IMAGE_FORMAT_CLASS_D16";
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ return "XGL_IMAGE_FORMAT_CLASS_D24";
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ return "XGL_IMAGE_FORMAT_CLASS_D32";
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return "XGL_IMAGE_FORMAT_CLASS_S8";
default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+ return "Unhandled XGL_IMAGE_FORMAT_CLASS";
}
}
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
- switch ((XGL_CULL_MODE)input_value)
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
{
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
+ case XGL_FORMAT_CONVERSION_BIT:
+ return "XGL_FORMAT_CONVERSION_BIT";
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ return "XGL_FORMAT_IMAGE_COPY_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
default:
- return "Unhandled XGL_CULL_MODE";
+ return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ case XGL_IMAGE_VIEW_1D:
+ return "XGL_IMAGE_VIEW_1D";
+ case XGL_IMAGE_VIEW_2D:
+ return "XGL_IMAGE_VIEW_2D";
+ case XGL_IMAGE_VIEW_3D:
+ return "XGL_IMAGE_VIEW_3D";
+ case XGL_IMAGE_VIEW_CUBE:
+ return "XGL_IMAGE_VIEW_CUBE";
default:
- return "Unhandled XGL_IMAGE_LAYOUT";
+ return "Unhandled XGL_IMAGE_VIEW_TYPE";
}
}
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_MEMORY_PRIORITY)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
default:
- return "Unhandled XGL_MEMORY_PRIORITY";
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
}
}
}
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
}
}
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
{
- switch ((XGL_VALIDATION_LEVEL)input_value)
+ switch ((XGL_COMPARE_FUNC)input_value)
{
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
default:
- return "Unhandled XGL_VALIDATION_LEVEL";
+ return "Unhandled XGL_COMPARE_FUNC";
}
}
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
{
- switch ((XGL_STATE_BIND_POINT)input_value)
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
{
- case XGL_STATE_BIND_COLOR_BLEND:
- return "XGL_STATE_BIND_COLOR_BLEND";
- case XGL_STATE_BIND_DEPTH_STENCIL:
- return "XGL_STATE_BIND_DEPTH_STENCIL";
- case XGL_STATE_BIND_RASTER:
- return "XGL_STATE_BIND_RASTER";
- case XGL_STATE_BIND_VIEWPORT:
- return "XGL_STATE_BIND_VIEWPORT";
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
default:
- return "Unhandled XGL_STATE_BIND_POINT";
+ return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ {
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ default:
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+{
+ switch ((XGL_IMAGE_ASPECT)input_value)
+ {
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
+ default:
+ return "Unhandled XGL_IMAGE_ASPECT";
}
}
}
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+ default:
+ return "Unhandled XGL_FACE_ORIENTATION";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_FILTER";
}
}
}
+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)
}
-static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
{
- switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ switch ((XGL_QUEUE_TYPE)input_value)
{
- case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
- return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
- case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
- return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
- case XGL_FORMAT_CONVERSION_BIT:
- return "XGL_FORMAT_CONVERSION_BIT";
- case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
- return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
- case XGL_FORMAT_IMAGE_COPY_BIT:
- return "XGL_FORMAT_IMAGE_COPY_BIT";
- case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
- return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
- case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
- return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
- case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
- return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
- case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
- return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
- case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
- return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
default:
- return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
+ return "Unhandled XGL_QUEUE_TYPE";
}
}
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
}
}
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ return "Unhandled XGL_COORDINATE_ORIGIN";
}
}
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ switch ((XGL_FILL_MODE)input_value)
{
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
default:
- return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+ return "Unhandled XGL_FILL_MODE";
}
}
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_WAIT_EVENT)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- return "XGL_MEMORY_PROPERTY_GPU_ONLY";
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return "XGL_WAIT_EVENT_TOP_OF_PIPE";
default:
- return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+ return "Unhandled XGL_WAIT_EVENT";
}
}
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
{
- switch ((XGL_COMPARE_FUNC)input_value)
+ switch ((XGL_STENCIL_OP)input_value)
{
- case XGL_COMPARE_ALWAYS:
- return "XGL_COMPARE_ALWAYS";
- case XGL_COMPARE_EQUAL:
- return "XGL_COMPARE_EQUAL";
- case XGL_COMPARE_GREATER:
- return "XGL_COMPARE_GREATER";
- case XGL_COMPARE_GREATER_EQUAL:
- return "XGL_COMPARE_GREATER_EQUAL";
- case XGL_COMPARE_LESS:
- return "XGL_COMPARE_LESS";
- case XGL_COMPARE_LESS_EQUAL:
- return "XGL_COMPARE_LESS_EQUAL";
- case XGL_COMPARE_NEVER:
- return "XGL_COMPARE_NEVER";
- case XGL_COMPARE_NOT_EQUAL:
- return "XGL_COMPARE_NOT_EQUAL";
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
default:
- return "Unhandled XGL_COMPARE_FUNC";
+ return "Unhandled XGL_STENCIL_OP";
}
}
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
- {
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- return "XGL_PIPELINE_BIND_POINT_COMPUTE";
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
- default:
- return "Unhandled XGL_PIPELINE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
- {
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
- return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
- default:
- return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
- {
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
- default:
- return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
- }
-}
-
-
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
-{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
- {
- case XGL_CHANNEL_SWIZZLE_A:
- return "XGL_CHANNEL_SWIZZLE_A";
- case XGL_CHANNEL_SWIZZLE_B:
- return "XGL_CHANNEL_SWIZZLE_B";
- case XGL_CHANNEL_SWIZZLE_G:
- return "XGL_CHANNEL_SWIZZLE_G";
- case XGL_CHANNEL_SWIZZLE_ONE:
- return "XGL_CHANNEL_SWIZZLE_ONE";
- case XGL_CHANNEL_SWIZZLE_R:
- return "XGL_CHANNEL_SWIZZLE_R";
- case XGL_CHANNEL_SWIZZLE_ZERO:
- return "XGL_CHANNEL_SWIZZLE_ZERO";
- default:
- return "Unhandled XGL_CHANNEL_SWIZZLE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
-{
- switch ((XGL_TEX_ADDRESS)input_value)
- {
- case XGL_TEX_ADDRESS_CLAMP:
- return "XGL_TEX_ADDRESS_CLAMP";
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- return "XGL_TEX_ADDRESS_CLAMP_BORDER";
- case XGL_TEX_ADDRESS_MIRROR:
- return "XGL_TEX_ADDRESS_MIRROR";
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- return "XGL_TEX_ADDRESS_MIRROR_ONCE";
- case XGL_TEX_ADDRESS_WRAP:
- return "XGL_TEX_ADDRESS_WRAP";
- default:
- return "Unhandled XGL_TEX_ADDRESS";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
-{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
{
case XGL_BUFFER_USAGE_GENERAL:
return "XGL_BUFFER_USAGE_GENERAL";
}
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
- default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_BLEND_FUNC)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
default:
- return "Unhandled XGL_QUEUE_FLAGS";
+ return "Unhandled XGL_BLEND_FUNC";
}
}
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_IMAGE_VIEW_1D:
- return "XGL_IMAGE_VIEW_1D";
- case XGL_IMAGE_VIEW_2D:
- return "XGL_IMAGE_VIEW_2D";
- case XGL_IMAGE_VIEW_3D:
- return "XGL_IMAGE_VIEW_3D";
- case XGL_IMAGE_VIEW_CUBE:
- return "XGL_IMAGE_VIEW_CUBE";
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
default:
- return "Unhandled XGL_IMAGE_VIEW_TYPE";
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
}
}
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ return "XGL_SHADER_STAGE_FLAGS_ALL";
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+ return "Unhandled XGL_SHADER_STAGE_FLAGS";
}
}
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return "XGL_MEMORY_REF_READ_ONLY_BIT";
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
default:
- return "Unhandled XGL_MEMORY_REF_FLAGS";
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
}
}
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
{
- switch ((XGL_STRUCTURE_TYPE)input_value)
+ switch ((XGL_RESULT)input_value)
{
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
- default:
- return "Unhandled XGL_STRUCTURE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
-{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
- {
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
- case XGL_ATTACHMENT_STORE_OP_STORE:
- return "XGL_ATTACHMENT_STORE_OP_STORE";
- default:
- return "Unhandled XGL_ATTACHMENT_STORE_OP";
- }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return "XGL_WAIT_EVENT_TOP_OF_PIPE";
- default:
- return "Unhandled XGL_WAIT_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
-{
- switch ((XGL_DEPTH_MODE)input_value)
- {
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
- default:
- return "Unhandled XGL_DEPTH_MODE";
- }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
- default:
- return "Unhandled XGL_FILL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ return "XGL_ERROR_BAD_PIPELINE_DATA";
+ case XGL_ERROR_BAD_SHADER_CODE:
+ return "XGL_ERROR_BAD_SHADER_CODE";
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+ case XGL_ERROR_DEVICE_LOST:
+ return "XGL_ERROR_DEVICE_LOST";
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ return "XGL_ERROR_INITIALIZATION_FAILED";
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ return "XGL_ERROR_INVALID_ALIGNMENT";
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case XGL_ERROR_INVALID_EXTENSION:
+ return "XGL_ERROR_INVALID_EXTENSION";
+ case XGL_ERROR_INVALID_FLAGS:
+ return "XGL_ERROR_INVALID_FLAGS";
+ case XGL_ERROR_INVALID_FORMAT:
+ return "XGL_ERROR_INVALID_FORMAT";
+ case XGL_ERROR_INVALID_HANDLE:
+ return "XGL_ERROR_INVALID_HANDLE";
+ case XGL_ERROR_INVALID_IMAGE:
+ return "XGL_ERROR_INVALID_IMAGE";
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ return "XGL_ERROR_INVALID_MEMORY_SIZE";
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ return "XGL_ERROR_INVALID_OBJECT_TYPE";
+ case XGL_ERROR_INVALID_ORDINAL:
+ return "XGL_ERROR_INVALID_ORDINAL";
+ case XGL_ERROR_INVALID_POINTER:
+ return "XGL_ERROR_INVALID_POINTER";
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ return "XGL_ERROR_INVALID_QUEUE_TYPE";
+ case XGL_ERROR_INVALID_VALUE:
+ return "XGL_ERROR_INVALID_VALUE";
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ return "XGL_ERROR_MEMORY_MAP_FAILED";
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ return "XGL_ERROR_MEMORY_NOT_BOUND";
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+ case XGL_ERROR_NOT_MAPPABLE:
+ return "XGL_ERROR_NOT_MAPPABLE";
+ case XGL_ERROR_NOT_SHAREABLE:
+ return "XGL_ERROR_NOT_SHAREABLE";
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+ case XGL_ERROR_OUT_OF_MEMORY:
+ return "XGL_ERROR_OUT_OF_MEMORY";
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ case XGL_ERROR_UNAVAILABLE:
+ return "XGL_ERROR_UNAVAILABLE";
+ case XGL_ERROR_UNKNOWN:
+ return "XGL_ERROR_UNKNOWN";
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
+ return "Unhandled XGL_RESULT";
}
}
}
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
+ return "Unhandled XGL_STATE_BIND_POINT";
}
}
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_IMAGE_LAYOUT)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
default:
- return "Unhandled XGL_IMAGE_ASPECT";
+ return "Unhandled XGL_IMAGE_LAYOUT";
}
}
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
default:
- return "Unhandled XGL_OBJECT_INFO_TYPE";
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
}
}
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ case XGL_MEMORY_TYPE_BUFFER:
+ return "XGL_MEMORY_TYPE_BUFFER";
+ case XGL_MEMORY_TYPE_IMAGE:
+ return "XGL_MEMORY_TYPE_IMAGE";
+ case XGL_MEMORY_TYPE_OTHER:
+ return "XGL_MEMORY_TYPE_OTHER";
default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ return "Unhandled XGL_MEMORY_TYPE";
}
}
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
{
- switch ((XGL_INDEX_TYPE)input_value)
+ switch ((XGL_CULL_MODE)input_value)
{
- case XGL_INDEX_16:
- return "XGL_INDEX_16";
- case XGL_INDEX_32:
- return "XGL_INDEX_32";
- case XGL_INDEX_8:
- return "XGL_INDEX_8";
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
default:
- return "Unhandled XGL_INDEX_TYPE";
+ return "Unhandled XGL_CULL_MODE";
}
}
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
{
- case XGL_LINEAR_TILING:
- return "XGL_LINEAR_TILING";
- case XGL_OPTIMAL_TILING:
- return "XGL_OPTIMAL_TILING";
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
default:
- return "Unhandled XGL_IMAGE_TILING";
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
}
}
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
default:
- return "Unhandled XGL_QUEUE_TYPE";
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
}
}
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
}
}
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- return "XGL_SHADER_STAGE_FLAGS_ALL";
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
default:
- return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
}
}
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_COPY_BIT:
- return "XGL_MEMORY_INPUT_COPY_BIT";
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- return "XGL_MEMORY_INPUT_CPU_READ_BIT";
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
- return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
default:
- return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+ return "Unhandled XGL_TIMESTAMP_TYPE";
}
}
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_IMAGE_TYPE)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
+ return "Unhandled XGL_IMAGE_TYPE";
}
}
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_LOGIC_OP_AND:
- return "XGL_LOGIC_OP_AND";
- case XGL_LOGIC_OP_AND_INVERTED:
- return "XGL_LOGIC_OP_AND_INVERTED";
- case XGL_LOGIC_OP_AND_REVERSE:
- return "XGL_LOGIC_OP_AND_REVERSE";
- case XGL_LOGIC_OP_CLEAR:
- return "XGL_LOGIC_OP_CLEAR";
- case XGL_LOGIC_OP_COPY:
- return "XGL_LOGIC_OP_COPY";
- case XGL_LOGIC_OP_COPY_INVERTED:
- return "XGL_LOGIC_OP_COPY_INVERTED";
- case XGL_LOGIC_OP_EQUIV:
- return "XGL_LOGIC_OP_EQUIV";
- case XGL_LOGIC_OP_INVERT:
- return "XGL_LOGIC_OP_INVERT";
- case XGL_LOGIC_OP_NAND:
- return "XGL_LOGIC_OP_NAND";
- case XGL_LOGIC_OP_NOOP:
- return "XGL_LOGIC_OP_NOOP";
- case XGL_LOGIC_OP_NOR:
- return "XGL_LOGIC_OP_NOR";
- case XGL_LOGIC_OP_OR:
- return "XGL_LOGIC_OP_OR";
- case XGL_LOGIC_OP_OR_INVERTED:
- return "XGL_LOGIC_OP_OR_INVERTED";
- case XGL_LOGIC_OP_OR_REVERSE:
- return "XGL_LOGIC_OP_OR_REVERSE";
- case XGL_LOGIC_OP_SET:
- return "XGL_LOGIC_OP_SET";
- case XGL_LOGIC_OP_XOR:
- return "XGL_LOGIC_OP_XOR";
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
default:
- return "Unhandled XGL_LOGIC_OP";
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
}
}
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- return "XGL_MEMORY_OUTPUT_COPY_BIT";
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
- default:
- return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
{
switch ((XGL_BLEND)input_value)
{
}
-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";
}
}
}
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
default:
- return "Unhandled XGL_TEX_FILTER";
+ return "Unhandled XGL_TEX_ADDRESS";
}
}
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
{
- switch ((XGL_BLEND_FUNC)input_value)
+ switch ((XGL_MEMORY_PRIORITY)input_value)
{
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
default:
- return "Unhandled XGL_BLEND_FUNC";
+ return "Unhandled XGL_MEMORY_PRIORITY";
}
}
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
{
- switch ((XGL_FACE_ORIENTATION)input_value)
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
{
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
default:
- return "Unhandled XGL_FACE_ORIENTATION";
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_QUEUE_FLAGS";
}
}
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
- case XGL_IMAGE_FORMAT_CLASS_D16:
- return "XGL_IMAGE_FORMAT_CLASS_D16";
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- return "XGL_IMAGE_FORMAT_CLASS_D16S8";
- case XGL_IMAGE_FORMAT_CLASS_D24:
- return "XGL_IMAGE_FORMAT_CLASS_D24";
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- return "XGL_IMAGE_FORMAT_CLASS_D24S8";
- case XGL_IMAGE_FORMAT_CLASS_D32:
- return "XGL_IMAGE_FORMAT_CLASS_D32";
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- return "XGL_IMAGE_FORMAT_CLASS_D32S8";
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return "XGL_IMAGE_FORMAT_CLASS_S8";
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ return "XGL_MEMORY_INPUT_COPY_BIT";
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
default:
- return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+ return "Unhandled XGL_STRUCTURE_TYPE";
}
}
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
}
}
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_PROVOKING_VERTEX_FIRST:
- return "XGL_PROVOKING_VERTEX_FIRST";
- case XGL_PROVOKING_VERTEX_LAST:
- return "XGL_PROVOKING_VERTEX_LAST";
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
default:
- return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
+ return "Unhandled XGL_LOGIC_OP";
}
}
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
{
- switch ((XGL_RESULT)input_value)
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
{
- case XGL_ERROR_BAD_PIPELINE_DATA:
- return "XGL_ERROR_BAD_PIPELINE_DATA";
- case XGL_ERROR_BAD_SHADER_CODE:
- return "XGL_ERROR_BAD_SHADER_CODE";
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- return "XGL_ERROR_DEVICE_ALREADY_CREATED";
- case XGL_ERROR_DEVICE_LOST:
- return "XGL_ERROR_DEVICE_LOST";
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- return "XGL_ERROR_INCOMPATIBLE_DEVICE";
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- return "XGL_ERROR_INCOMPATIBLE_DRIVER";
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- return "XGL_ERROR_INCOMPATIBLE_QUEUE";
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case XGL_ERROR_INITIALIZATION_FAILED:
- return "XGL_ERROR_INITIALIZATION_FAILED";
- case XGL_ERROR_INVALID_ALIGNMENT:
- return "XGL_ERROR_INVALID_ALIGNMENT";
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case XGL_ERROR_INVALID_EXTENSION:
- return "XGL_ERROR_INVALID_EXTENSION";
- case XGL_ERROR_INVALID_FLAGS:
- return "XGL_ERROR_INVALID_FLAGS";
- case XGL_ERROR_INVALID_FORMAT:
- return "XGL_ERROR_INVALID_FORMAT";
- case XGL_ERROR_INVALID_HANDLE:
- return "XGL_ERROR_INVALID_HANDLE";
- case XGL_ERROR_INVALID_IMAGE:
- return "XGL_ERROR_INVALID_IMAGE";
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- return "XGL_ERROR_INVALID_MEMORY_SIZE";
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- return "XGL_ERROR_INVALID_OBJECT_TYPE";
- case XGL_ERROR_INVALID_ORDINAL:
- return "XGL_ERROR_INVALID_ORDINAL";
- case XGL_ERROR_INVALID_POINTER:
- return "XGL_ERROR_INVALID_POINTER";
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- return "XGL_ERROR_INVALID_QUEUE_TYPE";
- case XGL_ERROR_INVALID_VALUE:
- return "XGL_ERROR_INVALID_VALUE";
- case XGL_ERROR_MEMORY_MAP_FAILED:
- return "XGL_ERROR_MEMORY_MAP_FAILED";
- case XGL_ERROR_MEMORY_NOT_BOUND:
- return "XGL_ERROR_MEMORY_NOT_BOUND";
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- return "XGL_ERROR_MEMORY_UNMAP_FAILED";
- case XGL_ERROR_NOT_MAPPABLE:
- return "XGL_ERROR_NOT_MAPPABLE";
- case XGL_ERROR_NOT_SHAREABLE:
- return "XGL_ERROR_NOT_SHAREABLE";
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- return "XGL_ERROR_OUT_OF_GPU_MEMORY";
- case XGL_ERROR_OUT_OF_MEMORY:
- return "XGL_ERROR_OUT_OF_MEMORY";
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
- case XGL_ERROR_UNAVAILABLE:
- return "XGL_ERROR_UNAVAILABLE";
- case XGL_ERROR_UNKNOWN:
- return "XGL_ERROR_UNKNOWN";
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case XGL_EVENT_RESET:
- return "XGL_EVENT_RESET";
- case XGL_EVENT_SET:
- return "XGL_EVENT_SET";
- case XGL_NOT_READY:
- return "XGL_NOT_READY";
- case XGL_SUCCESS:
- return "XGL_SUCCESS";
- case XGL_TIMEOUT:
- return "XGL_TIMEOUT";
- case XGL_UNSUPPORTED:
- return "XGL_UNSUPPORTED";
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
default:
- return "Unhandled XGL_RESULT";
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
}
}
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ case XGL_CHANNEL_SWIZZLE_A:
+ return "XGL_CHANNEL_SWIZZLE_A";
+ case XGL_CHANNEL_SWIZZLE_B:
+ return "XGL_CHANNEL_SWIZZLE_B";
+ case XGL_CHANNEL_SWIZZLE_G:
+ return "XGL_CHANNEL_SWIZZLE_G";
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ return "XGL_CHANNEL_SWIZZLE_ONE";
+ case XGL_CHANNEL_SWIZZLE_R:
+ return "XGL_CHANNEL_SWIZZLE_R";
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return "XGL_CHANNEL_SWIZZLE_ZERO";
default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ return "Unhandled XGL_CHANNEL_SWIZZLE";
}
}
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- return "XGL_SYSTEM_ALLOC_API_OBJECT";
- case XGL_SYSTEM_ALLOC_DEBUG:
- return "XGL_SYSTEM_ALLOC_DEBUG";
- case XGL_SYSTEM_ALLOC_INTERNAL:
- return "XGL_SYSTEM_ALLOC_INTERNAL";
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
default:
- return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+ return "Unhandled XGL_PIPELINE_BIND_POINT";
}
}
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- return "XGL_STENCIL_OP_DEC_CLAMP";
- case XGL_STENCIL_OP_DEC_WRAP:
- return "XGL_STENCIL_OP_DEC_WRAP";
- case XGL_STENCIL_OP_INC_CLAMP:
- return "XGL_STENCIL_OP_INC_CLAMP";
- case XGL_STENCIL_OP_INC_WRAP:
- return "XGL_STENCIL_OP_INC_WRAP";
- case XGL_STENCIL_OP_INVERT:
- return "XGL_STENCIL_OP_INVERT";
- case XGL_STENCIL_OP_KEEP:
- return "XGL_STENCIL_OP_KEEP";
- case XGL_STENCIL_OP_REPLACE:
- return "XGL_STENCIL_OP_REPLACE";
- case XGL_STENCIL_OP_ZERO:
- return "XGL_STENCIL_OP_ZERO";
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
default:
- return "Unhandled XGL_STENCIL_OP";
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
}
}
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ default:
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
}
}
#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_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ switch ((XGL_IMAGE_TILING)input_value)
{
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ case XGL_LINEAR_TILING:
+ case XGL_OPTIMAL_TILING:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ case XGL_IMAGE_FORMAT_CLASS_S8:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
- switch ((XGL_CULL_MODE)input_value)
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
{
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ case XGL_FORMAT_CONVERSION_BIT:
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ case XGL_IMAGE_VIEW_1D:
+ case XGL_IMAGE_VIEW_2D:
+ case XGL_IMAGE_VIEW_3D:
+ case XGL_IMAGE_VIEW_CUBE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_MEMORY_PRIORITY)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
{
- switch ((XGL_VALIDATION_LEVEL)input_value)
+ switch ((XGL_COMPARE_FUNC)input_value)
{
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
+ case XGL_COMPARE_ALWAYS:
+ case XGL_COMPARE_EQUAL:
+ case XGL_COMPARE_GREATER:
+ case XGL_COMPARE_GREATER_EQUAL:
+ case XGL_COMPARE_LESS:
+ case XGL_COMPARE_LESS_EQUAL:
+ case XGL_COMPARE_NEVER:
+ case XGL_COMPARE_NOT_EQUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
{
- switch ((XGL_STATE_BIND_POINT)input_value)
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
{
- case XGL_STATE_BIND_COLOR_BLEND:
- case XGL_STATE_BIND_DEPTH_STENCIL:
- case XGL_STATE_BIND_RASTER:
- case XGL_STATE_BIND_VIEWPORT:
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_BUFFER_VIEW_RAW:
- case XGL_BUFFER_VIEW_STRUCTURED:
- case XGL_BUFFER_VIEW_TYPED:
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
{
- switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
+ switch ((XGL_FACE_ORIENTATION)input_value)
{
- case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
- case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
- case XGL_FORMAT_CONVERSION_BIT:
- case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
- case XGL_FORMAT_IMAGE_COPY_BIT:
- case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
- case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
- case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
- case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
- case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ case XGL_FRONT_FACE_CCW:
+ case XGL_FRONT_FACE_CW:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_TEX_FILTER)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
+ case XGL_BUFFER_VIEW_RAW:
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ case XGL_BUFFER_VIEW_TYPED:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
{
- switch ((XGL_COMPARE_FUNC)input_value)
+ switch ((XGL_QUEUE_TYPE)input_value)
{
- case XGL_COMPARE_ALWAYS:
- case XGL_COMPARE_EQUAL:
- case XGL_COMPARE_GREATER:
- case XGL_COMPARE_GREATER_EQUAL:
- case XGL_COMPARE_LESS:
- case XGL_COMPARE_LESS_EQUAL:
- case XGL_COMPARE_NEVER:
- case XGL_COMPARE_NOT_EQUAL:
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
- {
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
-{
- switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
{
- case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
- case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
{
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_FILL_MODE)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_WAIT_EVENT)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- case XGL_CHANNEL_SWIZZLE_B:
- case XGL_CHANNEL_SWIZZLE_G:
- case XGL_CHANNEL_SWIZZLE_ONE:
- case XGL_CHANNEL_SWIZZLE_R:
- case XGL_CHANNEL_SWIZZLE_ZERO:
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_STENCIL_OP)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- case XGL_TEX_ADDRESS_MIRROR:
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- case XGL_TEX_ADDRESS_WRAP:
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
return 1;
default:
return 0;
}
-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;
}
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ case XGL_IMAGE_USAGE_GENERAL:
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
{
- case XGL_IMAGE_VIEW_1D:
- case XGL_IMAGE_VIEW_2D:
- case XGL_IMAGE_VIEW_3D:
- case XGL_IMAGE_VIEW_CUBE:
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ switch ((XGL_RESULT)input_value)
{
- case XGL_MEMORY_REF_READ_ONLY_BIT:
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ case XGL_ERROR_BAD_SHADER_CODE:
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ case XGL_ERROR_DEVICE_LOST:
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ case XGL_ERROR_INVALID_EXTENSION:
+ case XGL_ERROR_INVALID_FLAGS:
+ case XGL_ERROR_INVALID_FORMAT:
+ case XGL_ERROR_INVALID_HANDLE:
+ case XGL_ERROR_INVALID_IMAGE:
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ case XGL_ERROR_INVALID_ORDINAL:
+ case XGL_ERROR_INVALID_POINTER:
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ case XGL_ERROR_INVALID_VALUE:
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ case XGL_ERROR_NOT_MAPPABLE:
+ case XGL_ERROR_NOT_SHAREABLE:
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ case XGL_ERROR_OUT_OF_MEMORY:
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ case XGL_ERROR_UNAVAILABLE:
+ case XGL_ERROR_UNKNOWN:
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ case XGL_EVENT_RESET:
+ case XGL_EVENT_SET:
+ case XGL_NOT_READY:
+ case XGL_SUCCESS:
+ case XGL_TIMEOUT:
+ case XGL_UNSUPPORTED:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
{
- switch ((XGL_STRUCTURE_TYPE)input_value)
+ switch ((XGL_SET_EVENT)input_value)
{
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- case XGL_ATTACHMENT_STORE_OP_STORE:
+ case XGL_STATE_BIND_COLOR_BLEND:
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ case XGL_STATE_BIND_RASTER:
+ case XGL_STATE_BIND_VIEWPORT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
{
- switch ((XGL_WAIT_EVENT)input_value)
+ switch ((XGL_IMAGE_LAYOUT)input_value)
{
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ switch ((XGL_CULL_MODE)input_value)
{
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
{
- switch ((XGL_SET_EVENT)input_value)
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
{
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
{
- switch ((XGL_INDEX_TYPE)input_value)
+ switch ((XGL_IMAGE_TYPE)input_value)
{
- case XGL_INDEX_16:
- case XGL_INDEX_32:
- case XGL_INDEX_8:
+ case XGL_IMAGE_1D:
+ case XGL_IMAGE_2D:
+ case XGL_IMAGE_3D:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_LINEAR_TILING:
- case XGL_OPTIMAL_TILING:
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_BLEND)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- case XGL_QUEUE_TYPE_DMA:
- case XGL_QUEUE_TYPE_GRAPHICS:
+ case XGL_BLEND_CONSTANT_ALPHA:
+ case XGL_BLEND_CONSTANT_COLOR:
+ case XGL_BLEND_DEST_ALPHA:
+ case XGL_BLEND_DEST_COLOR:
+ case XGL_BLEND_ONE:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ case XGL_BLEND_SRC1_ALPHA:
+ case XGL_BLEND_SRC1_COLOR:
+ case XGL_BLEND_SRC_ALPHA:
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ case XGL_BLEND_SRC_COLOR:
+ case XGL_BLEND_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ case XGL_TOPOLOGY_LINE_LIST:
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ case XGL_TOPOLOGY_LINE_STRIP:
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ case XGL_TOPOLOGY_PATCH:
+ case XGL_TOPOLOGY_POINT_LIST:
+ case XGL_TOPOLOGY_QUAD_LIST:
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ case XGL_TOPOLOGY_RECT_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
{
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_COPY_BIT:
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ case XGL_ATTACHMENT_STORE_OP_STORE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
{
- case XGL_LOGIC_OP_AND:
- case XGL_LOGIC_OP_AND_INVERTED:
- case XGL_LOGIC_OP_AND_REVERSE:
- case XGL_LOGIC_OP_CLEAR:
- case XGL_LOGIC_OP_COPY:
- case XGL_LOGIC_OP_COPY_INVERTED:
- case XGL_LOGIC_OP_EQUIV:
- case XGL_LOGIC_OP_INVERT:
- case XGL_LOGIC_OP_NAND:
- case XGL_LOGIC_OP_NOOP:
- case XGL_LOGIC_OP_NOR:
- case XGL_LOGIC_OP_OR:
- case XGL_LOGIC_OP_OR_INVERTED:
- case XGL_LOGIC_OP_OR_REVERSE:
- case XGL_LOGIC_OP_SET:
- case XGL_LOGIC_OP_XOR:
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_INDEX_TYPE)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_BLEND)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_BLEND_CONSTANT_ALPHA:
- case XGL_BLEND_CONSTANT_COLOR:
- case XGL_BLEND_DEST_ALPHA:
- case XGL_BLEND_DEST_COLOR:
- case XGL_BLEND_ONE:
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- case XGL_BLEND_SRC1_ALPHA:
- case XGL_BLEND_SRC1_COLOR:
- case XGL_BLEND_SRC_ALPHA:
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- case XGL_BLEND_SRC_COLOR:
- case XGL_BLEND_ZERO:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
- {
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
- {
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- case XGL_IMAGE_USAGE_GENERAL:
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
return 1;
default:
return 0;
}
-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;
}
-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;
}
-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;
}
-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;
}
-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;
}
-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;
}
-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_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+static inline uint32_t validate_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ switch ((XGL_STRUCTURE_TYPE)input_value)
{
- case XGL_PROVOKING_VERTEX_FIRST:
- case XGL_PROVOKING_VERTEX_LAST:
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
{
- switch ((XGL_RESULT)input_value)
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
{
- case XGL_ERROR_BAD_PIPELINE_DATA:
- case XGL_ERROR_BAD_SHADER_CODE:
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- case XGL_ERROR_DEVICE_LOST:
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- case XGL_ERROR_INITIALIZATION_FAILED:
- case XGL_ERROR_INVALID_ALIGNMENT:
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- case XGL_ERROR_INVALID_EXTENSION:
- case XGL_ERROR_INVALID_FLAGS:
- case XGL_ERROR_INVALID_FORMAT:
- case XGL_ERROR_INVALID_HANDLE:
- case XGL_ERROR_INVALID_IMAGE:
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- case XGL_ERROR_INVALID_ORDINAL:
- case XGL_ERROR_INVALID_POINTER:
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- case XGL_ERROR_INVALID_VALUE:
- case XGL_ERROR_MEMORY_MAP_FAILED:
- case XGL_ERROR_MEMORY_NOT_BOUND:
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- case XGL_ERROR_NOT_MAPPABLE:
- case XGL_ERROR_NOT_SHAREABLE:
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- case XGL_ERROR_OUT_OF_MEMORY:
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- case XGL_ERROR_UNAVAILABLE:
- case XGL_ERROR_UNKNOWN:
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- case XGL_EVENT_RESET:
- case XGL_EVENT_SET:
- case XGL_NOT_READY:
- case XGL_SUCCESS:
- case XGL_TIMEOUT:
- case XGL_UNSUPPORTED:
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
+ case XGL_CHANNEL_SWIZZLE_A:
+ case XGL_CHANNEL_SWIZZLE_B:
+ case XGL_CHANNEL_SWIZZLE_G:
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ case XGL_CHANNEL_SWIZZLE_R:
+ case XGL_CHANNEL_SWIZZLE_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ case XGL_PROVOKING_VERTEX_LAST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
return 1;
default:
return 0;
*************************************************************************/
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"
#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>
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
)
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
#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
#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"
}
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;
m_pDSDump = NULL;
m_pCBDump = NULL;
m_pGlvSnapshotPrint = NULL;
+ m_adjustForGPU = false;
if (g_pReplaySettings && g_pReplaySettings->screenshotList) {
process_screenshot_list(g_pReplaySettings->screenshotList);
}
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;
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);
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;
}
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);
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;
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;
{
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
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;
};
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)
{
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()
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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)
{
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;
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;
#include <xgl.h>
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
- {
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
- default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
- }
-}
-
-
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
- switch ((XGL_BLEND_FUNC)input_value)
- {
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
- default:
- return "Unhandled XGL_BLEND_FUNC";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_MEMORY_REF_READ_ONLY_BIT:
- return "XGL_MEMORY_REF_READ_ONLY_BIT";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_MEMORY_REF_FLAGS";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
}
-static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- return "XGL_MEMORY_OUTPUT_COPY_BIT";
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
- default:
- return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
- switch ((XGL_STATE_BIND_POINT)input_value)
- {
- case XGL_STATE_BIND_COLOR_BLEND:
- return "XGL_STATE_BIND_COLOR_BLEND";
- case XGL_STATE_BIND_DEPTH_STENCIL:
- return "XGL_STATE_BIND_DEPTH_STENCIL";
- case XGL_STATE_BIND_RASTER:
- return "XGL_STATE_BIND_RASTER";
- case XGL_STATE_BIND_VIEWPORT:
- return "XGL_STATE_BIND_VIEWPORT";
- default:
- return "Unhandled XGL_STATE_BIND_POINT";
- }
-}
-
-
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
- switch ((XGL_LOGIC_OP)input_value)
- {
- case XGL_LOGIC_OP_AND:
- return "XGL_LOGIC_OP_AND";
- case XGL_LOGIC_OP_AND_INVERTED:
- return "XGL_LOGIC_OP_AND_INVERTED";
- case XGL_LOGIC_OP_AND_REVERSE:
- return "XGL_LOGIC_OP_AND_REVERSE";
- case XGL_LOGIC_OP_CLEAR:
- return "XGL_LOGIC_OP_CLEAR";
- case XGL_LOGIC_OP_COPY:
- return "XGL_LOGIC_OP_COPY";
- case XGL_LOGIC_OP_COPY_INVERTED:
- return "XGL_LOGIC_OP_COPY_INVERTED";
- case XGL_LOGIC_OP_EQUIV:
- return "XGL_LOGIC_OP_EQUIV";
- case XGL_LOGIC_OP_INVERT:
- return "XGL_LOGIC_OP_INVERT";
- case XGL_LOGIC_OP_NAND:
- return "XGL_LOGIC_OP_NAND";
- case XGL_LOGIC_OP_NOOP:
- return "XGL_LOGIC_OP_NOOP";
- case XGL_LOGIC_OP_NOR:
- return "XGL_LOGIC_OP_NOR";
- case XGL_LOGIC_OP_OR:
- return "XGL_LOGIC_OP_OR";
- case XGL_LOGIC_OP_OR_INVERTED:
- return "XGL_LOGIC_OP_OR_INVERTED";
- case XGL_LOGIC_OP_OR_REVERSE:
- return "XGL_LOGIC_OP_OR_REVERSE";
- case XGL_LOGIC_OP_SET:
- return "XGL_LOGIC_OP_SET";
- case XGL_LOGIC_OP_XOR:
- return "XGL_LOGIC_OP_XOR";
- default:
- return "Unhandled XGL_LOGIC_OP";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ return "XGL_PIPELINE_BIND_POINT_COMPUTE";
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ return "Unhandled XGL_PIPELINE_BIND_POINT";
}
}
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
default:
- return "Unhandled XGL_MEMORY_TYPE";
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
}
}
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_MEMORY_PRIORITY)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
default:
- return "Unhandled XGL_MEMORY_PRIORITY";
+ return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
}
}
}
-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";
}
}
}
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
-{
- switch ((XGL_QUEUE_TYPE)input_value)
- {
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
- default:
- return "Unhandled XGL_QUEUE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- return "XGL_SYSTEM_ALLOC_API_OBJECT";
- case XGL_SYSTEM_ALLOC_DEBUG:
- return "XGL_SYSTEM_ALLOC_DEBUG";
- case XGL_SYSTEM_ALLOC_INTERNAL:
- return "XGL_SYSTEM_ALLOC_INTERNAL";
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
- return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
default:
- return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
default:
- return "Unhandled XGL_DEPTH_MODE";
+ return "Unhandled XGL_TIMESTAMP_TYPE";
}
}
}
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
- {
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
- case XGL_IMAGE_USAGE_GENERAL:
- return "XGL_IMAGE_USAGE_GENERAL";
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- return "XGL_IMAGE_USAGE_IMAGE_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- return "XGL_IMAGE_USAGE_TEXTURE_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
- default:
- return "Unhandled XGL_IMAGE_USAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
- {
- case XGL_GPU_TYPE_DISCRETE:
- return "XGL_GPU_TYPE_DISCRETE";
- case XGL_GPU_TYPE_INTEGRATED:
- return "XGL_GPU_TYPE_INTEGRATED";
- case XGL_GPU_TYPE_OTHER:
- return "XGL_GPU_TYPE_OTHER";
- case XGL_GPU_TYPE_VIRTUAL:
- return "XGL_GPU_TYPE_VIRTUAL";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
-{
- switch ((XGL_STENCIL_OP)input_value)
- {
- case XGL_STENCIL_OP_DEC_CLAMP:
- return "XGL_STENCIL_OP_DEC_CLAMP";
- case XGL_STENCIL_OP_DEC_WRAP:
- return "XGL_STENCIL_OP_DEC_WRAP";
- case XGL_STENCIL_OP_INC_CLAMP:
- return "XGL_STENCIL_OP_INC_CLAMP";
- case XGL_STENCIL_OP_INC_WRAP:
- return "XGL_STENCIL_OP_INC_WRAP";
- case XGL_STENCIL_OP_INVERT:
- return "XGL_STENCIL_OP_INVERT";
- case XGL_STENCIL_OP_KEEP:
- return "XGL_STENCIL_OP_KEEP";
- case XGL_STENCIL_OP_REPLACE:
- return "XGL_STENCIL_OP_REPLACE";
- case XGL_STENCIL_OP_ZERO:
- return "XGL_STENCIL_OP_ZERO";
- default:
- return "Unhandled XGL_STENCIL_OP";
- }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
- default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ return "Unhandled XGL_IMAGE_ASPECT";
}
}
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
}
}
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
default:
- return "Unhandled XGL_OBJECT_INFO_TYPE";
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
}
}
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
{
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
+ case XGL_BUFFER_USAGE_GENERAL:
+ return "XGL_BUFFER_USAGE_GENERAL";
+ case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
+ case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
+ case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+ return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
+ case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+ return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
+ case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+ return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
+ case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+ return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
+ return "Unhandled XGL_BUFFER_USAGE_FLAGS";
}
}
}
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline const char* string_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
- default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- return "XGL_PROVOKING_VERTEX_FIRST";
- case XGL_PROVOKING_VERTEX_LAST:
- return "XGL_PROVOKING_VERTEX_LAST";
- default:
- return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
-{
- switch ((XGL_TEX_FILTER)input_value)
- {
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
- default:
- return "Unhandled XGL_TEX_FILTER";
- }
-}
-
-
-static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
-{
- switch ((XGL_BLEND)input_value)
- {
- case XGL_BLEND_CONSTANT_ALPHA:
- return "XGL_BLEND_CONSTANT_ALPHA";
- case XGL_BLEND_CONSTANT_COLOR:
- return "XGL_BLEND_CONSTANT_COLOR";
- case XGL_BLEND_DEST_ALPHA:
- return "XGL_BLEND_DEST_ALPHA";
- case XGL_BLEND_DEST_COLOR:
- return "XGL_BLEND_DEST_COLOR";
- case XGL_BLEND_ONE:
- return "XGL_BLEND_ONE";
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
- case XGL_BLEND_SRC1_ALPHA:
- return "XGL_BLEND_SRC1_ALPHA";
- case XGL_BLEND_SRC1_COLOR:
- return "XGL_BLEND_SRC1_COLOR";
- case XGL_BLEND_SRC_ALPHA:
- return "XGL_BLEND_SRC_ALPHA";
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- return "XGL_BLEND_SRC_ALPHA_SATURATE";
- case XGL_BLEND_SRC_COLOR:
- return "XGL_BLEND_SRC_COLOR";
- case XGL_BLEND_ZERO:
- return "XGL_BLEND_ZERO";
- default:
- return "Unhandled XGL_BLEND";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
- default:
- return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
- default:
- return "Unhandled XGL_CULL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
-{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
- {
- case XGL_BUFFER_VIEW_RAW:
- return "XGL_BUFFER_VIEW_RAW";
- case XGL_BUFFER_VIEW_STRUCTURED:
- return "XGL_BUFFER_VIEW_STRUCTURED";
- case XGL_BUFFER_VIEW_TYPED:
- return "XGL_BUFFER_VIEW_TYPED";
+ case XGL_STATE_BIND_COLOR_BLEND:
+ return "XGL_STATE_BIND_COLOR_BLEND";
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ return "XGL_STATE_BIND_DEPTH_STENCIL";
+ case XGL_STATE_BIND_RASTER:
+ return "XGL_STATE_BIND_RASTER";
+ case XGL_STATE_BIND_VIEWPORT:
+ return "XGL_STATE_BIND_VIEWPORT";
default:
- return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ return "Unhandled XGL_STATE_BIND_POINT";
}
}
}
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+ default:
+ return "Unhandled XGL_WAIT_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ {
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ return "XGL_IMAGE_FORMAT_CLASS_D16";
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ return "XGL_IMAGE_FORMAT_CLASS_D24";
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ return "XGL_IMAGE_FORMAT_CLASS_D32";
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return "XGL_IMAGE_FORMAT_CLASS_S8";
+ default:
+ return "Unhandled XGL_IMAGE_FORMAT_CLASS";
}
}
}
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
- default:
- return "Unhandled XGL_QUEUE_FLAGS";
- }
-}
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ default:
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ }
+}
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
{
- switch ((XGL_QUERY_TYPE)input_value)
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
{
- case XGL_QUERY_OCCLUSION:
- return "XGL_QUERY_OCCLUSION";
- case XGL_QUERY_PIPELINE_STATISTICS:
- return "XGL_QUERY_PIPELINE_STATISTICS";
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
default:
- return "Unhandled XGL_QUERY_TYPE";
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
}
}
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
default:
- return "Unhandled XGL_IMAGE_LAYOUT";
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
}
}
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_STENCIL_OP)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ return "Unhandled XGL_STENCIL_OP";
}
}
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ case XGL_BUFFER_VIEW_RAW:
+ return "XGL_BUFFER_VIEW_RAW";
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ return "XGL_BUFFER_VIEW_STRUCTURED";
+ case XGL_BUFFER_VIEW_TYPED:
+ return "XGL_BUFFER_VIEW_TYPED";
default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
+ return "Unhandled XGL_BUFFER_VIEW_TYPE";
}
}
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
}
}
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
{
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
}
}
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline const char* string_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
- switch ((XGL_VALIDATION_LEVEL)input_value)
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
{
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT";
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ return "XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT";
+ case XGL_FORMAT_CONVERSION_BIT:
+ return "XGL_FORMAT_CONVERSION_BIT";
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ return "XGL_FORMAT_DEPTH_ATTACHMENT_BIT";
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ return "XGL_FORMAT_IMAGE_COPY_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_READ_BIT";
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ return "XGL_FORMAT_IMAGE_SHADER_WRITE_BIT";
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ return "XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT";
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ return "XGL_FORMAT_MSAA_ATTACHMENT_BIT";
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
+ return "XGL_FORMAT_STENCIL_ATTACHMENT_BIT";
default:
- return "Unhandled XGL_VALIDATION_LEVEL";
+ return "Unhandled XGL_FORMAT_FEATURE_FLAGS";
}
}
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
{
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
default:
- return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+ return "Unhandled XGL_COORDINATE_ORIGIN";
}
}
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
{
- switch ((XGL_WAIT_EVENT)input_value)
+ switch ((XGL_MEMORY_PRIORITY)input_value)
{
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
default:
- return "Unhandled XGL_WAIT_EVENT";
+ return "Unhandled XGL_MEMORY_PRIORITY";
}
}
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return "XGL_BUFFER_CREATE_SPARSE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
default:
- return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+ return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
}
}
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
{
- switch ((XGL_SET_EVENT)input_value)
+ switch ((XGL_BLEND)input_value)
{
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_TOP_OF_PIPE:
- return "XGL_SET_EVENT_TOP_OF_PIPE";
+ case XGL_BLEND_CONSTANT_ALPHA:
+ return "XGL_BLEND_CONSTANT_ALPHA";
+ case XGL_BLEND_CONSTANT_COLOR:
+ return "XGL_BLEND_CONSTANT_COLOR";
+ case XGL_BLEND_DEST_ALPHA:
+ return "XGL_BLEND_DEST_ALPHA";
+ case XGL_BLEND_DEST_COLOR:
+ return "XGL_BLEND_DEST_COLOR";
+ case XGL_BLEND_ONE:
+ return "XGL_BLEND_ONE";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
+ case XGL_BLEND_SRC1_ALPHA:
+ return "XGL_BLEND_SRC1_ALPHA";
+ case XGL_BLEND_SRC1_COLOR:
+ return "XGL_BLEND_SRC1_COLOR";
+ case XGL_BLEND_SRC_ALPHA:
+ return "XGL_BLEND_SRC_ALPHA";
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ return "XGL_BLEND_SRC_ALPHA_SATURATE";
+ case XGL_BLEND_SRC_COLOR:
+ return "XGL_BLEND_SRC_COLOR";
+ case XGL_BLEND_ZERO:
+ return "XGL_BLEND_ZERO";
+ default:
+ return "Unhandled XGL_BLEND";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return "XGL_BUFFER_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+ default:
+ return "Unhandled XGL_FACE_ORIENTATION";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+ default:
+ return "Unhandled XGL_IMAGE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+{
+ switch ((XGL_MEMORY_TYPE)input_value)
+ {
+ case XGL_MEMORY_TYPE_BUFFER:
+ return "XGL_MEMORY_TYPE_BUFFER";
+ case XGL_MEMORY_TYPE_IMAGE:
+ return "XGL_MEMORY_TYPE_IMAGE";
+ case XGL_MEMORY_TYPE_OTHER:
+ return "XGL_MEMORY_TYPE_OTHER";
+ default:
+ return "Unhandled XGL_MEMORY_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
+{
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
+ {
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT";
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
+ return "XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT";
+ default:
+ return "Unhandled XGL_CMD_BUFFER_BUILD_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
+ default:
+ return "Unhandled XGL_BLEND_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
+ default:
+ return "Unhandled XGL_FILL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+{
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ {
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
+ default:
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+ default:
+ return "Unhandled XGL_QUEUE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE";
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_FILTER";
+ }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ return "XGL_SET_EVENT_TOP_OF_PIPE";
case XGL_SET_EVENT_TRANSFER_COMPLETE:
return "XGL_SET_EVENT_TRANSFER_COMPLETE";
case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
default:
- return "Unhandled XGL_SET_EVENT";
+ return "Unhandled XGL_SET_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
+ default:
+ return "Unhandled XGL_COMPARE_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ default:
+ return "Unhandled XGL_IMAGE_LAYOUT";
+ }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ {
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ return "XGL_SHADER_STAGE_FLAGS_ALL";
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ default:
+ return "Unhandled XGL_SHADER_STAGE_FLAGS";
}
}
-static inline const char* string_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- return "XGL_PIPELINE_BIND_POINT_COMPUTE";
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
- return "XGL_PIPELINE_BIND_POINT_GRAPHICS";
+ case XGL_SHADER_STAGE_COMPUTE:
+ return "XGL_SHADER_STAGE_COMPUTE";
+ case XGL_SHADER_STAGE_FRAGMENT:
+ return "XGL_SHADER_STAGE_FRAGMENT";
+ case XGL_SHADER_STAGE_GEOMETRY:
+ return "XGL_SHADER_STAGE_GEOMETRY";
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ return "XGL_SHADER_STAGE_TESS_CONTROL";
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ return "XGL_SHADER_STAGE_TESS_EVALUATION";
+ case XGL_SHADER_STAGE_VERTEX:
+ return "XGL_SHADER_STAGE_VERTEX";
default:
- return "Unhandled XGL_PIPELINE_BIND_POINT";
+ return "Unhandled XGL_PIPELINE_SHADER_STAGE";
}
}
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
{
- switch ((XGL_COMPARE_FUNC)input_value)
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
{
- case XGL_COMPARE_ALWAYS:
- return "XGL_COMPARE_ALWAYS";
- case XGL_COMPARE_EQUAL:
- return "XGL_COMPARE_EQUAL";
- case XGL_COMPARE_GREATER:
- return "XGL_COMPARE_GREATER";
- case XGL_COMPARE_GREATER_EQUAL:
- return "XGL_COMPARE_GREATER_EQUAL";
- case XGL_COMPARE_LESS:
- return "XGL_COMPARE_LESS";
- case XGL_COMPARE_LESS_EQUAL:
- return "XGL_COMPARE_LESS_EQUAL";
- case XGL_COMPARE_NEVER:
- return "XGL_COMPARE_NEVER";
- case XGL_COMPARE_NOT_EQUAL:
- return "XGL_COMPARE_NOT_EQUAL";
+ case XGL_CHANNEL_SWIZZLE_A:
+ return "XGL_CHANNEL_SWIZZLE_A";
+ case XGL_CHANNEL_SWIZZLE_B:
+ return "XGL_CHANNEL_SWIZZLE_B";
+ case XGL_CHANNEL_SWIZZLE_G:
+ return "XGL_CHANNEL_SWIZZLE_G";
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ return "XGL_CHANNEL_SWIZZLE_ONE";
+ case XGL_CHANNEL_SWIZZLE_R:
+ return "XGL_CHANNEL_SWIZZLE_R";
+ case XGL_CHANNEL_SWIZZLE_ZERO:
+ return "XGL_CHANNEL_SWIZZLE_ZERO";
default:
- return "Unhandled XGL_COMPARE_FUNC";
+ return "Unhandled XGL_CHANNEL_SWIZZLE";
}
}
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_INDEX_TYPE)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
- case XGL_IMAGE_FORMAT_CLASS_D16:
- return "XGL_IMAGE_FORMAT_CLASS_D16";
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- return "XGL_IMAGE_FORMAT_CLASS_D16S8";
- case XGL_IMAGE_FORMAT_CLASS_D24:
- return "XGL_IMAGE_FORMAT_CLASS_D24";
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- return "XGL_IMAGE_FORMAT_CLASS_D24S8";
- case XGL_IMAGE_FORMAT_CLASS_D32:
- return "XGL_IMAGE_FORMAT_CLASS_D32";
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- return "XGL_IMAGE_FORMAT_CLASS_D32S8";
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return "XGL_IMAGE_FORMAT_CLASS_S8";
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
default:
- return "Unhandled XGL_IMAGE_FORMAT_CLASS";
+ return "Unhandled XGL_INDEX_TYPE";
}
}
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
default:
- return "Unhandled XGL_FILL_MODE";
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
}
}
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- return "XGL_MEMORY_PROPERTY_GPU_ONLY";
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
default:
- return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+ default:
+ return "Unhandled XGL_CULL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ default:
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ default:
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
}
}
}
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
- default:
- return "Unhandled XGL_FACE_ORIENTATION";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
}
}
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
- {
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+ switch ((XGL_QUEUE_FLAGS)input_value)
+ {
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
+ return "Unhandled XGL_QUEUE_FLAGS";
}
}
-static inline const char* string_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- return "XGL_CHANNEL_SWIZZLE_A";
- case XGL_CHANNEL_SWIZZLE_B:
- return "XGL_CHANNEL_SWIZZLE_B";
- case XGL_CHANNEL_SWIZZLE_G:
- return "XGL_CHANNEL_SWIZZLE_G";
- case XGL_CHANNEL_SWIZZLE_ONE:
- return "XGL_CHANNEL_SWIZZLE_ONE";
- case XGL_CHANNEL_SWIZZLE_R:
- return "XGL_CHANNEL_SWIZZLE_R";
- case XGL_CHANNEL_SWIZZLE_ZERO:
- return "XGL_CHANNEL_SWIZZLE_ZERO";
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
default:
- return "Unhandled XGL_CHANNEL_SWIZZLE";
+ return "Unhandled XGL_LOGIC_OP";
}
}
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- return "XGL_SHADER_STAGE_FLAGS_ALL";
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
default:
- return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ return "Unhandled XGL_VALIDATION_LEVEL";
}
}
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
default:
- return "Unhandled XGL_IMAGE_ASPECT";
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
}
}
-static inline const char* string_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_BUFFER_USAGE_GENERAL:
- return "XGL_BUFFER_USAGE_GENERAL";
- case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDEX_FETCH_BIT";
- case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
- return "XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT";
- case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_RAW_BUFFER_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
- return "XGL_BUFFER_USAGE_SHADER_STORAGE_BIT";
- case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
- return "XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT";
- case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
- return "XGL_BUFFER_USAGE_UNIFORM_READ_BIT";
- case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
- return "XGL_BUFFER_USAGE_VERTEX_FETCH_BIT";
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
default:
- return "Unhandled XGL_BUFFER_USAGE_FLAGS";
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
}
}
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
}
}
}
}
-
-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";
- }
-}
-
#include <xgl.h>
-static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
- {
- case XGL_TOPOLOGY_LINE_LIST:
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- case XGL_TOPOLOGY_LINE_STRIP:
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- case XGL_TOPOLOGY_PATCH:
- case XGL_TOPOLOGY_POINT_LIST:
- case XGL_TOPOLOGY_QUAD_LIST:
- case XGL_TOPOLOGY_QUAD_STRIP:
- case XGL_TOPOLOGY_RECT_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
-{
- switch ((XGL_BLEND_FUNC)input_value)
- {
- case XGL_BLEND_FUNC_ADD:
- case XGL_BLEND_FUNC_MAX:
- case XGL_BLEND_FUNC_MIN:
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- case XGL_BLEND_FUNC_SUBTRACT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_MEMORY_REF_READ_ONLY_BIT:
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
-{
- switch ((XGL_STATE_BIND_POINT)input_value)
- {
- case XGL_STATE_BIND_COLOR_BLEND:
- case XGL_STATE_BIND_DEPTH_STENCIL:
- case XGL_STATE_BIND_RASTER:
- case XGL_STATE_BIND_VIEWPORT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
-{
- switch ((XGL_LOGIC_OP)input_value)
- {
- case XGL_LOGIC_OP_AND:
- case XGL_LOGIC_OP_AND_INVERTED:
- case XGL_LOGIC_OP_AND_REVERSE:
- case XGL_LOGIC_OP_CLEAR:
- case XGL_LOGIC_OP_COPY:
- case XGL_LOGIC_OP_COPY_INVERTED:
- case XGL_LOGIC_OP_EQUIV:
- case XGL_LOGIC_OP_INVERT:
- case XGL_LOGIC_OP_NAND:
- case XGL_LOGIC_OP_NOOP:
- case XGL_LOGIC_OP_NOR:
- case XGL_LOGIC_OP_OR:
- case XGL_LOGIC_OP_OR_INVERTED:
- case XGL_LOGIC_OP_OR_REVERSE:
- case XGL_LOGIC_OP_SET:
- case XGL_LOGIC_OP_XOR:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_MEMORY_PRIORITY)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
return 1;
default:
return 0;
}
-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;
}
-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;
}
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_IMAGE_TILING)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ case XGL_LINEAR_TILING:
+ case XGL_OPTIMAL_TILING:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_LINEAR_TILING:
- case XGL_OPTIMAL_TILING:
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
{
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- case XGL_IMAGE_USAGE_GENERAL:
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
+static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
-{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
- {
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
-{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
{
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
+ case XGL_BUFFER_USAGE_GENERAL:
+ case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
+ case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
+ case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
+ case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
+ case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
+ case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
+ case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_STATE_BIND_POINT(XGL_STATE_BIND_POINT input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_STATE_BIND_POINT)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
+ case XGL_STATE_BIND_COLOR_BLEND:
+ case XGL_STATE_BIND_DEPTH_STENCIL:
+ case XGL_STATE_BIND_RASTER:
+ case XGL_STATE_BIND_VIEWPORT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+{
+ switch ((XGL_RESULT)input_value)
+ {
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ case XGL_ERROR_BAD_SHADER_CODE:
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ case XGL_ERROR_DEVICE_LOST:
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ case XGL_ERROR_INVALID_EXTENSION:
+ case XGL_ERROR_INVALID_FLAGS:
+ case XGL_ERROR_INVALID_FORMAT:
+ case XGL_ERROR_INVALID_HANDLE:
+ case XGL_ERROR_INVALID_IMAGE:
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ case XGL_ERROR_INVALID_ORDINAL:
+ case XGL_ERROR_INVALID_POINTER:
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ case XGL_ERROR_INVALID_VALUE:
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ case XGL_ERROR_NOT_MAPPABLE:
+ case XGL_ERROR_NOT_SHAREABLE:
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ case XGL_ERROR_OUT_OF_MEMORY:
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ case XGL_ERROR_UNAVAILABLE:
+ case XGL_ERROR_UNKNOWN:
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ case XGL_EVENT_RESET:
+ case XGL_EVENT_SET:
+ case XGL_NOT_READY:
+ case XGL_SUCCESS:
+ case XGL_TIMEOUT:
+ case XGL_UNSUPPORTED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+{
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ {
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+{
+ switch ((XGL_TEX_ADDRESS)input_value)
+ {
+ case XGL_TEX_ADDRESS_CLAMP:
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ case XGL_TEX_ADDRESS_MIRROR:
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ case XGL_TEX_ADDRESS_WRAP:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+ case XGL_TOPOLOGY_LINE_LIST:
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ case XGL_TOPOLOGY_LINE_STRIP:
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ case XGL_TOPOLOGY_PATCH:
+ case XGL_TOPOLOGY_POINT_LIST:
+ case XGL_TOPOLOGY_QUAD_LIST:
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ case XGL_TOPOLOGY_RECT_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+{
+ switch ((XGL_STENCIL_OP)input_value)
+ {
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+{
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ case XGL_BUFFER_VIEW_TYPED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_FORMAT_FEATURE_FLAGS(XGL_FORMAT_FEATURE_FLAGS input_value)
{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
+ switch ((XGL_FORMAT_FEATURE_FLAGS)input_value)
{
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ case XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT:
+ case XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT:
+ case XGL_FORMAT_CONVERSION_BIT:
+ case XGL_FORMAT_DEPTH_ATTACHMENT_BIT:
+ case XGL_FORMAT_IMAGE_COPY_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_READ_BIT:
+ case XGL_FORMAT_IMAGE_SHADER_WRITE_BIT:
+ case XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT:
+ case XGL_FORMAT_MSAA_ATTACHMENT_BIT:
+ case XGL_FORMAT_STENCIL_ATTACHMENT_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- case XGL_TEX_FILTER_NEAREST:
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ case XGL_MEMORY_PRIORITY_LOW:
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ {
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ case XGL_FRONT_FACE_CW:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ switch ((XGL_IMAGE_TYPE)input_value)
{
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ case XGL_IMAGE_1D:
+ case XGL_IMAGE_2D:
+ case XGL_IMAGE_3D:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_CULL_MODE)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
+static inline uint32_t validate_XGL_CMD_BUFFER_BUILD_FLAGS(XGL_CMD_BUFFER_BUILD_FLAGS input_value)
{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ switch ((XGL_CMD_BUFFER_BUILD_FLAGS)input_value)
{
- case XGL_BUFFER_VIEW_RAW:
- case XGL_BUFFER_VIEW_STRUCTURED:
- case XGL_BUFFER_VIEW_TYPED:
+ case XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT:
+ case XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
{
- switch ((XGL_RESULT)input_value)
+ switch ((XGL_BLEND_FUNC)input_value)
{
- case XGL_ERROR_BAD_PIPELINE_DATA:
- case XGL_ERROR_BAD_SHADER_CODE:
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- case XGL_ERROR_DEVICE_LOST:
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- case XGL_ERROR_INITIALIZATION_FAILED:
- case XGL_ERROR_INVALID_ALIGNMENT:
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- case XGL_ERROR_INVALID_EXTENSION:
- case XGL_ERROR_INVALID_FLAGS:
- case XGL_ERROR_INVALID_FORMAT:
- case XGL_ERROR_INVALID_HANDLE:
- case XGL_ERROR_INVALID_IMAGE:
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- case XGL_ERROR_INVALID_ORDINAL:
- case XGL_ERROR_INVALID_POINTER:
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- case XGL_ERROR_INVALID_VALUE:
- case XGL_ERROR_MEMORY_MAP_FAILED:
- case XGL_ERROR_MEMORY_NOT_BOUND:
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- case XGL_ERROR_NOT_MAPPABLE:
- case XGL_ERROR_NOT_SHAREABLE:
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- case XGL_ERROR_OUT_OF_MEMORY:
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- case XGL_ERROR_UNAVAILABLE:
- case XGL_ERROR_UNKNOWN:
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- case XGL_EVENT_RESET:
- case XGL_EVENT_SET:
- case XGL_NOT_READY:
- case XGL_SUCCESS:
- case XGL_TIMEOUT:
- case XGL_UNSUPPORTED:
+ case XGL_BLEND_FUNC_ADD:
+ case XGL_BLEND_FUNC_MAX:
+ case XGL_BLEND_FUNC_MIN:
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ case XGL_BLEND_FUNC_SUBTRACT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_FILL_MODE)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- case XGL_TEX_ADDRESS_MIRROR:
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- case XGL_TEX_ADDRESS_WRAP:
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
{
- switch ((XGL_QUEUE_FLAGS)input_value)
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
{
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
{
- switch ((XGL_QUERY_TYPE)input_value)
+ switch ((XGL_QUEUE_TYPE)input_value)
{
- case XGL_QUERY_OCCLUSION:
- case XGL_QUERY_PIPELINE_STATISTICS:
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
+ switch ((XGL_TEX_FILTER)input_value)
{
- case XGL_QUERY_IMPRECISE_DATA_BIT:
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_SET_EVENT)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
+ switch ((XGL_COMPARE_FUNC)input_value)
{
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ case XGL_COMPARE_ALWAYS:
+ case XGL_COMPARE_EQUAL:
+ case XGL_COMPARE_GREATER:
+ case XGL_COMPARE_GREATER_EQUAL:
+ case XGL_COMPARE_LESS:
+ case XGL_COMPARE_LESS_EQUAL:
+ case XGL_COMPARE_NEVER:
+ case XGL_COMPARE_NOT_EQUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
{
- switch ((XGL_VALIDATION_LEVEL)input_value)
+ switch ((XGL_IMAGE_LAYOUT)input_value)
{
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
{
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_WAIT_EVENT)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
+ case XGL_CHANNEL_SWIZZLE_A:
+ case XGL_CHANNEL_SWIZZLE_B:
+ case XGL_CHANNEL_SWIZZLE_G:
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ case XGL_CHANNEL_SWIZZLE_R:
+ case XGL_CHANNEL_SWIZZLE_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
+{
+ switch ((XGL_INDEX_TYPE)input_value)
+ {
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_COMPARE_FUNC)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_COMPARE_ALWAYS:
- case XGL_COMPARE_EQUAL:
- case XGL_COMPARE_GREATER:
- case XGL_COMPARE_GREATER_EQUAL:
- case XGL_COMPARE_LESS:
- case XGL_COMPARE_LESS_EQUAL:
- case XGL_COMPARE_NEVER:
- case XGL_COMPARE_NOT_EQUAL:
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_CULL_MODE)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- case XGL_IMAGE_FORMAT_CLASS_D16:
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- case XGL_IMAGE_FORMAT_CLASS_D24:
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- case XGL_IMAGE_FORMAT_CLASS_D32:
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- case XGL_IMAGE_FORMAT_CLASS_S8:
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
{
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
{
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- case XGL_FRONT_FACE_CW:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
{
- case XGL_IMAGE_1D:
- case XGL_IMAGE_2D:
- case XGL_IMAGE_3D:
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ case XGL_QUEUE_COMPUTE_BIT:
+ case XGL_QUEUE_DMA_BIT:
+ case XGL_QUEUE_EXTENDED_BIT:
+ case XGL_QUEUE_GRAPHICS_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- case XGL_CHANNEL_SWIZZLE_B:
- case XGL_CHANNEL_SWIZZLE_G:
- case XGL_CHANNEL_SWIZZLE_ONE:
- case XGL_CHANNEL_SWIZZLE_R:
- case XGL_CHANNEL_SWIZZLE_ZERO:
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ case XGL_IMAGE_USAGE_GENERAL:
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_USAGE_FLAGS(XGL_BUFFER_USAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_BUFFER_USAGE_FLAGS)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_BUFFER_USAGE_GENERAL:
- case XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT:
- case XGL_BUFFER_USAGE_INDEX_FETCH_BIT:
- case XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT:
- case XGL_BUFFER_USAGE_RAW_BUFFER_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT:
- case XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT:
- case XGL_BUFFER_USAGE_SHADER_STORAGE_BIT:
- case XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT:
- case XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT:
- case XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT:
- case XGL_BUFFER_USAGE_UNIFORM_READ_BIT:
- case XGL_BUFFER_USAGE_VERTEX_FETCH_BIT:
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
{
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
return 1;
default:
return 0;
}
}
-
-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;
- }
-}
-
extern "C"
{
-#include "glvtrace_xgl_packet_id.h"
+#include "glv_vk_packet_id.h"
}
ApiReplay* g_pReplayer = NULL;
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
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
)
#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
* 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();
#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
#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
#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)
}
-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";
}
}
}
-static inline const char* string_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
-{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
- {
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
- return "XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT";
- default:
- return "Unhandled XGL_PIPELINE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
-{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
- {
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
- return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
- default:
- return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
- {
- case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
- return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
- case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
- return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
- case XGL_IMAGE_USAGE_GENERAL:
- return "XGL_IMAGE_USAGE_GENERAL";
- case XGL_IMAGE_USAGE_IMAGE_BIT:
- return "XGL_IMAGE_USAGE_IMAGE_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
- case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
- return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
- case XGL_IMAGE_USAGE_TEXTURE_BIT:
- return "XGL_IMAGE_USAGE_TEXTURE_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
- case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
- return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
- default:
- return "Unhandled XGL_IMAGE_USAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
-{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
- {
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
- case XGL_IMAGE_FORMAT_CLASS_D16:
- return "XGL_IMAGE_FORMAT_CLASS_D16";
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- return "XGL_IMAGE_FORMAT_CLASS_D16S8";
- case XGL_IMAGE_FORMAT_CLASS_D24:
- return "XGL_IMAGE_FORMAT_CLASS_D24";
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- return "XGL_IMAGE_FORMAT_CLASS_D24S8";
- case XGL_IMAGE_FORMAT_CLASS_D32:
- return "XGL_IMAGE_FORMAT_CLASS_D32";
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- return "XGL_IMAGE_FORMAT_CLASS_D32S8";
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
- case XGL_IMAGE_FORMAT_CLASS_S8:
- return "XGL_IMAGE_FORMAT_CLASS_S8";
- default:
- return "Unhandled XGL_IMAGE_FORMAT_CLASS";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_QUERY_TYPE)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_QUERY_OCCLUSION:
- return "XGL_QUERY_OCCLUSION";
- case XGL_QUERY_PIPELINE_STATISTICS:
- return "XGL_QUERY_PIPELINE_STATISTICS";
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ return "XGL_DEPTH_MODE_ZERO_TO_ONE";
default:
- return "Unhandled XGL_QUERY_TYPE";
+ return "Unhandled XGL_DEPTH_MODE";
}
}
-static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
{
- switch ((XGL_STRUCTURE_TYPE)input_value)
- {
- case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
- return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
- return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
- case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
- return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
- case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
- case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
- case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
- return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
- case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
- return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
- case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
- return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
- case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
- return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
- case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
- return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
- case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
- case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
- return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
- case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
- return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
- default:
- return "Unhandled XGL_STRUCTURE_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
-{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
- {
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
- case XGL_IMAGE_CREATE_SPARSE_BIT:
- return "XGL_IMAGE_CREATE_SPARSE_BIT";
- default:
- return "Unhandled XGL_IMAGE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
-{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
- {
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_COPY_BIT:
- return "XGL_MEMORY_INPUT_COPY_BIT";
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- return "XGL_MEMORY_INPUT_CPU_READ_BIT";
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
- return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
- default:
- return "Unhandled XGL_MEMORY_INPUT_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
-{
- switch ((XGL_IMAGE_ASPECT)input_value)
- {
- case XGL_IMAGE_ASPECT_COLOR:
- return "XGL_IMAGE_ASPECT_COLOR";
- case XGL_IMAGE_ASPECT_DEPTH:
- return "XGL_IMAGE_ASPECT_DEPTH";
- case XGL_IMAGE_ASPECT_STENCIL:
- return "XGL_IMAGE_ASPECT_STENCIL";
- default:
- return "Unhandled XGL_IMAGE_ASPECT";
- }
-}
-
-
-static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
- {
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
- return "XGL_DEVICE_CREATE_VALIDATION_BIT";
- default:
- return "Unhandled XGL_DEVICE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
-{
- switch ((XGL_COMPARE_FUNC)input_value)
- {
- case XGL_COMPARE_ALWAYS:
- return "XGL_COMPARE_ALWAYS";
- case XGL_COMPARE_EQUAL:
- return "XGL_COMPARE_EQUAL";
- case XGL_COMPARE_GREATER:
- return "XGL_COMPARE_GREATER";
- case XGL_COMPARE_GREATER_EQUAL:
- return "XGL_COMPARE_GREATER_EQUAL";
- case XGL_COMPARE_LESS:
- return "XGL_COMPARE_LESS";
- case XGL_COMPARE_LESS_EQUAL:
- return "XGL_COMPARE_LESS_EQUAL";
- case XGL_COMPARE_NEVER:
- return "XGL_COMPARE_NEVER";
- case XGL_COMPARE_NOT_EQUAL:
- return "XGL_COMPARE_NOT_EQUAL";
- default:
- return "Unhandled XGL_COMPARE_FUNC";
- }
-}
-
-
-static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
-{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
- {
- case XGL_SHADER_STAGE_FLAGS_ALL:
- return "XGL_SHADER_STAGE_FLAGS_ALL";
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
- return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
- default:
- return "Unhandled XGL_SHADER_STAGE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
-{
- switch ((XGL_FILL_MODE)input_value)
- {
- case XGL_FILL_POINTS:
- return "XGL_FILL_POINTS";
- case XGL_FILL_SOLID:
- return "XGL_FILL_SOLID";
- case XGL_FILL_WIREFRAME:
- return "XGL_FILL_WIREFRAME";
- default:
- return "Unhandled XGL_FILL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
-{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
- {
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
- return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
- default:
- return "Unhandled XGL_COORDINATE_ORIGIN";
- }
-}
-
-
-static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
-{
- switch ((XGL_WAIT_EVENT)input_value)
- {
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
- return "XGL_WAIT_EVENT_TOP_OF_PIPE";
- default:
- return "Unhandled XGL_WAIT_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
-{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
- {
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- return "XGL_DESCRIPTOR_TYPE_IMAGE";
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER";
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE";
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
- default:
- return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- return "XGL_MEMORY_PRIORITY_HIGH";
- case XGL_MEMORY_PRIORITY_LOW:
- return "XGL_MEMORY_PRIORITY_LOW";
- case XGL_MEMORY_PRIORITY_NORMAL:
- return "XGL_MEMORY_PRIORITY_NORMAL";
- case XGL_MEMORY_PRIORITY_UNUSED:
- return "XGL_MEMORY_PRIORITY_UNUSED";
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- return "XGL_MEMORY_PRIORITY_VERY_HIGH";
- case XGL_MEMORY_PRIORITY_VERY_LOW:
- return "XGL_MEMORY_PRIORITY_VERY_LOW";
- default:
- return "Unhandled XGL_MEMORY_PRIORITY";
- }
-}
-
-
-static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
-{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
- {
- case XGL_TIMESTAMP_BOTTOM:
- return "XGL_TIMESTAMP_BOTTOM";
- case XGL_TIMESTAMP_TOP:
- return "XGL_TIMESTAMP_TOP";
- default:
- return "Unhandled XGL_TIMESTAMP_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
- {
- case XGL_GPU_TYPE_DISCRETE:
- return "XGL_GPU_TYPE_DISCRETE";
- case XGL_GPU_TYPE_INTEGRATED:
- return "XGL_GPU_TYPE_INTEGRATED";
- case XGL_GPU_TYPE_OTHER:
- return "XGL_GPU_TYPE_OTHER";
- case XGL_GPU_TYPE_VIRTUAL:
- return "XGL_GPU_TYPE_VIRTUAL";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
-{
- switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
- {
- case XGL_TOPOLOGY_LINE_LIST:
- return "XGL_TOPOLOGY_LINE_LIST";
- case XGL_TOPOLOGY_LINE_LIST_ADJ:
- return "XGL_TOPOLOGY_LINE_LIST_ADJ";
- case XGL_TOPOLOGY_LINE_STRIP:
- return "XGL_TOPOLOGY_LINE_STRIP";
- case XGL_TOPOLOGY_LINE_STRIP_ADJ:
- return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
- case XGL_TOPOLOGY_PATCH:
- return "XGL_TOPOLOGY_PATCH";
- case XGL_TOPOLOGY_POINT_LIST:
- return "XGL_TOPOLOGY_POINT_LIST";
- case XGL_TOPOLOGY_QUAD_LIST:
- return "XGL_TOPOLOGY_QUAD_LIST";
- case XGL_TOPOLOGY_QUAD_STRIP:
- return "XGL_TOPOLOGY_QUAD_STRIP";
- case XGL_TOPOLOGY_RECT_LIST:
- return "XGL_TOPOLOGY_RECT_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST:
- return "XGL_TOPOLOGY_TRIANGLE_LIST";
- case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
- case XGL_TOPOLOGY_TRIANGLE_STRIP:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP";
- case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
- return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
- default:
- return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
- }
-}
-
-
-static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- return "XGL_IMAGE_VIEW_1D";
- case XGL_IMAGE_VIEW_2D:
- return "XGL_IMAGE_VIEW_2D";
- case XGL_IMAGE_VIEW_3D:
- return "XGL_IMAGE_VIEW_3D";
- case XGL_IMAGE_VIEW_CUBE:
- return "XGL_IMAGE_VIEW_CUBE";
- default:
- return "Unhandled XGL_IMAGE_VIEW_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
- default:
- return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
- default:
- return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
-{
- switch ((XGL_RESULT)input_value)
- {
- case XGL_ERROR_BAD_PIPELINE_DATA:
- return "XGL_ERROR_BAD_PIPELINE_DATA";
- case XGL_ERROR_BAD_SHADER_CODE:
- return "XGL_ERROR_BAD_SHADER_CODE";
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- return "XGL_ERROR_DEVICE_ALREADY_CREATED";
- case XGL_ERROR_DEVICE_LOST:
- return "XGL_ERROR_DEVICE_LOST";
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- return "XGL_ERROR_INCOMPATIBLE_DEVICE";
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- return "XGL_ERROR_INCOMPATIBLE_DRIVER";
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- return "XGL_ERROR_INCOMPATIBLE_QUEUE";
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
- case XGL_ERROR_INITIALIZATION_FAILED:
- return "XGL_ERROR_INITIALIZATION_FAILED";
- case XGL_ERROR_INVALID_ALIGNMENT:
- return "XGL_ERROR_INVALID_ALIGNMENT";
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
- case XGL_ERROR_INVALID_EXTENSION:
- return "XGL_ERROR_INVALID_EXTENSION";
- case XGL_ERROR_INVALID_FLAGS:
- return "XGL_ERROR_INVALID_FLAGS";
- case XGL_ERROR_INVALID_FORMAT:
- return "XGL_ERROR_INVALID_FORMAT";
- case XGL_ERROR_INVALID_HANDLE:
- return "XGL_ERROR_INVALID_HANDLE";
- case XGL_ERROR_INVALID_IMAGE:
- return "XGL_ERROR_INVALID_IMAGE";
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- return "XGL_ERROR_INVALID_MEMORY_SIZE";
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- return "XGL_ERROR_INVALID_OBJECT_TYPE";
- case XGL_ERROR_INVALID_ORDINAL:
- return "XGL_ERROR_INVALID_ORDINAL";
- case XGL_ERROR_INVALID_POINTER:
- return "XGL_ERROR_INVALID_POINTER";
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- return "XGL_ERROR_INVALID_QUEUE_TYPE";
- case XGL_ERROR_INVALID_VALUE:
- return "XGL_ERROR_INVALID_VALUE";
- case XGL_ERROR_MEMORY_MAP_FAILED:
- return "XGL_ERROR_MEMORY_MAP_FAILED";
- case XGL_ERROR_MEMORY_NOT_BOUND:
- return "XGL_ERROR_MEMORY_NOT_BOUND";
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- return "XGL_ERROR_MEMORY_UNMAP_FAILED";
- case XGL_ERROR_NOT_MAPPABLE:
- return "XGL_ERROR_NOT_MAPPABLE";
- case XGL_ERROR_NOT_SHAREABLE:
- return "XGL_ERROR_NOT_SHAREABLE";
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- return "XGL_ERROR_OUT_OF_GPU_MEMORY";
- case XGL_ERROR_OUT_OF_MEMORY:
- return "XGL_ERROR_OUT_OF_MEMORY";
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
- case XGL_ERROR_UNAVAILABLE:
- return "XGL_ERROR_UNAVAILABLE";
- case XGL_ERROR_UNKNOWN:
- return "XGL_ERROR_UNKNOWN";
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
- case XGL_EVENT_RESET:
- return "XGL_EVENT_RESET";
- case XGL_EVENT_SET:
- return "XGL_EVENT_SET";
- case XGL_NOT_READY:
- return "XGL_NOT_READY";
- case XGL_SUCCESS:
- return "XGL_SUCCESS";
- case XGL_TIMEOUT:
- return "XGL_TIMEOUT";
- case XGL_UNSUPPORTED:
- return "XGL_UNSUPPORTED";
- default:
- return "Unhandled XGL_RESULT";
- }
-}
-
-
-static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- return "XGL_BORDER_COLOR_OPAQUE_BLACK";
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- return "XGL_BORDER_COLOR_OPAQUE_WHITE";
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
- default:
- return "Unhandled XGL_BORDER_COLOR_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
- default:
- return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
- default:
- return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- return "XGL_INDEX_16";
- case XGL_INDEX_32:
- return "XGL_INDEX_32";
- case XGL_INDEX_8:
- return "XGL_INDEX_8";
- default:
- return "Unhandled XGL_INDEX_TYPE";
- }
-}
-
-
-static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- return "XGL_CULL_BACK";
- case XGL_CULL_FRONT:
- return "XGL_CULL_FRONT";
- case XGL_CULL_FRONT_AND_BACK:
- return "XGL_CULL_FRONT_AND_BACK";
- case XGL_CULL_NONE:
- return "XGL_CULL_NONE";
- default:
- return "Unhandled XGL_CULL_MODE";
- }
-}
-
-
-static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
- case XGL_SET_EVENT_TOP_OF_PIPE:
- return "XGL_SET_EVENT_TOP_OF_PIPE";
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- return "XGL_SET_EVENT_TRANSFER_COMPLETE";
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
- default:
- return "Unhandled XGL_SET_EVENT";
- }
-}
-
-
-static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
- {
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- return "XGL_MEMORY_PROPERTY_GPU_ONLY";
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
- default:
- return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
- {
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return "XGL_ATTACHMENT_LOAD_OP_LOAD";
- default:
- return "Unhandled XGL_ATTACHMENT_LOAD_OP";
- }
-}
-
-
-static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- return "XGL_PROVOKING_VERTEX_FIRST";
- case XGL_PROVOKING_VERTEX_LAST:
- return "XGL_PROVOKING_VERTEX_LAST";
- default:
- return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
- }
-}
-
-
-static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- return "XGL_VALIDATION_LEVEL_0";
- case XGL_VALIDATION_LEVEL_1:
- return "XGL_VALIDATION_LEVEL_1";
- case XGL_VALIDATION_LEVEL_2:
- return "XGL_VALIDATION_LEVEL_2";
- case XGL_VALIDATION_LEVEL_3:
- return "XGL_VALIDATION_LEVEL_3";
- case XGL_VALIDATION_LEVEL_4:
- return "XGL_VALIDATION_LEVEL_4";
- default:
- return "Unhandled XGL_VALIDATION_LEVEL";
- }
-}
-
-
-static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- return "XGL_FRONT_FACE_CCW";
- case XGL_FRONT_FACE_CW:
- return "XGL_FRONT_FACE_CW";
- default:
- return "Unhandled XGL_FACE_ORIENTATION";
- }
-}
-
-
-static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
- {
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
- default:
- return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
- }
-}
-
-
-static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- return "XGL_QUEUE_COMPUTE_BIT";
- case XGL_QUEUE_DMA_BIT:
- return "XGL_QUEUE_DMA_BIT";
- case XGL_QUEUE_EXTENDED_BIT:
- return "XGL_QUEUE_EXTENDED_BIT";
- case XGL_QUEUE_GRAPHICS_BIT:
- return "XGL_QUEUE_GRAPHICS_BIT";
- default:
- return "Unhandled XGL_QUEUE_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
- default:
- return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
- }
-}
-
-
-static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- return "XGL_TEX_MIPMAP_BASE";
- case XGL_TEX_MIPMAP_LINEAR:
- return "XGL_TEX_MIPMAP_LINEAR";
- case XGL_TEX_MIPMAP_NEAREST:
- return "XGL_TEX_MIPMAP_NEAREST";
- default:
- return "Unhandled XGL_TEX_MIPMAP_MODE";
- }
-}
-
-
-static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return "XGL_QUERY_IMPRECISE_DATA_BIT";
- default:
- return "Unhandled XGL_QUERY_CONTROL_FLAGS";
- }
-}
-
-
-static inline const char* string_XGL_FORMAT(XGL_FORMAT input_value)
-{
- switch ((XGL_FORMAT)input_value)
+ switch ((XGL_FORMAT)input_value)
{
case XGL_FMT_ASTC_10x10_SRGB:
return "XGL_FMT_ASTC_10x10_SRGB";
case XGL_FMT_UNDEFINED:
return "XGL_FMT_UNDEFINED";
default:
- return "Unhandled XGL_FORMAT";
+ return "Unhandled XGL_FORMAT";
+ }
+}
+
+
+static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+{
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ {
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
+ return "XGL_BUFFER_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
+ {
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT";
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ return "XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT";
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ return "XGL_MEMORY_PROPERTY_GPU_ONLY";
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ return "XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL";
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
+ return "XGL_MEMORY_PROPERTY_SHAREABLE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_PROPERTY_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ return "XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC";
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_REGION_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_LOWER_LEFT";
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return "XGL_COORDINATE_ORIGIN_UPPER_LEFT";
+ default:
+ return "Unhandled XGL_COORDINATE_ORIGIN";
+ }
+}
+
+
+static inline const char* string_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ return "XGL_CULL_BACK";
+ case XGL_CULL_FRONT:
+ return "XGL_CULL_FRONT";
+ case XGL_CULL_FRONT_AND_BACK:
+ return "XGL_CULL_FRONT_AND_BACK";
+ case XGL_CULL_NONE:
+ return "XGL_CULL_NONE";
+ default:
+ return "Unhandled XGL_CULL_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_USAGE_FLAGS(XGL_IMAGE_USAGE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_USAGE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT:
+ return "XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT";
+ case XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT:
+ return "XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT";
+ case XGL_IMAGE_USAGE_GENERAL:
+ return "XGL_IMAGE_USAGE_GENERAL";
+ case XGL_IMAGE_USAGE_IMAGE_BIT:
+ return "XGL_IMAGE_USAGE_IMAGE_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT";
+ case XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT:
+ return "XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT";
+ case XGL_IMAGE_USAGE_TEXTURE_BIT:
+ return "XGL_IMAGE_USAGE_TEXTURE_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT";
+ case XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT:
+ return "XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_USAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ return "XGL_MEMORY_OUTPUT_COPY_BIT";
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_CPU_WRITE_BIT";
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ return "XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_OUTPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_SET_EVENT(XGL_SET_EVENT input_value)
+{
+ switch ((XGL_SET_EVENT)input_value)
+ {
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE";
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ return "XGL_SET_EVENT_GPU_COMMANDS_COMPLETE";
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ return "XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE";
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ return "XGL_SET_EVENT_TOP_OF_PIPE";
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ return "XGL_SET_EVENT_TRANSFER_COMPLETE";
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return "XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE";
+ default:
+ return "Unhandled XGL_SET_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ return "XGL_MEMORY_INPUT_COPY_BIT";
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ return "XGL_MEMORY_INPUT_CPU_READ_BIT";
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ return "XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT";
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_INDEX_FETCH_BIT";
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ return "XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT";
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ return "XGL_MEMORY_INPUT_SHADER_READ_BIT";
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ return "XGL_MEMORY_INPUT_UNIFORM_READ_BIT";
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return "XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_INPUT_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ {
+ case XGL_TEX_MIPMAP_BASE:
+ return "XGL_TEX_MIPMAP_BASE";
+ case XGL_TEX_MIPMAP_LINEAR:
+ return "XGL_TEX_MIPMAP_LINEAR";
+ case XGL_TEX_MIPMAP_NEAREST:
+ return "XGL_TEX_MIPMAP_NEAREST";
+ default:
+ return "Unhandled XGL_TEX_MIPMAP_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ return "XGL_DESCRIPTOR_UDPATE_MODE_COPY";
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ return "XGL_DESCRIPTOR_UPDATE_MODE_FASTEST";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_UPDATE_MODE";
+ }
+}
+
+
+static inline const char* string_XGL_STRUCTURE_TYPE(XGL_STRUCTURE_TYPE input_value)
+{
+ switch ((XGL_STRUCTURE_TYPE)input_value)
+ {
+ case XGL_STRUCTURE_TYPE_APPLICATION_INFO:
+ return "XGL_STRUCTURE_TYPE_APPLICATION_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:
+ return "XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO";
+ case XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO:
+ return "XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO";
+ case XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO";
+ case XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO";
+ case XGL_STRUCTURE_TYPE_MEMORY_BARRIER:
+ return "XGL_STRUCTURE_TYPE_MEMORY_BARRIER";
+ case XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_BARRIER:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_BARRIER";
+ case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO:
+ return "XGL_STRUCTURE_TYPE_QUEUE_SEMAPHORE_OPEN_INFO";
+ case XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO:
+ return "XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO";
+ case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:
+ return "XGL_STRUCTURE_TYPE_UPDATE_AS_COPY";
+ case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_BUFFERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_IMAGES";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS";
+ case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
+ return "XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES";
+ default:
+ return "Unhandled XGL_STRUCTURE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ {
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
+ return "XGL_MEMORY_REF_READ_ONLY_BIT";
+ default:
+ return "Unhandled XGL_MEMORY_REF_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
+{
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
+ {
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ return "XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT";
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
+ return "XGL_DESCRIPTOR_SET_USAGE_STATIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_SET_USAGE";
+ }
+}
+
+
+static inline const char* string_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
+ {
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
+ return "XGL_SEMAPHORE_CREATE_SHAREABLE_BIT";
+ default:
+ return "Unhandled XGL_SEMAPHORE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+{
+ switch ((XGL_WAIT_EVENT)input_value)
+ {
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ return "XGL_WAIT_EVENT_BEFORE_RASTERIZATION";
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ return "XGL_WAIT_EVENT_TOP_OF_PIPE";
+ default:
+ return "Unhandled XGL_WAIT_EVENT";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
+{
+ switch ((XGL_QUEUE_FLAGS)input_value)
+ {
+ case XGL_QUEUE_COMPUTE_BIT:
+ return "XGL_QUEUE_COMPUTE_BIT";
+ case XGL_QUEUE_DMA_BIT:
+ return "XGL_QUEUE_DMA_BIT";
+ case XGL_QUEUE_EXTENDED_BIT:
+ return "XGL_QUEUE_EXTENDED_BIT";
+ case XGL_QUEUE_GRAPHICS_BIT:
+ return "XGL_QUEUE_GRAPHICS_BIT";
+ default:
+ return "Unhandled XGL_QUEUE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+{
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ {
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ return "XGL_SYSTEM_ALLOC_API_OBJECT";
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ return "XGL_SYSTEM_ALLOC_DEBUG";
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ return "XGL_SYSTEM_ALLOC_INTERNAL";
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_SHADER";
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ return "XGL_SYSTEM_ALLOC_INTERNAL_TEMP";
+ default:
+ return "Unhandled XGL_SYSTEM_ALLOC_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
+{
+ switch ((XGL_VALIDATION_LEVEL)input_value)
+ {
+ case XGL_VALIDATION_LEVEL_0:
+ return "XGL_VALIDATION_LEVEL_0";
+ case XGL_VALIDATION_LEVEL_1:
+ return "XGL_VALIDATION_LEVEL_1";
+ case XGL_VALIDATION_LEVEL_2:
+ return "XGL_VALIDATION_LEVEL_2";
+ case XGL_VALIDATION_LEVEL_3:
+ return "XGL_VALIDATION_LEVEL_3";
+ case XGL_VALIDATION_LEVEL_4:
+ return "XGL_VALIDATION_LEVEL_4";
+ default:
+ return "Unhandled XGL_VALIDATION_LEVEL";
+ }
+}
+
+
+static inline const char* string_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+{
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ {
+ case XGL_GPU_TYPE_DISCRETE:
+ return "XGL_GPU_TYPE_DISCRETE";
+ case XGL_GPU_TYPE_INTEGRATED:
+ return "XGL_GPU_TYPE_INTEGRATED";
+ case XGL_GPU_TYPE_OTHER:
+ return "XGL_GPU_TYPE_OTHER";
+ case XGL_GPU_TYPE_VIRTUAL:
+ return "XGL_GPU_TYPE_VIRTUAL";
+ default:
+ return "Unhandled XGL_PHYSICAL_GPU_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+{
+ switch ((XGL_IMAGE_LAYOUT)input_value)
+ {
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ return "XGL_IMAGE_LAYOUT_GENERAL";
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ default:
+ return "Unhandled XGL_IMAGE_LAYOUT";
+ }
+}
+
+
+static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
+{
+ switch ((XGL_BLEND)input_value)
+ {
+ case XGL_BLEND_CONSTANT_ALPHA:
+ return "XGL_BLEND_CONSTANT_ALPHA";
+ case XGL_BLEND_CONSTANT_COLOR:
+ return "XGL_BLEND_CONSTANT_COLOR";
+ case XGL_BLEND_DEST_ALPHA:
+ return "XGL_BLEND_DEST_ALPHA";
+ case XGL_BLEND_DEST_COLOR:
+ return "XGL_BLEND_DEST_COLOR";
+ case XGL_BLEND_ONE:
+ return "XGL_BLEND_ONE";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
+ case XGL_BLEND_SRC1_ALPHA:
+ return "XGL_BLEND_SRC1_ALPHA";
+ case XGL_BLEND_SRC1_COLOR:
+ return "XGL_BLEND_SRC1_COLOR";
+ case XGL_BLEND_SRC_ALPHA:
+ return "XGL_BLEND_SRC_ALPHA";
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ return "XGL_BLEND_SRC_ALPHA_SATURATE";
+ case XGL_BLEND_SRC_COLOR:
+ return "XGL_BLEND_SRC_COLOR";
+ case XGL_BLEND_ZERO:
+ return "XGL_BLEND_ZERO";
+ default:
+ return "Unhandled XGL_BLEND";
+ }
+}
+
+
+static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+{
+ switch ((XGL_QUEUE_TYPE)input_value)
+ {
+ case XGL_QUEUE_TYPE_COMPUTE:
+ return "XGL_QUEUE_TYPE_COMPUTE";
+ case XGL_QUEUE_TYPE_DMA:
+ return "XGL_QUEUE_TYPE_DMA";
+ case XGL_QUEUE_TYPE_GRAPHICS:
+ return "XGL_QUEUE_TYPE_GRAPHICS";
+ default:
+ return "Unhandled XGL_QUEUE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+{
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ {
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ return "XGL_SHADER_STAGE_FLAGS_ALL";
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT";
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT";
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT";
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT";
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ return "XGL_SHADER_STAGE_FLAGS_VERTEX_BIT";
+ default:
+ return "Unhandled XGL_SHADER_STAGE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_PRIMITIVE_TOPOLOGY(XGL_PRIMITIVE_TOPOLOGY input_value)
+{
+ switch ((XGL_PRIMITIVE_TOPOLOGY)input_value)
+ {
+ case XGL_TOPOLOGY_LINE_LIST:
+ return "XGL_TOPOLOGY_LINE_LIST";
+ case XGL_TOPOLOGY_LINE_LIST_ADJ:
+ return "XGL_TOPOLOGY_LINE_LIST_ADJ";
+ case XGL_TOPOLOGY_LINE_STRIP:
+ return "XGL_TOPOLOGY_LINE_STRIP";
+ case XGL_TOPOLOGY_LINE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_LINE_STRIP_ADJ";
+ case XGL_TOPOLOGY_PATCH:
+ return "XGL_TOPOLOGY_PATCH";
+ case XGL_TOPOLOGY_POINT_LIST:
+ return "XGL_TOPOLOGY_POINT_LIST";
+ case XGL_TOPOLOGY_QUAD_LIST:
+ return "XGL_TOPOLOGY_QUAD_LIST";
+ case XGL_TOPOLOGY_QUAD_STRIP:
+ return "XGL_TOPOLOGY_QUAD_STRIP";
+ case XGL_TOPOLOGY_RECT_LIST:
+ return "XGL_TOPOLOGY_RECT_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST";
+ case XGL_TOPOLOGY_TRIANGLE_LIST_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_LIST_ADJ";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP";
+ case XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ:
+ return "XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ";
+ default:
+ return "Unhandled XGL_PRIMITIVE_TOPOLOGY";
+ }
+}
+
+
+static inline const char* string_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT";
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
+ return "XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT";
+ default:
+ return "Unhandled XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+{
+ switch ((XGL_IMAGE_TILING)input_value)
+ {
+ case XGL_LINEAR_TILING:
+ return "XGL_LINEAR_TILING";
+ case XGL_OPTIMAL_TILING:
+ return "XGL_OPTIMAL_TILING";
+ default:
+ return "Unhandled XGL_IMAGE_TILING";
+ }
+}
+
+
+static inline const char* string_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ {
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ return "XGL_VERTEX_INPUT_STEP_RATE_DRAW";
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ return "XGL_VERTEX_INPUT_STEP_RATE_INSTANCE";
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return "XGL_VERTEX_INPUT_STEP_RATE_VERTEX";
+ default:
+ return "Unhandled XGL_VERTEX_INPUT_STEP_RATE";
+ }
+}
+
+
+static inline const char* string_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ return "XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT";
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return "XGL_DEVICE_CREATE_VALIDATION_BIT";
+ default:
+ return "Unhandled XGL_DEVICE_CREATE_FLAGS";
}
}
-static inline const char* string_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline const char* string_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- return "XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE";
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
- return "XGL_DEPTH_MODE_ZERO_TO_ONE";
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS";
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ return "XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT";
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return "XGL_INFO_TYPE_MEMORY_REQUIREMENTS";
default:
- return "Unhandled XGL_DEPTH_MODE";
+ return "Unhandled XGL_OBJECT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ return "XGL_PROVOKING_VERTEX_FIRST";
+ case XGL_PROVOKING_VERTEX_LAST:
+ return "XGL_PROVOKING_VERTEX_LAST";
+ default:
+ return "Unhandled XGL_PROVOKING_VERTEX_CONVENTION";
}
}
static inline const char* string_XGL_BUFFER_VIEW_TYPE(XGL_BUFFER_VIEW_TYPE input_value)
{
- switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ switch ((XGL_BUFFER_VIEW_TYPE)input_value)
+ {
+ case XGL_BUFFER_VIEW_RAW:
+ return "XGL_BUFFER_VIEW_RAW";
+ case XGL_BUFFER_VIEW_STRUCTURED:
+ return "XGL_BUFFER_VIEW_STRUCTURED";
+ case XGL_BUFFER_VIEW_TYPED:
+ return "XGL_BUFFER_VIEW_TYPED";
+ default:
+ return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+{
+ switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ {
+ case XGL_DESCRIPTOR_TYPE_IMAGE:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE";
+ case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER";
+ case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE";
+ case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER";
+ case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+ return "XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC";
+ default:
+ return "Unhandled XGL_DESCRIPTOR_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+{
+ switch ((XGL_IMAGE_TYPE)input_value)
+ {
+ case XGL_IMAGE_1D:
+ return "XGL_IMAGE_1D";
+ case XGL_IMAGE_2D:
+ return "XGL_IMAGE_2D";
+ case XGL_IMAGE_3D:
+ return "XGL_IMAGE_3D";
+ default:
+ return "Unhandled XGL_IMAGE_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+{
+ switch ((XGL_BLEND_FUNC)input_value)
+ {
+ case XGL_BLEND_FUNC_ADD:
+ return "XGL_BLEND_FUNC_ADD";
+ case XGL_BLEND_FUNC_MAX:
+ return "XGL_BLEND_FUNC_MAX";
+ case XGL_BLEND_FUNC_MIN:
+ return "XGL_BLEND_FUNC_MIN";
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return "XGL_BLEND_FUNC_SUBTRACT";
+ default:
+ return "Unhandled XGL_BLEND_FUNC";
+ }
+}
+
+
+static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+{
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ {
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ default:
+ return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ return "XGL_MEMORY_PRIORITY_HIGH";
+ case XGL_MEMORY_PRIORITY_LOW:
+ return "XGL_MEMORY_PRIORITY_LOW";
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ return "XGL_MEMORY_PRIORITY_NORMAL";
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ return "XGL_MEMORY_PRIORITY_UNUSED";
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ return "XGL_MEMORY_PRIORITY_VERY_HIGH";
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return "XGL_MEMORY_PRIORITY_VERY_LOW";
+ default:
+ return "Unhandled XGL_MEMORY_PRIORITY";
+ }
+}
+
+
+static inline const char* string_XGL_RESULT(XGL_RESULT input_value)
+{
+ switch ((XGL_RESULT)input_value)
+ {
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ return "XGL_ERROR_BAD_PIPELINE_DATA";
+ case XGL_ERROR_BAD_SHADER_CODE:
+ return "XGL_ERROR_BAD_SHADER_CODE";
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ return "XGL_ERROR_BUILDING_COMMAND_BUFFER";
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ return "XGL_ERROR_DEVICE_ALREADY_CREATED";
+ case XGL_ERROR_DEVICE_LOST:
+ return "XGL_ERROR_DEVICE_LOST";
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ return "XGL_ERROR_INCOMPATIBLE_DEVICE";
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ return "XGL_ERROR_INCOMPATIBLE_DRIVER";
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ return "XGL_ERROR_INCOMPATIBLE_QUEUE";
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ return "XGL_ERROR_INCOMPLETE_COMMAND_BUFFER";
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ return "XGL_ERROR_INITIALIZATION_FAILED";
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ return "XGL_ERROR_INVALID_ALIGNMENT";
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ return "XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA";
+ case XGL_ERROR_INVALID_EXTENSION:
+ return "XGL_ERROR_INVALID_EXTENSION";
+ case XGL_ERROR_INVALID_FLAGS:
+ return "XGL_ERROR_INVALID_FLAGS";
+ case XGL_ERROR_INVALID_FORMAT:
+ return "XGL_ERROR_INVALID_FORMAT";
+ case XGL_ERROR_INVALID_HANDLE:
+ return "XGL_ERROR_INVALID_HANDLE";
+ case XGL_ERROR_INVALID_IMAGE:
+ return "XGL_ERROR_INVALID_IMAGE";
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ return "XGL_ERROR_INVALID_MEMORY_SIZE";
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ return "XGL_ERROR_INVALID_OBJECT_TYPE";
+ case XGL_ERROR_INVALID_ORDINAL:
+ return "XGL_ERROR_INVALID_ORDINAL";
+ case XGL_ERROR_INVALID_POINTER:
+ return "XGL_ERROR_INVALID_POINTER";
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ return "XGL_ERROR_INVALID_QUEUE_TYPE";
+ case XGL_ERROR_INVALID_VALUE:
+ return "XGL_ERROR_INVALID_VALUE";
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ return "XGL_ERROR_MEMORY_MAP_FAILED";
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ return "XGL_ERROR_MEMORY_NOT_BOUND";
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ return "XGL_ERROR_MEMORY_UNMAP_FAILED";
+ case XGL_ERROR_NOT_MAPPABLE:
+ return "XGL_ERROR_NOT_MAPPABLE";
+ case XGL_ERROR_NOT_SHAREABLE:
+ return "XGL_ERROR_NOT_SHAREABLE";
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ return "XGL_ERROR_OUT_OF_GPU_MEMORY";
+ case XGL_ERROR_OUT_OF_MEMORY:
+ return "XGL_ERROR_OUT_OF_MEMORY";
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ return "XGL_ERROR_TOO_MANY_MEMORY_REFERENCES";
+ case XGL_ERROR_UNAVAILABLE:
+ return "XGL_ERROR_UNAVAILABLE";
+ case XGL_ERROR_UNKNOWN:
+ return "XGL_ERROR_UNKNOWN";
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ return "XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
+ case XGL_EVENT_RESET:
+ return "XGL_EVENT_RESET";
+ case XGL_EVENT_SET:
+ return "XGL_EVENT_SET";
+ case XGL_NOT_READY:
+ return "XGL_NOT_READY";
+ case XGL_SUCCESS:
+ return "XGL_SUCCESS";
+ case XGL_TIMEOUT:
+ return "XGL_TIMEOUT";
+ case XGL_UNSUPPORTED:
+ return "XGL_UNSUPPORTED";
+ default:
+ return "Unhandled XGL_RESULT";
+ }
+}
+
+
+static inline const char* string_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
{
- case XGL_BUFFER_VIEW_RAW:
- return "XGL_BUFFER_VIEW_RAW";
- case XGL_BUFFER_VIEW_STRUCTURED:
- return "XGL_BUFFER_VIEW_STRUCTURED";
- case XGL_BUFFER_VIEW_TYPED:
- return "XGL_BUFFER_VIEW_TYPED";
+ case XGL_FILL_POINTS:
+ return "XGL_FILL_POINTS";
+ case XGL_FILL_SOLID:
+ return "XGL_FILL_SOLID";
+ case XGL_FILL_WIREFRAME:
+ return "XGL_FILL_WIREFRAME";
default:
- return "Unhandled XGL_BUFFER_VIEW_TYPE";
+ return "Unhandled XGL_FILL_MODE";
}
}
-static inline const char* string_XGL_IMAGE_TYPE(XGL_IMAGE_TYPE input_value)
+static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
{
- switch ((XGL_IMAGE_TYPE)input_value)
+ switch ((XGL_TEX_FILTER)input_value)
{
- case XGL_IMAGE_1D:
- return "XGL_IMAGE_1D";
- case XGL_IMAGE_2D:
- return "XGL_IMAGE_2D";
- case XGL_IMAGE_3D:
- return "XGL_IMAGE_3D";
+ case XGL_TEX_FILTER_LINEAR:
+ return "XGL_TEX_FILTER_LINEAR";
+ case XGL_TEX_FILTER_NEAREST:
+ return "XGL_TEX_FILTER_NEAREST";
default:
- return "Unhandled XGL_IMAGE_TYPE";
+ return "Unhandled XGL_TEX_FILTER";
}
}
-static inline const char* string_XGL_BLEND(XGL_BLEND input_value)
+static inline const char* string_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
{
- switch ((XGL_BLEND)input_value)
+ switch ((XGL_QUERY_TYPE)input_value)
{
- case XGL_BLEND_CONSTANT_ALPHA:
- return "XGL_BLEND_CONSTANT_ALPHA";
- case XGL_BLEND_CONSTANT_COLOR:
- return "XGL_BLEND_CONSTANT_COLOR";
- case XGL_BLEND_DEST_ALPHA:
- return "XGL_BLEND_DEST_ALPHA";
- case XGL_BLEND_DEST_COLOR:
- return "XGL_BLEND_DEST_COLOR";
- case XGL_BLEND_ONE:
- return "XGL_BLEND_ONE";
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA";
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- return "XGL_BLEND_ONE_MINUS_CONSTANT_COLOR";
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- return "XGL_BLEND_ONE_MINUS_DEST_ALPHA";
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- return "XGL_BLEND_ONE_MINUS_DEST_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC1_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC1_COLOR";
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- return "XGL_BLEND_ONE_MINUS_SRC_ALPHA";
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- return "XGL_BLEND_ONE_MINUS_SRC_COLOR";
- case XGL_BLEND_SRC1_ALPHA:
- return "XGL_BLEND_SRC1_ALPHA";
- case XGL_BLEND_SRC1_COLOR:
- return "XGL_BLEND_SRC1_COLOR";
- case XGL_BLEND_SRC_ALPHA:
- return "XGL_BLEND_SRC_ALPHA";
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- return "XGL_BLEND_SRC_ALPHA_SATURATE";
- case XGL_BLEND_SRC_COLOR:
- return "XGL_BLEND_SRC_COLOR";
- case XGL_BLEND_ZERO:
- return "XGL_BLEND_ZERO";
+ case XGL_QUERY_OCCLUSION:
+ return "XGL_QUERY_OCCLUSION";
+ case XGL_QUERY_PIPELINE_STATISTICS:
+ return "XGL_QUERY_PIPELINE_STATISTICS";
default:
- return "Unhandled XGL_BLEND";
+ return "Unhandled XGL_QUERY_TYPE";
}
}
}
-static inline const char* string_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline const char* string_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- return "XGL_TEX_FILTER_LINEAR";
- case XGL_TEX_FILTER_NEAREST:
- return "XGL_TEX_FILTER_NEAREST";
+ case XGL_TIMESTAMP_BOTTOM:
+ return "XGL_TIMESTAMP_BOTTOM";
+ case XGL_TIMESTAMP_TOP:
+ return "XGL_TIMESTAMP_TOP";
default:
- return "Unhandled XGL_TEX_FILTER";
+ return "Unhandled XGL_TIMESTAMP_TYPE";
}
}
-static inline const char* string_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline const char* string_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- return "XGL_SHADER_STAGE_COMPUTE";
- case XGL_SHADER_STAGE_FRAGMENT:
- return "XGL_SHADER_STAGE_FRAGMENT";
- case XGL_SHADER_STAGE_GEOMETRY:
- return "XGL_SHADER_STAGE_GEOMETRY";
- case XGL_SHADER_STAGE_TESS_CONTROL:
- return "XGL_SHADER_STAGE_TESS_CONTROL";
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- return "XGL_SHADER_STAGE_TESS_EVALUATION";
- case XGL_SHADER_STAGE_VERTEX:
- return "XGL_SHADER_STAGE_VERTEX";
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ return "XGL_BORDER_COLOR_OPAQUE_BLACK";
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ return "XGL_BORDER_COLOR_OPAQUE_WHITE";
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
+ return "XGL_BORDER_COLOR_TRANSPARENT_BLACK";
default:
- return "Unhandled XGL_PIPELINE_SHADER_STAGE";
+ return "Unhandled XGL_BORDER_COLOR_TYPE";
}
}
-static inline const char* string_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_BLEND_FUNC)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_BLEND_FUNC_ADD:
- return "XGL_BLEND_FUNC_ADD";
- case XGL_BLEND_FUNC_MAX:
- return "XGL_BLEND_FUNC_MAX";
- case XGL_BLEND_FUNC_MIN:
- return "XGL_BLEND_FUNC_MIN";
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- return "XGL_BLEND_FUNC_REVERSE_SUBTRACT";
- case XGL_BLEND_FUNC_SUBTRACT:
- return "XGL_BLEND_FUNC_SUBTRACT";
+ case XGL_LOGIC_OP_AND:
+ return "XGL_LOGIC_OP_AND";
+ case XGL_LOGIC_OP_AND_INVERTED:
+ return "XGL_LOGIC_OP_AND_INVERTED";
+ case XGL_LOGIC_OP_AND_REVERSE:
+ return "XGL_LOGIC_OP_AND_REVERSE";
+ case XGL_LOGIC_OP_CLEAR:
+ return "XGL_LOGIC_OP_CLEAR";
+ case XGL_LOGIC_OP_COPY:
+ return "XGL_LOGIC_OP_COPY";
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ return "XGL_LOGIC_OP_COPY_INVERTED";
+ case XGL_LOGIC_OP_EQUIV:
+ return "XGL_LOGIC_OP_EQUIV";
+ case XGL_LOGIC_OP_INVERT:
+ return "XGL_LOGIC_OP_INVERT";
+ case XGL_LOGIC_OP_NAND:
+ return "XGL_LOGIC_OP_NAND";
+ case XGL_LOGIC_OP_NOOP:
+ return "XGL_LOGIC_OP_NOOP";
+ case XGL_LOGIC_OP_NOR:
+ return "XGL_LOGIC_OP_NOR";
+ case XGL_LOGIC_OP_OR:
+ return "XGL_LOGIC_OP_OR";
+ case XGL_LOGIC_OP_OR_INVERTED:
+ return "XGL_LOGIC_OP_OR_INVERTED";
+ case XGL_LOGIC_OP_OR_REVERSE:
+ return "XGL_LOGIC_OP_OR_REVERSE";
+ case XGL_LOGIC_OP_SET:
+ return "XGL_LOGIC_OP_SET";
+ case XGL_LOGIC_OP_XOR:
+ return "XGL_LOGIC_OP_XOR";
default:
- return "Unhandled XGL_BLEND_FUNC";
+ return "Unhandled XGL_LOGIC_OP";
}
}
-static inline const char* string_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline const char* string_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL";
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_GENERAL:
- return "XGL_IMAGE_LAYOUT_GENERAL";
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL";
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
- return "XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL";
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
+ return "XGL_QUERY_IMPRECISE_DATA_BIT";
default:
- return "Unhandled XGL_IMAGE_LAYOUT";
+ return "Unhandled XGL_QUERY_CONTROL_FLAGS";
}
}
-static inline const char* string_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline const char* string_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- return "XGL_BUFFER_CREATE_SHAREABLE_BIT";
- case XGL_BUFFER_CREATE_SPARSE_BIT:
- return "XGL_BUFFER_CREATE_SPARSE_BIT";
+ case XGL_IMAGE_ASPECT_COLOR:
+ return "XGL_IMAGE_ASPECT_COLOR";
+ case XGL_IMAGE_ASPECT_DEPTH:
+ return "XGL_IMAGE_ASPECT_DEPTH";
+ case XGL_IMAGE_ASPECT_STENCIL:
+ return "XGL_IMAGE_ASPECT_STENCIL";
default:
- return "Unhandled XGL_BUFFER_CREATE_FLAGS";
+ return "Unhandled XGL_IMAGE_ASPECT";
}
}
-static inline const char* string_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline const char* string_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- return "XGL_MEMORY_TYPE_BUFFER";
- case XGL_MEMORY_TYPE_IMAGE:
- return "XGL_MEMORY_TYPE_IMAGE";
- case XGL_MEMORY_TYPE_OTHER:
- return "XGL_MEMORY_TYPE_OTHER";
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ return "XGL_ATTACHMENT_LOAD_OP_CLEAR";
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_LOAD_OP_DONT_CARE";
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
+ return "XGL_ATTACHMENT_LOAD_OP_LOAD";
default:
- return "Unhandled XGL_MEMORY_TYPE";
+ return "Unhandled XGL_ATTACHMENT_LOAD_OP";
}
}
-static inline const char* string_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline const char* string_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- return "XGL_QUEUE_TYPE_COMPUTE";
- case XGL_QUEUE_TYPE_DMA:
- return "XGL_QUEUE_TYPE_DMA";
- case XGL_QUEUE_TYPE_GRAPHICS:
- return "XGL_QUEUE_TYPE_GRAPHICS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_16_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_24_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_32_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_48_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ return "XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK";
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_8_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ return "XGL_IMAGE_FORMAT_CLASS_96_BITS";
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ return "XGL_IMAGE_FORMAT_CLASS_D16";
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D16S8";
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ return "XGL_IMAGE_FORMAT_CLASS_D24";
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D24S8";
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ return "XGL_IMAGE_FORMAT_CLASS_D32";
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ return "XGL_IMAGE_FORMAT_CLASS_D32S8";
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ return "XGL_IMAGE_FORMAT_CLASS_LINEAR";
+ case XGL_IMAGE_FORMAT_CLASS_S8:
+ return "XGL_IMAGE_FORMAT_CLASS_S8";
default:
- return "Unhandled XGL_QUEUE_TYPE";
+ return "Unhandled XGL_IMAGE_FORMAT_CLASS";
}
}
-static inline const char* string_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_LINEAR_TILING:
- return "XGL_LINEAR_TILING";
- case XGL_OPTIMAL_TILING:
- return "XGL_OPTIMAL_TILING";
+ case XGL_TEX_ADDRESS_CLAMP:
+ return "XGL_TEX_ADDRESS_CLAMP";
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ return "XGL_TEX_ADDRESS_CLAMP_BORDER";
+ case XGL_TEX_ADDRESS_MIRROR:
+ return "XGL_TEX_ADDRESS_MIRROR";
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ return "XGL_TEX_ADDRESS_MIRROR_ONCE";
+ case XGL_TEX_ADDRESS_WRAP:
+ return "XGL_TEX_ADDRESS_WRAP";
default:
- return "Unhandled XGL_IMAGE_TILING";
+ return "Unhandled XGL_TEX_ADDRESS";
}
}
}
-static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline const char* string_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_INDEX_TYPE)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
- return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ case XGL_INDEX_16:
+ return "XGL_INDEX_16";
+ case XGL_INDEX_32:
+ return "XGL_INDEX_32";
+ case XGL_INDEX_8:
+ return "XGL_INDEX_8";
default:
- return "Unhandled XGL_FORMAT_INFO_TYPE";
+ return "Unhandled XGL_INDEX_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ return "XGL_COMPARE_ALWAYS";
+ case XGL_COMPARE_EQUAL:
+ return "XGL_COMPARE_EQUAL";
+ case XGL_COMPARE_GREATER:
+ return "XGL_COMPARE_GREATER";
+ case XGL_COMPARE_GREATER_EQUAL:
+ return "XGL_COMPARE_GREATER_EQUAL";
+ case XGL_COMPARE_LESS:
+ return "XGL_COMPARE_LESS";
+ case XGL_COMPARE_LESS_EQUAL:
+ return "XGL_COMPARE_LESS_EQUAL";
+ case XGL_COMPARE_NEVER:
+ return "XGL_COMPARE_NEVER";
+ case XGL_COMPARE_NOT_EQUAL:
+ return "XGL_COMPARE_NOT_EQUAL";
+ default:
+ return "Unhandled XGL_COMPARE_FUNC";
}
}
}
-static inline const char* string_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline const char* string_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_STENCIL_OP)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- return "XGL_TEX_ADDRESS_CLAMP";
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- return "XGL_TEX_ADDRESS_CLAMP_BORDER";
- case XGL_TEX_ADDRESS_MIRROR:
- return "XGL_TEX_ADDRESS_MIRROR";
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- return "XGL_TEX_ADDRESS_MIRROR_ONCE";
- case XGL_TEX_ADDRESS_WRAP:
- return "XGL_TEX_ADDRESS_WRAP";
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ return "XGL_STENCIL_OP_DEC_CLAMP";
+ case XGL_STENCIL_OP_DEC_WRAP:
+ return "XGL_STENCIL_OP_DEC_WRAP";
+ case XGL_STENCIL_OP_INC_CLAMP:
+ return "XGL_STENCIL_OP_INC_CLAMP";
+ case XGL_STENCIL_OP_INC_WRAP:
+ return "XGL_STENCIL_OP_INC_WRAP";
+ case XGL_STENCIL_OP_INVERT:
+ return "XGL_STENCIL_OP_INVERT";
+ case XGL_STENCIL_OP_KEEP:
+ return "XGL_STENCIL_OP_KEEP";
+ case XGL_STENCIL_OP_REPLACE:
+ return "XGL_STENCIL_OP_REPLACE";
+ case XGL_STENCIL_OP_ZERO:
+ return "XGL_STENCIL_OP_ZERO";
default:
- return "Unhandled XGL_TEX_ADDRESS";
+ return "Unhandled XGL_STENCIL_OP";
}
}
-static inline const char* string_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline const char* string_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- return "XGL_GPU_COMPAT_ASIC_FEATURES_BIT";
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- return "XGL_GPU_COMPAT_IQ_MATCH_BIT";
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- return "XGL_GPU_COMPAT_PEER_TRANSFER_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- return "XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT";
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- return "XGL_GPU_COMPAT_SHARED_MEMORY_BIT";
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
- return "XGL_GPU_COMPAT_SHARED_SYNC_BIT";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES";
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return "XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES";
default:
- return "Unhandled XGL_GPU_COMPATIBILITY_FLAGS";
+ return "Unhandled XGL_PHYSICAL_GPU_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ return "XGL_IMAGE_CREATE_CLONEABLE_BIT";
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ return "XGL_IMAGE_CREATE_INVARIANT_DATA_BIT";
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ return "XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT";
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ return "XGL_IMAGE_CREATE_SHAREABLE_BIT";
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return "XGL_IMAGE_CREATE_SPARSE_BIT";
+ default:
+ return "Unhandled XGL_IMAGE_CREATE_FLAGS";
+ }
+}
+
+
+static inline const char* string_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ return "XGL_ATTACHMENT_STORE_OP_DONT_CARE";
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ return "XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA";
+ case XGL_ATTACHMENT_STORE_OP_STORE:
+ return "XGL_ATTACHMENT_STORE_OP_STORE";
+ default:
+ return "Unhandled XGL_ATTACHMENT_STORE_OP";
}
}
}
-static inline const char* string_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
+static inline const char* string_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
{
- switch ((XGL_LOGIC_OP)input_value)
+ switch ((XGL_IMAGE_VIEW_TYPE)input_value)
{
- case XGL_LOGIC_OP_AND:
- return "XGL_LOGIC_OP_AND";
- case XGL_LOGIC_OP_AND_INVERTED:
- return "XGL_LOGIC_OP_AND_INVERTED";
- case XGL_LOGIC_OP_AND_REVERSE:
- return "XGL_LOGIC_OP_AND_REVERSE";
- case XGL_LOGIC_OP_CLEAR:
- return "XGL_LOGIC_OP_CLEAR";
- case XGL_LOGIC_OP_COPY:
- return "XGL_LOGIC_OP_COPY";
- case XGL_LOGIC_OP_COPY_INVERTED:
- return "XGL_LOGIC_OP_COPY_INVERTED";
- case XGL_LOGIC_OP_EQUIV:
- return "XGL_LOGIC_OP_EQUIV";
- case XGL_LOGIC_OP_INVERT:
- return "XGL_LOGIC_OP_INVERT";
- case XGL_LOGIC_OP_NAND:
- return "XGL_LOGIC_OP_NAND";
- case XGL_LOGIC_OP_NOOP:
- return "XGL_LOGIC_OP_NOOP";
- case XGL_LOGIC_OP_NOR:
- return "XGL_LOGIC_OP_NOR";
- case XGL_LOGIC_OP_OR:
- return "XGL_LOGIC_OP_OR";
- case XGL_LOGIC_OP_OR_INVERTED:
- return "XGL_LOGIC_OP_OR_INVERTED";
- case XGL_LOGIC_OP_OR_REVERSE:
- return "XGL_LOGIC_OP_OR_REVERSE";
- case XGL_LOGIC_OP_SET:
- return "XGL_LOGIC_OP_SET";
- case XGL_LOGIC_OP_XOR:
- return "XGL_LOGIC_OP_XOR";
+ case XGL_IMAGE_VIEW_1D:
+ return "XGL_IMAGE_VIEW_1D";
+ case XGL_IMAGE_VIEW_2D:
+ return "XGL_IMAGE_VIEW_2D";
+ case XGL_IMAGE_VIEW_3D:
+ return "XGL_IMAGE_VIEW_3D";
+ case XGL_IMAGE_VIEW_CUBE:
+ return "XGL_IMAGE_VIEW_CUBE";
default:
- return "Unhandled XGL_LOGIC_OP";
+ return "Unhandled XGL_IMAGE_VIEW_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+{
+ switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ return "XGL_INFO_TYPE_FORMAT_PROPERTIES";
+ default:
+ return "Unhandled XGL_FORMAT_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
+{
+ switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ return "XGL_INFO_TYPE_SUBRESOURCE_LAYOUT";
+ default:
+ return "Unhandled XGL_SUBRESOURCE_INFO_TYPE";
+ }
+}
+
+
+static inline const char* string_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
+{
+ switch ((XGL_FACE_ORIENTATION)input_value)
+ {
+ case XGL_FRONT_FACE_CCW:
+ return "XGL_FRONT_FACE_CCW";
+ case XGL_FRONT_FACE_CW:
+ return "XGL_FRONT_FACE_CW";
+ default:
+ return "Unhandled XGL_FACE_ORIENTATION";
}
}
#include <xgl.h>
-static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
+static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
{
- switch ((XGL_STENCIL_OP)input_value)
+ switch ((XGL_PIPELINE_BIND_POINT)input_value)
{
- case XGL_STENCIL_OP_DEC_CLAMP:
- case XGL_STENCIL_OP_DEC_WRAP:
- case XGL_STENCIL_OP_INC_CLAMP:
- case XGL_STENCIL_OP_INC_WRAP:
- case XGL_STENCIL_OP_INVERT:
- case XGL_STENCIL_OP_KEEP:
- case XGL_STENCIL_OP_REPLACE:
- case XGL_STENCIL_OP_ZERO:
+ case XGL_PIPELINE_BIND_POINT_COMPUTE:
+ case XGL_PIPELINE_BIND_POINT_GRAPHICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
+static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
{
- switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
+ switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
{
- case XGL_SYSTEM_ALLOC_API_OBJECT:
- case XGL_SYSTEM_ALLOC_DEBUG:
- case XGL_SYSTEM_ALLOC_INTERNAL:
- case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
- case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
+ case XGL_SHADER_STAGE_COMPUTE:
+ case XGL_SHADER_STAGE_FRAGMENT:
+ case XGL_SHADER_STAGE_GEOMETRY:
+ case XGL_SHADER_STAGE_TESS_CONTROL:
+ case XGL_SHADER_STAGE_TESS_EVALUATION:
+ case XGL_SHADER_STAGE_VERTEX:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
+static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
{
- switch ((XGL_MEMORY_REF_FLAGS)input_value)
+ switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
{
- case XGL_MEMORY_REF_READ_ONLY_BIT:
+ case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_BIND_POINT(XGL_PIPELINE_BIND_POINT input_value)
+static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
{
- switch ((XGL_PIPELINE_BIND_POINT)input_value)
+ switch ((XGL_MEMORY_TYPE)input_value)
{
- case XGL_PIPELINE_BIND_POINT_COMPUTE:
- case XGL_PIPELINE_BIND_POINT_GRAPHICS:
+ case XGL_MEMORY_TYPE_BUFFER:
+ case XGL_MEMORY_TYPE_IMAGE:
+ case XGL_MEMORY_TYPE_OTHER:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
{
- switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
+ switch ((XGL_CHANNEL_SWIZZLE)input_value)
{
- case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_COPY_BIT:
- case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
- case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
+ case XGL_CHANNEL_SWIZZLE_A:
+ case XGL_CHANNEL_SWIZZLE_B:
+ case XGL_CHANNEL_SWIZZLE_G:
+ case XGL_CHANNEL_SWIZZLE_ONE:
+ case XGL_CHANNEL_SWIZZLE_R:
+ case XGL_CHANNEL_SWIZZLE_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
{
- switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ switch ((XGL_DEPTH_MODE)input_value)
{
- case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
- case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
- case XGL_ATTACHMENT_STORE_OP_STORE:
+ case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
+ case XGL_DEPTH_MODE_ZERO_TO_ONE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
{
- switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ switch ((XGL_FORMAT)input_value)
{
- case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
- case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ case XGL_FMT_ASTC_10x10_SRGB:
+ case XGL_FMT_ASTC_10x10_UNORM:
+ case XGL_FMT_ASTC_10x5_SRGB:
+ case XGL_FMT_ASTC_10x5_UNORM:
+ case XGL_FMT_ASTC_10x6_SRGB:
+ case XGL_FMT_ASTC_10x6_UNORM:
+ case XGL_FMT_ASTC_10x8_SRGB:
+ case XGL_FMT_ASTC_10x8_UNORM:
+ case XGL_FMT_ASTC_12x10_SRGB:
+ case XGL_FMT_ASTC_12x10_UNORM:
+ case XGL_FMT_ASTC_12x12_SRGB:
+ case XGL_FMT_ASTC_12x12_UNORM:
+ case XGL_FMT_ASTC_4x4_SRGB:
+ case XGL_FMT_ASTC_4x4_UNORM:
+ case XGL_FMT_ASTC_4x5_SRGB:
+ case XGL_FMT_ASTC_4x5_UNORM:
+ case XGL_FMT_ASTC_5x5_SRGB:
+ case XGL_FMT_ASTC_5x5_UNORM:
+ case XGL_FMT_ASTC_6x5_SRGB:
+ case XGL_FMT_ASTC_6x5_UNORM:
+ case XGL_FMT_ASTC_6x6_SRGB:
+ case XGL_FMT_ASTC_6x6_UNORM:
+ case XGL_FMT_ASTC_8x5_SRGB:
+ case XGL_FMT_ASTC_8x5_UNORM:
+ case XGL_FMT_ASTC_8x6_SRGB:
+ case XGL_FMT_ASTC_8x6_UNORM:
+ case XGL_FMT_ASTC_8x8_SRGB:
+ case XGL_FMT_ASTC_8x8_UNORM:
+ case XGL_FMT_B10G10R10A2_SINT:
+ case XGL_FMT_B10G10R10A2_SNORM:
+ case XGL_FMT_B10G10R10A2_SSCALED:
+ case XGL_FMT_B10G10R10A2_UINT:
+ case XGL_FMT_B10G10R10A2_UNORM:
+ case XGL_FMT_B10G10R10A2_USCALED:
+ case XGL_FMT_B5G6R5_UNORM:
+ case XGL_FMT_B5G6R5_USCALED:
+ case XGL_FMT_B8G8R8A8_SINT:
+ case XGL_FMT_B8G8R8A8_SNORM:
+ case XGL_FMT_B8G8R8A8_SRGB:
+ case XGL_FMT_B8G8R8A8_SSCALED:
+ case XGL_FMT_B8G8R8A8_UINT:
+ case XGL_FMT_B8G8R8A8_UNORM:
+ case XGL_FMT_B8G8R8A8_USCALED:
+ case XGL_FMT_B8G8R8_SINT:
+ case XGL_FMT_B8G8R8_SNORM:
+ case XGL_FMT_B8G8R8_SRGB:
+ case XGL_FMT_B8G8R8_SSCALED:
+ case XGL_FMT_B8G8R8_UINT:
+ case XGL_FMT_B8G8R8_UNORM:
+ case XGL_FMT_B8G8R8_USCALED:
+ case XGL_FMT_BC1_SRGB:
+ case XGL_FMT_BC1_UNORM:
+ case XGL_FMT_BC2_SRGB:
+ case XGL_FMT_BC2_UNORM:
+ case XGL_FMT_BC3_SRGB:
+ case XGL_FMT_BC3_UNORM:
+ case XGL_FMT_BC4_SNORM:
+ case XGL_FMT_BC4_UNORM:
+ case XGL_FMT_BC5_SNORM:
+ case XGL_FMT_BC5_UNORM:
+ case XGL_FMT_BC6H_SFLOAT:
+ case XGL_FMT_BC6H_UFLOAT:
+ case XGL_FMT_BC7_SRGB:
+ case XGL_FMT_BC7_UNORM:
+ case XGL_FMT_D16_UNORM:
+ case XGL_FMT_D16_UNORM_S8_UINT:
+ case XGL_FMT_D24_UNORM:
+ case XGL_FMT_D24_UNORM_S8_UINT:
+ case XGL_FMT_D32_SFLOAT:
+ case XGL_FMT_D32_SFLOAT_S8_UINT:
+ case XGL_FMT_EAC_R11G11_SNORM:
+ case XGL_FMT_EAC_R11G11_UNORM:
+ case XGL_FMT_EAC_R11_SNORM:
+ case XGL_FMT_EAC_R11_UNORM:
+ case XGL_FMT_ETC2_R8G8B8A1_UNORM:
+ case XGL_FMT_ETC2_R8G8B8A8_UNORM:
+ case XGL_FMT_ETC2_R8G8B8_UNORM:
+ case XGL_FMT_R10G10B10A2_SINT:
+ case XGL_FMT_R10G10B10A2_SNORM:
+ case XGL_FMT_R10G10B10A2_SSCALED:
+ case XGL_FMT_R10G10B10A2_UINT:
+ case XGL_FMT_R10G10B10A2_UNORM:
+ case XGL_FMT_R10G10B10A2_USCALED:
+ case XGL_FMT_R11G11B10_UFLOAT:
+ case XGL_FMT_R16G16B16A16_SFLOAT:
+ case XGL_FMT_R16G16B16A16_SINT:
+ case XGL_FMT_R16G16B16A16_SNORM:
+ case XGL_FMT_R16G16B16A16_SSCALED:
+ case XGL_FMT_R16G16B16A16_UINT:
+ case XGL_FMT_R16G16B16A16_UNORM:
+ case XGL_FMT_R16G16B16A16_USCALED:
+ case XGL_FMT_R16G16B16_SFLOAT:
+ case XGL_FMT_R16G16B16_SINT:
+ case XGL_FMT_R16G16B16_SNORM:
+ case XGL_FMT_R16G16B16_SSCALED:
+ case XGL_FMT_R16G16B16_UINT:
+ case XGL_FMT_R16G16B16_UNORM:
+ case XGL_FMT_R16G16B16_USCALED:
+ case XGL_FMT_R16G16_SFLOAT:
+ case XGL_FMT_R16G16_SINT:
+ case XGL_FMT_R16G16_SNORM:
+ case XGL_FMT_R16G16_SSCALED:
+ case XGL_FMT_R16G16_UINT:
+ case XGL_FMT_R16G16_UNORM:
+ case XGL_FMT_R16G16_USCALED:
+ case XGL_FMT_R16_SFLOAT:
+ case XGL_FMT_R16_SINT:
+ case XGL_FMT_R16_SNORM:
+ case XGL_FMT_R16_SSCALED:
+ case XGL_FMT_R16_UINT:
+ case XGL_FMT_R16_UNORM:
+ case XGL_FMT_R16_USCALED:
+ case XGL_FMT_R32G32B32A32_SFLOAT:
+ case XGL_FMT_R32G32B32A32_SINT:
+ case XGL_FMT_R32G32B32A32_UINT:
+ case XGL_FMT_R32G32B32_SFLOAT:
+ case XGL_FMT_R32G32B32_SINT:
+ case XGL_FMT_R32G32B32_UINT:
+ case XGL_FMT_R32G32_SFLOAT:
+ case XGL_FMT_R32G32_SINT:
+ case XGL_FMT_R32G32_UINT:
+ case XGL_FMT_R32_SFLOAT:
+ case XGL_FMT_R32_SINT:
+ case XGL_FMT_R32_UINT:
+ case XGL_FMT_R4G4B4A4_UNORM:
+ case XGL_FMT_R4G4B4A4_USCALED:
+ case XGL_FMT_R4G4_UNORM:
+ case XGL_FMT_R4G4_USCALED:
+ case XGL_FMT_R5G5B5A1_UNORM:
+ case XGL_FMT_R5G5B5A1_USCALED:
+ case XGL_FMT_R5G6B5_UNORM:
+ case XGL_FMT_R5G6B5_USCALED:
+ case XGL_FMT_R64G64B64A64_SFLOAT:
+ case XGL_FMT_R64G64B64_SFLOAT:
+ case XGL_FMT_R64G64_SFLOAT:
+ case XGL_FMT_R64_SFLOAT:
+ case XGL_FMT_R8G8B8A8_SINT:
+ case XGL_FMT_R8G8B8A8_SNORM:
+ case XGL_FMT_R8G8B8A8_SRGB:
+ case XGL_FMT_R8G8B8A8_SSCALED:
+ case XGL_FMT_R8G8B8A8_UINT:
+ case XGL_FMT_R8G8B8A8_UNORM:
+ case XGL_FMT_R8G8B8A8_USCALED:
+ case XGL_FMT_R8G8B8_SINT:
+ case XGL_FMT_R8G8B8_SNORM:
+ case XGL_FMT_R8G8B8_SRGB:
+ case XGL_FMT_R8G8B8_SSCALED:
+ case XGL_FMT_R8G8B8_UINT:
+ case XGL_FMT_R8G8B8_UNORM:
+ case XGL_FMT_R8G8B8_USCALED:
+ case XGL_FMT_R8G8_SINT:
+ case XGL_FMT_R8G8_SNORM:
+ case XGL_FMT_R8G8_SRGB:
+ case XGL_FMT_R8G8_SSCALED:
+ case XGL_FMT_R8G8_UINT:
+ case XGL_FMT_R8G8_UNORM:
+ case XGL_FMT_R8G8_USCALED:
+ case XGL_FMT_R8_SINT:
+ case XGL_FMT_R8_SNORM:
+ case XGL_FMT_R8_SRGB:
+ case XGL_FMT_R8_SSCALED:
+ case XGL_FMT_R8_UINT:
+ case XGL_FMT_R8_UNORM:
+ case XGL_FMT_R8_USCALED:
+ case XGL_FMT_R9G9B9E5_UFLOAT:
+ case XGL_FMT_S8_UINT:
+ case XGL_FMT_UNDEFINED:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_CHANNEL_SWIZZLE(XGL_CHANNEL_SWIZZLE input_value)
+static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
{
- switch ((XGL_CHANNEL_SWIZZLE)input_value)
+ switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
{
- case XGL_CHANNEL_SWIZZLE_A:
- case XGL_CHANNEL_SWIZZLE_B:
- case XGL_CHANNEL_SWIZZLE_G:
- case XGL_CHANNEL_SWIZZLE_ONE:
- case XGL_CHANNEL_SWIZZLE_R:
- case XGL_CHANNEL_SWIZZLE_ZERO:
+ case XGL_BUFFER_CREATE_SHAREABLE_BIT:
+ case XGL_BUFFER_CREATE_SPARSE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_CREATE_FLAGS(XGL_PIPELINE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
{
- switch ((XGL_PIPELINE_CREATE_FLAGS)input_value)
+ switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
{
- case XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
+ case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
+ case XGL_MEMORY_PROPERTY_GPU_ONLY:
+ case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
+ case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
{
- switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
{
- case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
- case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
+ case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
+ case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+{
+ switch ((XGL_COORDINATE_ORIGIN)input_value)
+ {
+ case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
+ case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
+{
+ switch ((XGL_CULL_MODE)input_value)
+ {
+ case XGL_CULL_BACK:
+ case XGL_CULL_FRONT:
+ case XGL_CULL_FRONT_AND_BACK:
+ case XGL_CULL_NONE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
+static inline uint32_t validate_XGL_MEMORY_OUTPUT_FLAGS(XGL_MEMORY_OUTPUT_FLAGS input_value)
{
- switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
+ switch ((XGL_MEMORY_OUTPUT_FLAGS)input_value)
{
- case XGL_IMAGE_FORMAT_CLASS_128_BITS:
- case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_16_BITS:
- case XGL_IMAGE_FORMAT_CLASS_24_BITS:
- case XGL_IMAGE_FORMAT_CLASS_32_BITS:
- case XGL_IMAGE_FORMAT_CLASS_48_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BITS:
- case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
- case XGL_IMAGE_FORMAT_CLASS_8_BITS:
- case XGL_IMAGE_FORMAT_CLASS_96_BITS:
- case XGL_IMAGE_FORMAT_CLASS_D16:
- case XGL_IMAGE_FORMAT_CLASS_D16S8:
- case XGL_IMAGE_FORMAT_CLASS_D24:
- case XGL_IMAGE_FORMAT_CLASS_D24S8:
- case XGL_IMAGE_FORMAT_CLASS_D32:
- case XGL_IMAGE_FORMAT_CLASS_D32S8:
- case XGL_IMAGE_FORMAT_CLASS_LINEAR:
- case XGL_IMAGE_FORMAT_CLASS_S8:
+ case XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_COPY_BIT:
+ case XGL_MEMORY_OUTPUT_CPU_WRITE_BIT:
+ case XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
{
- switch ((XGL_QUERY_TYPE)input_value)
+ switch ((XGL_SET_EVENT)input_value)
{
- case XGL_QUERY_OCCLUSION:
- case XGL_QUERY_PIPELINE_STATISTICS:
+ case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
+ case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
+ case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
+ case XGL_SET_EVENT_TOP_OF_PIPE:
+ case XGL_SET_EVENT_TRANSFER_COMPLETE:
+ case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+{
+ switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ {
+ case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_COPY_BIT:
+ case XGL_MEMORY_INPUT_CPU_READ_BIT:
+ case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
+ case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
+ case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
+ case XGL_MEMORY_INPUT_SHADER_READ_BIT:
+ case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
+ case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
+{
+ switch ((XGL_TEX_MIPMAP_MODE)input_value)
+ {
+ case XGL_TEX_MIPMAP_BASE:
+ case XGL_TEX_MIPMAP_LINEAR:
+ case XGL_TEX_MIPMAP_NEAREST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DESCRIPTOR_UPDATE_MODE(XGL_DESCRIPTOR_UPDATE_MODE input_value)
+{
+ switch ((XGL_DESCRIPTOR_UPDATE_MODE)input_value)
+ {
+ case XGL_DESCRIPTOR_UDPATE_MODE_COPY:
+ case XGL_DESCRIPTOR_UPDATE_MODE_FASTEST:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_MEMORY_REF_FLAGS(XGL_MEMORY_REF_FLAGS input_value)
{
- switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ switch ((XGL_MEMORY_REF_FLAGS)input_value)
{
- case XGL_IMAGE_CREATE_CLONEABLE_BIT:
- case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
- case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
- case XGL_IMAGE_CREATE_SHAREABLE_BIT:
- case XGL_IMAGE_CREATE_SPARSE_BIT:
+ case XGL_MEMORY_REF_READ_ONLY_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_INPUT_FLAGS(XGL_MEMORY_INPUT_FLAGS input_value)
+static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
{
- switch ((XGL_MEMORY_INPUT_FLAGS)input_value)
+ switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
{
- case XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_COPY_BIT:
- case XGL_MEMORY_INPUT_CPU_READ_BIT:
- case XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT:
- case XGL_MEMORY_INPUT_INDEX_FETCH_BIT:
- case XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT:
- case XGL_MEMORY_INPUT_SHADER_READ_BIT:
- case XGL_MEMORY_INPUT_UNIFORM_READ_BIT:
- case XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT:
+ case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
+ case XGL_DESCRIPTOR_SET_USAGE_STATIC:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
+static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
{
- switch ((XGL_IMAGE_ASPECT)input_value)
+ switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
{
- case XGL_IMAGE_ASPECT_COLOR:
- case XGL_IMAGE_ASPECT_DEPTH:
- case XGL_IMAGE_ASPECT_STENCIL:
+ case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
{
- switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ switch ((XGL_WAIT_EVENT)input_value)
{
- case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
- case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
+ case XGL_WAIT_EVENT_TOP_OF_PIPE:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
{
- switch ((XGL_COMPARE_FUNC)input_value)
+ switch ((XGL_QUEUE_FLAGS)input_value)
{
- case XGL_COMPARE_ALWAYS:
- case XGL_COMPARE_EQUAL:
- case XGL_COMPARE_GREATER:
- case XGL_COMPARE_GREATER_EQUAL:
- case XGL_COMPARE_LESS:
- case XGL_COMPARE_LESS_EQUAL:
- case XGL_COMPARE_NEVER:
- case XGL_COMPARE_NOT_EQUAL:
+ case XGL_QUEUE_COMPUTE_BIT:
+ case XGL_QUEUE_DMA_BIT:
+ case XGL_QUEUE_EXTENDED_BIT:
+ case XGL_QUEUE_GRAPHICS_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
+static inline uint32_t validate_XGL_SYSTEM_ALLOC_TYPE(XGL_SYSTEM_ALLOC_TYPE input_value)
{
- switch ((XGL_SHADER_STAGE_FLAGS)input_value)
+ switch ((XGL_SYSTEM_ALLOC_TYPE)input_value)
{
- case XGL_SHADER_STAGE_FLAGS_ALL:
- case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
- case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
- case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
- case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
- case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
+ case XGL_SYSTEM_ALLOC_API_OBJECT:
+ case XGL_SYSTEM_ALLOC_DEBUG:
+ case XGL_SYSTEM_ALLOC_INTERNAL:
+ case XGL_SYSTEM_ALLOC_INTERNAL_SHADER:
+ case XGL_SYSTEM_ALLOC_INTERNAL_TEMP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
{
- switch ((XGL_FILL_MODE)input_value)
+ switch ((XGL_VALIDATION_LEVEL)input_value)
{
- case XGL_FILL_POINTS:
- case XGL_FILL_SOLID:
- case XGL_FILL_WIREFRAME:
+ case XGL_VALIDATION_LEVEL_0:
+ case XGL_VALIDATION_LEVEL_1:
+ case XGL_VALIDATION_LEVEL_2:
+ case XGL_VALIDATION_LEVEL_3:
+ case XGL_VALIDATION_LEVEL_4:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_COORDINATE_ORIGIN(XGL_COORDINATE_ORIGIN input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
{
- switch ((XGL_COORDINATE_ORIGIN)input_value)
+ switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
{
- case XGL_COORDINATE_ORIGIN_LOWER_LEFT:
- case XGL_COORDINATE_ORIGIN_UPPER_LEFT:
+ case XGL_GPU_TYPE_DISCRETE:
+ case XGL_GPU_TYPE_INTEGRATED:
+ case XGL_GPU_TYPE_OTHER:
+ case XGL_GPU_TYPE_VIRTUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_WAIT_EVENT(XGL_WAIT_EVENT input_value)
+static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
{
- switch ((XGL_WAIT_EVENT)input_value)
+ switch ((XGL_IMAGE_LAYOUT)input_value)
{
- case XGL_WAIT_EVENT_BEFORE_RASTERIZATION:
- case XGL_WAIT_EVENT_TOP_OF_PIPE:
+ case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_GENERAL:
+ case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
+ case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DESCRIPTOR_TYPE(XGL_DESCRIPTOR_TYPE input_value)
+static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
{
- switch ((XGL_DESCRIPTOR_TYPE)input_value)
+ switch ((XGL_BLEND)input_value)
{
- case XGL_DESCRIPTOR_TYPE_IMAGE:
- case XGL_DESCRIPTOR_TYPE_IMAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER:
- case XGL_DESCRIPTOR_TYPE_RAW_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_SAMPLER:
- case XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_SHADER_STORAGE_BUFFER_DYNAMIC:
- case XGL_DESCRIPTOR_TYPE_TEXTURE:
- case XGL_DESCRIPTOR_TYPE_TEXTURE_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SEMAPHORE_CREATE_FLAGS(XGL_SEMAPHORE_CREATE_FLAGS input_value)
-{
- switch ((XGL_SEMAPHORE_CREATE_FLAGS)input_value)
- {
- case XGL_SEMAPHORE_CREATE_SHAREABLE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
-{
- switch ((XGL_MEMORY_PRIORITY)input_value)
- {
- case XGL_MEMORY_PRIORITY_HIGH:
- case XGL_MEMORY_PRIORITY_LOW:
- case XGL_MEMORY_PRIORITY_NORMAL:
- case XGL_MEMORY_PRIORITY_UNUSED:
- case XGL_MEMORY_PRIORITY_VERY_HIGH:
- case XGL_MEMORY_PRIORITY_VERY_LOW:
+ case XGL_BLEND_CONSTANT_ALPHA:
+ case XGL_BLEND_CONSTANT_COLOR:
+ case XGL_BLEND_DEST_ALPHA:
+ case XGL_BLEND_DEST_COLOR:
+ case XGL_BLEND_ONE:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
+ case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
+ case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
+ case XGL_BLEND_ONE_MINUS_DEST_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
+ case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
+ case XGL_BLEND_ONE_MINUS_SRC_COLOR:
+ case XGL_BLEND_SRC1_ALPHA:
+ case XGL_BLEND_SRC1_COLOR:
+ case XGL_BLEND_SRC_ALPHA:
+ case XGL_BLEND_SRC_ALPHA_SATURATE:
+ case XGL_BLEND_SRC_COLOR:
+ case XGL_BLEND_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
+static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
{
- switch ((XGL_TIMESTAMP_TYPE)input_value)
+ switch ((XGL_QUEUE_TYPE)input_value)
{
- case XGL_TIMESTAMP_BOTTOM:
- case XGL_TIMESTAMP_TOP:
+ case XGL_QUEUE_TYPE_COMPUTE:
+ case XGL_QUEUE_TYPE_DMA:
+ case XGL_QUEUE_TYPE_GRAPHICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PHYSICAL_GPU_TYPE(XGL_PHYSICAL_GPU_TYPE input_value)
+static inline uint32_t validate_XGL_SHADER_STAGE_FLAGS(XGL_SHADER_STAGE_FLAGS input_value)
{
- switch ((XGL_PHYSICAL_GPU_TYPE)input_value)
+ switch ((XGL_SHADER_STAGE_FLAGS)input_value)
{
- case XGL_GPU_TYPE_DISCRETE:
- case XGL_GPU_TYPE_INTEGRATED:
- case XGL_GPU_TYPE_OTHER:
- case XGL_GPU_TYPE_VIRTUAL:
+ case XGL_SHADER_STAGE_FLAGS_ALL:
+ case XGL_SHADER_STAGE_FLAGS_COMPUTE_BIT:
+ case XGL_SHADER_STAGE_FLAGS_FRAGMENT_BIT:
+ case XGL_SHADER_STAGE_FLAGS_GEOMETRY_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_CONTROL_BIT:
+ case XGL_SHADER_STAGE_FLAGS_TESS_EVALUATION_BIT:
+ case XGL_SHADER_STAGE_FLAGS_VERTEX_BIT:
return 1;
default:
return 0;
return 0;
}
}
-
-
-static inline uint32_t validate_XGL_IMAGE_VIEW_TYPE(XGL_IMAGE_VIEW_TYPE input_value)
-{
- switch ((XGL_IMAGE_VIEW_TYPE)input_value)
- {
- case XGL_IMAGE_VIEW_1D:
- case XGL_IMAGE_VIEW_2D:
- case XGL_IMAGE_VIEW_3D:
- case XGL_IMAGE_VIEW_CUBE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_SET_USAGE(XGL_DESCRIPTOR_SET_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_SET_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_SET_USAGE_ONE_SHOT:
- case XGL_DESCRIPTOR_SET_USAGE_STATIC:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SUBRESOURCE_INFO_TYPE(XGL_SUBRESOURCE_INFO_TYPE input_value)
-{
- switch ((XGL_SUBRESOURCE_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
-{
- switch ((XGL_RESULT)input_value)
- {
- case XGL_ERROR_BAD_PIPELINE_DATA:
- case XGL_ERROR_BAD_SHADER_CODE:
- case XGL_ERROR_BUILDING_COMMAND_BUFFER:
- case XGL_ERROR_DEVICE_ALREADY_CREATED:
- case XGL_ERROR_DEVICE_LOST:
- case XGL_ERROR_INCOMPATIBLE_DEVICE:
- case XGL_ERROR_INCOMPATIBLE_DRIVER:
- case XGL_ERROR_INCOMPATIBLE_QUEUE:
- case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
- case XGL_ERROR_INITIALIZATION_FAILED:
- case XGL_ERROR_INVALID_ALIGNMENT:
- case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
- case XGL_ERROR_INVALID_EXTENSION:
- case XGL_ERROR_INVALID_FLAGS:
- case XGL_ERROR_INVALID_FORMAT:
- case XGL_ERROR_INVALID_HANDLE:
- case XGL_ERROR_INVALID_IMAGE:
- case XGL_ERROR_INVALID_MEMORY_SIZE:
- case XGL_ERROR_INVALID_OBJECT_TYPE:
- case XGL_ERROR_INVALID_ORDINAL:
- case XGL_ERROR_INVALID_POINTER:
- case XGL_ERROR_INVALID_QUEUE_TYPE:
- case XGL_ERROR_INVALID_VALUE:
- case XGL_ERROR_MEMORY_MAP_FAILED:
- case XGL_ERROR_MEMORY_NOT_BOUND:
- case XGL_ERROR_MEMORY_UNMAP_FAILED:
- case XGL_ERROR_NOT_MAPPABLE:
- case XGL_ERROR_NOT_SHAREABLE:
- case XGL_ERROR_OUT_OF_GPU_MEMORY:
- case XGL_ERROR_OUT_OF_MEMORY:
- case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
- case XGL_ERROR_UNAVAILABLE:
- case XGL_ERROR_UNKNOWN:
- case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
- case XGL_EVENT_RESET:
- case XGL_EVENT_SET:
- case XGL_NOT_READY:
- case XGL_SUCCESS:
- case XGL_TIMEOUT:
- case XGL_UNSUPPORTED:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
-{
- switch ((XGL_BORDER_COLOR_TYPE)input_value)
- {
- case XGL_BORDER_COLOR_OPAQUE_BLACK:
- case XGL_BORDER_COLOR_OPAQUE_WHITE:
- case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
-{
- switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
- {
- case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
- case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
- case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
-{
- switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
- {
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
- case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
-{
- switch ((XGL_INDEX_TYPE)input_value)
- {
- case XGL_INDEX_16:
- case XGL_INDEX_32:
- case XGL_INDEX_8:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_CULL_MODE(XGL_CULL_MODE input_value)
-{
- switch ((XGL_CULL_MODE)input_value)
- {
- case XGL_CULL_BACK:
- case XGL_CULL_FRONT:
- case XGL_CULL_FRONT_AND_BACK:
- case XGL_CULL_NONE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_SET_EVENT(XGL_SET_EVENT input_value)
-{
- switch ((XGL_SET_EVENT)input_value)
- {
- case XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE:
- case XGL_SET_EVENT_GPU_COMMANDS_COMPLETE:
- case XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE:
- case XGL_SET_EVENT_TOP_OF_PIPE:
- case XGL_SET_EVENT_TRANSFER_COMPLETE:
- case XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_MEMORY_PROPERTY_FLAGS(XGL_MEMORY_PROPERTY_FLAGS input_value)
-{
- switch ((XGL_MEMORY_PROPERTY_FLAGS)input_value)
- {
- case XGL_MEMORY_PROPERTY_CPU_GPU_COHERENT_BIT:
- case XGL_MEMORY_PROPERTY_CPU_UNCACHED_BIT:
- case XGL_MEMORY_PROPERTY_CPU_VISIBLE_BIT:
- case XGL_MEMORY_PROPERTY_CPU_WRITE_COMBINED_BIT:
- case XGL_MEMORY_PROPERTY_GPU_ONLY:
- case XGL_MEMORY_PROPERTY_PREFER_CPU_LOCAL:
- case XGL_MEMORY_PROPERTY_SHAREABLE_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
-{
- switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
- {
- case XGL_ATTACHMENT_LOAD_OP_CLEAR:
- case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
- case XGL_ATTACHMENT_LOAD_OP_LOAD:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
-{
- switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
- {
- case XGL_PROVOKING_VERTEX_FIRST:
- case XGL_PROVOKING_VERTEX_LAST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VALIDATION_LEVEL(XGL_VALIDATION_LEVEL input_value)
-{
- switch ((XGL_VALIDATION_LEVEL)input_value)
- {
- case XGL_VALIDATION_LEVEL_0:
- case XGL_VALIDATION_LEVEL_1:
- case XGL_VALIDATION_LEVEL_2:
- case XGL_VALIDATION_LEVEL_3:
- case XGL_VALIDATION_LEVEL_4:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FACE_ORIENTATION(XGL_FACE_ORIENTATION input_value)
-{
- switch ((XGL_FACE_ORIENTATION)input_value)
- {
- case XGL_FRONT_FACE_CCW:
- case XGL_FRONT_FACE_CW:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
-{
- switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
- {
- case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
- case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
- case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUEUE_FLAGS(XGL_QUEUE_FLAGS input_value)
-{
- switch ((XGL_QUEUE_FLAGS)input_value)
- {
- case XGL_QUEUE_COMPUTE_BIT:
- case XGL_QUEUE_DMA_BIT:
- case XGL_QUEUE_EXTENDED_BIT:
- case XGL_QUEUE_GRAPHICS_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_DESCRIPTOR_REGION_USAGE(XGL_DESCRIPTOR_REGION_USAGE input_value)
-{
- switch ((XGL_DESCRIPTOR_REGION_USAGE)input_value)
- {
- case XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC:
- case XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_TEX_MIPMAP_MODE(XGL_TEX_MIPMAP_MODE input_value)
-{
- switch ((XGL_TEX_MIPMAP_MODE)input_value)
- {
- case XGL_TEX_MIPMAP_BASE:
- case XGL_TEX_MIPMAP_LINEAR:
- case XGL_TEX_MIPMAP_NEAREST:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
-{
- switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
- {
- case XGL_QUERY_IMPRECISE_DATA_BIT:
- return 1;
- default:
- return 0;
- }
-}
-
-
-static inline uint32_t validate_XGL_FORMAT(XGL_FORMAT input_value)
-{
- switch ((XGL_FORMAT)input_value)
- {
- case XGL_FMT_ASTC_10x10_SRGB:
- case XGL_FMT_ASTC_10x10_UNORM:
- case XGL_FMT_ASTC_10x5_SRGB:
- case XGL_FMT_ASTC_10x5_UNORM:
- case XGL_FMT_ASTC_10x6_SRGB:
- case XGL_FMT_ASTC_10x6_UNORM:
- case XGL_FMT_ASTC_10x8_SRGB:
- case XGL_FMT_ASTC_10x8_UNORM:
- case XGL_FMT_ASTC_12x10_SRGB:
- case XGL_FMT_ASTC_12x10_UNORM:
- case XGL_FMT_ASTC_12x12_SRGB:
- case XGL_FMT_ASTC_12x12_UNORM:
- case XGL_FMT_ASTC_4x4_SRGB:
- case XGL_FMT_ASTC_4x4_UNORM:
- case XGL_FMT_ASTC_4x5_SRGB:
- case XGL_FMT_ASTC_4x5_UNORM:
- case XGL_FMT_ASTC_5x5_SRGB:
- case XGL_FMT_ASTC_5x5_UNORM:
- case XGL_FMT_ASTC_6x5_SRGB:
- case XGL_FMT_ASTC_6x5_UNORM:
- case XGL_FMT_ASTC_6x6_SRGB:
- case XGL_FMT_ASTC_6x6_UNORM:
- case XGL_FMT_ASTC_8x5_SRGB:
- case XGL_FMT_ASTC_8x5_UNORM:
- case XGL_FMT_ASTC_8x6_SRGB:
- case XGL_FMT_ASTC_8x6_UNORM:
- case XGL_FMT_ASTC_8x8_SRGB:
- case XGL_FMT_ASTC_8x8_UNORM:
- case XGL_FMT_B10G10R10A2_SINT:
- case XGL_FMT_B10G10R10A2_SNORM:
- case XGL_FMT_B10G10R10A2_SSCALED:
- case XGL_FMT_B10G10R10A2_UINT:
- case XGL_FMT_B10G10R10A2_UNORM:
- case XGL_FMT_B10G10R10A2_USCALED:
- case XGL_FMT_B5G6R5_UNORM:
- case XGL_FMT_B5G6R5_USCALED:
- case XGL_FMT_B8G8R8A8_SINT:
- case XGL_FMT_B8G8R8A8_SNORM:
- case XGL_FMT_B8G8R8A8_SRGB:
- case XGL_FMT_B8G8R8A8_SSCALED:
- case XGL_FMT_B8G8R8A8_UINT:
- case XGL_FMT_B8G8R8A8_UNORM:
- case XGL_FMT_B8G8R8A8_USCALED:
- case XGL_FMT_B8G8R8_SINT:
- case XGL_FMT_B8G8R8_SNORM:
- case XGL_FMT_B8G8R8_SRGB:
- case XGL_FMT_B8G8R8_SSCALED:
- case XGL_FMT_B8G8R8_UINT:
- case XGL_FMT_B8G8R8_UNORM:
- case XGL_FMT_B8G8R8_USCALED:
- case XGL_FMT_BC1_SRGB:
- case XGL_FMT_BC1_UNORM:
- case XGL_FMT_BC2_SRGB:
- case XGL_FMT_BC2_UNORM:
- case XGL_FMT_BC3_SRGB:
- case XGL_FMT_BC3_UNORM:
- case XGL_FMT_BC4_SNORM:
- case XGL_FMT_BC4_UNORM:
- case XGL_FMT_BC5_SNORM:
- case XGL_FMT_BC5_UNORM:
- case XGL_FMT_BC6H_SFLOAT:
- case XGL_FMT_BC6H_UFLOAT:
- case XGL_FMT_BC7_SRGB:
- case XGL_FMT_BC7_UNORM:
- case XGL_FMT_D16_UNORM:
- case XGL_FMT_D16_UNORM_S8_UINT:
- case XGL_FMT_D24_UNORM:
- case XGL_FMT_D24_UNORM_S8_UINT:
- case XGL_FMT_D32_SFLOAT:
- case XGL_FMT_D32_SFLOAT_S8_UINT:
- case XGL_FMT_EAC_R11G11_SNORM:
- case XGL_FMT_EAC_R11G11_UNORM:
- case XGL_FMT_EAC_R11_SNORM:
- case XGL_FMT_EAC_R11_UNORM:
- case XGL_FMT_ETC2_R8G8B8A1_UNORM:
- case XGL_FMT_ETC2_R8G8B8A8_UNORM:
- case XGL_FMT_ETC2_R8G8B8_UNORM:
- case XGL_FMT_R10G10B10A2_SINT:
- case XGL_FMT_R10G10B10A2_SNORM:
- case XGL_FMT_R10G10B10A2_SSCALED:
- case XGL_FMT_R10G10B10A2_UINT:
- case XGL_FMT_R10G10B10A2_UNORM:
- case XGL_FMT_R10G10B10A2_USCALED:
- case XGL_FMT_R11G11B10_UFLOAT:
- case XGL_FMT_R16G16B16A16_SFLOAT:
- case XGL_FMT_R16G16B16A16_SINT:
- case XGL_FMT_R16G16B16A16_SNORM:
- case XGL_FMT_R16G16B16A16_SSCALED:
- case XGL_FMT_R16G16B16A16_UINT:
- case XGL_FMT_R16G16B16A16_UNORM:
- case XGL_FMT_R16G16B16A16_USCALED:
- case XGL_FMT_R16G16B16_SFLOAT:
- case XGL_FMT_R16G16B16_SINT:
- case XGL_FMT_R16G16B16_SNORM:
- case XGL_FMT_R16G16B16_SSCALED:
- case XGL_FMT_R16G16B16_UINT:
- case XGL_FMT_R16G16B16_UNORM:
- case XGL_FMT_R16G16B16_USCALED:
- case XGL_FMT_R16G16_SFLOAT:
- case XGL_FMT_R16G16_SINT:
- case XGL_FMT_R16G16_SNORM:
- case XGL_FMT_R16G16_SSCALED:
- case XGL_FMT_R16G16_UINT:
- case XGL_FMT_R16G16_UNORM:
- case XGL_FMT_R16G16_USCALED:
- case XGL_FMT_R16_SFLOAT:
- case XGL_FMT_R16_SINT:
- case XGL_FMT_R16_SNORM:
- case XGL_FMT_R16_SSCALED:
- case XGL_FMT_R16_UINT:
- case XGL_FMT_R16_UNORM:
- case XGL_FMT_R16_USCALED:
- case XGL_FMT_R32G32B32A32_SFLOAT:
- case XGL_FMT_R32G32B32A32_SINT:
- case XGL_FMT_R32G32B32A32_UINT:
- case XGL_FMT_R32G32B32_SFLOAT:
- case XGL_FMT_R32G32B32_SINT:
- case XGL_FMT_R32G32B32_UINT:
- case XGL_FMT_R32G32_SFLOAT:
- case XGL_FMT_R32G32_SINT:
- case XGL_FMT_R32G32_UINT:
- case XGL_FMT_R32_SFLOAT:
- case XGL_FMT_R32_SINT:
- case XGL_FMT_R32_UINT:
- case XGL_FMT_R4G4B4A4_UNORM:
- case XGL_FMT_R4G4B4A4_USCALED:
- case XGL_FMT_R4G4_UNORM:
- case XGL_FMT_R4G4_USCALED:
- case XGL_FMT_R5G5B5A1_UNORM:
- case XGL_FMT_R5G5B5A1_USCALED:
- case XGL_FMT_R5G6B5_UNORM:
- case XGL_FMT_R5G6B5_USCALED:
- case XGL_FMT_R64G64B64A64_SFLOAT:
- case XGL_FMT_R64G64B64_SFLOAT:
- case XGL_FMT_R64G64_SFLOAT:
- case XGL_FMT_R64_SFLOAT:
- case XGL_FMT_R8G8B8A8_SINT:
- case XGL_FMT_R8G8B8A8_SNORM:
- case XGL_FMT_R8G8B8A8_SRGB:
- case XGL_FMT_R8G8B8A8_SSCALED:
- case XGL_FMT_R8G8B8A8_UINT:
- case XGL_FMT_R8G8B8A8_UNORM:
- case XGL_FMT_R8G8B8A8_USCALED:
- case XGL_FMT_R8G8B8_SINT:
- case XGL_FMT_R8G8B8_SNORM:
- case XGL_FMT_R8G8B8_SRGB:
- case XGL_FMT_R8G8B8_SSCALED:
- case XGL_FMT_R8G8B8_UINT:
- case XGL_FMT_R8G8B8_UNORM:
- case XGL_FMT_R8G8B8_USCALED:
- case XGL_FMT_R8G8_SINT:
- case XGL_FMT_R8G8_SNORM:
- case XGL_FMT_R8G8_SRGB:
- case XGL_FMT_R8G8_SSCALED:
- case XGL_FMT_R8G8_UINT:
- case XGL_FMT_R8G8_UNORM:
- case XGL_FMT_R8G8_USCALED:
- case XGL_FMT_R8_SINT:
- case XGL_FMT_R8_SNORM:
- case XGL_FMT_R8_SRGB:
- case XGL_FMT_R8_SSCALED:
- case XGL_FMT_R8_UINT:
- case XGL_FMT_R8_UNORM:
- case XGL_FMT_R8_USCALED:
- case XGL_FMT_R9G9B9E5_UFLOAT:
- case XGL_FMT_S8_UINT:
- case XGL_FMT_UNDEFINED:
+
+
+static inline uint32_t validate_XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS(XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT:
+ case XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_DEPTH_MODE(XGL_DEPTH_MODE input_value)
+static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
{
- switch ((XGL_DEPTH_MODE)input_value)
+ switch ((XGL_IMAGE_TILING)input_value)
{
- case XGL_DEPTH_MODE_NEGATIVE_ONE_TO_ONE:
- case XGL_DEPTH_MODE_ZERO_TO_ONE:
+ case XGL_LINEAR_TILING:
+ case XGL_OPTIMAL_TILING:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_VERTEX_INPUT_STEP_RATE(XGL_VERTEX_INPUT_STEP_RATE input_value)
+{
+ switch ((XGL_VERTEX_INPUT_STEP_RATE)input_value)
+ {
+ case XGL_VERTEX_INPUT_STEP_RATE_DRAW:
+ case XGL_VERTEX_INPUT_STEP_RATE_INSTANCE:
+ case XGL_VERTEX_INPUT_STEP_RATE_VERTEX:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_DEVICE_CREATE_FLAGS(XGL_DEVICE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_DEVICE_CREATE_FLAGS)input_value)
+ {
+ case XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT:
+ case XGL_DEVICE_CREATE_VALIDATION_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_OBJECT_INFO_TYPE(XGL_OBJECT_INFO_TYPE input_value)
+{
+ switch ((XGL_OBJECT_INFO_TYPE)input_value)
+ {
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_PROVOKING_VERTEX_CONVENTION(XGL_PROVOKING_VERTEX_CONVENTION input_value)
+{
+ switch ((XGL_PROVOKING_VERTEX_CONVENTION)input_value)
+ {
+ case XGL_PROVOKING_VERTEX_FIRST:
+ case XGL_PROVOKING_VERTEX_LAST:
return 1;
default:
return 0;
}
+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)
}
-static inline uint32_t validate_XGL_BLEND(XGL_BLEND input_value)
+static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
{
- switch ((XGL_BLEND)input_value)
+ switch ((XGL_BLEND_FUNC)input_value)
{
- case XGL_BLEND_CONSTANT_ALPHA:
- case XGL_BLEND_CONSTANT_COLOR:
- case XGL_BLEND_DEST_ALPHA:
- case XGL_BLEND_DEST_COLOR:
- case XGL_BLEND_ONE:
- case XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA:
- case XGL_BLEND_ONE_MINUS_CONSTANT_COLOR:
- case XGL_BLEND_ONE_MINUS_DEST_ALPHA:
- case XGL_BLEND_ONE_MINUS_DEST_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC1_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC1_COLOR:
- case XGL_BLEND_ONE_MINUS_SRC_ALPHA:
- case XGL_BLEND_ONE_MINUS_SRC_COLOR:
- case XGL_BLEND_SRC1_ALPHA:
- case XGL_BLEND_SRC1_COLOR:
- case XGL_BLEND_SRC_ALPHA:
- case XGL_BLEND_SRC_ALPHA_SATURATE:
- case XGL_BLEND_SRC_COLOR:
- case XGL_BLEND_ZERO:
+ case XGL_BLEND_FUNC_ADD:
+ case XGL_BLEND_FUNC_MAX:
+ case XGL_BLEND_FUNC_MIN:
+ case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
+ case XGL_BLEND_FUNC_SUBTRACT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+{
+ switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ {
+ case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
+ case XGL_GPU_COMPAT_IQ_MATCH_BIT:
+ case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
+ case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
+ case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_MEMORY_PRIORITY(XGL_MEMORY_PRIORITY input_value)
+{
+ switch ((XGL_MEMORY_PRIORITY)input_value)
+ {
+ case XGL_MEMORY_PRIORITY_HIGH:
+ case XGL_MEMORY_PRIORITY_LOW:
+ case XGL_MEMORY_PRIORITY_NORMAL:
+ case XGL_MEMORY_PRIORITY_UNUSED:
+ case XGL_MEMORY_PRIORITY_VERY_HIGH:
+ case XGL_MEMORY_PRIORITY_VERY_LOW:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_RESULT(XGL_RESULT input_value)
+{
+ switch ((XGL_RESULT)input_value)
+ {
+ case XGL_ERROR_BAD_PIPELINE_DATA:
+ case XGL_ERROR_BAD_SHADER_CODE:
+ case XGL_ERROR_BUILDING_COMMAND_BUFFER:
+ case XGL_ERROR_DEVICE_ALREADY_CREATED:
+ case XGL_ERROR_DEVICE_LOST:
+ case XGL_ERROR_INCOMPATIBLE_DEVICE:
+ case XGL_ERROR_INCOMPATIBLE_DRIVER:
+ case XGL_ERROR_INCOMPATIBLE_QUEUE:
+ case XGL_ERROR_INCOMPLETE_COMMAND_BUFFER:
+ case XGL_ERROR_INITIALIZATION_FAILED:
+ case XGL_ERROR_INVALID_ALIGNMENT:
+ case XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA:
+ case XGL_ERROR_INVALID_EXTENSION:
+ case XGL_ERROR_INVALID_FLAGS:
+ case XGL_ERROR_INVALID_FORMAT:
+ case XGL_ERROR_INVALID_HANDLE:
+ case XGL_ERROR_INVALID_IMAGE:
+ case XGL_ERROR_INVALID_MEMORY_SIZE:
+ case XGL_ERROR_INVALID_OBJECT_TYPE:
+ case XGL_ERROR_INVALID_ORDINAL:
+ case XGL_ERROR_INVALID_POINTER:
+ case XGL_ERROR_INVALID_QUEUE_TYPE:
+ case XGL_ERROR_INVALID_VALUE:
+ case XGL_ERROR_MEMORY_MAP_FAILED:
+ case XGL_ERROR_MEMORY_NOT_BOUND:
+ case XGL_ERROR_MEMORY_UNMAP_FAILED:
+ case XGL_ERROR_NOT_MAPPABLE:
+ case XGL_ERROR_NOT_SHAREABLE:
+ case XGL_ERROR_OUT_OF_GPU_MEMORY:
+ case XGL_ERROR_OUT_OF_MEMORY:
+ case XGL_ERROR_TOO_MANY_MEMORY_REFERENCES:
+ case XGL_ERROR_UNAVAILABLE:
+ case XGL_ERROR_UNKNOWN:
+ case XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
+ case XGL_EVENT_RESET:
+ case XGL_EVENT_SET:
+ case XGL_NOT_READY:
+ case XGL_SUCCESS:
+ case XGL_TIMEOUT:
+ case XGL_UNSUPPORTED:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_FILL_MODE(XGL_FILL_MODE input_value)
+{
+ switch ((XGL_FILL_MODE)input_value)
+ {
+ case XGL_FILL_POINTS:
+ case XGL_FILL_SOLID:
+ case XGL_FILL_WIREFRAME:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+{
+ switch ((XGL_TEX_FILTER)input_value)
+ {
+ case XGL_TEX_FILTER_LINEAR:
+ case XGL_TEX_FILTER_NEAREST:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_QUERY_TYPE(XGL_QUERY_TYPE input_value)
+{
+ switch ((XGL_QUERY_TYPE)input_value)
+ {
+ case XGL_QUERY_OCCLUSION:
+ case XGL_QUERY_PIPELINE_STATISTICS:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_FILTER(XGL_TEX_FILTER input_value)
+static inline uint32_t validate_XGL_TIMESTAMP_TYPE(XGL_TIMESTAMP_TYPE input_value)
{
- switch ((XGL_TEX_FILTER)input_value)
+ switch ((XGL_TIMESTAMP_TYPE)input_value)
{
- case XGL_TEX_FILTER_LINEAR:
- case XGL_TEX_FILTER_NEAREST:
+ case XGL_TIMESTAMP_BOTTOM:
+ case XGL_TIMESTAMP_TOP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_PIPELINE_SHADER_STAGE(XGL_PIPELINE_SHADER_STAGE input_value)
+static inline uint32_t validate_XGL_BORDER_COLOR_TYPE(XGL_BORDER_COLOR_TYPE input_value)
{
- switch ((XGL_PIPELINE_SHADER_STAGE)input_value)
+ switch ((XGL_BORDER_COLOR_TYPE)input_value)
{
- case XGL_SHADER_STAGE_COMPUTE:
- case XGL_SHADER_STAGE_FRAGMENT:
- case XGL_SHADER_STAGE_GEOMETRY:
- case XGL_SHADER_STAGE_TESS_CONTROL:
- case XGL_SHADER_STAGE_TESS_EVALUATION:
- case XGL_SHADER_STAGE_VERTEX:
+ case XGL_BORDER_COLOR_OPAQUE_BLACK:
+ case XGL_BORDER_COLOR_OPAQUE_WHITE:
+ case XGL_BORDER_COLOR_TRANSPARENT_BLACK:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BLEND_FUNC(XGL_BLEND_FUNC input_value)
+static inline uint32_t validate_XGL_LOGIC_OP(XGL_LOGIC_OP input_value)
{
- switch ((XGL_BLEND_FUNC)input_value)
+ switch ((XGL_LOGIC_OP)input_value)
{
- case XGL_BLEND_FUNC_ADD:
- case XGL_BLEND_FUNC_MAX:
- case XGL_BLEND_FUNC_MIN:
- case XGL_BLEND_FUNC_REVERSE_SUBTRACT:
- case XGL_BLEND_FUNC_SUBTRACT:
+ case XGL_LOGIC_OP_AND:
+ case XGL_LOGIC_OP_AND_INVERTED:
+ case XGL_LOGIC_OP_AND_REVERSE:
+ case XGL_LOGIC_OP_CLEAR:
+ case XGL_LOGIC_OP_COPY:
+ case XGL_LOGIC_OP_COPY_INVERTED:
+ case XGL_LOGIC_OP_EQUIV:
+ case XGL_LOGIC_OP_INVERT:
+ case XGL_LOGIC_OP_NAND:
+ case XGL_LOGIC_OP_NOOP:
+ case XGL_LOGIC_OP_NOR:
+ case XGL_LOGIC_OP_OR:
+ case XGL_LOGIC_OP_OR_INVERTED:
+ case XGL_LOGIC_OP_OR_REVERSE:
+ case XGL_LOGIC_OP_SET:
+ case XGL_LOGIC_OP_XOR:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_LAYOUT(XGL_IMAGE_LAYOUT input_value)
+static inline uint32_t validate_XGL_QUERY_CONTROL_FLAGS(XGL_QUERY_CONTROL_FLAGS input_value)
{
- switch ((XGL_IMAGE_LAYOUT)input_value)
+ switch ((XGL_QUERY_CONTROL_FLAGS)input_value)
{
- case XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL:
- case XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
- case XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_GENERAL:
- case XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL:
- case XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL:
+ case XGL_QUERY_IMPRECISE_DATA_BIT:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_BUFFER_CREATE_FLAGS(XGL_BUFFER_CREATE_FLAGS input_value)
+static inline uint32_t validate_XGL_IMAGE_ASPECT(XGL_IMAGE_ASPECT input_value)
{
- switch ((XGL_BUFFER_CREATE_FLAGS)input_value)
+ switch ((XGL_IMAGE_ASPECT)input_value)
{
- case XGL_BUFFER_CREATE_SHAREABLE_BIT:
- case XGL_BUFFER_CREATE_SPARSE_BIT:
+ case XGL_IMAGE_ASPECT_COLOR:
+ case XGL_IMAGE_ASPECT_DEPTH:
+ case XGL_IMAGE_ASPECT_STENCIL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_MEMORY_TYPE(XGL_MEMORY_TYPE input_value)
+static inline uint32_t validate_XGL_ATTACHMENT_LOAD_OP(XGL_ATTACHMENT_LOAD_OP input_value)
{
- switch ((XGL_MEMORY_TYPE)input_value)
+ switch ((XGL_ATTACHMENT_LOAD_OP)input_value)
{
- case XGL_MEMORY_TYPE_BUFFER:
- case XGL_MEMORY_TYPE_IMAGE:
- case XGL_MEMORY_TYPE_OTHER:
+ case XGL_ATTACHMENT_LOAD_OP_CLEAR:
+ case XGL_ATTACHMENT_LOAD_OP_DONT_CARE:
+ case XGL_ATTACHMENT_LOAD_OP_LOAD:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_QUEUE_TYPE(XGL_QUEUE_TYPE input_value)
+static inline uint32_t validate_XGL_IMAGE_FORMAT_CLASS(XGL_IMAGE_FORMAT_CLASS input_value)
{
- switch ((XGL_QUEUE_TYPE)input_value)
+ switch ((XGL_IMAGE_FORMAT_CLASS)input_value)
{
- case XGL_QUEUE_TYPE_COMPUTE:
- case XGL_QUEUE_TYPE_DMA:
- case XGL_QUEUE_TYPE_GRAPHICS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_16_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_24_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_32_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_48_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK:
+ case XGL_IMAGE_FORMAT_CLASS_8_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_96_BITS:
+ case XGL_IMAGE_FORMAT_CLASS_D16:
+ case XGL_IMAGE_FORMAT_CLASS_D16S8:
+ case XGL_IMAGE_FORMAT_CLASS_D24:
+ case XGL_IMAGE_FORMAT_CLASS_D24S8:
+ case XGL_IMAGE_FORMAT_CLASS_D32:
+ case XGL_IMAGE_FORMAT_CLASS_D32S8:
+ case XGL_IMAGE_FORMAT_CLASS_LINEAR:
+ case XGL_IMAGE_FORMAT_CLASS_S8:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_IMAGE_TILING(XGL_IMAGE_TILING input_value)
+static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
{
- switch ((XGL_IMAGE_TILING)input_value)
+ switch ((XGL_TEX_ADDRESS)input_value)
{
- case XGL_LINEAR_TILING:
- case XGL_OPTIMAL_TILING:
+ case XGL_TEX_ADDRESS_CLAMP:
+ case XGL_TEX_ADDRESS_CLAMP_BORDER:
+ case XGL_TEX_ADDRESS_MIRROR:
+ case XGL_TEX_ADDRESS_MIRROR_ONCE:
+ case XGL_TEX_ADDRESS_WRAP:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_FORMAT_INFO_TYPE(XGL_FORMAT_INFO_TYPE input_value)
+static inline uint32_t validate_XGL_INDEX_TYPE(XGL_INDEX_TYPE input_value)
{
- switch ((XGL_FORMAT_INFO_TYPE)input_value)
+ switch ((XGL_INDEX_TYPE)input_value)
{
- case XGL_INFO_TYPE_FORMAT_PROPERTIES:
+ case XGL_INDEX_16:
+ case XGL_INDEX_32:
+ case XGL_INDEX_8:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_COMPARE_FUNC(XGL_COMPARE_FUNC input_value)
+{
+ switch ((XGL_COMPARE_FUNC)input_value)
+ {
+ case XGL_COMPARE_ALWAYS:
+ case XGL_COMPARE_EQUAL:
+ case XGL_COMPARE_GREATER:
+ case XGL_COMPARE_GREATER_EQUAL:
+ case XGL_COMPARE_LESS:
+ case XGL_COMPARE_LESS_EQUAL:
+ case XGL_COMPARE_NEVER:
+ case XGL_COMPARE_NOT_EQUAL:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_TEX_ADDRESS(XGL_TEX_ADDRESS input_value)
+static inline uint32_t validate_XGL_STENCIL_OP(XGL_STENCIL_OP input_value)
{
- switch ((XGL_TEX_ADDRESS)input_value)
+ switch ((XGL_STENCIL_OP)input_value)
{
- case XGL_TEX_ADDRESS_CLAMP:
- case XGL_TEX_ADDRESS_CLAMP_BORDER:
- case XGL_TEX_ADDRESS_MIRROR:
- case XGL_TEX_ADDRESS_MIRROR_ONCE:
- case XGL_TEX_ADDRESS_WRAP:
+ case XGL_STENCIL_OP_DEC_CLAMP:
+ case XGL_STENCIL_OP_DEC_WRAP:
+ case XGL_STENCIL_OP_INC_CLAMP:
+ case XGL_STENCIL_OP_INC_WRAP:
+ case XGL_STENCIL_OP_INVERT:
+ case XGL_STENCIL_OP_KEEP:
+ case XGL_STENCIL_OP_REPLACE:
+ case XGL_STENCIL_OP_ZERO:
return 1;
default:
return 0;
}
-static inline uint32_t validate_XGL_GPU_COMPATIBILITY_FLAGS(XGL_GPU_COMPATIBILITY_FLAGS input_value)
+static inline uint32_t validate_XGL_PHYSICAL_GPU_INFO_TYPE(XGL_PHYSICAL_GPU_INFO_TYPE input_value)
{
- switch ((XGL_GPU_COMPATIBILITY_FLAGS)input_value)
+ switch ((XGL_PHYSICAL_GPU_INFO_TYPE)input_value)
{
- case XGL_GPU_COMPAT_ASIC_FEATURES_BIT:
- case XGL_GPU_COMPAT_IQ_MATCH_BIT:
- case XGL_GPU_COMPAT_PEER_TRANSFER_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT:
- case XGL_GPU_COMPAT_SHARED_MEMORY_BIT:
- case XGL_GPU_COMPAT_SHARED_SYNC_BIT:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:
+ case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_IMAGE_CREATE_FLAGS(XGL_IMAGE_CREATE_FLAGS input_value)
+{
+ switch ((XGL_IMAGE_CREATE_FLAGS)input_value)
+ {
+ case XGL_IMAGE_CREATE_CLONEABLE_BIT:
+ case XGL_IMAGE_CREATE_INVARIANT_DATA_BIT:
+ case XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT:
+ case XGL_IMAGE_CREATE_SHAREABLE_BIT:
+ case XGL_IMAGE_CREATE_SPARSE_BIT:
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+
+static inline uint32_t validate_XGL_ATTACHMENT_STORE_OP(XGL_ATTACHMENT_STORE_OP input_value)
+{
+ switch ((XGL_ATTACHMENT_STORE_OP)input_value)
+ {
+ case XGL_ATTACHMENT_STORE_OP_DONT_CARE:
+ case XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA:
+ case XGL_ATTACHMENT_STORE_OP_STORE:
return 1;
default:
return 0;
}
-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;
// Function Prototypes
size_t get_struct_chain_size(const void* pStruct);
size_t get_dynamic_struct_size(const void* pStruct);
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
+size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct);
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct);
size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
-size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
-size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
+size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_FORMAT_PROPERTIES);
+ structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
+ structSize = sizeof(XGL_APPLICATION_INFO);
+ structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
+ structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
}
return structSize;
}
-size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
+ structSize = sizeof(XGL_LINK_CONST_BUFFER);
+ structSize += pStruct->bufferSize;
}
return structSize;
}
-size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
+size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+ structSize = sizeof(XGL_UPDATE_SAMPLERS);
+ structSize += pStruct->count*sizeof(XGL_SAMPLER);
}
return structSize;
}
-size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
+ structSize = sizeof(XGL_STENCIL_OP_STATE);
}
return structSize;
}
-size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
+ structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
+ structSize = sizeof(XGL_DEVICE_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->queueRecordCount; i++) {
+ structSize += xgl_size_xgl_device_queue_create_info(&pStruct->pRequestedQueues[i]);
+ }
+ for (i = 0; i < pStruct->extensionCount; i++) {
+ structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppEnabledExtensionNames[i]))));
+ }
}
return structSize;
}
-size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_AS_COPY);
+ structSize = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
}
return structSize;
}
-size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
+size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CLEAR_COLOR);
+ structSize = sizeof(XGL_UPDATE_BUFFERS);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*) + xgl_size_xgl_buffer_view_attach_info(pStruct->pBufferViews[i]));
+ }
}
return structSize;
}
-size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_EXTENT2D);
+ structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
}
return structSize;
}
-size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO);
uint32_t i = 0;
- for (i = 0; i < pStruct->colorAttachmentCount; i++) {
- structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
+ for (i = 0; i < pStruct->bindingCount; i++) {
+ structSize += xgl_size_xgl_vertex_input_binding_description(&pStruct->pVertexBindingDescriptions[i]);
+ }
+ for (i = 0; i < pStruct->attributeCount; i++) {
+ structSize += xgl_size_xgl_vertex_input_attribute_description(&pStruct->pVertexAttributeDescriptions[i]);
}
- structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
}
return structSize;
}
-size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
+size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_ALLOC_CALLBACKS);
+ structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
+ structSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
}
return structSize;
}
-size_t xgl_size_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
+size_t xgl_size_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_LINK_CONST_BUFFER);
- structSize += pStruct->bufferSize;
+ structSize = sizeof(XGL_DRAW_INDEXED_INDIRECT_CMD);
}
return structSize;
}
-size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+ structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+ structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
+ }
+ for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
+ structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
+ }
}
return structSize;
}
-size_t xgl_size_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEVICE_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->queueRecordCount; i++) {
- structSize += xgl_size_xgl_device_queue_create_info(&pStruct->pRequestedQueues[i]);
- }
- for (i = 0; i < pStruct->extensionCount; i++) {
- structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppEnabledExtensionNames[i]))));
- }
+ structSize = sizeof(XGL_SHADER_CREATE_INFO);
+ structSize += pStruct->codeSize;
}
return structSize;
}
-size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_RESOLVE);
+ structSize = sizeof(XGL_MEMORY_REF);
}
return structSize;
}
-size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
+size_t xgl_size_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
+ structSize = sizeof(XGL_FORMAT_PROPERTIES);
}
return structSize;
}
-size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_FENCE_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
}
return structSize;
}
-size_t xgl_size_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_RS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_ALLOC_CALLBACKS);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_COPY);
+ structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->attachmentCount; i++) {
+ structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
+ }
}
return structSize;
}
-size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
+ structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
+ structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
+ structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->attachmentCount; i++) {
- structSize += xgl_size_xgl_pipeline_cb_attachment_state(&pStruct->pAttachments[i]);
- }
+ structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
}
return structSize;
}
-size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ structSize = sizeof(XGL_FENCE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
+size_t xgl_size_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
- structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
+ structSize = sizeof(XGL_FRAMEBUFFER_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+ structSize += xgl_size_xgl_color_attachment_bind_info(&pStruct->pColorAttachments[i]);
+ }
+ structSize += xgl_size_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment);
}
return structSize;
}
-size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_extent2d(const XGL_EXTENT2D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+ structSize = sizeof(XGL_EXTENT2D);
}
return structSize;
}
-size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
+size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_EVENT_WAIT_INFO);
- structSize += pStruct->eventCount*sizeof(XGL_EVENT);
- structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+ structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
- }
+ structSize = sizeof(XGL_IMAGE_SUBRESOURCE_RANGE);
}
return structSize;
}
-size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
+ structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_OPEN_INFO);
+ structSize = sizeof(XGL_OFFSET2D);
}
return structSize;
}
-size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
+ structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO);
+ structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+size_t xgl_size_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_BARRIER);
- structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
- structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
+ structSize = sizeof(XGL_PIPELINE_MS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_BARRIER);
+ structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_IMAGE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
+size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE);
+ structSize = sizeof(XGL_UPDATE_IMAGES);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*) + xgl_size_xgl_image_view_attach_info(pStruct->pImageViews[i]));
+ }
}
return structSize;
}
-size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
+ structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
+size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_APPLICATION_INFO);
- structSize += sizeof(char)*(1+strlen(pStruct->pAppName));
- structSize += sizeof(char)*(1+strlen(pStruct->pEngineName));
+ structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO);
+ structSize = sizeof(XGL_RECT);
}
return structSize;
}
-size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
+size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
+ structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
+size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
+ structSize = sizeof(XGL_DEVICE_QUEUE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DRAW_INDIRECT_CMD);
+ structSize = sizeof(XGL_MEMORY_OPEN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_VIEW_CREATE_INFO);
+ structSize = sizeof(XGL_UPDATE_AS_COPY);
}
return structSize;
}
-size_t xgl_size_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
+size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_BEGIN_INFO);
+ structSize = sizeof(XGL_IMAGE_COPY);
}
return structSize;
}
-size_t xgl_size_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
+size_t xgl_size_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_COPY);
+ structSize = sizeof(XGL_IMAGE_RESOLVE);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
+size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
+ structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+size_t xgl_size_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
+ structSize = sizeof(XGL_IMAGE_MEMORY_BARRIER);
}
return structSize;
}
-size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
+ structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_BARRIER);
+ structSize += pStruct->eventCount*sizeof(XGL_SET_EVENT);
+ structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
}
return structSize;
}
-size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+size_t xgl_size_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CHANNEL_MAPPING);
+ structSize = sizeof(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES);
}
return structSize;
}
-size_t xgl_size_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PEER_IMAGE_OPEN_INFO);
+ structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
uint32_t i = 0;
- for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
- structSize += xgl_size_xgl_viewport(&pStruct->pViewports[i]);
- }
- for (i = 0; i < pStruct->viewportAndScissorCount; i++) {
- structSize += xgl_size_xgl_rect(&pStruct->pScissors[i]);
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
}
}
return structSize;
}
-size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+size_t xgl_size_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
+ structSize = sizeof(XGL_PEER_MEMORY_OPEN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
- structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
- structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
- uint32_t i = 0;
- for (i = 0; i < pStruct->colorAttachmentCount; i++) {
- structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
- }
+ structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
}
return structSize;
}
-size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
+size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_VIEWPORT);
+ structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
}
return structSize;
}
-size_t xgl_size_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DYNAMIC_DS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->count; i++) {
+ structSize += xgl_size_xgl_descriptor_type_count(&pStruct->pTypeCount[i]);
+ }
}
return structSize;
}
-size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_viewport(const XGL_VIEWPORT* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_CREATE_INFO);
+ structSize = sizeof(XGL_VIEWPORT);
}
return structSize;
}
-size_t xgl_size_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);
+ structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_rect(const XGL_RECT* pStruct)
+size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_RECT);
+ structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+size_t xgl_size_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_MEMORY_BARRIER);
+ structSize = sizeof(XGL_CMD_BUFFER_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_DS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+size_t xgl_size_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DESCRIPTOR_TYPE_COUNT);
+ structSize = sizeof(XGL_MEMORY_REQUIREMENTS);
}
return structSize;
}
-size_t xgl_size_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+size_t xgl_size_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += xgl_size_xgl_sampler_image_view_info(&pStruct->pSamplerImageViews[i]);
- }
+ structSize = sizeof(XGL_QUEUE_SEMAPHORE_OPEN_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_QUERY_POOL_CREATE_INFO);
+ structSize = sizeof(XGL_MEMORY_BARRIER);
}
return structSize;
}
-size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_EVENT_CREATE_INFO);
+ structSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);
}
return structSize;
}
-size_t xgl_size_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+size_t xgl_size_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_OFFSET2D);
+ structSize = sizeof(XGL_CHANNEL_MAPPING);
}
return structSize;
}
-size_t xgl_size_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+size_t xgl_size_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_BUFFERS);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*) + xgl_size_xgl_buffer_view_attach_info(pStruct->pBufferViews[i]));
- }
+ structSize = sizeof(XGL_CLEAR_COLOR);
}
return structSize;
}
-size_t xgl_size_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+size_t xgl_size_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_REF);
+ structSize = sizeof(XGL_DYNAMIC_CB_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
+size_t xgl_size_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
+ structSize = sizeof(XGL_BUFFER_VIEW_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->bindingCount; i++) {
- structSize += xgl_size_xgl_vertex_input_binding_description(&pStruct->pVertexBindingDescriptions[i]);
- }
- for (i = 0; i < pStruct->attributeCount; i++) {
- structSize += xgl_size_xgl_vertex_input_attribute_description(&pStruct->pVertexAttributeDescriptions[i]);
- }
+ structSize = sizeof(XGL_SAMPLER_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+size_t xgl_size_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
+ structSize = sizeof(XGL_EVENT_WAIT_INFO);
+ structSize += pStruct->eventCount*sizeof(XGL_EVENT);
+ structSize += pStruct->memBarrierCount*(sizeof(void*) + sizeof(XGL_IMAGE_MEMORY_BARRIER));
}
return structSize;
}
-size_t xgl_size_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_SHADER_CREATE_INFO);
- structSize += pStruct->codeSize;
+ structSize = sizeof(XGL_BUFFER_IMAGE_COPY);
}
return structSize;
}
-size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+size_t xgl_size_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_OFFSET3D);
+ structSize = sizeof(XGL_EVENT_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_LAYER_CREATE_INFO);
- uint32_t i = 0;
- for (i = 0; i < pStruct->layerCount; i++) {
- structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
- }
+ structSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
}
return structSize;
}
-size_t xgl_size_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO);
+ structSize = sizeof(XGL_IMAGE_VIEW_ATTACH_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+size_t xgl_size_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEPTH_STENCIL_BIND_INFO);
+ structSize = sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+size_t xgl_size_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ structSize = sizeof(XGL_BUFFER_COPY);
}
return structSize;
}
-size_t xgl_size_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
+size_t xgl_size_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_SUBRESOURCE_RANGE);
+ structSize = sizeof(XGL_IMAGE_MEMORY_BIND_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
+size_t xgl_size_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_IMAGES);
- uint32_t i = 0;
- for (i = 0; i < pStruct->count; i++) {
- structSize += (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*) + xgl_size_xgl_image_view_attach_info(pStruct->pImageViews[i]));
- }
+ structSize = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
}
return structSize;
}
-size_t xgl_size_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DISPATCH_INDIRECT_CMD);
+ structSize = sizeof(XGL_PIPELINE_SHADER);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->linkConstBufferCount; i++) {
+ structSize += xgl_size_xgl_link_const_buffer(&pStruct->pLinkConstBufferInfo[i]);
+ }
}
return structSize;
}
-size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+size_t xgl_size_xgl_offset3d(const XGL_OFFSET3D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_EXTENT3D);
+ structSize = sizeof(XGL_OFFSET3D);
}
return structSize;
}
-size_t xgl_size_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+size_t xgl_size_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_CLEAR_COLOR_VALUE);
+ structSize = sizeof(XGL_BUFFER_VIEW_ATTACH_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+size_t xgl_size_xgl_extent3d(const XGL_EXTENT3D* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);
+ structSize = sizeof(XGL_EXTENT3D);
}
return structSize;
}
-size_t xgl_size_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_DEVICE_QUEUE_CREATE_INFO);
+ structSize = sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO);
+ structSize += xgl_size_xgl_image_view_attach_info(pStruct->pImageView);
}
return structSize;
}
-size_t xgl_size_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+size_t xgl_size_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_STENCIL_OP_STATE);
+ structSize = sizeof(XGL_IMAGE_SUBRESOURCE);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
+size_t xgl_size_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_SHADER);
+ structSize = sizeof(XGL_LAYER_CREATE_INFO);
uint32_t i = 0;
- for (i = 0; i < pStruct->linkConstBufferCount; i++) {
- structSize += xgl_size_xgl_link_const_buffer(&pStruct->pLinkConstBufferInfo[i]);
+ for (i = 0; i < pStruct->layerCount; i++) {
+ structSize += (sizeof(char*) + (sizeof(char) * (1 + strlen(pStruct->ppActiveLayerNames[i]))));
}
}
return structSize;
}
-size_t xgl_size_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_QUEUE_SEMAPHORE_CREATE_INFO);
+ structSize = sizeof(XGL_PIPELINE_VP_STATE_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+size_t xgl_size_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_STATISTICS_DATA);
+ structSize = sizeof(XGL_BUFFER_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);
+ structSize = sizeof(XGL_RENDER_PASS_CREATE_INFO);
+ structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_LOAD_OP);
+ structSize += pStruct->colorAttachmentCount*sizeof(XGL_ATTACHMENT_STORE_OP);
+ uint32_t i = 0;
+ for (i = 0; i < pStruct->colorAttachmentCount; i++) {
+ structSize += xgl_size_xgl_clear_color(&pStruct->pColorLoadClearValues[i]);
+ }
}
return structSize;
}
-size_t xgl_size_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+size_t xgl_size_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION);
+ structSize = sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+size_t xgl_size_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_UPDATE_SAMPLERS);
- structSize += pStruct->count*sizeof(XGL_SAMPLER);
+ structSize = sizeof(XGL_GPU_COMPATIBILITY_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_IMAGE_CREATE_INFO);
+ structSize = sizeof(XGL_MEMORY_ALLOC_INFO);
}
return structSize;
}
-size_t xgl_size_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+size_t xgl_size_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
{
size_t structSize = 0;
if (pStruct) {
- structSize = sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);
+ structSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);
}
return structSize;
}
#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;
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(extra_indent);
return str;
}
-char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soffset = %p\n%ssize = %p\n%srowPitch = %p\n%sdepthPitch = %p\n", prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->rowPitch), prefix, (void*)(pStruct->depthPitch));
- return str;
-}
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
return str;
}
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
return str;
}
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
+ snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
return str;
}
-char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pColorAttachments) {
- tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+ if (pStruct->pRequestedQueues) {
+ tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr);
+ snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
}
else
stp_strs[1] = "";
- if (pStruct->pDepthStencilAttachment) {
- tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spDepthStencilAttachment (%p)\n%s", prefix, (void*)pStruct->pDepthStencilAttachment, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scolorAttachmentCount = %u\n%spColorAttachments = %p\n%spDepthStencilAttachment = %p\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorAttachments), prefix, (void*)(pStruct->pDepthStencilAttachment), prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
- return str;
-}
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
- return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferId = %u\n%sbufferSize = %p\n%spBufferData = %p\n", prefix, (pStruct->bufferId), prefix, (void*)(pStruct->bufferSize), prefix, (pStruct->pBufferData));
- return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
+ snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
return str;
}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
{
char* str;
size_t len;
}
else
stp_strs[0] = "";
- if (pStruct->pRequestedQueues) {
- tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+ if (pStruct->pBufferViews) {
+ tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spRequestedQueues (%p)\n%s", prefix, (void*)pStruct->pRequestedQueues, tmpStr);
+ snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
}
else
stp_strs[1] = "";
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueRecordCount = %u\n%spRequestedQueues = %p\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->queueRecordCount), prefix, (void*)(pStruct->pRequestedQueues), prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[5];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssrcSubresource (%p)\n%s", prefix, (void*)&pStruct->srcSubresource, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %ssrcOffset (%p)\n%s", prefix, (void*)&pStruct->srcOffset, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sdestSubresource (%p)\n%s", prefix, (void*)&pStruct->destSubresource, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[3] = (char*)malloc(len);
- snprintf(stp_strs[3], len, " %sdestOffset (%p)\n%s", prefix, (void*)&pStruct->destOffset, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[4] = (char*)malloc(len);
- snprintf(stp_strs[4], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcSubresource = %p\n%ssrcOffset = %p\n%sdestSubresource = %p\n%sdestOffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->srcSubresource), prefix, (void*)&(pStruct->srcOffset), prefix, (void*)&(pStruct->destSubresource), prefix, (void*)&(pStruct->destOffset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
return str;
}
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
+ if (pStruct->pVertexBindingDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
}
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
+ else
+ stp_strs[1] = "";
+ if (pStruct->pVertexAttributeDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
}
else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+ snprintf(str, len, "%soffset = %p\n%ssize = %p\n%srowPitch = %p\n%sdepthPitch = %p\n", prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->rowPitch), prefix, (void*)(pStruct->depthPitch));
return str;
}
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ if (pStruct->pViewports) {
+ tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pScissors) {
+ tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+ return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+ return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%spUserData = %p\n%spfnAlloc = %p\n%spfnFree = %p\n", prefix, (pStruct->pUserData), prefix, (void*)(pStruct->pfnAlloc), prefix, (void*)(pStruct->pfnFree));
+ return str;
+}
char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pImageView) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+ return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pTypeCount) {
- tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+ if (pStruct->pColorAttachments) {
+ tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
+ snprintf(stp_strs[1], len, " %spColorAttachments (%p)\n%s", prefix, (void*)pStruct->pColorAttachments, tmpStr);
}
else
stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ if (pStruct->pDepthStencilAttachment) {
+ tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spDepthStencilAttachment (%p)\n%s", prefix, (void*)pStruct->pDepthStencilAttachment, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scolorAttachmentCount = %u\n%spColorAttachments = %p\n%spDepthStencilAttachment = %p\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorAttachments), prefix, (void*)(pStruct->pDepthStencilAttachment), prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
+ return str;
+}
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ return str;
+}
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
+ return str;
+}
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sshader (%p)\n%s", prefix, (void*)&pStruct->shader, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sshader = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->shader));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ if (pStruct->pImageViews) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spAppName = %p\n%sappVersion = %u\n%spEngineName = %p\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->pAppName), prefix, (pStruct->appVersion), prefix, (pStruct->pEngineName), prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %s\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n%slastSetLayout = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource));
+ snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
- return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
return str;
}
-char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %ssubresourceRange (%p)\n%s", prefix, (void*)&pStruct->subresourceRange, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%sviewType = %s\n%sformat = %s\n%schannels = %p\n%ssubresourceRange = %p\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)&(pStruct->subresourceRange), prefix, (pStruct->minLod));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedMem));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sdescriptorSet = %p\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (void*)(pStruct->descriptorSet), prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
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;
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]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sfront (%p)\n%s", prefix, (void*)&pStruct->front, tmpStr);
+ tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sback (%p)\n%s", prefix, (void*)&pStruct->back, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %scs (%p)\n%s", prefix, (void*)&pStruct->cs, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scs = %p\n%sflags = %u\n%slastSetLayout = %p\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->cs), prefix, (pStruct->flags), prefix, (void*)(pStruct->lastSetLayout), prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
return str;
}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%soriginalImage = %p\n", prefix, (void*)(pStruct->originalImage));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pViewports) {
- tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ if (pStruct->pSamplerImageViews) {
+ tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spViewports (%p)\n%s", prefix, (void*)pStruct->pViewports, tmpStr);
+ snprintf(stp_strs[1], len, " %spSamplerImageViews (%p)\n%s", prefix, (void*)pStruct->pSamplerImageViews, tmpStr);
}
else
stp_strs[1] = "";
- if (pStruct->pScissors) {
- tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spScissors (%p)\n%s", prefix, (void*)pStruct->pScissors, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplerImageViews));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
}
else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sviewportAndScissorCount = %u\n%spViewports = %p\n%spScissors = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->viewportAndScissorCount), prefix, (void*)(pStruct->pViewports), prefix, (void*)(pStruct->pScissors));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soriginalMem = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->originalMem));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+ snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
return str;
}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
- if (pStruct->pColorLoadClearValues) {
- tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
+ if (pStruct->pTypeCount) {
+ tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spTypeCount (%p)\n%s", prefix, (void*)pStruct->pTypeCount, tmpStr);
}
else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scount = %u\n%spTypeCount = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->count), prefix, (void*)(pStruct->pTypeCount));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
return str;
}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderPass = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->renderPass));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
return str;
}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssize = %p\n%salignment = %p\n%sgranularity = %p\n%smemProps = %u\n%smemType = %s\n", prefix, (void*)(pStruct->size), prefix, (void*)(pStruct->alignment), prefix, (void*)(pStruct->granularity), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = %p\n%soffset = %p\n%ssize = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, (void*)(pStruct->buffer), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->size));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssharedSemaphore = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->sharedSemaphore));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sfront (%p)\n%s", prefix, (void*)&pStruct->front, tmpStr);
- tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sback (%p)\n%s", prefix, (void*)&pStruct->back, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = %p\n%sback = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, (void*)&(pStruct->front), prefix, (void*)&(pStruct->back));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
return str;
}
-char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pSamplerImageViews) {
- tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spSamplerImageViews (%p)\n%s", prefix, (void*)pStruct->pSamplerImageViews, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ char* stp_strs[1];
+ tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %scolor (%p)\n%s", prefix, (void*)&pStruct->color, tmpStr);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplerImageViews));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%scolor = %p\n%suseRawValue = %s\n", prefix, (void*)&(pStruct->color), prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sblendConst = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->blendConst));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (%p)\n%s", prefix, (void*)&pStruct->channels, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbuffer = %p\n%sviewType = %s\n%sstride = %p\n%sformat = %s\n%schannels = %p\n%soffset = %p\n%srange = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->buffer), prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, (void*)(pStruct->stride), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->channels), prefix, (void*)(pStruct->offset), prefix, (void*)(pStruct->range));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
- return str;
-}
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- if (pStruct->pBufferViews) {
- tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spBufferViews (%p)\n%s", prefix, (void*)pStruct->pBufferViews, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pBufferViews));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%smem = %p\n%sflags = %u\n", prefix, (void*)(pStruct->mem), prefix, (pStruct->flags));
- return str;
-}
-char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%seventCount = %u\n%spEvents = %p\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->eventCount), prefix, (void*)(pStruct->pEvents), prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix, (void*)(pStruct->ppMemBarriers));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %simageSubresource (%p)\n%s", prefix, (void*)&pStruct->imageSubresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %simageOffset (%p)\n%s", prefix, (void*)&pStruct->imageOffset, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %simageExtent (%p)\n%s", prefix, (void*)&pStruct->imageExtent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferOffset = %p\n%simageSubresource = %p\n%simageOffset = %p\n%simageExtent = %p\n", prefix, (void*)(pStruct->bufferOffset), prefix, (void*)&(pStruct->imageSubresource), prefix, (void*)&(pStruct->imageOffset), prefix, (void*)&(pStruct->imageExtent));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pVertexBindingDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexBindingDescriptions, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pVertexAttributeDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (%p)\n%s", prefix, (void*)pStruct->pVertexAttributeDescriptions, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sbindingCount = %u\n%spVertexBindingDescriptions = %p\n%sattributeCount = %u\n%spVertexAttributeDescriptions = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->bindingCount), prefix, (void*)(pStruct->pVertexBindingDescriptions), prefix, (pStruct->attributeCount), prefix, (void*)(pStruct->pVertexAttributeDescriptions));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = %p\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, (void*)(pStruct->maxInlineMemoryUpdateSize), prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
return str;
}
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%scodeSize = %p\n%spCode = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->codeSize), prefix, (pStruct->pCode), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
}
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssrcOffset = %p\n%sdestOffset = %p\n%scopySize = %p\n", prefix, (void*)(pStruct->srcOffset), prefix, (void*)(pStruct->destOffset), prefix, (void*)(pStruct->copySize));
+ return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssubresource (%p)\n%s", prefix, (void*)&pStruct->subresource, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (%p)\n%s", prefix, (void*)&pStruct->msaaResolveSubResource, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ snprintf(stp_strs[1], len, " %soffset (%p)\n%s", prefix, (void*)&pStruct->offset, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simage = %p\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = %p\n%smsaaResolveSubResource = %p\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->image), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, (void*)(pStruct->msaaResolveImage), prefix, (void*)&(pStruct->msaaResolveSubResource), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssubresource = %p\n%soffset = %p\n%sextent = %p\n", prefix, (void*)&(pStruct->subresource), prefix, (void*)&(pStruct->offset), prefix, (void*)&(pStruct->extent));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = %p\n%slayout = %s\n", prefix, (void*)(pStruct->view), prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
return str;
}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pLinkConstBufferInfo) {
+ tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
return str;
}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- if (pStruct->pImageViews) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spImageViews (%p)\n%s", prefix, (void*)pStruct->pImageViews, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pImageViews));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sview = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->view));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
return str;
}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pImageView) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spImageView (%p)\n%s", prefix, (void*)pStruct->pImageView, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
+ snprintf(str, len, "%spSampler = %p\n%spImageView = %p\n", prefix, (void*)(pStruct->pSampler), prefix, (void*)(pStruct->pImageView));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sfloatColor = %p\n%srawColor = %p\n", prefix, (void*)(pStruct->floatColor), prefix, (void*)(pStruct->rawColor));
+ snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
return str;
}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
- return str;
-}
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
- return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- if (pStruct->pLinkConstBufferInfo) {
- tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (%p)\n%s", prefix, (void*)pStruct->pLinkConstBufferInfo, tmpStr);
+ snprintf(stp_strs[0], len, " %spNext (%p)\n%s", prefix, (void*)pStruct->pNext, tmpStr);
+ free(tmpStr);
}
else
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sstage = %s\n%sshader = %p\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = %p\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, (void*)(pStruct->shader), prefix, (pStruct->linkConstBufferCount), prefix, (void*)(pStruct->pLinkConstBufferInfo));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%ssize = %p\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->size), prefix, (pStruct->usage), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
- return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
- return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
- return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %srenderArea (%p)\n%s", prefix, (void*)&pStruct->renderArea, tmpStr);
+ if (pStruct->pColorLoadClearValues) {
+ tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spColorLoadClearValues (%p)\n%s", prefix, (void*)pStruct->pColorLoadClearValues, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sindex = %u\n%scount = %u\n%spSamplers = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->index), prefix, (pStruct->count), prefix, (void*)(pStruct->pSamplers));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%srenderArea = %p\n%sframebuffer = %p\n%scolorAttachmentCount = %u\n%spColorLoadOps = %p\n%spColorStoreOps = %p\n%spColorLoadClearValues = %p\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)&(pStruct->renderArea), prefix, (void*)(pStruct->framebuffer), prefix, (pStruct->colorAttachmentCount), prefix, (void*)(pStruct->pColorLoadOps), prefix, (void*)(pStruct->pColorStoreOps), prefix, (void*)(pStruct->pColorLoadClearValues), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (%p)\n%s", prefix, (void*)&pStruct->extent, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%simageType = %s\n%sformat = %s\n%sextent = %p\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, (void*)&(pStruct->extent), prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = %p\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix, (void*)(pStruct->immutableSampler));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ return str;
+}
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = %p\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+ snprintf(str, len, "%ssType = %s\n%spNext = %p\n%sallocationSize = %p\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, (pStruct->pNext), prefix, (void*)(pStruct->allocationSize), prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
+ return str;
+}
char* dynamic_display(const void* pStruct, const char* prefix)
{
// Cast to APP_INFO ptr initially just to pull sType off struct
#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;
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(extra_indent);
return str;
}
-char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%soffset = addr\n%ssize = addr\n%srowPitch = addr\n%sdepthPitch = addr\n", prefix, prefix, prefix, prefix);
- return str;
-}
-char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
return str;
}
-char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
+char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
return str;
}
-char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
+char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
+ snprintf(str, len, "%soriginalImage = addr\n", prefix);
return str;
}
-char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pColorAttachments) {
- tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
+ if (pStruct->pRequestedQueues) {
+ tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spColorAttachments (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
}
else
stp_strs[1] = "";
- if (pStruct->pDepthStencilAttachment) {
- tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spDepthStencilAttachment (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scolorAttachmentCount = %u\n%spColorAttachments = addr\n%spDepthStencilAttachment = addr\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
- return str;
-}
-char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
- return str;
-}
-char* xgl_print_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbufferId = %u\n%sbufferSize = addr\n%spBufferData = addr\n", prefix, (pStruct->bufferId), prefix, prefix);
- return str;
-}
-char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
+ snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
return str;
}
-char* xgl_print_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
{
char* str;
size_t len;
}
else
stp_strs[0] = "";
- if (pStruct->pRequestedQueues) {
- tmpStr = xgl_print_xgl_device_queue_create_info(pStruct->pRequestedQueues, extra_indent);
+ if (pStruct->pBufferViews) {
+ tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spRequestedQueues (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
}
else
stp_strs[1] = "";
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueRecordCount = %u\n%spRequestedQueues = addr\n%sextensionCount = %u\n%sppEnabledExtensionNames = %s\n%smaxValidationLevel = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->queueRecordCount), prefix, prefix, (pStruct->extensionCount), prefix, (pStruct->ppEnabledExtensionNames)[0], prefix, string_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct, const char* prefix)
+char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[5];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->srcSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssrcSubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->srcOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %ssrcOffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->destSubresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sdestSubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset2d(&pStruct->destOffset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[3] = (char*)malloc(len);
- snprintf(stp_strs[3], len, " %sdestOffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[4] = (char*)malloc(len);
- snprintf(stp_strs[4], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + strlen(stp_strs[3]) + strlen(stp_strs[4]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcSubresource = addr\n%ssrcOffset = addr\n%sdestSubresource = addr\n%sdestOffset = addr\n%sextent = addr\n", prefix, prefix, prefix, prefix, prefix);
- for (int32_t stp_index = 4; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
return str;
}
-char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
+ if (pStruct->pVertexBindingDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
}
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
+ else
+ stp_strs[1] = "";
+ if (pStruct->pVertexAttributeDescriptions) {
+ tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
}
else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+char* xgl_print_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+ snprintf(str, len, "%soffset = addr\n%ssize = addr\n%srowPitch = addr\n%sdepthPitch = addr\n", prefix, prefix, prefix, prefix);
return str;
}
-char* xgl_print_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%sindexCount = %u\n%sinstanceCount = %u\n%sfirstIndex = %u\n%svertexOffset = %i\n%sfirstInstance = %u\n", prefix, (pStruct->indexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstIndex), prefix, (pStruct->vertexOffset), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ if (pStruct->pViewports) {
+ tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ if (pStruct->pScissors) {
+ tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
+char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
+ return str;
+}
+char* xgl_print_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%slinearTilingFeatures = %u\n%soptimalTilingFeatures = %u\n", prefix, (pStruct->linearTilingFeatures), prefix, (pStruct->optimalTilingFeatures));
+ return str;
+}
+char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
+ return str;
+}
+char* xgl_print_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%spUserData = addr\n%spfnAlloc = addr\n%spfnFree = addr\n", prefix, prefix, prefix);
+ return str;
+}
char* xgl_print_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n", prefix, (pStruct->usage));
+ snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
return str;
}
-char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
- if (pStruct->pImageView) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
+ char* stp_strs[2];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
+ return str;
+}
+char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
+ return str;
+}
+char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pTypeCount) {
- tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
+ if (pStruct->pColorAttachments) {
+ tmpStr = xgl_print_xgl_color_attachment_bind_info(pStruct->pColorAttachments, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %spColorAttachments (addr)\n%s", prefix, tmpStr);
}
else
stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ if (pStruct->pDepthStencilAttachment) {
+ tmpStr = xgl_print_xgl_depth_stencil_bind_info(pStruct->pDepthStencilAttachment, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spDepthStencilAttachment (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scolorAttachmentCount = %u\n%spColorAttachments = addr\n%spDepthStencilAttachment = addr\n%ssampleCount = %u\n%swidth = %u\n%sheight = %u\n%slayers = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, (pStruct->sampleCount), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->layers));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_extent2d(const XGL_EXTENT2D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n", prefix, (pStruct->width), prefix, (pStruct->height));
+ return str;
+}
+char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ return str;
+}
+char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
+ return str;
+}
+char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->shader, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sshader (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sshader = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ if (pStruct->pImageViews) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%stopology = %s\n%sdisableVertexReuse = %s\n%sprimitiveRestartEnable = %s\n%sprimitiveRestartIndex = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology), prefix, (pStruct->disableVertexReuse) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartEnable) ? "TRUE" : "FALSE", prefix, (pStruct->primitiveRestartIndex));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sblendEnable = %s\n%sformat = %s\n%ssrcBlendColor = %s\n%sdestBlendColor = %s\n%sblendFuncColor = %s\n%ssrcBlendAlpha = %s\n%sdestBlendAlpha = %s\n%sblendFuncAlpha = %s\n%schannelWriteMask = %hu\n", prefix, (pStruct->blendEnable) ? "TRUE" : "FALSE", prefix, string_XGL_FORMAT(pStruct->format), prefix, string_XGL_BLEND(pStruct->srcBlendColor), prefix, string_XGL_BLEND(pStruct->destBlendColor), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncColor), prefix, string_XGL_BLEND(pStruct->srcBlendAlpha), prefix, string_XGL_BLEND(pStruct->destBlendAlpha), prefix, string_XGL_BLEND_FUNC(pStruct->blendFuncAlpha), prefix, (pStruct->channelWriteMask));
- return str;
-}
-char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_application_info(const XGL_APPLICATION_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %ssubresourceRange (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spAppName = addr\n%sappVersion = %u\n%spEngineName = addr\n%sengineVersion = %u\n%sapiVersion = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->appVersion), prefix, prefix, (pStruct->engineVersion), prefix, (pStruct->apiVersion));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sviewType = %s\n%sformat = %s\n%schannels = addr\n%ssubresourceRange = addr\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix, (pStruct->minLod));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdepthClipEnable = %s\n%srasterizerDiscardEnable = %s\n%sprogramPointSize = %s\n%spointOrigin = %s\n%sprovokingVertex = %s\n%sfillMode = %s\n%scullMode = %s\n%sfrontFace = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->depthClipEnable) ? "TRUE" : "FALSE", prefix, (pStruct->rasterizerDiscardEnable) ? "TRUE" : "FALSE", prefix, (pStruct->programPointSize) ? "TRUE" : "FALSE", prefix, string_XGL_COORDINATE_ORIGIN(pStruct->pointOrigin), prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(pStruct->provokingVertex), prefix, string_XGL_FILL_MODE(pStruct->fillMode), prefix, string_XGL_CULL_MODE(pStruct->cullMode), prefix, string_XGL_FACE_ORIENTATION(pStruct->frontFace));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n%slastSetLayout = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags), prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sformat = %s\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix);
+ snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
- tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
- return str;
-}
-char* xgl_print_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%svertexCount = %u\n%sinstanceCount = %u\n%sfirstVertex = %u\n%sfirstInstance = %u\n", prefix, (pStruct->vertexCount), prefix, (pStruct->instanceCount), prefix, (pStruct->firstVertex), prefix, (pStruct->firstInstance));
+ snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
return str;
}
-char* xgl_print_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->subresourceRange, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %ssubresourceRange (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%sviewType = %s\n%sformat = %s\n%schannels = addr\n%ssubresourceRange = addr\n%sminLod = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_VIEW_TYPE(pStruct->viewType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix, (pStruct->minLod));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sdescriptorSet = addr\n%sdescriptorIndex = %u\n%scount = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, prefix, (pStruct->descriptorIndex), prefix, (pStruct->count));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
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;
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]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
- return str;
-}
-char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %sfront (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sback (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = addr\n%sback = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_pipeline_shader(&pStruct->cs, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %scs (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scs = addr\n%sflags = %u\n%slastSetLayout = addr\n%slocalSizeX = %u\n%slocalSizeY = %u\n%slocalSizeZ = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->flags), prefix, prefix, (pStruct->localSizeX), prefix, (pStruct->localSizeY), prefix, (pStruct->localSizeZ));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ snprintf(str, len, "%ssupportsMigration = %s\n%ssupportsPinning = %s\n", prefix, (pStruct->supportsMigration) ? "TRUE" : "FALSE", prefix, (pStruct->supportsPinning) ? "TRUE" : "FALSE");
return str;
}
-char* xgl_print_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%soriginalImage = addr\n", prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pViewports) {
- tmpStr = xgl_print_xgl_viewport(pStruct->pViewports, extra_indent);
+ if (pStruct->pSamplerImageViews) {
+ tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spViewports (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[1], len, " %spSamplerImageViews (addr)\n%s", prefix, tmpStr);
}
else
stp_strs[1] = "";
- if (pStruct->pScissors) {
- tmpStr = xgl_print_xgl_rect(pStruct->pScissors, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spScissors (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
}
else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sviewportAndScissorCount = %u\n%spViewports = addr\n%spScissors = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->viewportAndScissorCount), prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soriginalMem = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
+ snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
return str;
}
-char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ return str;
+}
+char* xgl_print_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
- if (pStruct->pColorLoadClearValues) {
- tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
+ if (pStruct->pTypeCount) {
+ tmpStr = xgl_print_xgl_descriptor_type_count(pStruct->pTypeCount, extra_indent);
len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %spTypeCount (addr)\n%s", prefix, tmpStr);
}
else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ stp_strs[1] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scount = %u\n%spTypeCount = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->count), prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
snprintf(str, len, "%soriginX = %f\n%soriginY = %f\n%swidth = %f\n%sheight = %f\n%sminDepth = %f\n%smaxDepth = %f\n", prefix, (pStruct->originX), prefix, (pStruct->originY), prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth));
return str;
}
-char* xgl_print_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sminDepth = %f\n%smaxDepth = %f\n%sstencilReadMask = %u\n%sstencilWriteMask = %u\n%sstencilFrontRef = %u\n%sstencilBackRef = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->minDepth), prefix, (pStruct->maxDepth), prefix, (pStruct->stencilReadMask), prefix, (pStruct->stencilWriteMask), prefix, (pStruct->stencilFrontRef), prefix, (pStruct->stencilBackRef));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderPass = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeueType = %s\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUEUE_TYPE(pStruct->queueType), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_rect(const XGL_RECT* pStruct, const char* prefix)
+char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- char* tmpStr;
- char* extra_indent = (char*)malloc(strlen(prefix) + 3);
- strcpy(extra_indent, " ");
- strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- tmpStr = xgl_print_xgl_offset2d(&pStruct->offset, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %soffset (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_extent2d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%soffset = addr\n%sextent = addr\n", prefix, prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
- if (0 < strlen(stp_strs[stp_index])) {
- strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
- free(stp_strs[stp_index]);
- }
- }
- free(extra_indent);
+ snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
return str;
}
-char* xgl_print_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssize = addr\n%salignment = addr\n%sgranularity = addr\n%smemProps = %u\n%smemType = %s\n", prefix, prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType));
+ return str;
+}
+char* xgl_print_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n%sbuffer = addr\n%soffset = addr\n%ssize = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask), prefix, prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssharedSemaphore = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[3];
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->front, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sfront (addr)\n%s", prefix, tmpStr);
- tmpStr = xgl_print_xgl_stencil_op_state(&pStruct->back, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %sback (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sformat = %s\n%sdepthTestEnable = %s\n%sdepthWriteEnable = %s\n%sdepthFunc = %s\n%sdepthBoundsEnable = %s\n%sstencilTestEnable = %s\n%sfront = addr\n%sback = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->depthTestEnable) ? "TRUE" : "FALSE", prefix, (pStruct->depthWriteEnable) ? "TRUE" : "FALSE", prefix, string_XGL_COMPARE_FUNC(pStruct->depthFunc), prefix, (pStruct->depthBoundsEnable) ? "TRUE" : "FALSE", prefix, (pStruct->stencilTestEnable) ? "TRUE" : "FALSE", prefix, prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%soutputMask = %u\n%sinputMask = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->outputMask), prefix, (pStruct->inputMask));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%stype = %s\n%scount = %u\n", prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->type), prefix, (pStruct->count));
+ snprintf(str, len, "%smaxGpuClock = %f\n%saluPerClock = %f\n%stexPerClock = %f\n%sprimsPerClock = %f\n%spixelsPerClock = %f\n", prefix, (pStruct->maxGpuClock), prefix, (pStruct->aluPerClock), prefix, (pStruct->texPerClock), prefix, (pStruct->primsPerClock), prefix, (pStruct->pixelsPerClock));
return str;
}
-char* xgl_print_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct, const char* prefix)
+char* xgl_print_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sr = %s\n%sg = %s\n%sb = %s\n%sa = %s\n", prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->r), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->g), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->b), prefix, string_XGL_CHANNEL_SWIZZLE(pStruct->a));
+ return str;
+}
+char* xgl_print_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- if (pStruct->pSamplerImageViews) {
- tmpStr = xgl_print_xgl_sampler_image_view_info(pStruct->pSamplerImageViews, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spSamplerImageViews (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ char* stp_strs[1];
+ tmpStr = xgl_print_xgl_clear_color_value(&pStruct->color, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %scolor (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplerImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%scolor = addr\n%suseRawValue = %s\n", prefix, prefix, (pStruct->useRawValue) ? "TRUE" : "FALSE");
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%squeryType = %s\n%sslots = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_QUERY_TYPE(pStruct->queryType), prefix, (pStruct->slots));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sblendConst = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[2];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_channel_mapping(&pStruct->channels, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %schannels (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbuffer = addr\n%sviewType = %s\n%sstride = addr\n%sformat = %s\n%schannels = addr\n%soffset = addr\n%srange = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_BUFFER_VIEW_TYPE(pStruct->viewType), prefix, prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, prefix);
+ for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_offset2d(const XGL_OFFSET2D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n", prefix, (pStruct->x), prefix, (pStruct->y));
- return str;
-}
-char* xgl_print_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- if (pStruct->pBufferViews) {
- tmpStr = xgl_print_xgl_buffer_view_attach_info(pStruct->pBufferViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spBufferViews (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spBufferViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%smagFilter = %s\n%sminFilter = %s\n%smipMode = %s\n%saddressU = %s\n%saddressV = %s\n%saddressW = %s\n%smipLodBias = %f\n%smaxAnisotropy = %u\n%scompareFunc = %s\n%sminLod = %f\n%smaxLod = %f\n%sborderColorType = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_TEX_FILTER(pStruct->magFilter), prefix, string_XGL_TEX_FILTER(pStruct->minFilter), prefix, string_XGL_TEX_MIPMAP_MODE(pStruct->mipMode), prefix, string_XGL_TEX_ADDRESS(pStruct->addressU), prefix, string_XGL_TEX_ADDRESS(pStruct->addressV), prefix, string_XGL_TEX_ADDRESS(pStruct->addressW), prefix, (pStruct->mipLodBias), prefix, (pStruct->maxAnisotropy), prefix, string_XGL_COMPARE_FUNC(pStruct->compareFunc), prefix, (pStruct->minLod), prefix, (pStruct->maxLod), prefix, string_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_memory_ref(const XGL_MEMORY_REF* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%smem = addr\n%sflags = %u\n", prefix, prefix, (pStruct->flags));
- return str;
-}
-char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%seventCount = %u\n%spEvents = addr\n%swaitEvent = %s\n%smemBarrierCount = %u\n%sppMemBarriers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->eventCount), prefix, prefix, string_XGL_WAIT_EVENT(pStruct->waitEvent), prefix, (pStruct->memBarrierCount), prefix);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->imageSubresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %simageSubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->imageOffset, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %simageOffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->imageExtent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %simageExtent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%sbufferOffset = addr\n%simageSubresource = addr\n%simageOffset = addr\n%simageExtent = addr\n", prefix, prefix, prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
+ return str;
+}
+char* xgl_print_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- if (pStruct->pVertexBindingDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_binding_description(pStruct->pVertexBindingDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spVertexBindingDescriptions (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- if (pStruct->pVertexAttributeDescriptions) {
- tmpStr = xgl_print_xgl_vertex_input_attribute_description(pStruct->pVertexAttributeDescriptions, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[2] = (char*)malloc(len);
- snprintf(stp_strs[2], len, " %spVertexAttributeDescriptions (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[2] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sbindingCount = %u\n%spVertexBindingDescriptions = addr\n%sattributeCount = %u\n%spVertexAttributeDescriptions = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->bindingCount), prefix, prefix, (pStruct->attributeCount), prefix);
- for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->flags));
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ snprintf(str, len, "%sapiVersion = %u\n%sdriverVersion = %u\n%svendorId = %u\n%sdeviceId = %u\n%sgpuType = %s\n%sgpuName = %s\n%smaxMemRefsPerSubmission = %u\n%smaxInlineMemoryUpdateSize = addr\n%smaxBoundDescriptorSets = %u\n%smaxThreadGroupSize = %u\n%stimestampFrequency = %lu\n%smultiColorAttachmentClears = %s\n%smaxDescriptorSets = %u\n%smaxViewports = %u\n%smaxColorAttachments = %u\n", prefix, (pStruct->apiVersion), prefix, (pStruct->driverVersion), prefix, (pStruct->vendorId), prefix, (pStruct->deviceId), prefix, string_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType), prefix, (pStruct->gpuName), prefix, (pStruct->maxMemRefsPerSubmission), prefix, prefix, (pStruct->maxBoundDescriptorSets), prefix, (pStruct->maxThreadGroupSize), prefix, (pStruct->timestampFrequency), prefix, (pStruct->multiColorAttachmentClears) ? "TRUE" : "FALSE", prefix, (pStruct->maxDescriptorSets), prefix, (pStruct->maxViewports), prefix, (pStruct->maxColorAttachments));
return str;
}
-char* xgl_print_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%scodeSize = addr\n%spCode = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n%slayout = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
}
- }
- free(extra_indent);
- return str;
-}
-char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%ssrcOffset = addr\n%sdestOffset = addr\n%scopySize = addr\n", prefix, prefix, prefix);
+ return str;
+}
+char* xgl_print_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[2];
- if (pStruct->pNext) {
- tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
- len = 256+strlen(tmpStr);
- stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
- free(tmpStr);
- }
- else
- stp_strs[0] = "";
- tmpStr = xgl_print_xgl_image_subresource_range(&pStruct->msaaResolveSubResource, extra_indent);
+ char* stp_strs[3];
+ tmpStr = xgl_print_xgl_image_subresource(&pStruct->subresource, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %ssubresource (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_offset3d(&pStruct->offset, extra_indent);
len = 256+strlen(tmpStr);
stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %smsaaResolveSubResource (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ snprintf(stp_strs[1], len, " %soffset (addr)\n%s", prefix, tmpStr);
+ tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %sextent (addr)\n%s", prefix, tmpStr);
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simage = addr\n%smipLevel = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n%smsaaResolveImage = addr\n%smsaaResolveSubResource = addr\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->mipLevel), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize), prefix, prefix, prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssubresource = addr\n%soffset = addr\n%sextent = addr\n", prefix, prefix, prefix);
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sview = addr\n%slayout = %s\n", prefix, prefix, string_XGL_IMAGE_LAYOUT(pStruct->layout));
+ snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
return str;
}
-char* xgl_print_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pLinkConstBufferInfo) {
+ tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct, const char* prefix)
+char* xgl_print_xgl_offset3d(const XGL_OFFSET3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%saspect = %s\n%sbaseMipLevel = %u\n%smipLevels = %u\n%sbaseArraySlice = %u\n%sarraySize = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->baseMipLevel), prefix, (pStruct->mipLevels), prefix, (pStruct->baseArraySlice), prefix, (pStruct->arraySize));
+ snprintf(str, len, "%sx = %i\n%sy = %i\n%sz = %i\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
return str;
}
-char* xgl_print_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- if (pStruct->pImageViews) {
- tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageViews[0], extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %spImageViews (addr)\n%s", prefix, tmpStr);
- }
- else
- stp_strs[1] = "";
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%sindex = %u\n%scount = %u\n%spImageViews = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sview = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct, const char* prefix)
+char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sx = %u\n%sy = %u\n%sz = %u\n", prefix, (pStruct->x), prefix, (pStruct->y), prefix, (pStruct->z));
+ snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
return str;
}
-char* xgl_print_xgl_extent3d(const XGL_EXTENT3D* pStruct, const char* prefix)
+char* xgl_print_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
- len = sizeof(char)*1024;
+ char* tmpStr;
+ char* extra_indent = (char*)malloc(strlen(prefix) + 3);
+ strcpy(extra_indent, " ");
+ strncat(extra_indent, prefix, strlen(prefix));
+ char* stp_strs[1];
+ if (pStruct->pImageView) {
+ tmpStr = xgl_print_xgl_image_view_attach_info(pStruct->pImageView, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[0] = (char*)malloc(len);
+ snprintf(stp_strs[0], len, " %spImageView (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[0] = "";
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%swidth = %i\n%sheight = %i\n%sdepth = %i\n", prefix, (pStruct->width), prefix, (pStruct->height), prefix, (pStruct->depth));
+ snprintf(str, len, "%spSampler = addr\n%spImageView = addr\n", prefix, prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ if (0 < strlen(stp_strs[stp_index])) {
+ strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
+ free(stp_strs[stp_index]);
+ }
+ }
+ free(extra_indent);
return str;
}
-char* xgl_print_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct, const char* prefix)
+char* xgl_print_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct, const char* prefix)
{
char* str;
size_t len;
len = sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sfloatColor = addr\n%srawColor = addr\n", prefix, prefix);
+ snprintf(str, len, "%saspect = %s\n%smipLevel = %u\n%sarraySlice = %u\n", prefix, string_XGL_IMAGE_ASPECT(pStruct->aspect), prefix, (pStruct->mipLevel), prefix, (pStruct->arraySlice));
return str;
}
-char* xgl_print_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%susage = %u\n%sformatClass = %s\n%ssamples = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->usage), prefix, string_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass), prefix, (pStruct->samples));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%slayerCount = %u\n%sppActiveLayerNames = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->layerCount), prefix, (pStruct->ppActiveLayerNames)[0]);
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%squeueNodeIndex = %u\n%squeueCount = %u\n", prefix, (pStruct->queueNodeIndex), prefix, (pStruct->queueCount));
- return str;
-}
-char* xgl_print_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstencilFailOp = %s\n%sstencilPassOp = %s\n%sstencilDepthFailOp = %s\n%sstencilFunc = %s\n", prefix, string_XGL_STENCIL_OP(pStruct->stencilFailOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilPassOp), prefix, string_XGL_STENCIL_OP(pStruct->stencilDepthFailOp), prefix, string_XGL_COMPARE_FUNC(pStruct->stencilFunc));
- return str;
-}
-char* xgl_print_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct, const char* prefix)
+char* xgl_print_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
char* stp_strs[1];
- if (pStruct->pLinkConstBufferInfo) {
- tmpStr = xgl_print_xgl_link_const_buffer(pStruct->pLinkConstBufferInfo, extra_indent);
- len = 256+strlen(tmpStr)+strlen(prefix);
+ if (pStruct->pNext) {
+ tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
+ len = 256+strlen(tmpStr);
stp_strs[0] = (char*)malloc(len);
- snprintf(stp_strs[0], len, " %spLinkConstBufferInfo (addr)\n%s", prefix, tmpStr);
+ snprintf(stp_strs[0], len, " %spNext (addr)\n%s", prefix, tmpStr);
+ free(tmpStr);
}
else
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%sstage = %s\n%sshader = addr\n%slinkConstBufferCount = %u\n%spLinkConstBufferInfo = addr\n", prefix, string_XGL_PIPELINE_SHADER_STAGE(pStruct->stage), prefix, prefix, (pStruct->linkConstBufferCount), prefix);
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%snumViewports = %u\n%sclipOrigin = %s\n%sdepthMode = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->numViewports), prefix, string_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin), prefix, string_XGL_DEPTH_MODE(pStruct->depthMode));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sinitialCount = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->initialCount), prefix, (pStruct->flags));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%ssize = addr\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->usage), prefix, (pStruct->flags));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sfsInvocations = %lu\n%scPrimitives = %lu\n%scInvocations = %lu\n%svsInvocations = %lu\n%sgsInvocations = %lu\n%sgsPrimitives = %lu\n%siaPrimitives = %lu\n%siaVertices = %lu\n%stcsInvocations = %lu\n%stesInvocations = %lu\n%scsInvocations = %lu\n", prefix, (pStruct->fsInvocations), prefix, (pStruct->cPrimitives), prefix, (pStruct->cInvocations), prefix, (pStruct->vsInvocations), prefix, (pStruct->gsInvocations), prefix, (pStruct->gsPrimitives), prefix, (pStruct->iaPrimitives), prefix, (pStruct->iaVertices), prefix, (pStruct->tcsInvocations), prefix, (pStruct->tesInvocations), prefix, (pStruct->csInvocations));
- return str;
-}
-char* xgl_print_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sbinding = %u\n%sformat = %s\n%soffsetInBytes = %u\n", prefix, (pStruct->binding), prefix, string_XGL_FORMAT(pStruct->format), prefix, (pStruct->offsetInBytes));
- return str;
-}
-char* xgl_print_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct, const char* prefix)
-{
- char* str;
- size_t len;
- len = sizeof(char)*1024;
- str = (char*)malloc(len);
- snprintf(str, len, "%sstrideInBytes = %u\n%sstepRate = %s\n", prefix, (pStruct->strideInBytes), prefix, string_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate));
- return str;
-}
-char* xgl_print_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct, const char* prefix)
+char* xgl_print_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
char* extra_indent = (char*)malloc(strlen(prefix) + 3);
strcpy(extra_indent, " ");
strncat(extra_indent, prefix, strlen(prefix));
- char* stp_strs[1];
+ char* stp_strs[3];
if (pStruct->pNext) {
tmpStr = dynamic_display((void*)pStruct->pNext, prefix);
len = 256+strlen(tmpStr);
}
else
stp_strs[0] = "";
- len = strlen(stp_strs[0]) + sizeof(char)*1024;
+ tmpStr = xgl_print_xgl_rect(&pStruct->renderArea, extra_indent);
+ len = 256+strlen(tmpStr);
+ stp_strs[1] = (char*)malloc(len);
+ snprintf(stp_strs[1], len, " %srenderArea (addr)\n%s", prefix, tmpStr);
+ if (pStruct->pColorLoadClearValues) {
+ tmpStr = xgl_print_xgl_clear_color(pStruct->pColorLoadClearValues, extra_indent);
+ len = 256+strlen(tmpStr)+strlen(prefix);
+ stp_strs[2] = (char*)malloc(len);
+ snprintf(stp_strs[2], len, " %spColorLoadClearValues (addr)\n%s", prefix, tmpStr);
+ }
+ else
+ stp_strs[2] = "";
+ len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + strlen(stp_strs[2]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sindex = %u\n%scount = %u\n%spSamplers = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->index), prefix, (pStruct->count), prefix);
- for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%srenderArea = addr\n%sframebuffer = addr\n%scolorAttachmentCount = %u\n%spColorLoadOps = addr\n%spColorStoreOps = addr\n%spColorLoadClearValues = addr\n%sdepthLoadOp = %s\n%sdepthLoadClearValue = %f\n%sdepthStoreOp = %s\n%sstencilLoadOp = %s\n%sstencilLoadClearValue = %u\n%sstencilStoreOp = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, prefix, (pStruct->colorAttachmentCount), prefix, prefix, prefix, prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp), prefix, (pStruct->depthLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp), prefix, string_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp), prefix, (pStruct->stencilLoadClearValue), prefix, string_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp));
+ for (int32_t stp_index = 2; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
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);
}
else
stp_strs[0] = "";
- tmpStr = xgl_print_xgl_extent3d(&pStruct->extent, extra_indent);
- len = 256+strlen(tmpStr);
- stp_strs[1] = (char*)malloc(len);
- snprintf(stp_strs[1], len, " %sextent (addr)\n%s", prefix, tmpStr);
- len = strlen(stp_strs[0]) + strlen(stp_strs[1]) + sizeof(char)*1024;
+ len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%simageType = %s\n%sformat = %s\n%sextent = addr\n%smipLevels = %u\n%sarraySize = %u\n%ssamples = %u\n%stiling = %s\n%susage = %u\n%sflags = %u\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_IMAGE_TYPE(pStruct->imageType), prefix, string_XGL_FORMAT(pStruct->format), prefix, prefix, (pStruct->mipLevels), prefix, (pStruct->arraySize), prefix, (pStruct->samples), prefix, string_XGL_IMAGE_TILING(pStruct->tiling), prefix, (pStruct->usage), prefix, (pStruct->flags));
- for (int32_t stp_index = 1; stp_index >= 0; stp_index--) {
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sdescriptorType = %s\n%scount = %u\n%sstageFlags = %u\n%simmutableSampler = addr\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, string_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType), prefix, (pStruct->count), prefix, (pStruct->stageFlags), prefix);
+ for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(stp_strs[stp_index]);
free(extra_indent);
return str;
}
-char* xgl_print_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct, const char* prefix)
+char* xgl_print_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%scompatibilityFlags = %u\n", prefix, (pStruct->compatibilityFlags));
+ return str;
+}
+char* xgl_print_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct, const char* prefix)
{
char* str;
size_t len;
stp_strs[0] = "";
len = strlen(stp_strs[0]) + sizeof(char)*1024;
str = (char*)malloc(len);
- snprintf(str, len, "%ssType = %s\n%spNext = addr\n%spatchControlPoints = %u\n%soptimalTessFactor = %f\n%sfixedTessFactor = %f\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, (pStruct->patchControlPoints), prefix, (pStruct->optimalTessFactor), prefix, (pStruct->fixedTessFactor));
+ snprintf(str, len, "%ssType = %s\n%spNext = addr\n%sallocationSize = addr\n%smemProps = %u\n%smemType = %s\n%smemPriority = %s\n", prefix, string_XGL_STRUCTURE_TYPE(pStruct->sType), prefix, prefix, prefix, (pStruct->memProps), prefix, string_XGL_MEMORY_TYPE(pStruct->memType), prefix, string_XGL_MEMORY_PRIORITY(pStruct->memPriority));
for (int32_t stp_index = 0; stp_index >= 0; stp_index--) {
if (0 < strlen(stp_strs[stp_index])) {
strncat(str, stp_strs[stp_index], strlen(stp_strs[stp_index]));
free(extra_indent);
return str;
}
+char* xgl_print_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct, const char* prefix)
+{
+ char* str;
+ size_t len;
+ len = sizeof(char)*1024;
+ str = (char*)malloc(len);
+ snprintf(str, len, "%squeueFlags = %u\n%squeueCount = %u\n%smaxAtomicCounters = %u\n%ssupportsTimestamps = %s\n", prefix, (pStruct->queueFlags), prefix, (pStruct->queueCount), prefix, (pStruct->maxAtomicCounters), prefix, (pStruct->supportsTimestamps) ? "TRUE" : "FALSE");
+ return str;
+}
char* dynamic_display(const void* pStruct, const char* prefix)
{
// Cast to APP_INFO ptr initially just to pull sType off struct
#include "xgl_enum_validate_helper.h"
// Function Prototypes
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
-uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct);
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct);
uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct);
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
+uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct);
uint32_t xgl_validate_xgl_pipeline_rs_state_create_info(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct);
uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct);
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
-uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct);
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct);
uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct);
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct);
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct);
uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct);
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct);
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct);
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct);
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct);
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct);
uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct);
uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct);
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct);
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct);
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct);
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct);
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct);
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct);
+uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct);
uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct);
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct);
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct);
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct);
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct);
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct);
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct);
uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct);
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct);
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct);
-uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct);
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct);
-uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct);
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct);
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct);
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct);
+uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct);
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct);
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct);
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct);
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct);
-uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
+uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
- return 0;
- if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
+ if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
+uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_TEX_FILTER(pStruct->magFilter))
- return 0;
- if (!validate_XGL_TEX_FILTER(pStruct->minFilter))
- return 0;
- if (!validate_XGL_TEX_MIPMAP_MODE(pStruct->mipMode))
- return 0;
- if (!validate_XGL_TEX_ADDRESS(pStruct->addressU))
- return 0;
- if (!validate_XGL_TEX_ADDRESS(pStruct->addressV))
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
return 0;
- if (!validate_XGL_TEX_ADDRESS(pStruct->addressW))
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
return 0;
- if (!validate_XGL_COMPARE_FUNC(pStruct->compareFunc))
+ if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
return 0;
- if (!validate_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType))
+ if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
+uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
+uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
-{
- if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+ if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
+uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
return 0;
- if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
+ if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
+uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
{
- if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
+ if (!validate_XGL_FORMAT(pStruct->format))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_link_const_buffer(const XGL_LINK_CONST_BUFFER* pStruct)
-{
- return 1;
-}
-uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
{
- if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
+ return 0;
+ if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_device_create_info(const XGL_DEVICE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pRequestedQueues && !xgl_validate_xgl_device_queue_create_info((const XGL_DEVICE_QUEUE_CREATE_INFO*)pStruct->pRequestedQueues))
- return 0;
- if (!validate_XGL_VALIDATION_LEVEL(pStruct->maxValidationLevel))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
+uint32_t xgl_validate_xgl_subresource_layout(const XGL_SUBRESOURCE_LAYOUT* pStruct)
{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
- return 0;
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
- return 0;
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
- return 0;
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
- return 0;
- if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
+uint32_t xgl_validate_xgl_draw_indexed_indirect_cmd(const XGL_DRAW_INDEXED_INDIRECT_CMD* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
+ return 0;
+ if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_dynamic_rs_state_create_info(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
+uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
+uint32_t xgl_validate_xgl_format_properties(const XGL_FORMAT_PROPERTIES* pStruct)
{
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_alloc_callbacks(const XGL_ALLOC_CALLBACKS* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
uint32_t xgl_validate_xgl_pipeline_cb_state_create_info(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pStruct)
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_buffer_memory_requirements(const XGL_BUFFER_MEMORY_REQUIREMENTS* pStruct)
+uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
+uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
{
- if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!validate_XGL_FORMAT(pStruct->format))
return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ if (!validate_XGL_BLEND(pStruct->srcBlendColor))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->destBlendColor))
+ return 0;
+ if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
+ return 0;
+ if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
+ return 0;
+ if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
+uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
+ if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
+ if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
+uint32_t xgl_validate_xgl_fence_create_info(const XGL_FENCE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
- return 0;
- if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_framebuffer_create_info(const XGL_FRAMEBUFFER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (pStruct->pColorAttachments && !xgl_validate_xgl_color_attachment_bind_info((const XGL_COLOR_ATTACHMENT_BIND_INFO*)pStruct->pColorAttachments))
+ return 0;
+ if (pStruct->pDepthStencilAttachment && !xgl_validate_xgl_depth_stencil_bind_info((const XGL_DEPTH_STENCIL_BIND_INFO*)pStruct->pDepthStencilAttachment))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_extent2d(const XGL_EXTENT2D* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_shader_stage_create_info(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->shader))
+ if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
+uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_ia_state_create_info(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_PRIMITIVE_TOPOLOGY(pStruct->topology))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_cb_attachment_state(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pStruct)
+uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
{
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!validate_XGL_BLEND(pStruct->srcBlendColor))
- return 0;
- if (!validate_XGL_BLEND(pStruct->destBlendColor))
- return 0;
- if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncColor))
- return 0;
- if (!validate_XGL_BLEND(pStruct->srcBlendAlpha))
- return 0;
- if (!validate_XGL_BLEND(pStruct->destBlendAlpha))
- return 0;
- if (!validate_XGL_BLEND_FUNC(pStruct->blendFuncAlpha))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_application_info(const XGL_APPLICATION_INFO* pStruct)
+uint32_t xgl_validate_xgl_pipeline_ms_state_create_info(const XGL_PIPELINE_MS_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_color_attachment_view_create_info(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
+ return 0;
if (!validate_XGL_FORMAT(pStruct->format))
return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+ return 0;
+ if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
+uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
{
- if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset))
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+ if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
+uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
{
- if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_draw_indirect_cmd(const XGL_DRAW_INDIRECT_CMD* pStruct)
-{
- return 1;
-}
uint32_t xgl_validate_xgl_image_view_create_info(const XGL_IMAGE_VIEW_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_cmd_buffer_begin_info(const XGL_CMD_BUFFER_BEGIN_INFO* pStruct)
+uint32_t xgl_validate_xgl_graphics_pipeline_create_info(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
+{
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
+ return 0;
+ if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_open_info(const XGL_MEMORY_OPEN_INFO* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_update_as_copy(const XGL_UPDATE_AS_COPY* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ return 0;
return 1;
}
uint32_t xgl_validate_xgl_image_copy(const XGL_IMAGE_COPY* pStruct)
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_resolve(const XGL_IMAGE_RESOLVE* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!validate_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin))
- return 0;
- if (!validate_XGL_DEPTH_MODE(pStruct->depthMode))
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->srcSubresource))
return 0;
- return 1;
-}
-uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
-{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->srcOffset))
return 0;
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->destSubresource))
return 0;
- if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
+ if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->destOffset))
return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
+ if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
+uint32_t xgl_validate_xgl_color_attachment_bind_info(const XGL_COLOR_ATTACHMENT_BIND_INFO* pStruct)
{
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
+uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_compute_pipeline_create_info(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_memory_barrier(const XGL_IMAGE_MEMORY_BARRIER* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_pipeline_shader((const XGL_PIPELINE_SHADER*)&pStruct->cs))
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->oldLayout))
+ return 0;
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->newLayout))
+ return 0;
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->subresourceRange))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
+uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
{
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
+ if (!validate_XGL_FORMAT(pStruct->format))
return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
+ if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
+ return 0;
+ if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
+ return 0;
+ if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
+ return 0;
+ return 1;
+}
+uint32_t xgl_validate_xgl_pipeline_barrier(const XGL_PIPELINE_BARRIER* pStruct)
+{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
+ if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_peer_image_open_info(const XGL_PEER_IMAGE_OPEN_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_memory_properties(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_dynamic_vp_state_create_info(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pViewports && !xgl_validate_xgl_viewport((const XGL_VIEWPORT*)pStruct->pViewports))
- return 0;
- if (pStruct->pScissors && !xgl_validate_xgl_rect((const XGL_RECT*)pStruct->pScissors))
+ if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
+uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_peer_memory_open_info(const XGL_PEER_MEMORY_OPEN_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_rect((const XGL_RECT*)&pStruct->renderArea))
- return 0;
- if (pStruct->pColorLoadClearValues && !xgl_validate_xgl_clear_color((const XGL_CLEAR_COLOR*)pStruct->pColorLoadClearValues))
- return 0;
- if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp))
- return 0;
- if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp))
- return 0;
- if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp))
- return 0;
- if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
+uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
{
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_dynamic_ds_state_create_info(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_descriptor_region_create_info(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (pStruct->pTypeCount && !xgl_validate_xgl_descriptor_type_count((const XGL_DESCRIPTOR_TYPE_COUNT*)pStruct->pTypeCount))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_cmd_buffer_graphics_begin_info(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pStruct)
+uint32_t xgl_validate_xgl_viewport(const XGL_VIEWPORT* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_rect(const XGL_RECT* pStruct)
+uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
{
- if (!xgl_validate_xgl_offset2d((const XGL_OFFSET2D*)&pStruct->offset))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!xgl_validate_xgl_extent2d((const XGL_EXTENT2D*)&pStruct->extent))
+ if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_buffer_memory_barrier(const XGL_BUFFER_MEMORY_BARRIER* pStruct)
+uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_ds_state_create_info(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_cmd_buffer_create_info(const XGL_CMD_BUFFER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!validate_XGL_COMPARE_FUNC(pStruct->depthFunc))
- return 0;
- if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->front))
- return 0;
- if (!xgl_validate_xgl_stencil_op_state((const XGL_STENCIL_OP_STATE*)&pStruct->back))
+ if (!validate_XGL_QUEUE_TYPE(pStruct->queueType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_descriptor_type_count(const XGL_DESCRIPTOR_TYPE_COUNT* pStruct)
+uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
{
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->type))
+ if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_update_sampler_textures(const XGL_UPDATE_SAMPLER_TEXTURES* pStruct)
+uint32_t xgl_validate_xgl_memory_requirements(const XGL_MEMORY_REQUIREMENTS* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (pStruct->pSamplerImageViews && !xgl_validate_xgl_sampler_image_view_info((const XGL_SAMPLER_IMAGE_VIEW_INFO*)pStruct->pSamplerImageViews))
+ if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_query_pool_create_info(const XGL_QUERY_POOL_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_queue_semaphore_open_info(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_QUERY_TYPE(pStruct->queryType))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_memory_barrier(const XGL_MEMORY_BARRIER* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_offset2d(const XGL_OFFSET2D* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_performance(const XGL_PHYSICAL_GPU_PERFORMANCE* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_update_buffers(const XGL_UPDATE_BUFFERS* pStruct)
+uint32_t xgl_validate_xgl_channel_mapping(const XGL_CHANNEL_MAPPING* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->r))
return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->g))
return 0;
- if (pStruct->pBufferViews && !xgl_validate_xgl_buffer_view_attach_info((const XGL_BUFFER_VIEW_ATTACH_INFO*)pStruct->pBufferViews))
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->b))
+ return 0;
+ if (!validate_XGL_CHANNEL_SWIZZLE(pStruct->a))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_memory_ref(const XGL_MEMORY_REF* pStruct)
+uint32_t xgl_validate_xgl_clear_color(const XGL_CLEAR_COLOR* pStruct)
{
+ if (!xgl_validate_xgl_clear_color_value((const XGL_CLEAR_COLOR_VALUE*)&pStruct->color))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
+uint32_t xgl_validate_xgl_dynamic_cb_state_create_info(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_vertex_input_create_info(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_buffer_view_create_info(const XGL_BUFFER_VIEW_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (pStruct->pVertexBindingDescriptions && !xgl_validate_xgl_vertex_input_binding_description((const XGL_VERTEX_INPUT_BINDING_DESCRIPTION*)pStruct->pVertexBindingDescriptions))
+ if (!validate_XGL_BUFFER_VIEW_TYPE(pStruct->viewType))
return 0;
- if (pStruct->pVertexAttributeDescriptions && !xgl_validate_xgl_vertex_input_attribute_description((const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*)pStruct->pVertexAttributeDescriptions))
+ if (!validate_XGL_FORMAT(pStruct->format))
+ return 0;
+ if (!xgl_validate_xgl_channel_mapping((const XGL_CHANNEL_MAPPING*)&pStruct->channels))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+uint32_t xgl_validate_xgl_sampler_create_info(const XGL_SAMPLER_CREATE_INFO* pStruct)
{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_TEX_FILTER(pStruct->magFilter))
+ return 0;
+ if (!validate_XGL_TEX_FILTER(pStruct->minFilter))
+ return 0;
+ if (!validate_XGL_TEX_MIPMAP_MODE(pStruct->mipMode))
+ return 0;
+ if (!validate_XGL_TEX_ADDRESS(pStruct->addressU))
+ return 0;
+ if (!validate_XGL_TEX_ADDRESS(pStruct->addressV))
+ return 0;
+ if (!validate_XGL_TEX_ADDRESS(pStruct->addressW))
+ return 0;
+ if (!validate_XGL_COMPARE_FUNC(pStruct->compareFunc))
+ return 0;
+ if (!validate_XGL_BORDER_COLOR_TYPE(pStruct->borderColorType))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_shader_create_info(const XGL_SHADER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_event_wait_info(const XGL_EVENT_WAIT_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (!validate_XGL_WAIT_EVENT(pStruct->waitEvent))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
+uint32_t xgl_validate_xgl_buffer_image_copy(const XGL_BUFFER_IMAGE_COPY* pStruct)
{
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->imageSubresource))
+ return 0;
+ if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->imageOffset))
+ return 0;
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->imageExtent))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_event_create_info(const XGL_EVENT_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_depth_stencil_view_create_info(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_properties(const XGL_PHYSICAL_GPU_PROPERTIES* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
- if (!xgl_validate_xgl_image_subresource_range((const XGL_IMAGE_SUBRESOURCE_RANGE*)&pStruct->msaaResolveSubResource))
+ if (!validate_XGL_PHYSICAL_GPU_TYPE(pStruct->gpuType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_depth_stencil_bind_info(const XGL_DEPTH_STENCIL_BIND_INFO* pStruct)
+uint32_t xgl_validate_xgl_image_view_attach_info(const XGL_IMAGE_VIEW_ATTACH_INFO* pStruct)
{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
if (!validate_XGL_IMAGE_LAYOUT(pStruct->layout))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
+uint32_t xgl_validate_xgl_memory_alloc_buffer_info(const XGL_MEMORY_ALLOC_BUFFER_INFO* pStruct)
{
- if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_subresource_range(const XGL_IMAGE_SUBRESOURCE_RANGE* pStruct)
+uint32_t xgl_validate_xgl_buffer_copy(const XGL_BUFFER_COPY* pStruct)
{
- if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_update_images(const XGL_UPDATE_IMAGES* pStruct)
+uint32_t xgl_validate_xgl_image_memory_bind_info(const XGL_IMAGE_MEMORY_BIND_INFO* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ if (!xgl_validate_xgl_image_subresource((const XGL_IMAGE_SUBRESOURCE*)&pStruct->subresource))
return 0;
- if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ if (!xgl_validate_xgl_offset3d((const XGL_OFFSET3D*)&pStruct->offset))
return 0;
- if (pStruct->pImageViews && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageViews))
+ if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_dispatch_indirect_cmd(const XGL_DISPATCH_INDIRECT_CMD* pStruct)
+uint32_t xgl_validate_xgl_image_memory_requirements(const XGL_IMAGE_MEMORY_REQUIREMENTS* pStruct)
{
+ if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
+uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
{
+ if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
+ return 0;
+ if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_clear_color_value(const XGL_CLEAR_COLOR_VALUE* pStruct)
+uint32_t xgl_validate_xgl_offset3d(const XGL_OFFSET3D* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_memory_alloc_image_info(const XGL_MEMORY_ALLOC_IMAGE_INFO* pStruct)
+uint32_t xgl_validate_xgl_buffer_view_attach_info(const XGL_BUFFER_VIEW_ATTACH_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_IMAGE_FORMAT_CLASS(pStruct->formatClass))
- return 0;
return 1;
}
-uint32_t xgl_validate_xgl_device_queue_create_info(const XGL_DEVICE_QUEUE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_extent3d(const XGL_EXTENT3D* pStruct)
{
return 1;
}
-uint32_t xgl_validate_xgl_stencil_op_state(const XGL_STENCIL_OP_STATE* pStruct)
+uint32_t xgl_validate_xgl_sampler_image_view_info(const XGL_SAMPLER_IMAGE_VIEW_INFO* pStruct)
{
- if (!validate_XGL_STENCIL_OP(pStruct->stencilFailOp))
- return 0;
- if (!validate_XGL_STENCIL_OP(pStruct->stencilPassOp))
- return 0;
- if (!validate_XGL_STENCIL_OP(pStruct->stencilDepthFailOp))
- return 0;
- if (!validate_XGL_COMPARE_FUNC(pStruct->stencilFunc))
+ if (pStruct->pImageView && !xgl_validate_xgl_image_view_attach_info((const XGL_IMAGE_VIEW_ATTACH_INFO*)pStruct->pImageView))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_shader(const XGL_PIPELINE_SHADER* pStruct)
+uint32_t xgl_validate_xgl_image_subresource(const XGL_IMAGE_SUBRESOURCE* pStruct)
{
- if (!validate_XGL_PIPELINE_SHADER_STAGE(pStruct->stage))
- return 0;
- if (pStruct->pLinkConstBufferInfo && !xgl_validate_xgl_link_const_buffer((const XGL_LINK_CONST_BUFFER*)pStruct->pLinkConstBufferInfo))
+ if (!validate_XGL_IMAGE_ASPECT(pStruct->aspect))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_queue_semaphore_create_info(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_layer_create_info(const XGL_LAYER_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_statistics_data(const XGL_PIPELINE_STATISTICS_DATA* pStruct)
+uint32_t xgl_validate_xgl_pipeline_vp_state_create_info(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pStruct)
{
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!validate_XGL_COORDINATE_ORIGIN(pStruct->clipOrigin))
+ return 0;
+ if (!validate_XGL_DEPTH_MODE(pStruct->depthMode))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_vertex_input_attribute_description(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pStruct)
+uint32_t xgl_validate_xgl_buffer_create_info(const XGL_BUFFER_CREATE_INFO* pStruct)
{
- if (!validate_XGL_FORMAT(pStruct->format))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_vertex_input_binding_description(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pStruct)
+uint32_t xgl_validate_xgl_render_pass_create_info(const XGL_RENDER_PASS_CREATE_INFO* pStruct)
{
- if (!validate_XGL_VERTEX_INPUT_STEP_RATE(pStruct->stepRate))
+ if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
+ return 0;
+ if (!xgl_validate_xgl_rect((const XGL_RECT*)&pStruct->renderArea))
+ return 0;
+ if (pStruct->pColorLoadClearValues && !xgl_validate_xgl_clear_color((const XGL_CLEAR_COLOR*)pStruct->pColorLoadClearValues))
+ return 0;
+ if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->depthLoadOp))
+ return 0;
+ if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->depthStoreOp))
+ return 0;
+ if (!validate_XGL_ATTACHMENT_LOAD_OP(pStruct->stencilLoadOp))
+ return 0;
+ if (!validate_XGL_ATTACHMENT_STORE_OP(pStruct->stencilStoreOp))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_update_samplers(const XGL_UPDATE_SAMPLERS* pStruct)
+uint32_t xgl_validate_xgl_descriptor_set_layout_create_info(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
+ if (!validate_XGL_DESCRIPTOR_TYPE(pStruct->descriptorType))
+ return 0;
return 1;
}
-uint32_t xgl_validate_xgl_image_create_info(const XGL_IMAGE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_gpu_compatibility_info(const XGL_GPU_COMPATIBILITY_INFO* pStruct)
+{
+ return 1;
+}
+uint32_t xgl_validate_xgl_memory_alloc_info(const XGL_MEMORY_ALLOC_INFO* pStruct)
{
if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
return 0;
- if (!validate_XGL_IMAGE_TYPE(pStruct->imageType))
- return 0;
- if (!validate_XGL_FORMAT(pStruct->format))
- return 0;
- if (!xgl_validate_xgl_extent3d((const XGL_EXTENT3D*)&pStruct->extent))
+ if (!validate_XGL_MEMORY_TYPE(pStruct->memType))
return 0;
- if (!validate_XGL_IMAGE_TILING(pStruct->tiling))
+ if (!validate_XGL_MEMORY_PRIORITY(pStruct->memPriority))
return 0;
return 1;
}
-uint32_t xgl_validate_xgl_pipeline_tess_state_create_info(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pStruct)
+uint32_t xgl_validate_xgl_physical_gpu_queue_properties(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pStruct)
{
- if (!validate_XGL_STRUCTURE_TYPE(pStruct->sType))
- return 0;
return 1;
}
\ No newline at end of file
}
-// xgl_format_properties_struct_wrapper class definition
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
+xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_format_properties_struct_wrapper::display_single_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_format_properties_struct_wrapper::display_struct_members()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
- printf("%*s %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
+ printf("%*s %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
+ printf("%*s %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
}
// Output all struct elements, each on their own line
-void xgl_format_properties_struct_wrapper::display_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_format_properties_struct_wrapper::display_full_txt()
+void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_buffer_image_copy_struct_wrapper class definition
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_application_info_struct_wrapper class definition
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
+xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
+void xgl_application_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
+void xgl_application_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
- printf("%*s %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
- printf("%*s %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
- printf("%*s %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
+ printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
+ printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
+ printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
}
// Output all struct elements, each on their own line
-void xgl_buffer_image_copy_struct_wrapper::display_txt()
+void xgl_application_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
+void xgl_application_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.imageExtent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.imageOffset) {
- xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.imageSubresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_peer_memory_open_info_struct_wrapper class definition
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_link_const_buffer_struct_wrapper class definition
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
+xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
+void xgl_link_const_buffer_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_link_const_buffer_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
+ printf("%*s %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
+ printf("%*s %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
+ printf("%*s %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
}
// Output all struct elements, each on their own line
-void xgl_peer_memory_open_info_struct_wrapper::display_txt()
+void xgl_link_const_buffer_struct_wrapper::display_txt()
{
- printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_link_const_buffer_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_subresource_layout_struct_wrapper class definition
-xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_samplers_struct_wrapper class definition
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {}
+xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_subresource_layout_struct_wrapper::display_single_txt()
+void xgl_update_samplers_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_SUBRESOURCE_LAYOUT = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_subresource_layout_struct_wrapper::display_struct_members()
+void xgl_update_samplers_struct_wrapper::display_struct_members()
{
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
- printf("%*s %srowPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.rowPitch));
- printf("%*s %sdepthPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.depthPitch));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; 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_subresource_layout_struct_wrapper::display_txt()
+void xgl_update_samplers_struct_wrapper::display_txt()
{
- printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_subresource_layout_struct_wrapper::display_full_txt()
+void xgl_update_samplers_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_physical_gpu_queue_properties_struct_wrapper class definition
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_stencil_op_state_struct_wrapper class definition
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
+xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
+void xgl_stencil_op_state_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
+void xgl_stencil_op_state_struct_wrapper::display_struct_members()
{
- printf("%*s %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
- printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
- printf("%*s %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
- printf("%*s %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
+ printf("%*s %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
+ printf("%*s %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
+ printf("%*s %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
+ printf("%*s %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
}
// Output all struct elements, each on their own line
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
+void xgl_stencil_op_state_struct_wrapper::display_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
+void xgl_stencil_op_state_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_sampler_create_info_struct_wrapper class definition
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_peer_image_open_info_struct_wrapper class definition
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
+xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_sampler_create_info_struct_wrapper::display_single_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_create_info_struct_wrapper::display_struct_members()
+void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %smagFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.magFilter));
- printf("%*s %sminFilter = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_FILTER(m_struct.minFilter));
- printf("%*s %smipMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_MIPMAP_MODE(m_struct.mipMode));
- printf("%*s %saddressU = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressU));
- printf("%*s %saddressV = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressV));
- printf("%*s %saddressW = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_TEX_ADDRESS(m_struct.addressW));
- printf("%*s %smipLodBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLodBias));
- printf("%*s %smaxAnisotropy = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAnisotropy));
- printf("%*s %scompareFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.compareFunc));
- printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
- printf("%*s %smaxLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxLod));
- printf("%*s %sborderColorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BORDER_COLOR_TYPE(m_struct.borderColorType));
+ printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
}
// Output all struct elements, each on their own line
-void xgl_sampler_create_info_struct_wrapper::display_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_create_info_struct_wrapper::display_full_txt()
+void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_draw_indexed_indirect_cmd_struct_wrapper class definition
-xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_device_create_info_struct_wrapper class definition
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_struct_wrapper() {}
+xgl_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_device_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_struct_members()
+void xgl_device_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sindexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.indexCount));
- printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
- printf("%*s %sfirstIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstIndex));
- printf("%*s %svertexOffset = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexOffset));
- printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
-}
-
-// Output all struct elements, each on their own line
-void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt()
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %squeueRecordCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueRecordCount));
+ uint32_t i;
+ for (i = 0; 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_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_device_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; 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_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_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_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_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_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
+xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_as_copy_struct_wrapper::display_single_txt()
+void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_as_copy_struct_wrapper::display_struct_members()
+void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
- printf("%*s %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
}
// Output all struct elements, each on their own line
-void xgl_update_as_copy_struct_wrapper::display_txt()
+void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_as_copy_struct_wrapper::display_full_txt()
+void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_clear_color_struct_wrapper class definition
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_buffers_struct_wrapper class definition
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
+xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_clear_color_struct_wrapper::display_single_txt()
+void xgl_update_buffers_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_struct_wrapper::display_struct_members()
+void xgl_update_buffers_struct_wrapper::display_struct_members()
{
- printf("%*s %scolor = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.color));
- printf("%*s %suseRawValue = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.useRawValue) ? "TRUE" : "FALSE");
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; 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_clear_color_struct_wrapper::display_txt()
+void xgl_update_buffers_struct_wrapper::display_txt()
{
- printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_struct_wrapper::display_full_txt()
+void xgl_update_buffers_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.color) {
- xgl_clear_color_value_struct_wrapper class0(&m_struct.color);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
+ uint32_t i;
+ for (i = 0; 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_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_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_extent2d_struct_wrapper::xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
+xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_extent2d_struct_wrapper::display_single_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_EXTENT2D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_extent2d_struct_wrapper::display_struct_members()
+void xgl_vertex_input_attribute_description_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 %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_extent2d_struct_wrapper::display_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
{
- printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent2d_struct_wrapper::display_full_txt()
+void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_framebuffer_create_info_struct_wrapper class definition
-xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_struct_wrapper() {}
+xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_framebuffer_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_FRAMEBUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_framebuffer_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
+ printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
uint32_t i;
- for (i = 0; i<colorAttachmentCount; i++) {
- printf("%*s %spColorAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorAttachments)[i]);
+ for (i = 0; i<bindingCount; i++) {
+ printf("%*s %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
+ }
+ printf("%*s %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
+ for (i = 0; i<attributeCount; i++) {
+ printf("%*s %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
}
- printf("%*s %spDepthStencilAttachment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pDepthStencilAttachment));
- printf("%*s %ssampleCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleCount));
- printf("%*s %swidth = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
- printf("%*s %sheight = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
- printf("%*s %slayers = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layers));
}
// Output all struct elements, each on their own line
-void xgl_framebuffer_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_framebuffer_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pDepthStencilAttachment) {
- xgl_depth_stencil_bind_info_struct_wrapper class0(m_struct.pDepthStencilAttachment);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
uint32_t i;
- for (i = 0; i<colorAttachmentCount; i++) {
- xgl_color_attachment_bind_info_struct_wrapper class1(&(m_struct.pColorAttachments[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();
}
}
-// 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_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_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
+xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
- printf("%*s %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
- printf("%*s %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_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_alloc_callbacks_struct_wrapper::display_txt()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
+void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_memory_requirements_struct_wrapper class definition
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_subresource_layout_struct_wrapper class definition
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_subresource_layout_struct_wrapper::xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
+xgl_subresource_layout_struct_wrapper::~xgl_subresource_layout_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_subresource_layout_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_SUBRESOURCE_LAYOUT = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_requirements_struct_wrapper::display_struct_members()
+void xgl_subresource_layout_struct_wrapper::display_struct_members()
{
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
- printf("%*s %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
- printf("%*s %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
- printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
- printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
-}
+ printf("%*s %srowPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.rowPitch));
+ printf("%*s %sdepthPitch = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.depthPitch));
+}
// Output all struct elements, each on their own line
-void xgl_memory_requirements_struct_wrapper::display_txt()
+void xgl_subresource_layout_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_requirements_struct_wrapper::display_full_txt()
+void xgl_subresource_layout_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SUBRESOURCE_LAYOUT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_link_const_buffer_struct_wrapper class definition
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_draw_indexed_indirect_cmd_struct_wrapper class definition
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_link_const_buffer_struct_wrapper::xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_draw_indexed_indirect_cmd_struct_wrapper::xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_link_const_buffer_struct_wrapper::~xgl_link_const_buffer_struct_wrapper() {}
+xgl_draw_indexed_indirect_cmd_struct_wrapper::~xgl_draw_indexed_indirect_cmd_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_link_const_buffer_struct_wrapper::display_single_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_LINK_CONST_BUFFER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DRAW_INDEXED_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_link_const_buffer_struct_wrapper::display_struct_members()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_struct_members()
{
- printf("%*s %sbufferId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bufferId));
- printf("%*s %sbufferSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferSize));
- printf("%*s %spBufferData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pBufferData));
+ printf("%*s %sindexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.indexCount));
+ printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
+ printf("%*s %sfirstIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstIndex));
+ printf("%*s %svertexOffset = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexOffset));
+ printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
}
// Output all struct elements, each on their own line
-void xgl_link_const_buffer_struct_wrapper::display_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_txt()
{
- printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_link_const_buffer_struct_wrapper::display_full_txt()
+void xgl_draw_indexed_indirect_cmd_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_LINK_CONST_BUFFER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDEXED_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_physical_gpu_properties_struct_wrapper class definition
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
+xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
- printf("%*s %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
- printf("%*s %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
- printf("%*s %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
- printf("%*s %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
uint32_t i;
- for (i = 0; i<XGL_MAX_PHYSICAL_GPU_NAME; i++) {
- printf("%*s %sgpuName = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.gpuName));
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ printf("%*s %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
+ }
+ for (i = 0; i<viewportAndScissorCount; i++) {
+ printf("%*s %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
}
- printf("%*s %smaxMemRefsPerSubmission = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxMemRefsPerSubmission));
- printf("%*s %smaxInlineMemoryUpdateSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.maxInlineMemoryUpdateSize));
- printf("%*s %smaxBoundDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxBoundDescriptorSets));
- printf("%*s %smaxThreadGroupSize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxThreadGroupSize));
- printf("%*s %stimestampFrequency = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.timestampFrequency));
- printf("%*s %smultiColorAttachmentClears = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.multiColorAttachmentClears) ? "TRUE" : "FALSE");
- printf("%*s %smaxDescriptorSets = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDescriptorSets));
- printf("%*s %smaxViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxViewports));
- printf("%*s %smaxColorAttachments = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxColorAttachments));
}
// Output all struct elements, each on their own line
-void xgl_physical_gpu_properties_struct_wrapper::display_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
+void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; 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_device_create_info_struct_wrapper class definition
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_device_create_info_struct_wrapper::xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_device_create_info_struct_wrapper::~xgl_device_create_info_struct_wrapper() {}
+xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_device_create_info_struct_wrapper::display_single_txt()
+void xgl_shader_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DEVICE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_device_create_info_struct_wrapper::display_struct_members()
+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 %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 %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_device_create_info_struct_wrapper::display_txt()
+void xgl_shader_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_create_info_struct_wrapper::display_full_txt()
+void xgl_shader_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DEVICE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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')
+// 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_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* 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_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
+xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_resolve_struct_wrapper::display_single_txt()
+void xgl_memory_ref_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_RESOLVE = %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_image_resolve_struct_wrapper::display_struct_members()
+void xgl_memory_ref_struct_wrapper::display_struct_members()
{
- printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
- printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
- printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
- printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %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_image_resolve_struct_wrapper::display_txt()
+void xgl_memory_ref_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_resolve_struct_wrapper::display_full_txt()
+void xgl_memory_ref_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent2d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.destOffset) {
- xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.destSubresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
- }
- if (&m_struct.srcOffset) {
- xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
- class3.set_indent(m_indent + 4);
- class3.display_full_txt();
- }
- if (&m_struct.srcSubresource) {
- xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
- class4.set_indent(m_indent + 4);
- class4.display_full_txt();
- }
}
-// xgl_image_view_attach_info_struct_wrapper class definition
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_format_properties_struct_wrapper class definition
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_format_properties_struct_wrapper::xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
+xgl_format_properties_struct_wrapper::~xgl_format_properties_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
+void xgl_format_properties_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_FORMAT_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
+void xgl_format_properties_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+ printf("%*s %slinearTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linearTilingFeatures));
+ printf("%*s %soptimalTilingFeatures = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTilingFeatures));
}
// Output all struct elements, each on their own line
-void xgl_image_view_attach_info_struct_wrapper::display_txt()
+void xgl_format_properties_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
+void xgl_format_properties_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FORMAT_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_fence_create_info_struct_wrapper class definition
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_statistics_data_struct_wrapper class definition
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
+xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_fence_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_fence_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
-}
+ printf("%*s %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
+ printf("%*s %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
+ printf("%*s %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
+ printf("%*s %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
+ printf("%*s %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
+ printf("%*s %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
+ printf("%*s %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
+ printf("%*s %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
+ printf("%*s %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
+ printf("%*s %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
+ printf("%*s %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
+}
// Output all struct elements, each on their own line
-void xgl_fence_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
{
- printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_fence_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_dynamic_rs_state_create_info_struct_wrapper class definition
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_alloc_callbacks_struct_wrapper class definition
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_dynamic_rs_state_create_info_struct_wrapper::xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_alloc_callbacks_struct_wrapper::xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_dynamic_rs_state_create_info_struct_wrapper::~xgl_dynamic_rs_state_create_info_struct_wrapper() {}
+xgl_alloc_callbacks_struct_wrapper::~xgl_alloc_callbacks_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_single_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DYNAMIC_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_ALLOC_CALLBACKS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_struct_members()
+void xgl_alloc_callbacks_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBias));
- printf("%*s %sdepthBiasClamp = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBiasClamp));
- printf("%*s %sslopeScaledDepthBias = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.slopeScaledDepthBias));
- printf("%*s %spointSize = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointSize));
- printf("%*s %spointFadeThreshold = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pointFadeThreshold));
- printf("%*s %slineWidth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.lineWidth));
+ printf("%*s %spUserData = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pUserData));
+ printf("%*s %spfnAlloc = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnAlloc));
+ printf("%*s %spfnFree = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pfnFree));
}
// Output all struct elements, each on their own line
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_txt()
{
- printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_rs_state_create_info_struct_wrapper::display_full_txt()
+void xgl_alloc_callbacks_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DYNAMIC_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_ALLOC_CALLBACKS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_buffer_copy_struct_wrapper class definition
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
+xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_copy_struct_wrapper::display_single_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_copy_struct_wrapper::display_struct_members()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
- printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
- printf("%*s %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
+ printf("%*s %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
+ printf("%*s %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
+ printf("%*s %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
+ uint32_t i;
+ for (i = 0; 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_buffer_copy_struct_wrapper::display_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_copy_struct_wrapper::display_full_txt()
+void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; 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_color_attachment_bind_info_struct_wrapper class definition
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
+xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %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_color_attachment_bind_info_struct_wrapper::display_struct_members()
+void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
{
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+ printf("%*s %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_color_attachment_bind_info_struct_wrapper::display_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
+void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_buffer_view_create_info_struct_wrapper class definition
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_color_attachment_view_create_info_struct_wrapper class definition
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
+xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
- printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
- printf("%*s %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
- printf("%*s %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+ printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
}
// Output all struct elements, each on their own line
-void xgl_buffer_view_create_info_struct_wrapper::display_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
+void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.channels) {
- xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
+ if (&m_struct.msaaResolveSubResource) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
}
-// xgl_queue_semaphore_open_info_struct_wrapper class definition
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_cb_attachment_state_struct_wrapper class definition
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
+xgl_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssharedSemaphore = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedSemaphore));
+ printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
+ printf("%*s %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
+ printf("%*s %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
+ printf("%*s %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
+ printf("%*s %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
+ printf("%*s %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
+ printf("%*s %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
}
// Output all struct elements, each on their own line
-void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_txt()
{
- printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_pipeline_cb_state_create_info_struct_wrapper class definition
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_vertex_input_binding_description_struct_wrapper class definition
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_cb_state_create_info_struct_wrapper::xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_cb_state_create_info_struct_wrapper::~xgl_pipeline_cb_state_create_info_struct_wrapper() {}
+xgl_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_single_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_struct_members()
+void xgl_vertex_input_binding_description_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %salphaToCoverageEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.alphaToCoverageEnable) ? "TRUE" : "FALSE");
- printf("%*s %slogicOpEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.logicOpEnable) ? "TRUE" : "FALSE");
- printf("%*s %slogicOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_LOGIC_OP(m_struct.logicOp));
- printf("%*s %sattachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attachmentCount));
- uint32_t i;
- for (i = 0; i<attachmentCount; i++) {
- printf("%*s %spAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pAttachments)[i]);
- }
+ 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_pipeline_cb_state_create_info_struct_wrapper::display_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_state_create_info_struct_wrapper::display_full_txt()
+void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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')
+// 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_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_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_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
+xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- uint32_t i;
- for (i = 0; i<4; i++) {
- printf("%*s %sblendConst[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.blendConst)[i]);
- }
+ printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
}
// Output all struct elements, each on their own line
-void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_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_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.shader) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_buffer_memory_requirements_struct_wrapper class definition
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_fence_create_info_struct_wrapper class definition
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_memory_requirements_struct_wrapper::xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_fence_create_info_struct_wrapper::xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_memory_requirements_struct_wrapper::~xgl_buffer_memory_requirements_struct_wrapper() {}
+xgl_fence_create_info_struct_wrapper::~xgl_fence_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_fence_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_FENCE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_requirements_struct_wrapper::display_struct_members()
+void xgl_fence_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_buffer_memory_requirements_struct_wrapper::display_txt()
+void xgl_fence_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_requirements_struct_wrapper::display_full_txt()
+void xgl_fence_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FENCE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_sampler_image_view_info_struct_wrapper class definition
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_framebuffer_create_info_struct_wrapper class definition
+xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_framebuffer_create_info_struct_wrapper::xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
+xgl_framebuffer_create_info_struct_wrapper::~xgl_framebuffer_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_FRAMEBUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
+void xgl_framebuffer_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
- printf("%*s %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
+ uint32_t i;
+ for (i = 0; i<colorAttachmentCount; i++) {
+ printf("%*s %spColorAttachments[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorAttachments)[i]);
+ }
+ printf("%*s %spDepthStencilAttachment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pDepthStencilAttachment));
+ printf("%*s %ssampleCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.sampleCount));
+ printf("%*s %swidth = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %slayers = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layers));
}
// Output all struct elements, each on their own line
-void xgl_sampler_image_view_info_struct_wrapper::display_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
+void xgl_framebuffer_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_FRAMEBUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pImageView) {
- xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
+ if (m_struct.pDepthStencilAttachment) {
+ xgl_depth_stencil_bind_info_struct_wrapper class0(m_struct.pDepthStencilAttachment);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
+ uint32_t i;
+ for (i = 0; i<colorAttachmentCount; i++) {
+ xgl_color_attachment_bind_info_struct_wrapper class1(&(m_struct.pColorAttachments[i]));
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_descriptor_set_layout_create_info_struct_wrapper class definition
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_descriptor_set_layout_create_info_struct_wrapper::xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_descriptor_set_layout_create_info_struct_wrapper::~xgl_descriptor_set_layout_create_info_struct_wrapper() {}
+xgl_extent2d_struct_wrapper::~xgl_extent2d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
+void xgl_extent2d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = %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_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
+void xgl_extent2d_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %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));
+ 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_descriptor_set_layout_create_info_struct_wrapper::display_txt()
+void xgl_extent2d_struct_wrapper::display_txt()
{
- printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
+void xgl_extent2d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_event_wait_info_struct_wrapper class definition
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_compute_pipeline_create_info_struct_wrapper class definition
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_event_wait_info_struct_wrapper::xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
+xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_event_wait_info_struct_wrapper::display_single_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_event_wait_info_struct_wrapper::display_struct_members()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
- uint32_t i;
- for (i = 0; i<eventCount; i++) {
- printf("%*s %spEvents[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pEvents)[i]);
- }
- printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
- printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
- for (i = 0; i<memBarrierCount; i++) {
- printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
- }
+ printf("%*s %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_event_wait_info_struct_wrapper::display_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_wait_info_struct_wrapper::display_full_txt()
+void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.cs) {
+ xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_descriptor_region_create_info_struct_wrapper class definition
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_subresource_range_struct_wrapper class definition
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
+xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
+void xgl_image_subresource_range_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
+void xgl_image_subresource_range_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
- }
+ 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_descriptor_region_create_info_struct_wrapper::display_txt()
+void xgl_image_subresource_range_struct_wrapper::display_txt()
{
- printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
+void xgl_image_subresource_range_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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')
+// 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_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
+xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
- printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
- printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
- printf("%*s %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
+ printf("%*s %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_memory_alloc_info_struct_wrapper::display_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_memory_open_info_struct_wrapper class definition
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_offset2d_struct_wrapper class definition
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_open_info_struct_wrapper::display_single_txt()
+void xgl_offset2d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_open_info_struct_wrapper::display_struct_members()
+void xgl_offset2d_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
+ printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
+ printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
}
// Output all struct elements, each on their own line
-void xgl_memory_open_info_struct_wrapper::display_txt()
+void xgl_offset2d_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_open_info_struct_wrapper::display_full_txt()
+void xgl_offset2d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_graphics_pipeline_create_info_struct_wrapper class definition
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_queue_semaphore_create_info_struct_wrapper class definition
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
+xgl_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
- printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
}
// Output all struct elements, each on their own line
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_pipeline_shader_stage_create_info_struct_wrapper class definition
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_clear_color_value_struct_wrapper class definition
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_stage_create_info_struct_wrapper::~xgl_pipeline_shader_stage_create_info_struct_wrapper() {}
+xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_single_txt()
+void xgl_clear_color_value_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_struct_members()
+void xgl_clear_color_value_struct_wrapper::display_struct_members()
+{
+ uint32_t i;
+ for (i = 0; i<4; i++) {
+ printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
+ }
+ for (i = 0; i<4; i++) {
+ printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
+ }
+}
+
+// Output all struct elements, each on their own line
+void xgl_clear_color_value_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_clear_color_value_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_buffer_memory_barrier_struct_wrapper class definition
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.shader));
+ printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+ printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+ printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_txt()
+void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_stage_create_info_struct_wrapper::display_full_txt()
+void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_SHADER_STAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.shader) {
- xgl_pipeline_shader_struct_wrapper class0(&m_struct.shader);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_pipeline_barrier_struct_wrapper class definition
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_rs_state_create_info_struct_wrapper class definition
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
+xgl_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
- uint32_t i;
- for (i = 0; i<eventCount; i++) {
- printf("%*s %spEvents[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_SET_EVENT(*m_struct.pEvents)[i]);
- }
- printf("%*s %swaitEvent = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_WAIT_EVENT(m_struct.waitEvent));
- printf("%*s %smemBarrierCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memBarrierCount));
- for (i = 0; i<memBarrierCount; i++) {
- printf("%*s %sppMemBarriers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.ppMemBarriers)[i]);
- }
+ printf("%*s %sdepthClipEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthClipEnable) ? "TRUE" : "FALSE");
+ printf("%*s %srasterizerDiscardEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.rasterizerDiscardEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sprogramPointSize = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.programPointSize) ? "TRUE" : "FALSE");
+ printf("%*s %spointOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.pointOrigin));
+ printf("%*s %sprovokingVertex = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(m_struct.provokingVertex));
+ printf("%*s %sfillMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FILL_MODE(m_struct.fillMode));
+ printf("%*s %scullMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CULL_MODE(m_struct.cullMode));
+ printf("%*s %sfrontFace = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FACE_ORIENTATION(m_struct.frontFace));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_barrier_struct_wrapper::display_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
+void xgl_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_memory_barrier_struct_wrapper class definition
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_create_info_struct_wrapper class definition
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_barrier_struct_wrapper::xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
+xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_image_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_image_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
- printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+ printf("%*s %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_memory_barrier_struct_wrapper::display_txt()
+void xgl_image_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_image_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_pipeline_ia_state_create_info_struct_wrapper class definition
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_images_struct_wrapper class definition
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_ia_state_create_info_struct_wrapper::xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_ia_state_create_info_struct_wrapper::~xgl_pipeline_ia_state_create_info_struct_wrapper() {}
+xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_single_txt()
+void xgl_update_images_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_IA_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_struct_members()
+void xgl_update_images_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %stopology = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PRIMITIVE_TOPOLOGY(m_struct.topology));
- printf("%*s %sdisableVertexReuse = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.disableVertexReuse) ? "TRUE" : "FALSE");
- printf("%*s %sprimitiveRestartEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartEnable) ? "TRUE" : "FALSE");
- printf("%*s %sprimitiveRestartIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.primitiveRestartIndex));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; 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_pipeline_ia_state_create_info_struct_wrapper::display_txt()
+void xgl_update_images_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ia_state_create_info_struct_wrapper::display_full_txt()
+void xgl_update_images_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_IA_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; 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_pipeline_cb_attachment_state_struct_wrapper class definition
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_pipeline_cb_attachment_state_struct_wrapper::xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_pipeline_cb_attachment_state_struct_wrapper::~xgl_pipeline_cb_attachment_state_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_pipeline_cb_attachment_state_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_CB_ATTACHMENT_STATE = %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_pipeline_cb_attachment_state_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sblendEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.blendEnable) ? "TRUE" : "FALSE");
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %ssrcBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendColor));
- printf("%*s %sdestBlendColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendColor));
- printf("%*s %sblendFuncColor = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncColor));
- printf("%*s %ssrcBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.srcBlendAlpha));
- printf("%*s %sdestBlendAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND(m_struct.destBlendAlpha));
- printf("%*s %sblendFuncAlpha = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BLEND_FUNC(m_struct.blendFuncAlpha));
- printf("%*s %schannelWriteMask = %hu\n", m_indent, "", &m_dummy_prefix, (m_struct.channelWriteMask));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_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_pipeline_cb_attachment_state_struct_wrapper::display_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_cb_attachment_state_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_CB_ATTACHMENT_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_cmd_buffer_create_info_struct_wrapper class definition
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_view_create_info_struct_wrapper class definition
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
+xgl_image_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
+void xgl_image_view_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
+void xgl_image_view_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_VIEW_TYPE(m_struct.viewType));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
+ printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
+ printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
}
// Output all struct elements, each on their own line
-void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
+void xgl_image_view_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
+void xgl_image_view_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.subresourceRange) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.channels) {
+ xgl_channel_mapping_struct_wrapper class1(&m_struct.channels);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_application_info_struct_wrapper class definition
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_graphics_pipeline_create_info_struct_wrapper class definition
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_application_info_struct_wrapper::xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_graphics_pipeline_create_info_struct_wrapper::xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_application_info_struct_wrapper::~xgl_application_info_struct_wrapper() {}
+xgl_graphics_pipeline_create_info_struct_wrapper::~xgl_graphics_pipeline_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_application_info_struct_wrapper::display_single_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_APPLICATION_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_GRAPHICS_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_application_info_struct_wrapper::display_struct_members()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %spAppName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pAppName));
- printf("%*s %sappVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.appVersion));
- printf("%*s %spEngineName = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pEngineName));
- printf("%*s %sengineVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.engineVersion));
- printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
}
// Output all struct elements, each on their own line
-void xgl_application_info_struct_wrapper::display_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_application_info_struct_wrapper::display_full_txt()
+void xgl_graphics_pipeline_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_APPLICATION_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GRAPHICS_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_pipeline_rs_state_create_info_struct_wrapper class definition
-xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_rect_struct_wrapper class definition
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_rs_state_create_info_struct_wrapper::xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_rs_state_create_info_struct_wrapper::~xgl_pipeline_rs_state_create_info_struct_wrapper() {}
+xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_single_txt()
+void xgl_rect_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_RS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_struct_members()
+void xgl_rect_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdepthClipEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthClipEnable) ? "TRUE" : "FALSE");
- printf("%*s %srasterizerDiscardEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.rasterizerDiscardEnable) ? "TRUE" : "FALSE");
- printf("%*s %sprogramPointSize = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.programPointSize) ? "TRUE" : "FALSE");
- printf("%*s %spointOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.pointOrigin));
- printf("%*s %sprovokingVertex = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PROVOKING_VERTEX_CONVENTION(m_struct.provokingVertex));
- printf("%*s %sfillMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FILL_MODE(m_struct.fillMode));
- printf("%*s %scullMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CULL_MODE(m_struct.cullMode));
- printf("%*s %sfrontFace = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FACE_ORIENTATION(m_struct.frontFace));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_txt()
+void xgl_rect_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_rs_state_create_info_struct_wrapper::display_full_txt()
+void xgl_rect_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_RS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.offset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.offset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
}
}
-// xgl_color_attachment_view_create_info_struct_wrapper class definition
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_color_attachment_view_create_info_struct_wrapper::xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_color_attachment_view_create_info_struct_wrapper::~xgl_color_attachment_view_create_info_struct_wrapper() {}
+xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_color_attachment_view_create_info_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
- printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
+ printf("%*s %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
}
// Output all struct elements, each on their own line
-void xgl_color_attachment_view_create_info_struct_wrapper::display_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_color_attachment_view_create_info_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.msaaResolveSubResource) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_image_memory_bind_info_struct_wrapper class definition
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_device_queue_create_info_struct_wrapper class definition
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
+xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
+void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
+ printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
}
// Output all struct elements, each on their own line
-void xgl_image_memory_bind_info_struct_wrapper::display_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
+void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.offset) {
- xgl_offset3d_struct_wrapper class1(&m_struct.offset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.subresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
+}
+
+
+// xgl_memory_open_info_struct_wrapper class definition
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_memory_open_info_struct_wrapper::~xgl_memory_open_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_memory_open_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_memory_open_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssharedMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.sharedMem));
+}
+
+// Output all struct elements, each on their own line
+void xgl_memory_open_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_memory_open_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_image_subresource_struct_wrapper class definition
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_as_copy_struct_wrapper class definition
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_as_copy_struct_wrapper::xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
+xgl_update_as_copy_struct_wrapper::~xgl_update_as_copy_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_subresource_struct_wrapper::display_single_txt()
+void xgl_update_as_copy_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_AS_COPY = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_struct_wrapper::display_struct_members()
+void xgl_update_as_copy_struct_wrapper::display_struct_members()
{
- printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
+ printf("%*s %sdescriptorSet = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.descriptorSet));
+ printf("%*s %sdescriptorIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.descriptorIndex));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
}
// Output all struct elements, each on their own line
-void xgl_image_subresource_struct_wrapper::display_txt()
+void xgl_update_as_copy_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_struct_wrapper::display_full_txt()
+void xgl_update_as_copy_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_AS_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_draw_indirect_cmd_struct_wrapper class definition
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_copy_struct_wrapper class definition
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_draw_indirect_cmd_struct_wrapper::xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_draw_indirect_cmd_struct_wrapper::~xgl_draw_indirect_cmd_struct_wrapper() {}
+xgl_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_draw_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_image_copy_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DRAW_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_draw_indirect_cmd_struct_wrapper::display_struct_members()
+void xgl_image_copy_struct_wrapper::display_struct_members()
{
- printf("%*s %svertexCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vertexCount));
- printf("%*s %sinstanceCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.instanceCount));
- printf("%*s %sfirstVertex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstVertex));
- printf("%*s %sfirstInstance = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.firstInstance));
+ printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+ printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
}
// Output all struct elements, each on their own line
-void xgl_draw_indirect_cmd_struct_wrapper::display_txt()
+void xgl_image_copy_struct_wrapper::display_txt()
{
- printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_draw_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_image_copy_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DRAW_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.destOffset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.destOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.destSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (&m_struct.srcOffset) {
+ xgl_offset3d_struct_wrapper class3(&m_struct.srcOffset);
+ class3.set_indent(m_indent + 4);
+ class3.display_full_txt();
+ }
+ if (&m_struct.srcSubresource) {
+ xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+ class4.set_indent(m_indent + 4);
+ class4.display_full_txt();
+ }
}
-// xgl_image_view_create_info_struct_wrapper class definition
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_resolve_struct_wrapper class definition
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_view_create_info_struct_wrapper::xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_resolve_struct_wrapper::xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_view_create_info_struct_wrapper::~xgl_image_view_create_info_struct_wrapper() {}
+xgl_image_resolve_struct_wrapper::~xgl_image_resolve_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_view_create_info_struct_wrapper::display_single_txt()
+void xgl_image_resolve_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_RESOLVE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_view_create_info_struct_wrapper::display_struct_members()
+void xgl_image_resolve_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
- printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_VIEW_TYPE(m_struct.viewType));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
- printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
- printf("%*s %sminLod = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minLod));
+ printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
+ printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
}
// Output all struct elements, each on their own line
-void xgl_image_view_create_info_struct_wrapper::display_txt()
+void xgl_image_resolve_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_view_create_info_struct_wrapper::display_full_txt()
+void xgl_image_resolve_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_RESOLVE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.subresourceRange) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
+ if (&m_struct.extent) {
+ xgl_extent2d_struct_wrapper class0(&m_struct.extent);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
- if (&m_struct.channels) {
- xgl_channel_mapping_struct_wrapper class1(&m_struct.channels);
+ if (&m_struct.destOffset) {
+ xgl_offset2d_struct_wrapper class1(&m_struct.destOffset);
class1.set_indent(m_indent + 4);
class1.display_full_txt();
}
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
+ if (&m_struct.destSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
+ if (&m_struct.srcOffset) {
+ xgl_offset2d_struct_wrapper class3(&m_struct.srcOffset);
+ class3.set_indent(m_indent + 4);
+ class3.display_full_txt();
+ }
+ if (&m_struct.srcSubresource) {
+ xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
+ class4.set_indent(m_indent + 4);
+ class4.display_full_txt();
}
}
-// xgl_cmd_buffer_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_color_attachment_bind_info_struct_wrapper class definition
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_begin_info_struct_wrapper::xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_color_attachment_bind_info_struct_wrapper::xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_begin_info_struct_wrapper::~xgl_cmd_buffer_begin_info_struct_wrapper() {}
+xgl_color_attachment_bind_info_struct_wrapper::~xgl_color_attachment_bind_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_single_txt()
+void xgl_color_attachment_bind_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CMD_BUFFER_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_COLOR_ATTACHMENT_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_struct_members()
+void xgl_color_attachment_bind_info_struct_wrapper::display_struct_members()
+{
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+}
+
+// Output all struct elements, each on their own line
+void xgl_color_attachment_bind_info_struct_wrapper::display_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+// Output all struct elements, and for any structs pointed to, print complete contents
+void xgl_color_attachment_bind_info_struct_wrapper::display_full_txt()
+{
+ printf("%*sXGL_COLOR_ATTACHMENT_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ this->display_struct_members();
+}
+
+
+// xgl_dynamic_ds_state_create_info_struct_wrapper class definition
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+{
+ m_struct = *pInStruct;
+ m_origStructAddr = pInStruct;
+}
+xgl_dynamic_ds_state_create_info_struct_wrapper::~xgl_dynamic_ds_state_create_info_struct_wrapper() {}
+// Output 'structname = struct_address' on a single line
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_single_txt()
+{
+ printf(" %*sXGL_DYNAMIC_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+}
+
+// Private helper function that displays the members of the wrapped struct
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sminDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.minDepth));
+ printf("%*s %smaxDepth = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxDepth));
+ printf("%*s %sstencilReadMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilReadMask));
+ printf("%*s %sstencilWriteMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilWriteMask));
+ printf("%*s %sstencilFrontRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilFrontRef));
+ printf("%*s %sstencilBackRef = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilBackRef));
}
// Output all struct elements, each on their own line
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_txt()
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_begin_info_struct_wrapper::display_full_txt()
+void xgl_dynamic_ds_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CMD_BUFFER_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_image_copy_struct_wrapper class definition
-xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_memory_barrier_struct_wrapper class definition
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_copy_struct_wrapper::xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_copy_struct_wrapper::~xgl_image_copy_struct_wrapper() {}
+xgl_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_copy_struct_wrapper::display_single_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_copy_struct_wrapper::display_struct_members()
+void xgl_image_memory_barrier_struct_wrapper::display_struct_members()
{
- printf("%*s %ssrcSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcSubresource));
- printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.srcOffset));
- printf("%*s %sdestSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destSubresource));
- printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.destOffset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
+ printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
+ printf("%*s %soldLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.oldLayout));
+ printf("%*s %snewLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.newLayout));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
}
// Output all struct elements, each on their own line
-void xgl_image_copy_struct_wrapper::display_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_copy_struct_wrapper::display_full_txt()
+void xgl_image_memory_barrier_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ if (&m_struct.subresourceRange) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
class0.set_indent(m_indent + 4);
class0.display_full_txt();
}
- if (&m_struct.destOffset) {
- xgl_offset3d_struct_wrapper class1(&m_struct.destOffset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (&m_struct.destSubresource) {
- xgl_image_subresource_struct_wrapper class2(&m_struct.destSubresource);
- class2.set_indent(m_indent + 4);
- class2.display_full_txt();
- }
- if (&m_struct.srcOffset) {
- xgl_offset3d_struct_wrapper class3(&m_struct.srcOffset);
- class3.set_indent(m_indent + 4);
- class3.display_full_txt();
- }
- if (&m_struct.srcSubresource) {
- xgl_image_subresource_struct_wrapper class4(&m_struct.srcSubresource);
- class4.set_indent(m_indent + 4);
- class4.display_full_txt();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_pipeline_vp_state_create_info_struct_wrapper class definition
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vp_state_create_info_struct_wrapper::xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
+xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %snumViewports = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.numViewports));
- printf("%*s %sclipOrigin = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COORDINATE_ORIGIN(m_struct.clipOrigin));
- printf("%*s %sdepthMode = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DEPTH_MODE(m_struct.depthMode));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
+ printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
+ printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
+ printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.back) {
+ xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.front) {
+ xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_image_memory_barrier_struct_wrapper class definition
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_pipeline_barrier_struct_wrapper class definition
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_barrier_struct_wrapper::xgl_image_memory_barrier_struct_wrapper(const XGL_IMAGE_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_pipeline_barrier_struct_wrapper::xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_barrier_struct_wrapper::~xgl_image_memory_barrier_struct_wrapper() {}
+xgl_pipeline_barrier_struct_wrapper::~xgl_pipeline_barrier_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_pipeline_barrier_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
- printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
- printf("%*s %soldLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.oldLayout));
- printf("%*s %snewLayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.newLayout));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
- printf("%*s %ssubresourceRange = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresourceRange));
+ printf("%*s %seventCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.eventCount));
+ uint32_t i;
+ for (i = 0; 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_image_memory_barrier_struct_wrapper::display_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_pipeline_barrier_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.subresourceRange) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.subresourceRange);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_memory_alloc_buffer_info_struct_wrapper class definition
-xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_alloc_image_info_struct_wrapper class definition
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_alloc_buffer_info_struct_wrapper::~xgl_memory_alloc_buffer_info_struct_wrapper() {}
+xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_buffer_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_ALLOC_BUFFER_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_buffer_info_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
}
// Output all struct elements, each on their own line
-void xgl_memory_alloc_buffer_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_compute_pipeline_create_info_struct_wrapper class definition
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_update_sampler_textures_struct_wrapper class definition
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_compute_pipeline_create_info_struct_wrapper::xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_compute_pipeline_create_info_struct_wrapper::~xgl_compute_pipeline_create_info_struct_wrapper() {}
+xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_compute_pipeline_create_info_struct_wrapper::display_single_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_COMPUTE_PIPELINE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_compute_pipeline_create_info_struct_wrapper::display_struct_members()
+void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scs = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.cs));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
- printf("%*s %slastSetLayout = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.lastSetLayout));
- printf("%*s %slocalSizeX = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeX));
- printf("%*s %slocalSizeY = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeY));
- printf("%*s %slocalSizeZ = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.localSizeZ));
+ printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ uint32_t i;
+ for (i = 0; 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_compute_pipeline_create_info_struct_wrapper::display_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_txt()
{
- printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_compute_pipeline_create_info_struct_wrapper::display_full_txt()
+void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_COMPUTE_PIPELINE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.cs) {
- xgl_pipeline_shader_struct_wrapper class0(&m_struct.cs);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
+ uint32_t i;
+ for (i = 0; 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_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_peer_image_open_info_struct_wrapper class definition
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_peer_memory_open_info_struct_wrapper class definition
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_image_open_info_struct_wrapper::xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_peer_memory_open_info_struct_wrapper::xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_peer_image_open_info_struct_wrapper::~xgl_peer_image_open_info_struct_wrapper() {}
+xgl_peer_memory_open_info_struct_wrapper::~xgl_peer_memory_open_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_peer_image_open_info_struct_wrapper::display_single_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PEER_IMAGE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PEER_MEMORY_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_peer_image_open_info_struct_wrapper::display_struct_members()
+void xgl_peer_memory_open_info_struct_wrapper::display_struct_members()
{
- printf("%*s %soriginalImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalImage));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %soriginalMem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.originalMem));
}
// Output all struct elements, each on their own line
-void xgl_peer_image_open_info_struct_wrapper::display_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_peer_image_open_info_struct_wrapper::display_full_txt()
+void xgl_peer_memory_open_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PEER_IMAGE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PEER_MEMORY_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_dynamic_vp_state_create_info_struct_wrapper class definition
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_descriptor_type_count_struct_wrapper class definition
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_dynamic_vp_state_create_info_struct_wrapper::xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_dynamic_vp_state_create_info_struct_wrapper::~xgl_dynamic_vp_state_create_info_struct_wrapper() {}
+xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_single_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DYNAMIC_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_struct_members()
+void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sviewportAndScissorCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.viewportAndScissorCount));
- uint32_t i;
- for (i = 0; i<viewportAndScissorCount; i++) {
- printf("%*s %spViewports[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pViewports)[i]);
- }
- for (i = 0; i<viewportAndScissorCount; i++) {
- printf("%*s %spScissors[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pScissors)[i]);
- }
+ printf("%*s %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_dynamic_vp_state_create_info_struct_wrapper::display_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_txt()
{
- printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dynamic_vp_state_create_info_struct_wrapper::display_full_txt()
+void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DYNAMIC_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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_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_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_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_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_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
+xgl_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
+void xgl_dispatch_indirect_cmd_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 %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_physical_gpu_performance_struct_wrapper::display_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
+void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_render_pass_create_info_struct_wrapper class definition
-xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_descriptor_region_create_info_struct_wrapper class definition
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_descriptor_region_create_info_struct_wrapper::xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_render_pass_create_info_struct_wrapper::~xgl_render_pass_create_info_struct_wrapper() {}
+xgl_descriptor_region_create_info_struct_wrapper::~xgl_descriptor_region_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_render_pass_create_info_struct_wrapper::display_single_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_RENDER_PASS_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DESCRIPTOR_REGION_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_render_pass_create_info_struct_wrapper::display_struct_members()
+void xgl_descriptor_region_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %srenderArea = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.renderArea));
- printf("%*s %sframebuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.framebuffer));
- printf("%*s %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
+ printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
uint32_t i;
- for (i = 0; i<colorAttachmentCount; i++) {
- printf("%*s %spColorLoadOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_LOAD_OP(*m_struct.pColorLoadOps)[i]);
- }
- for (i = 0; i<colorAttachmentCount; i++) {
- printf("%*s %spColorStoreOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_STORE_OP(*m_struct.pColorStoreOps)[i]);
- }
- for (i = 0; i<colorAttachmentCount; i++) {
- printf("%*s %spColorLoadClearValues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorLoadClearValues)[i]);
+ for (i = 0; i<count; i++) {
+ printf("%*s %spTypeCount[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pTypeCount)[i]);
}
- printf("%*s %sdepthLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.depthLoadOp));
- printf("%*s %sdepthLoadClearValue = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthLoadClearValue));
- printf("%*s %sdepthStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.depthStoreOp));
- printf("%*s %sstencilLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.stencilLoadOp));
- printf("%*s %sstencilLoadClearValue = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilLoadClearValue));
- printf("%*s %sstencilStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.stencilStoreOp));
}
// Output all struct elements, each on their own line
-void xgl_render_pass_create_info_struct_wrapper::display_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_render_pass_create_info_struct_wrapper::display_full_txt()
+void xgl_descriptor_region_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_REGION_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
uint32_t i;
- for (i = 0; i<colorAttachmentCount; i++) {
- xgl_clear_color_struct_wrapper class0(&(m_struct.pColorLoadClearValues[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.renderArea) {
- xgl_rect_struct_wrapper class1(&m_struct.renderArea);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_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')
+// xgl_depth_stencil_view_create_info_struct_wrapper class definition
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
+xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_create_info_struct_wrapper::display_single_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_create_info_struct_wrapper::display_struct_members()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
+ printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
+ printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_buffer_create_info_struct_wrapper::display_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_create_info_struct_wrapper::display_full_txt()
+void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.msaaResolveSubResource) {
+ xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_cmd_buffer_graphics_begin_info_struct_wrapper class definition
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_query_pool_create_info_struct_wrapper class definition
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_cmd_buffer_graphics_begin_info_struct_wrapper::~xgl_cmd_buffer_graphics_begin_info_struct_wrapper() {}
+xgl_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_single_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_struct_members()
+void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %srenderPass = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.renderPass));
+ printf("%*s %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
+ printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
}
// Output all struct elements, each on their own line
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_cmd_buffer_graphics_begin_info_struct_wrapper::display_full_txt()
+void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_rect_struct_wrapper class definition
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::xgl_rect_struct_wrapper(const XGL_RECT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
-{
- m_struct = *pInStruct;
- m_origStructAddr = pInStruct;
-}
-xgl_rect_struct_wrapper::~xgl_rect_struct_wrapper() {}
-// Output 'structname = struct_address' on a single line
-void xgl_rect_struct_wrapper::display_single_txt()
-{
- printf(" %*sXGL_RECT = %p", m_indent, "", (void*)m_origStructAddr);
-}
-
-// Private helper function that displays the members of the wrapped struct
-void xgl_rect_struct_wrapper::display_struct_members()
-{
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
-}
-
-// Output all struct elements, each on their own line
-void xgl_rect_struct_wrapper::display_txt()
-{
- printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
-}
-
-// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_rect_struct_wrapper::display_full_txt()
-{
- printf("%*sXGL_RECT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
- this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent2d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.offset) {
- xgl_offset2d_struct_wrapper class1(&m_struct.offset);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
-}
-
-
-// xgl_buffer_memory_barrier_struct_wrapper class definition
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_cmd_buffer_create_info_struct_wrapper class definition
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_memory_barrier_struct_wrapper::xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_cmd_buffer_create_info_struct_wrapper::xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_memory_barrier_struct_wrapper::~xgl_buffer_memory_barrier_struct_wrapper() {}
+xgl_cmd_buffer_create_info_struct_wrapper::~xgl_cmd_buffer_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_memory_barrier_struct_wrapper::display_single_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CMD_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_memory_barrier_struct_wrapper::display_struct_members()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %soutputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.outputMask));
- printf("%*s %sinputMask = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.inputMask));
- printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
- printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
- printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+ printf("%*s %squeueType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUEUE_TYPE(m_struct.queueType));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_buffer_memory_barrier_struct_wrapper::display_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_memory_barrier_struct_wrapper::display_full_txt()
+void xgl_cmd_buffer_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CMD_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_pipeline_ds_state_create_info_struct_wrapper class definition
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_depth_stencil_bind_info_struct_wrapper class definition
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_ds_state_create_info_struct_wrapper::xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_ds_state_create_info_struct_wrapper::~xgl_pipeline_ds_state_create_info_struct_wrapper() {}
+xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_single_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_DS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_struct_members()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %sdepthTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthTestEnable) ? "TRUE" : "FALSE");
- printf("%*s %sdepthWriteEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthWriteEnable) ? "TRUE" : "FALSE");
- printf("%*s %sdepthFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.depthFunc));
- printf("%*s %sdepthBoundsEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.depthBoundsEnable) ? "TRUE" : "FALSE");
- printf("%*s %sstencilTestEnable = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilTestEnable) ? "TRUE" : "FALSE");
- printf("%*s %sfront = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.front));
- printf("%*s %sback = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.back));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_ds_state_create_info_struct_wrapper::display_full_txt()
+void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_DS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.back) {
- xgl_stencil_op_state_struct_wrapper class0(&m_struct.back);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
- if (&m_struct.front) {
- xgl_stencil_op_state_struct_wrapper class1(&m_struct.front);
- class1.set_indent(m_indent + 4);
- class1.display_full_txt();
- }
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_descriptor_type_count_struct_wrapper class definition
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_requirements_struct_wrapper class definition
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_descriptor_type_count_struct_wrapper::xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_requirements_struct_wrapper::xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_descriptor_type_count_struct_wrapper::~xgl_descriptor_type_count_struct_wrapper() {}
+xgl_memory_requirements_struct_wrapper::~xgl_memory_requirements_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_descriptor_type_count_struct_wrapper::display_single_txt()
+void xgl_memory_requirements_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DESCRIPTOR_TYPE_COUNT = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_descriptor_type_count_struct_wrapper::display_struct_members()
+void xgl_memory_requirements_struct_wrapper::display_struct_members()
{
- printf("%*s %stype = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.type));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+ printf("%*s %salignment = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.alignment));
+ printf("%*s %sgranularity = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.granularity));
+ printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+ printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
}
// Output all struct elements, each on their own line
-void xgl_descriptor_type_count_struct_wrapper::display_txt()
+void xgl_memory_requirements_struct_wrapper::display_txt()
{
- printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_descriptor_type_count_struct_wrapper::display_full_txt()
+void xgl_memory_requirements_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DESCRIPTOR_TYPE_COUNT struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_update_sampler_textures_struct_wrapper class definition
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_queue_semaphore_open_info_struct_wrapper class definition
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_sampler_textures_struct_wrapper::xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_queue_semaphore_open_info_struct_wrapper::xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_sampler_textures_struct_wrapper::~xgl_update_sampler_textures_struct_wrapper() {}
+xgl_queue_semaphore_open_info_struct_wrapper::~xgl_queue_semaphore_open_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_sampler_textures_struct_wrapper::display_single_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_SAMPLER_TEXTURES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_QUEUE_SEMAPHORE_OPEN_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_sampler_textures_struct_wrapper::display_struct_members()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spSamplerImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pSamplerImageViews)[i]);
- }
+ 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_update_sampler_textures_struct_wrapper::display_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_sampler_textures_struct_wrapper::display_full_txt()
+void xgl_queue_semaphore_open_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_SAMPLER_TEXTURES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_QUEUE_SEMAPHORE_OPEN_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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')
+// 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_query_pool_create_info_struct_wrapper::xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_query_pool_create_info_struct_wrapper::~xgl_query_pool_create_info_struct_wrapper() {}
+xgl_memory_barrier_struct_wrapper::~xgl_memory_barrier_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_query_pool_create_info_struct_wrapper::display_single_txt()
+void xgl_memory_barrier_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_QUERY_POOL_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_BARRIER = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_query_pool_create_info_struct_wrapper::display_struct_members()
+void xgl_memory_barrier_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %squeryType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_QUERY_TYPE(m_struct.queryType));
- printf("%*s %sslots = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.slots));
+ printf("%*s %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_query_pool_create_info_struct_wrapper::display_txt()
+void xgl_memory_barrier_struct_wrapper::display_txt()
{
- printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_query_pool_create_info_struct_wrapper::display_full_txt()
+void xgl_memory_barrier_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_QUERY_POOL_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_BARRIER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_event_create_info_struct_wrapper class definition
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_physical_gpu_performance_struct_wrapper class definition
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_physical_gpu_performance_struct_wrapper::xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
+xgl_physical_gpu_performance_struct_wrapper::~xgl_physical_gpu_performance_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_event_create_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PHYSICAL_GPU_PERFORMANCE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_event_create_info_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_performance_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %smaxGpuClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.maxGpuClock));
+ printf("%*s %saluPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.aluPerClock));
+ printf("%*s %stexPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.texPerClock));
+ printf("%*s %sprimsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.primsPerClock));
+ printf("%*s %spixelsPerClock = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.pixelsPerClock));
}
// Output all struct elements, each on their own line
-void xgl_event_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_txt()
{
- printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_event_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_performance_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_PERFORMANCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_offset2d_struct_wrapper class definition
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_channel_mapping_struct_wrapper class definition
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset2d_struct_wrapper::xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_channel_mapping_struct_wrapper::xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset2d_struct_wrapper::~xgl_offset2d_struct_wrapper() {}
+xgl_channel_mapping_struct_wrapper::~xgl_channel_mapping_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_offset2d_struct_wrapper::display_single_txt()
+void xgl_channel_mapping_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_OFFSET2D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CHANNEL_MAPPING = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_offset2d_struct_wrapper::display_struct_members()
+void xgl_channel_mapping_struct_wrapper::display_struct_members()
{
- printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
- printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
+ printf("%*s %sr = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.r));
+ printf("%*s %sg = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.g));
+ printf("%*s %sb = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.b));
+ printf("%*s %sa = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_CHANNEL_SWIZZLE(m_struct.a));
}
// Output all struct elements, each on their own line
-void xgl_offset2d_struct_wrapper::display_txt()
+void xgl_channel_mapping_struct_wrapper::display_txt()
{
- printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset2d_struct_wrapper::display_full_txt()
+void xgl_channel_mapping_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_OFFSET2D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CHANNEL_MAPPING struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_update_buffers_struct_wrapper class definition
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_clear_color_struct_wrapper class definition
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_buffers_struct_wrapper::xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_clear_color_struct_wrapper::xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_buffers_struct_wrapper::~xgl_update_buffers_struct_wrapper() {}
+xgl_clear_color_struct_wrapper::~xgl_clear_color_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_buffers_struct_wrapper::display_single_txt()
+void xgl_clear_color_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_BUFFERS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_CLEAR_COLOR = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_buffers_struct_wrapper::display_struct_members()
+void xgl_clear_color_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spBufferViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pBufferViews)[i]);
- }
+ 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_update_buffers_struct_wrapper::display_txt()
+void xgl_clear_color_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_buffers_struct_wrapper::display_full_txt()
+void xgl_clear_color_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_BUFFERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_CLEAR_COLOR struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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);
+ 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_memory_ref_struct_wrapper class definition
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_memory_ref_struct_wrapper::xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_dynamic_cb_state_create_info_struct_wrapper::xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_ref_struct_wrapper::~xgl_memory_ref_struct_wrapper() {}
+xgl_dynamic_cb_state_create_info_struct_wrapper::~xgl_dynamic_cb_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_ref_struct_wrapper::display_single_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_REF = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_DYNAMIC_CB_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_ref_struct_wrapper::display_struct_members()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %smem = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.mem));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %ssType = %s\n", m_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_memory_ref_struct_wrapper::display_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_ref_struct_wrapper::display_full_txt()
+void xgl_dynamic_cb_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_REF struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DYNAMIC_CB_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_buffer_view_attach_info_struct_wrapper class definition
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_view_create_info_struct_wrapper class definition
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_view_create_info_struct_wrapper::xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
+xgl_buffer_view_create_info_struct_wrapper::~xgl_buffer_view_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
+void xgl_buffer_view_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %sbuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.buffer));
+ printf("%*s %sviewType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_BUFFER_VIEW_TYPE(m_struct.viewType));
+ printf("%*s %sstride = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.stride));
+ printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
+ printf("%*s %schannels = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.channels));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.offset));
+ printf("%*s %srange = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.range));
}
// Output all struct elements, each on their own line
-void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
+void xgl_buffer_view_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.channels) {
+ xgl_channel_mapping_struct_wrapper class0(&m_struct.channels);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_pipeline_vertex_input_create_info_struct_wrapper class definition
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_sampler_create_info_struct_wrapper class definition
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_sampler_create_info_struct_wrapper::xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_vertex_input_create_info_struct_wrapper::~xgl_pipeline_vertex_input_create_info_struct_wrapper() {}
+xgl_sampler_create_info_struct_wrapper::~xgl_sampler_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_single_txt()
+void xgl_sampler_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_SAMPLER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_struct_members()
+void xgl_sampler_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sbindingCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.bindingCount));
- uint32_t i;
- for (i = 0; i<bindingCount; i++) {
- printf("%*s %spVertexBindingDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexBindingDescriptions)[i]);
- }
- printf("%*s %sattributeCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.attributeCount));
- for (i = 0; i<attributeCount; i++) {
- printf("%*s %spVertexAttributeDescriptions[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pVertexAttributeDescriptions)[i]);
- }
+ printf("%*s %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_pipeline_vertex_input_create_info_struct_wrapper::display_txt()
+void xgl_sampler_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_vertex_input_create_info_struct_wrapper::display_full_txt()
+void xgl_sampler_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_VERTEX_INPUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SAMPLER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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_gpu_compatibility_info_struct_wrapper class definition
-xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {}
+xgl_event_wait_info_struct_wrapper::~xgl_event_wait_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt()
+void xgl_event_wait_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_GPU_COMPATIBILITY_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_EVENT_WAIT_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_gpu_compatibility_info_struct_wrapper::display_struct_members()
+void xgl_event_wait_info_struct_wrapper::display_struct_members()
{
- printf("%*s %scompatibilityFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.compatibilityFlags));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_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_gpu_compatibility_info_struct_wrapper::display_txt()
+void xgl_event_wait_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_gpu_compatibility_info_struct_wrapper::display_full_txt()
+void xgl_event_wait_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EVENT_WAIT_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_shader_create_info_struct_wrapper class definition
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_image_copy_struct_wrapper class definition
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_shader_create_info_struct_wrapper::xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_image_copy_struct_wrapper::xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_shader_create_info_struct_wrapper::~xgl_shader_create_info_struct_wrapper() {}
+xgl_buffer_image_copy_struct_wrapper::~xgl_buffer_image_copy_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_shader_create_info_struct_wrapper::display_single_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_SHADER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_IMAGE_COPY = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_shader_create_info_struct_wrapper::display_struct_members()
+void xgl_buffer_image_copy_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %scodeSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.codeSize));
- printf("%*s %spCode = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pCode));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sbufferOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.bufferOffset));
+ printf("%*s %simageSubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageSubresource));
+ printf("%*s %simageOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageOffset));
+ printf("%*s %simageExtent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.imageExtent));
}
// Output all struct elements, each on their own line
-void xgl_shader_create_info_struct_wrapper::display_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_txt()
{
- printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_shader_create_info_struct_wrapper::display_full_txt()
+void xgl_buffer_image_copy_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_SHADER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_IMAGE_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
+ if (&m_struct.imageExtent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.imageExtent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.imageOffset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.imageOffset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.imageSubresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.imageSubresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
}
}
-// xgl_offset3d_struct_wrapper class definition
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_event_create_info_struct_wrapper class definition
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_event_create_info_struct_wrapper::xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
+xgl_event_create_info_struct_wrapper::~xgl_event_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_offset3d_struct_wrapper::display_single_txt()
+void xgl_event_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_EVENT_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_offset3d_struct_wrapper::display_struct_members()
+void xgl_event_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sx = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.x));
- printf("%*s %sy = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.y));
- printf("%*s %sz = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.z));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_offset3d_struct_wrapper::display_txt()
+void xgl_event_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_offset3d_struct_wrapper::display_full_txt()
+void xgl_event_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EVENT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_layer_create_info_struct_wrapper class definition
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_physical_gpu_properties_struct_wrapper class definition
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_physical_gpu_properties_struct_wrapper::xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
+xgl_physical_gpu_properties_struct_wrapper::~xgl_physical_gpu_properties_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_layer_create_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PHYSICAL_GPU_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_layer_create_info_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_properties_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
+ printf("%*s %sapiVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.apiVersion));
+ printf("%*s %sdriverVersion = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.driverVersion));
+ printf("%*s %svendorId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.vendorId));
+ printf("%*s %sdeviceId = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.deviceId));
+ printf("%*s %sgpuType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PHYSICAL_GPU_TYPE(m_struct.gpuType));
uint32_t i;
- for (i = 0; i<layerCount; i++) {
- printf("%*s %sppActiveLayerNames = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.ppActiveLayerNames)[0]);
+ 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_layer_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_txt()
{
- printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_layer_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_properties_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_depth_stencil_view_create_info_struct_wrapper class definition
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_view_attach_info_struct_wrapper class definition
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_depth_stencil_view_create_info_struct_wrapper::xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_view_attach_info_struct_wrapper::xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_depth_stencil_view_create_info_struct_wrapper::~xgl_depth_stencil_view_create_info_struct_wrapper() {}
+xgl_image_view_attach_info_struct_wrapper::~xgl_image_view_attach_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_single_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_struct_members()
+void xgl_image_view_attach_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.image));
- printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %smsaaResolveImage = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.msaaResolveImage));
- printf("%*s %smsaaResolveSubResource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.msaaResolveSubResource));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
+ printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
}
// Output all struct elements, each on their own line
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_view_create_info_struct_wrapper::display_full_txt()
+void xgl_image_view_attach_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DEPTH_STENCIL_VIEW_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.msaaResolveSubResource) {
- xgl_image_subresource_range_struct_wrapper class0(&m_struct.msaaResolveSubResource);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_depth_stencil_bind_info_struct_wrapper class definition
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_alloc_buffer_info_struct_wrapper class definition
+xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_depth_stencil_bind_info_struct_wrapper::xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_alloc_buffer_info_struct_wrapper::xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_depth_stencil_bind_info_struct_wrapper::~xgl_depth_stencil_bind_info_struct_wrapper() {}
+xgl_memory_alloc_buffer_info_struct_wrapper::~xgl_memory_alloc_buffer_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DEPTH_STENCIL_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_ALLOC_BUFFER_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_depth_stencil_bind_info_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
- printf("%*s %slayout = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_LAYOUT(m_struct.layout));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
}
// Output all struct elements, each on their own line
-void xgl_depth_stencil_bind_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_depth_stencil_bind_info_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_buffer_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DEPTH_STENCIL_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_BUFFER_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_image_memory_requirements_struct_wrapper class definition
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_copy_struct_wrapper class definition
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_copy_struct_wrapper::xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
+xgl_buffer_copy_struct_wrapper::~xgl_buffer_copy_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
+void xgl_buffer_copy_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_COPY = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
+void xgl_buffer_copy_struct_wrapper::display_struct_members()
{
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %ssrcOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.srcOffset));
+ printf("%*s %sdestOffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.destOffset));
+ printf("%*s %scopySize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.copySize));
}
// Output all struct elements, each on their own line
-void xgl_image_memory_requirements_struct_wrapper::display_txt()
+void xgl_buffer_copy_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
+void xgl_buffer_copy_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_COPY struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_image_subresource_range_struct_wrapper class definition
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_memory_bind_info_struct_wrapper class definition
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_range_struct_wrapper::xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_memory_bind_info_struct_wrapper::xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_subresource_range_struct_wrapper::~xgl_image_subresource_range_struct_wrapper() {}
+xgl_image_memory_bind_info_struct_wrapper::~xgl_image_memory_bind_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_subresource_range_struct_wrapper::display_single_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_SUBRESOURCE_RANGE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_MEMORY_BIND_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_subresource_range_struct_wrapper::display_struct_members()
+void xgl_image_memory_bind_info_struct_wrapper::display_struct_members()
{
- printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
- printf("%*s %sbaseMipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseMipLevel));
- printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
- printf("%*s %sbaseArraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.baseArraySlice));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
+ printf("%*s %ssubresource = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.subresource));
+ printf("%*s %soffset = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.offset));
+ printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
}
// Output all struct elements, each on their own line
-void xgl_image_subresource_range_struct_wrapper::display_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_subresource_range_struct_wrapper::display_full_txt()
+void xgl_image_memory_bind_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_SUBRESOURCE_RANGE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_BIND_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (&m_struct.extent) {
+ xgl_extent3d_struct_wrapper class0(&m_struct.extent);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.offset) {
+ xgl_offset3d_struct_wrapper class1(&m_struct.offset);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (&m_struct.subresource) {
+ xgl_image_subresource_struct_wrapper class2(&m_struct.subresource);
+ class2.set_indent(m_indent + 4);
+ class2.display_full_txt();
+ }
}
-// xgl_update_images_struct_wrapper class definition
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_memory_requirements_struct_wrapper class definition
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_images_struct_wrapper::xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_memory_requirements_struct_wrapper::xgl_image_memory_requirements_struct_wrapper(const XGL_IMAGE_MEMORY_REQUIREMENTS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_images_struct_wrapper::~xgl_update_images_struct_wrapper() {}
+xgl_image_memory_requirements_struct_wrapper::~xgl_image_memory_requirements_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_images_struct_wrapper::display_single_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_IMAGES = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_MEMORY_REQUIREMENTS = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_images_struct_wrapper::display_struct_members()
+void xgl_image_memory_requirements_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sdescriptorType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_DESCRIPTOR_TYPE(m_struct.descriptorType));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spImageViews[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pImageViews)[i]);
- }
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
+ printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
}
// Output all struct elements, each on their own line
-void xgl_update_images_struct_wrapper::display_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_images_struct_wrapper::display_full_txt()
+void xgl_image_memory_requirements_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_IMAGES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_MEMORY_REQUIREMENTS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; 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')
+// 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_dispatch_indirect_cmd_struct_wrapper::xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_dispatch_indirect_cmd_struct_wrapper::~xgl_dispatch_indirect_cmd_struct_wrapper() {}
+xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_single_txt()
+void xgl_pipeline_shader_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DISPATCH_INDIRECT_CMD = %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_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));
+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_dispatch_indirect_cmd_struct_wrapper::display_txt()
+void xgl_pipeline_shader_struct_wrapper::display_txt()
{
- printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_dispatch_indirect_cmd_struct_wrapper::display_full_txt()
+void xgl_pipeline_shader_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DISPATCH_INDIRECT_CMD struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; 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_extent3d_struct_wrapper class definition
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_offset3d_struct_wrapper::xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
+xgl_offset3d_struct_wrapper::~xgl_offset3d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_extent3d_struct_wrapper::display_single_txt()
+void xgl_offset3d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_OFFSET3D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_extent3d_struct_wrapper::display_struct_members()
+void xgl_offset3d_struct_wrapper::display_struct_members()
{
- printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
- printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
- printf("%*s %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
+ printf("%*s %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_extent3d_struct_wrapper::display_txt()
+void xgl_offset3d_struct_wrapper::display_txt()
{
- printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_extent3d_struct_wrapper::display_full_txt()
+void xgl_offset3d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_OFFSET3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_clear_color_value_struct_wrapper class definition
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_view_attach_info_struct_wrapper class definition
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_value_struct_wrapper::xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_view_attach_info_struct_wrapper::xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_clear_color_value_struct_wrapper::~xgl_clear_color_value_struct_wrapper() {}
+xgl_buffer_view_attach_info_struct_wrapper::~xgl_buffer_view_attach_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_clear_color_value_struct_wrapper::display_single_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_CLEAR_COLOR_VALUE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_VIEW_ATTACH_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_clear_color_value_struct_wrapper::display_struct_members()
+void xgl_buffer_view_attach_info_struct_wrapper::display_struct_members()
{
- uint32_t i;
- for (i = 0; i<4; i++) {
- printf("%*s %sfloatColor[%u] = %f\n", m_indent, "", &m_dummy_prefix, i, (m_struct.floatColor)[i]);
- }
- for (i = 0; i<4; i++) {
- printf("%*s %srawColor[%u] = %u\n", m_indent, "", &m_dummy_prefix, i, (m_struct.rawColor)[i]);
- }
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %sview = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.view));
}
// Output all struct elements, each on their own line
-void xgl_clear_color_value_struct_wrapper::display_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_clear_color_value_struct_wrapper::display_full_txt()
+void xgl_buffer_view_attach_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_CLEAR_COLOR_VALUE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_VIEW_ATTACH_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_memory_alloc_image_info_struct_wrapper class definition
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_extent3d_struct_wrapper class definition
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_alloc_image_info_struct_wrapper::xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_extent3d_struct_wrapper::xgl_extent3d_struct_wrapper(const XGL_EXTENT3D* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_memory_alloc_image_info_struct_wrapper::~xgl_memory_alloc_image_info_struct_wrapper() {}
+xgl_extent3d_struct_wrapper::~xgl_extent3d_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_memory_alloc_image_info_struct_wrapper::display_single_txt()
+void xgl_extent3d_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_MEMORY_ALLOC_IMAGE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_EXTENT3D = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_memory_alloc_image_info_struct_wrapper::display_struct_members()
+void xgl_extent3d_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sformatClass = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_FORMAT_CLASS(m_struct.formatClass));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
+ printf("%*s %swidth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.width));
+ printf("%*s %sheight = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.height));
+ printf("%*s %sdepth = %i\n", m_indent, "", &m_dummy_prefix, (m_struct.depth));
}
// Output all struct elements, each on their own line
-void xgl_memory_alloc_image_info_struct_wrapper::display_txt()
+void xgl_extent3d_struct_wrapper::display_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_memory_alloc_image_info_struct_wrapper::display_full_txt()
+void xgl_extent3d_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_MEMORY_ALLOC_IMAGE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_EXTENT3D struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_device_queue_create_info_struct_wrapper class definition
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_sampler_image_view_info_struct_wrapper class definition
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_device_queue_create_info_struct_wrapper::xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_sampler_image_view_info_struct_wrapper::xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_device_queue_create_info_struct_wrapper::~xgl_device_queue_create_info_struct_wrapper() {}
+xgl_sampler_image_view_info_struct_wrapper::~xgl_sampler_image_view_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_device_queue_create_info_struct_wrapper::display_single_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_DEVICE_QUEUE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_SAMPLER_IMAGE_VIEW_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_device_queue_create_info_struct_wrapper::display_struct_members()
+void xgl_sampler_image_view_info_struct_wrapper::display_struct_members()
{
- printf("%*s %squeueNodeIndex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueNodeIndex));
- printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+ printf("%*s %spSampler = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pSampler));
+ printf("%*s %spImageView = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.pImageView));
}
// Output all struct elements, each on their own line
-void xgl_device_queue_create_info_struct_wrapper::display_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_device_queue_create_info_struct_wrapper::display_full_txt()
+void xgl_sampler_image_view_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_DEVICE_QUEUE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_SAMPLER_IMAGE_VIEW_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pImageView) {
+ xgl_image_view_attach_info_struct_wrapper class0(m_struct.pImageView);
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
}
-// xgl_stencil_op_state_struct_wrapper class definition
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_image_subresource_struct_wrapper class definition
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_stencil_op_state_struct_wrapper::xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_image_subresource_struct_wrapper::xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_stencil_op_state_struct_wrapper::~xgl_stencil_op_state_struct_wrapper() {}
+xgl_image_subresource_struct_wrapper::~xgl_image_subresource_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_stencil_op_state_struct_wrapper::display_single_txt()
+void xgl_image_subresource_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_STENCIL_OP_STATE = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_IMAGE_SUBRESOURCE = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_stencil_op_state_struct_wrapper::display_struct_members()
+void xgl_image_subresource_struct_wrapper::display_struct_members()
{
- printf("%*s %sstencilFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilFailOp));
- printf("%*s %sstencilPassOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilPassOp));
- printf("%*s %sstencilDepthFailOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STENCIL_OP(m_struct.stencilDepthFailOp));
- printf("%*s %sstencilFunc = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_COMPARE_FUNC(m_struct.stencilFunc));
+ printf("%*s %saspect = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_ASPECT(m_struct.aspect));
+ printf("%*s %smipLevel = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevel));
+ printf("%*s %sarraySlice = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySlice));
}
// Output all struct elements, each on their own line
-void xgl_stencil_op_state_struct_wrapper::display_txt()
+void xgl_image_subresource_struct_wrapper::display_txt()
{
- printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_stencil_op_state_struct_wrapper::display_full_txt()
+void xgl_image_subresource_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_STENCIL_OP_STATE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_IMAGE_SUBRESOURCE struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
-// xgl_pipeline_shader_struct_wrapper class definition
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_layer_create_info_struct_wrapper class definition
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_struct_wrapper::xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_layer_create_info_struct_wrapper::xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_shader_struct_wrapper::~xgl_pipeline_shader_struct_wrapper() {}
+xgl_layer_create_info_struct_wrapper::~xgl_layer_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_shader_struct_wrapper::display_single_txt()
+void xgl_layer_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_SHADER = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_LAYER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_shader_struct_wrapper::display_struct_members()
+void xgl_layer_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sstage = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_PIPELINE_SHADER_STAGE(m_struct.stage));
- printf("%*s %sshader = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.shader));
- printf("%*s %slinkConstBufferCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.linkConstBufferCount));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %slayerCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.layerCount));
uint32_t i;
- for (i = 0; i<linkConstBufferCount; i++) {
- printf("%*s %spLinkConstBufferInfo[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pLinkConstBufferInfo)[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_pipeline_shader_struct_wrapper::display_txt()
+void xgl_layer_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_shader_struct_wrapper::display_full_txt()
+void xgl_layer_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_SHADER struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_LAYER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- uint32_t i;
- for (i = 0; i<linkConstBufferCount; i++) {
- xgl_link_const_buffer_struct_wrapper class0(&(m_struct.pLinkConstBufferInfo[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_queue_semaphore_create_info_struct_wrapper class definition
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_queue_semaphore_create_info_struct_wrapper::xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_queue_semaphore_create_info_struct_wrapper::~xgl_queue_semaphore_create_info_struct_wrapper() {}
+xgl_pipeline_vp_state_create_info_struct_wrapper::~xgl_pipeline_vp_state_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_queue_semaphore_create_info_struct_wrapper::display_single_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_QUEUE_SEMAPHORE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PIPELINE_VP_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_queue_semaphore_create_info_struct_wrapper::display_struct_members()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sinitialCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.initialCount));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %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_queue_semaphore_create_info_struct_wrapper::display_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_queue_semaphore_create_info_struct_wrapper::display_full_txt()
+void xgl_pipeline_vp_state_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_QUEUE_SEMAPHORE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PIPELINE_VP_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
-// xgl_pipeline_statistics_data_struct_wrapper class definition
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_buffer_create_info_struct_wrapper class definition
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_statistics_data_struct_wrapper::xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_buffer_create_info_struct_wrapper::xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_statistics_data_struct_wrapper::~xgl_pipeline_statistics_data_struct_wrapper() {}
+xgl_buffer_create_info_struct_wrapper::~xgl_buffer_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_statistics_data_struct_wrapper::display_single_txt()
+void xgl_buffer_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_STATISTICS_DATA = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_BUFFER_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_statistics_data_struct_wrapper::display_struct_members()
+void xgl_buffer_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sfsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.fsInvocations));
- printf("%*s %scPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cPrimitives));
- printf("%*s %scInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.cInvocations));
- printf("%*s %svsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.vsInvocations));
- printf("%*s %sgsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsInvocations));
- printf("%*s %sgsPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.gsPrimitives));
- printf("%*s %siaPrimitives = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaPrimitives));
- printf("%*s %siaVertices = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.iaVertices));
- printf("%*s %stcsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tcsInvocations));
- printf("%*s %stesInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.tesInvocations));
- printf("%*s %scsInvocations = %lu\n", m_indent, "", &m_dummy_prefix, (m_struct.csInvocations));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %ssize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.size));
+ printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
+ printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
}
// Output all struct elements, each on their own line
-void xgl_pipeline_statistics_data_struct_wrapper::display_txt()
+void xgl_buffer_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_statistics_data_struct_wrapper::display_full_txt()
+void xgl_buffer_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_STATISTICS_DATA struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_BUFFER_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_vertex_input_attribute_description_struct_wrapper class definition
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_render_pass_create_info_struct_wrapper class definition
+xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_vertex_input_attribute_description_struct_wrapper::xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_render_pass_create_info_struct_wrapper::xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_vertex_input_attribute_description_struct_wrapper::~xgl_vertex_input_attribute_description_struct_wrapper() {}
+xgl_render_pass_create_info_struct_wrapper::~xgl_render_pass_create_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_single_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_RENDER_PASS_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_vertex_input_attribute_description_struct_wrapper::display_struct_members()
+void xgl_render_pass_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sbinding = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.binding));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %soffsetInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.offsetInBytes));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %srenderArea = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.renderArea));
+ printf("%*s %sframebuffer = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.framebuffer));
+ printf("%*s %scolorAttachmentCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.colorAttachmentCount));
+ uint32_t i;
+ for (i = 0; i<colorAttachmentCount; i++) {
+ printf("%*s %spColorLoadOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_LOAD_OP(*m_struct.pColorLoadOps)[i]);
+ }
+ for (i = 0; i<colorAttachmentCount; i++) {
+ printf("%*s %spColorStoreOps[%u] = %s\n", m_indent, "", &m_dummy_prefix, i, string_XGL_ATTACHMENT_STORE_OP(*m_struct.pColorStoreOps)[i]);
+ }
+ for (i = 0; i<colorAttachmentCount; i++) {
+ printf("%*s %spColorLoadClearValues[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (void*)(m_struct.pColorLoadClearValues)[i]);
+ }
+ printf("%*s %sdepthLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.depthLoadOp));
+ printf("%*s %sdepthLoadClearValue = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.depthLoadClearValue));
+ printf("%*s %sdepthStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.depthStoreOp));
+ printf("%*s %sstencilLoadOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_LOAD_OP(m_struct.stencilLoadOp));
+ printf("%*s %sstencilLoadClearValue = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.stencilLoadClearValue));
+ printf("%*s %sstencilStoreOp = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_ATTACHMENT_STORE_OP(m_struct.stencilStoreOp));
}
// Output all struct elements, each on their own line
-void xgl_vertex_input_attribute_description_struct_wrapper::display_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_attribute_description_struct_wrapper::display_full_txt()
+void xgl_render_pass_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_RENDER_PASS_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ uint32_t i;
+ for (i = 0; i<colorAttachmentCount; i++) {
+ xgl_clear_color_struct_wrapper class0(&(m_struct.pColorLoadClearValues[i]));
+ class0.set_indent(m_indent + 4);
+ class0.display_full_txt();
+ }
+ if (&m_struct.renderArea) {
+ xgl_rect_struct_wrapper class1(&m_struct.renderArea);
+ class1.set_indent(m_indent + 4);
+ class1.display_full_txt();
+ }
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_vertex_input_binding_description_struct_wrapper class definition
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_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_vertex_input_binding_description_struct_wrapper::xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_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_vertex_input_binding_description_struct_wrapper::~xgl_vertex_input_binding_description_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_vertex_input_binding_description_struct_wrapper::display_single_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION = %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_vertex_input_binding_description_struct_wrapper::display_struct_members()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_struct_members()
{
- printf("%*s %sstrideInBytes = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.strideInBytes));
- printf("%*s %sstepRate = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_VERTEX_INPUT_STEP_RATE(m_struct.stepRate));
+ printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
+ printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
+ printf("%*s %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_vertex_input_binding_description_struct_wrapper::display_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_vertex_input_binding_description_struct_wrapper::display_full_txt()
+void xgl_descriptor_set_layout_create_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_VERTEX_INPUT_BINDING_DESCRIPTION struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
+ if (m_struct.pNext) {
+ dynamic_display_full_txt(m_struct.pNext, m_indent);
+ }
}
-// xgl_update_samplers_struct_wrapper class definition
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_gpu_compatibility_info_struct_wrapper class definition
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_samplers_struct_wrapper::xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_gpu_compatibility_info_struct_wrapper::xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_update_samplers_struct_wrapper::~xgl_update_samplers_struct_wrapper() {}
+xgl_gpu_compatibility_info_struct_wrapper::~xgl_gpu_compatibility_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_update_samplers_struct_wrapper::display_single_txt()
+void xgl_gpu_compatibility_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_UPDATE_SAMPLERS = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_GPU_COMPATIBILITY_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_update_samplers_struct_wrapper::display_struct_members()
+void xgl_gpu_compatibility_info_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %sindex = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.index));
- printf("%*s %scount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.count));
- uint32_t i;
- for (i = 0; i<count; i++) {
- printf("%*s %spSamplers[%u] = %p\n", m_indent, "", &m_dummy_prefix, i, (m_struct.pSamplers)[i]);
- }
+ printf("%*s %scompatibilityFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.compatibilityFlags));
}
// Output all struct elements, each on their own line
-void xgl_update_samplers_struct_wrapper::display_txt()
+void xgl_gpu_compatibility_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_update_samplers_struct_wrapper::display_full_txt()
+void xgl_gpu_compatibility_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_UPDATE_SAMPLERS struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_GPU_COMPATIBILITY_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
-// xgl_image_create_info_struct_wrapper class definition
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_memory_alloc_info_struct_wrapper class definition
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_create_info_struct_wrapper::xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_memory_alloc_info_struct_wrapper::xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_image_create_info_struct_wrapper::~xgl_image_create_info_struct_wrapper() {}
+xgl_memory_alloc_info_struct_wrapper::~xgl_memory_alloc_info_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_image_create_info_struct_wrapper::display_single_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_IMAGE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_MEMORY_ALLOC_INFO = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_image_create_info_struct_wrapper::display_struct_members()
+void xgl_memory_alloc_info_struct_wrapper::display_struct_members()
{
printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %simageType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TYPE(m_struct.imageType));
- printf("%*s %sformat = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_FORMAT(m_struct.format));
- printf("%*s %sextent = %p\n", m_indent, "", &m_dummy_prefix, (void*)&(m_struct.extent));
- printf("%*s %smipLevels = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.mipLevels));
- printf("%*s %sarraySize = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.arraySize));
- printf("%*s %ssamples = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.samples));
- printf("%*s %stiling = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_IMAGE_TILING(m_struct.tiling));
- printf("%*s %susage = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.usage));
- printf("%*s %sflags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.flags));
+ printf("%*s %sallocationSize = %p\n", m_indent, "", &m_dummy_prefix, (void*)(m_struct.allocationSize));
+ printf("%*s %smemProps = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.memProps));
+ printf("%*s %smemType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_TYPE(m_struct.memType));
+ printf("%*s %smemPriority = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_MEMORY_PRIORITY(m_struct.memPriority));
}
// Output all struct elements, each on their own line
-void xgl_image_create_info_struct_wrapper::display_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_txt()
{
- printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_image_create_info_struct_wrapper::display_full_txt()
+void xgl_memory_alloc_info_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_IMAGE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_MEMORY_ALLOC_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (&m_struct.extent) {
- xgl_extent3d_struct_wrapper class0(&m_struct.extent);
- class0.set_indent(m_indent + 4);
- class0.display_full_txt();
- }
if (m_struct.pNext) {
dynamic_display_full_txt(m_struct.pNext, m_indent);
}
}
-// xgl_pipeline_tess_state_create_info_struct_wrapper class definition
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+// xgl_physical_gpu_queue_properties_struct_wrapper class definition
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper() : m_struct(), m_indent(0), m_dummy_prefix('\0'), m_origStructAddr(NULL) {}
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_tess_state_create_info_struct_wrapper::xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct) : m_indent(0), m_dummy_prefix('\0')
+xgl_physical_gpu_queue_properties_struct_wrapper::xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct) : m_indent(0), m_dummy_prefix('\0')
{
m_struct = *pInStruct;
m_origStructAddr = pInStruct;
}
-xgl_pipeline_tess_state_create_info_struct_wrapper::~xgl_pipeline_tess_state_create_info_struct_wrapper() {}
+xgl_physical_gpu_queue_properties_struct_wrapper::~xgl_physical_gpu_queue_properties_struct_wrapper() {}
// Output 'structname = struct_address' on a single line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_single_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_single_txt()
{
- printf(" %*sXGL_PIPELINE_TESS_STATE_CREATE_INFO = %p", m_indent, "", (void*)m_origStructAddr);
+ printf(" %*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES = %p", m_indent, "", (void*)m_origStructAddr);
}
// Private helper function that displays the members of the wrapped struct
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_struct_members()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_struct_members()
{
- printf("%*s %ssType = %s\n", m_indent, "", &m_dummy_prefix, string_XGL_STRUCTURE_TYPE(m_struct.sType));
- printf("%*s %spNext = %p\n", m_indent, "", &m_dummy_prefix, (m_struct.pNext));
- printf("%*s %spatchControlPoints = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.patchControlPoints));
- printf("%*s %soptimalTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.optimalTessFactor));
- printf("%*s %sfixedTessFactor = %f\n", m_indent, "", &m_dummy_prefix, (m_struct.fixedTessFactor));
+ printf("%*s %squeueFlags = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueFlags));
+ printf("%*s %squeueCount = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.queueCount));
+ printf("%*s %smaxAtomicCounters = %u\n", m_indent, "", &m_dummy_prefix, (m_struct.maxAtomicCounters));
+ printf("%*s %ssupportsTimestamps = %s\n", m_indent, "", &m_dummy_prefix, (m_struct.supportsTimestamps) ? "TRUE" : "FALSE");
}
// Output all struct elements, each on their own line
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_txt()
{
- printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
}
// Output all struct elements, and for any structs pointed to, print complete contents
-void xgl_pipeline_tess_state_create_info_struct_wrapper::display_full_txt()
+void xgl_physical_gpu_queue_properties_struct_wrapper::display_full_txt()
{
- printf("%*sXGL_PIPELINE_TESS_STATE_CREATE_INFO struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
+ printf("%*sXGL_PHYSICAL_GPU_QUEUE_PROPERTIES struct contents at %p:\n", m_indent, "", (void*)m_origStructAddr);
this->display_struct_members();
- if (m_struct.pNext) {
- dynamic_display_full_txt(m_struct.pNext, m_indent);
- }
}
//any footer info for class
#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();
+ virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
- void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
- XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
- void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
+ void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
+ bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
+ void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
+ bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
+ void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
+ uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
+ void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
private:
- XGL_FORMAT_PROPERTIES m_struct;
- const XGL_FORMAT_PROPERTIES* m_origStructAddr;
+ XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_image_copy_struct_wrapper
+class xgl_application_info_struct_wrapper
{
public:
- xgl_buffer_image_copy_struct_wrapper();
- xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
- xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
+ xgl_application_info_struct_wrapper();
+ xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
+ xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
- virtual ~xgl_buffer_image_copy_struct_wrapper();
+ virtual ~xgl_application_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
- void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
- void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
- XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
- void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
- XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
- void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ const char* get_pAppName() { return m_struct.pAppName; }
+ uint32_t get_appVersion() { return m_struct.appVersion; }
+ void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
+ const char* get_pEngineName() { return m_struct.pEngineName; }
+ uint32_t get_engineVersion() { return m_struct.engineVersion; }
+ void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
+ uint32_t get_apiVersion() { return m_struct.apiVersion; }
+ void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
private:
- XGL_BUFFER_IMAGE_COPY m_struct;
- const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
+ XGL_APPLICATION_INFO m_struct;
+ const XGL_APPLICATION_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_peer_memory_open_info_struct_wrapper
+class xgl_link_const_buffer_struct_wrapper
{
public:
- xgl_peer_memory_open_info_struct_wrapper();
- xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
- xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+ xgl_link_const_buffer_struct_wrapper();
+ xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
+ xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
- virtual ~xgl_peer_memory_open_info_struct_wrapper();
+ virtual ~xgl_link_const_buffer_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_bufferId() { return m_struct.bufferId; }
+ void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
+ size_t get_bufferSize() { return m_struct.bufferSize; }
+ void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
+ const void* get_pBufferData() { return m_struct.pBufferData; }
+
+
+private:
+ XGL_LINK_CONST_BUFFER m_struct;
+ const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_update_samplers_struct_wrapper
+{
+public:
+ xgl_update_samplers_struct_wrapper();
+ xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
+ xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
+
+ virtual ~xgl_update_samplers_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
- void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_PEER_MEMORY_OPEN_INFO m_struct;
- const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
+ XGL_UPDATE_SAMPLERS m_struct;
+ const XGL_UPDATE_SAMPLERS* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_subresource_layout_struct_wrapper
+class xgl_stencil_op_state_struct_wrapper
{
public:
- xgl_subresource_layout_struct_wrapper();
- xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct);
- xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct);
+ xgl_stencil_op_state_struct_wrapper();
+ xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
+ xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
- virtual ~xgl_subresource_layout_struct_wrapper();
+ virtual ~xgl_stencil_op_state_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_offset() { return m_struct.offset; }
- void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
- XGL_GPU_SIZE get_rowPitch() { return m_struct.rowPitch; }
- void set_rowPitch(XGL_GPU_SIZE inValue) { m_struct.rowPitch = inValue; }
- XGL_GPU_SIZE get_depthPitch() { return m_struct.depthPitch; }
- void set_depthPitch(XGL_GPU_SIZE inValue) { m_struct.depthPitch = inValue; }
+ XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
+ void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
+ XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
+ void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
+ XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
+ void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
+ XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
+ void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
private:
- XGL_SUBRESOURCE_LAYOUT m_struct;
- const XGL_SUBRESOURCE_LAYOUT* m_origStructAddr;
+ XGL_STENCIL_OP_STATE m_struct;
+ const XGL_STENCIL_OP_STATE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_physical_gpu_queue_properties_struct_wrapper
+class xgl_peer_image_open_info_struct_wrapper
{
public:
- xgl_physical_gpu_queue_properties_struct_wrapper();
- xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
- xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+ xgl_peer_image_open_info_struct_wrapper();
+ xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+ xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
- virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
+ virtual ~xgl_peer_image_open_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
- void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
- uint32_t get_queueCount() { return m_struct.queueCount; }
- void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
- uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
- void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
- bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
- void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
+ XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
+ void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
private:
- XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
- const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
+ XGL_PEER_IMAGE_OPEN_INFO m_struct;
+ const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_sampler_create_info_struct_wrapper
+class xgl_device_create_info_struct_wrapper
{
public:
- xgl_sampler_create_info_struct_wrapper();
- xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct);
- xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct);
+ xgl_device_create_info_struct_wrapper();
+ xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
+ xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
- virtual ~xgl_sampler_create_info_struct_wrapper();
+ virtual ~xgl_device_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_TEX_FILTER get_magFilter() { return m_struct.magFilter; }
- void set_magFilter(XGL_TEX_FILTER inValue) { m_struct.magFilter = inValue; }
- XGL_TEX_FILTER get_minFilter() { return m_struct.minFilter; }
- void set_minFilter(XGL_TEX_FILTER inValue) { m_struct.minFilter = inValue; }
- XGL_TEX_MIPMAP_MODE get_mipMode() { return m_struct.mipMode; }
- void set_mipMode(XGL_TEX_MIPMAP_MODE inValue) { m_struct.mipMode = inValue; }
- XGL_TEX_ADDRESS get_addressU() { return m_struct.addressU; }
- void set_addressU(XGL_TEX_ADDRESS inValue) { m_struct.addressU = inValue; }
- XGL_TEX_ADDRESS get_addressV() { return m_struct.addressV; }
- void set_addressV(XGL_TEX_ADDRESS inValue) { m_struct.addressV = inValue; }
- XGL_TEX_ADDRESS get_addressW() { return m_struct.addressW; }
- void set_addressW(XGL_TEX_ADDRESS inValue) { m_struct.addressW = inValue; }
- float get_mipLodBias() { return m_struct.mipLodBias; }
- void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; }
- uint32_t get_maxAnisotropy() { return m_struct.maxAnisotropy; }
- void set_maxAnisotropy(uint32_t inValue) { m_struct.maxAnisotropy = inValue; }
- XGL_COMPARE_FUNC get_compareFunc() { return m_struct.compareFunc; }
- void set_compareFunc(XGL_COMPARE_FUNC inValue) { m_struct.compareFunc = inValue; }
- float get_minLod() { return m_struct.minLod; }
- void set_minLod(float inValue) { m_struct.minLod = inValue; }
- float get_maxLod() { return m_struct.maxLod; }
- void set_maxLod(float inValue) { m_struct.maxLod = inValue; }
- XGL_BORDER_COLOR_TYPE get_borderColorType() { return m_struct.borderColorType; }
- void set_borderColorType(XGL_BORDER_COLOR_TYPE inValue) { m_struct.borderColorType = inValue; }
+ uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
+ void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
+ uint32_t get_extensionCount() { return m_struct.extensionCount; }
+ void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
+ XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
+ void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_SAMPLER_CREATE_INFO m_struct;
- const XGL_SAMPLER_CREATE_INFO* m_origStructAddr;
+ XGL_DEVICE_CREATE_INFO m_struct;
+ const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_draw_indexed_indirect_cmd_struct_wrapper
+class xgl_buffer_memory_requirements_struct_wrapper
{
public:
- xgl_draw_indexed_indirect_cmd_struct_wrapper();
- xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
- xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+ xgl_buffer_memory_requirements_struct_wrapper();
+ xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
- virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
+ virtual ~xgl_buffer_memory_requirements_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_indexCount() { return m_struct.indexCount; }
- void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
- uint32_t get_instanceCount() { return m_struct.instanceCount; }
- void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
- uint32_t get_firstIndex() { return m_struct.firstIndex; }
- void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
- int32_t get_vertexOffset() { return m_struct.vertexOffset; }
- void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
- uint32_t get_firstInstance() { return m_struct.firstInstance; }
- void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
private:
- XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
- const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
+ XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
+ const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_update_as_copy_struct_wrapper
+class xgl_update_buffers_struct_wrapper
{
public:
- xgl_update_as_copy_struct_wrapper();
- xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
- xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
+ xgl_update_buffers_struct_wrapper();
+ xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
+ xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
- virtual ~xgl_update_as_copy_struct_wrapper();
+ virtual ~xgl_update_buffers_struct_wrapper();
void display_txt();
void display_single_txt();
const void* get_pNext() { return m_struct.pNext; }
XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
- void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
- uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
- void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
uint32_t get_count() { return m_struct.count; }
void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_UPDATE_AS_COPY m_struct;
- const XGL_UPDATE_AS_COPY* m_origStructAddr;
+ XGL_UPDATE_BUFFERS m_struct;
+ const XGL_UPDATE_BUFFERS* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_clear_color_struct_wrapper
+class xgl_vertex_input_attribute_description_struct_wrapper
{
public:
- xgl_clear_color_struct_wrapper();
- xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
- xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
+ xgl_vertex_input_attribute_description_struct_wrapper();
+ xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+ xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
- virtual ~xgl_clear_color_struct_wrapper();
+ virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
- void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
- bool32_t get_useRawValue() { return m_struct.useRawValue; }
- void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
+ uint32_t get_binding() { return m_struct.binding; }
+ void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
+ void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
private:
- XGL_CLEAR_COLOR m_struct;
- const XGL_CLEAR_COLOR* m_origStructAddr;
+ XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
+ const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_extent2d_struct_wrapper
+class xgl_pipeline_vertex_input_create_info_struct_wrapper
{
public:
- xgl_extent2d_struct_wrapper();
- xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
- xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
+ xgl_pipeline_vertex_input_create_info_struct_wrapper();
+ xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+ xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
- virtual ~xgl_extent2d_struct_wrapper();
+ virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_width() { return m_struct.width; }
- void set_width(int32_t inValue) { m_struct.width = inValue; }
- int32_t get_height() { return m_struct.height; }
- void set_height(int32_t inValue) { m_struct.height = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_bindingCount() { return m_struct.bindingCount; }
+ void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
+ uint32_t get_attributeCount() { return m_struct.attributeCount; }
+ void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
private:
- XGL_EXTENT2D m_struct;
- const XGL_EXTENT2D* m_origStructAddr;
+ XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
+ const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_framebuffer_create_info_struct_wrapper
+class xgl_dynamic_rs_state_create_info_struct_wrapper
{
public:
- xgl_framebuffer_create_info_struct_wrapper();
- xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
- xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+ xgl_dynamic_rs_state_create_info_struct_wrapper();
+ xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_framebuffer_create_info_struct_wrapper();
+ virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
- void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
- const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
- uint32_t get_sampleCount() { return m_struct.sampleCount; }
- void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
- uint32_t get_width() { return m_struct.width; }
- void set_width(uint32_t inValue) { m_struct.width = inValue; }
- uint32_t get_height() { return m_struct.height; }
- void set_height(uint32_t inValue) { m_struct.height = inValue; }
- uint32_t get_layers() { return m_struct.layers; }
- void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
+ float get_depthBias() { return m_struct.depthBias; }
+ void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
+ float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
+ void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
+ float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
+ void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
+ float get_pointSize() { return m_struct.pointSize; }
+ void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
+ float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
+ void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
+ float get_lineWidth() { return m_struct.lineWidth; }
+ void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
private:
- XGL_FRAMEBUFFER_CREATE_INFO m_struct;
- const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
+ XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_alloc_callbacks_struct_wrapper
+class xgl_subresource_layout_struct_wrapper
{
public:
- xgl_alloc_callbacks_struct_wrapper();
- xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
- xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
+ xgl_subresource_layout_struct_wrapper();
+ xgl_subresource_layout_struct_wrapper(XGL_SUBRESOURCE_LAYOUT* pInStruct);
+ xgl_subresource_layout_struct_wrapper(const XGL_SUBRESOURCE_LAYOUT* pInStruct);
- virtual ~xgl_alloc_callbacks_struct_wrapper();
+ virtual ~xgl_subresource_layout_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- void* get_pUserData() { return m_struct.pUserData; }
- void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
- XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
- void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
- XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
- void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_GPU_SIZE get_rowPitch() { return m_struct.rowPitch; }
+ void set_rowPitch(XGL_GPU_SIZE inValue) { m_struct.rowPitch = inValue; }
+ XGL_GPU_SIZE get_depthPitch() { return m_struct.depthPitch; }
+ void set_depthPitch(XGL_GPU_SIZE inValue) { m_struct.depthPitch = inValue; }
private:
- XGL_ALLOC_CALLBACKS m_struct;
- const XGL_ALLOC_CALLBACKS* m_origStructAddr;
+ XGL_SUBRESOURCE_LAYOUT m_struct;
+ const XGL_SUBRESOURCE_LAYOUT* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_requirements_struct_wrapper
+class xgl_draw_indexed_indirect_cmd_struct_wrapper
{
public:
- xgl_memory_requirements_struct_wrapper();
- xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
- xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_draw_indexed_indirect_cmd_struct_wrapper();
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
+ xgl_draw_indexed_indirect_cmd_struct_wrapper(const XGL_DRAW_INDEXED_INDIRECT_CMD* pInStruct);
- virtual ~xgl_memory_requirements_struct_wrapper();
+ virtual ~xgl_draw_indexed_indirect_cmd_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
- XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
- void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
- XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
- void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
- XGL_FLAGS get_memProps() { return m_struct.memProps; }
- void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
- XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
- void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+ uint32_t get_indexCount() { return m_struct.indexCount; }
+ void set_indexCount(uint32_t inValue) { m_struct.indexCount = inValue; }
+ uint32_t get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+ uint32_t get_firstIndex() { return m_struct.firstIndex; }
+ void set_firstIndex(uint32_t inValue) { m_struct.firstIndex = inValue; }
+ int32_t get_vertexOffset() { return m_struct.vertexOffset; }
+ void set_vertexOffset(int32_t inValue) { m_struct.vertexOffset = inValue; }
+ uint32_t get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
private:
- XGL_MEMORY_REQUIREMENTS m_struct;
- const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
+ XGL_DRAW_INDEXED_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDEXED_INDIRECT_CMD* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_link_const_buffer_struct_wrapper
+class xgl_dynamic_vp_state_create_info_struct_wrapper
{
public:
- xgl_link_const_buffer_struct_wrapper();
- xgl_link_const_buffer_struct_wrapper(XGL_LINK_CONST_BUFFER* pInStruct);
- xgl_link_const_buffer_struct_wrapper(const XGL_LINK_CONST_BUFFER* pInStruct);
+ xgl_dynamic_vp_state_create_info_struct_wrapper();
+ xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_link_const_buffer_struct_wrapper();
+ virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_bufferId() { return m_struct.bufferId; }
- void set_bufferId(uint32_t inValue) { m_struct.bufferId = inValue; }
- size_t get_bufferSize() { return m_struct.bufferSize; }
- void set_bufferSize(size_t inValue) { m_struct.bufferSize = inValue; }
- const void* get_pBufferData() { return m_struct.pBufferData; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
+ void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
private:
- XGL_LINK_CONST_BUFFER m_struct;
- const XGL_LINK_CONST_BUFFER* m_origStructAddr;
+ XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_physical_gpu_properties_struct_wrapper
+class xgl_shader_create_info_struct_wrapper
{
public:
- xgl_physical_gpu_properties_struct_wrapper();
- xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
- xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+ xgl_shader_create_info_struct_wrapper();
+ xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
+ xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
- virtual ~xgl_physical_gpu_properties_struct_wrapper();
+ virtual ~xgl_shader_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_apiVersion() { return m_struct.apiVersion; }
- void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
- uint32_t get_driverVersion() { return m_struct.driverVersion; }
- void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; }
- uint32_t get_vendorId() { return m_struct.vendorId; }
- void set_vendorId(uint32_t inValue) { m_struct.vendorId = inValue; }
- uint32_t get_deviceId() { return m_struct.deviceId; }
- void set_deviceId(uint32_t inValue) { m_struct.deviceId = inValue; }
- XGL_PHYSICAL_GPU_TYPE get_gpuType() { return m_struct.gpuType; }
- void set_gpuType(XGL_PHYSICAL_GPU_TYPE inValue) { m_struct.gpuType = inValue; }
- uint32_t get_maxMemRefsPerSubmission() { return m_struct.maxMemRefsPerSubmission; }
- void set_maxMemRefsPerSubmission(uint32_t inValue) { m_struct.maxMemRefsPerSubmission = inValue; }
- XGL_GPU_SIZE get_maxInlineMemoryUpdateSize() { return m_struct.maxInlineMemoryUpdateSize; }
- void set_maxInlineMemoryUpdateSize(XGL_GPU_SIZE inValue) { m_struct.maxInlineMemoryUpdateSize = inValue; }
- uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; }
- void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; }
- uint32_t get_maxThreadGroupSize() { return m_struct.maxThreadGroupSize; }
- void set_maxThreadGroupSize(uint32_t inValue) { m_struct.maxThreadGroupSize = inValue; }
- uint64_t get_timestampFrequency() { return m_struct.timestampFrequency; }
- void set_timestampFrequency(uint64_t inValue) { m_struct.timestampFrequency = inValue; }
- bool32_t get_multiColorAttachmentClears() { return m_struct.multiColorAttachmentClears; }
- void set_multiColorAttachmentClears(bool32_t inValue) { m_struct.multiColorAttachmentClears = inValue; }
- uint32_t get_maxDescriptorSets() { return m_struct.maxDescriptorSets; }
- void set_maxDescriptorSets(uint32_t inValue) { m_struct.maxDescriptorSets = inValue; }
- uint32_t get_maxViewports() { return m_struct.maxViewports; }
- void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; }
- uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; }
- void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ size_t get_codeSize() { return m_struct.codeSize; }
+ void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
+ const void* get_pCode() { return m_struct.pCode; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_PHYSICAL_GPU_PROPERTIES m_struct;
- const XGL_PHYSICAL_GPU_PROPERTIES* m_origStructAddr;
+ XGL_SHADER_CREATE_INFO m_struct;
+ const XGL_SHADER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_device_create_info_struct_wrapper
+class xgl_memory_ref_struct_wrapper
{
public:
- xgl_device_create_info_struct_wrapper();
- xgl_device_create_info_struct_wrapper(XGL_DEVICE_CREATE_INFO* pInStruct);
- xgl_device_create_info_struct_wrapper(const XGL_DEVICE_CREATE_INFO* pInStruct);
+ xgl_memory_ref_struct_wrapper();
+ xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
+ xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
- virtual ~xgl_device_create_info_struct_wrapper();
+ virtual ~xgl_memory_ref_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_queueRecordCount() { return m_struct.queueRecordCount; }
- void set_queueRecordCount(uint32_t inValue) { m_struct.queueRecordCount = inValue; }
- uint32_t get_extensionCount() { return m_struct.extensionCount; }
- void set_extensionCount(uint32_t inValue) { m_struct.extensionCount = inValue; }
- XGL_VALIDATION_LEVEL get_maxValidationLevel() { return m_struct.maxValidationLevel; }
- void set_maxValidationLevel(XGL_VALIDATION_LEVEL inValue) { m_struct.maxValidationLevel = inValue; }
+ XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
+ void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
XGL_FLAGS get_flags() { return m_struct.flags; }
void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_DEVICE_CREATE_INFO m_struct;
- const XGL_DEVICE_CREATE_INFO* m_origStructAddr;
+ XGL_MEMORY_REF m_struct;
+ const XGL_MEMORY_REF* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_resolve_struct_wrapper
+class xgl_format_properties_struct_wrapper
{
public:
- xgl_image_resolve_struct_wrapper();
- xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
- xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
+ xgl_format_properties_struct_wrapper();
+ xgl_format_properties_struct_wrapper(XGL_FORMAT_PROPERTIES* pInStruct);
+ xgl_format_properties_struct_wrapper(const XGL_FORMAT_PROPERTIES* pInStruct);
- virtual ~xgl_image_resolve_struct_wrapper();
+ virtual ~xgl_format_properties_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
- void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
- XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
- void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
- void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
- XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
- void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
- XGL_EXTENT2D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+ XGL_FLAGS get_linearTilingFeatures() { return m_struct.linearTilingFeatures; }
+ void set_linearTilingFeatures(XGL_FLAGS inValue) { m_struct.linearTilingFeatures = inValue; }
+ XGL_FLAGS get_optimalTilingFeatures() { return m_struct.optimalTilingFeatures; }
+ void set_optimalTilingFeatures(XGL_FLAGS inValue) { m_struct.optimalTilingFeatures = inValue; }
private:
- XGL_IMAGE_RESOLVE m_struct;
- const XGL_IMAGE_RESOLVE* m_origStructAddr;
+ XGL_FORMAT_PROPERTIES m_struct;
+ const XGL_FORMAT_PROPERTIES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_view_attach_info_struct_wrapper
+class xgl_pipeline_statistics_data_struct_wrapper
{
public:
- xgl_image_view_attach_info_struct_wrapper();
- xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
- xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+ xgl_pipeline_statistics_data_struct_wrapper();
+ xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
+ xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
- virtual ~xgl_image_view_attach_info_struct_wrapper();
+ virtual ~xgl_pipeline_statistics_data_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_IMAGE_VIEW inValue) { m_struct.view = inValue; }
- XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
- void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+ uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
+ void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
+ uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
+ void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
+ uint64_t get_cInvocations() { return m_struct.cInvocations; }
+ void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
+ uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
+ void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
+ uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
+ void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
+ uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
+ void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
+ uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
+ void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
+ uint64_t get_iaVertices() { return m_struct.iaVertices; }
+ void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
+ uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
+ void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
+ uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
+ void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
+ uint64_t get_csInvocations() { return m_struct.csInvocations; }
+ void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
private:
- XGL_IMAGE_VIEW_ATTACH_INFO m_struct;
- const XGL_IMAGE_VIEW_ATTACH_INFO* m_origStructAddr;
+ XGL_PIPELINE_STATISTICS_DATA m_struct;
+ const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_fence_create_info_struct_wrapper
+class xgl_alloc_callbacks_struct_wrapper
{
public:
- xgl_fence_create_info_struct_wrapper();
- xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
- xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
+ xgl_alloc_callbacks_struct_wrapper();
+ xgl_alloc_callbacks_struct_wrapper(XGL_ALLOC_CALLBACKS* pInStruct);
+ xgl_alloc_callbacks_struct_wrapper(const XGL_ALLOC_CALLBACKS* pInStruct);
- virtual ~xgl_fence_create_info_struct_wrapper();
+ virtual ~xgl_alloc_callbacks_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ void* get_pUserData() { return m_struct.pUserData; }
+ void set_pUserData(void* inValue) { m_struct.pUserData = inValue; }
+ XGL_ALLOC_FUNCTION get_pfnAlloc() { return m_struct.pfnAlloc; }
+ void set_pfnAlloc(XGL_ALLOC_FUNCTION inValue) { m_struct.pfnAlloc = inValue; }
+ XGL_FREE_FUNCTION get_pfnFree() { return m_struct.pfnFree; }
+ void set_pfnFree(XGL_FREE_FUNCTION inValue) { m_struct.pfnFree = inValue; }
private:
- XGL_FENCE_CREATE_INFO m_struct;
- const XGL_FENCE_CREATE_INFO* m_origStructAddr;
+ XGL_ALLOC_CALLBACKS m_struct;
+ const XGL_ALLOC_CALLBACKS* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_dynamic_rs_state_create_info_struct_wrapper
+class xgl_pipeline_cb_state_create_info_struct_wrapper
{
public:
- xgl_dynamic_rs_state_create_info_struct_wrapper();
- xgl_dynamic_rs_state_create_info_struct_wrapper(XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_rs_state_create_info_struct_wrapper(const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_cb_state_create_info_struct_wrapper();
+ xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_dynamic_rs_state_create_info_struct_wrapper();
+ virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- float get_depthBias() { return m_struct.depthBias; }
- void set_depthBias(float inValue) { m_struct.depthBias = inValue; }
- float get_depthBiasClamp() { return m_struct.depthBiasClamp; }
- void set_depthBiasClamp(float inValue) { m_struct.depthBiasClamp = inValue; }
- float get_slopeScaledDepthBias() { return m_struct.slopeScaledDepthBias; }
- void set_slopeScaledDepthBias(float inValue) { m_struct.slopeScaledDepthBias = inValue; }
- float get_pointSize() { return m_struct.pointSize; }
- void set_pointSize(float inValue) { m_struct.pointSize = inValue; }
- float get_pointFadeThreshold() { return m_struct.pointFadeThreshold; }
- void set_pointFadeThreshold(float inValue) { m_struct.pointFadeThreshold = inValue; }
- float get_lineWidth() { return m_struct.lineWidth; }
- void set_lineWidth(float inValue) { m_struct.lineWidth = inValue; }
+ bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
+ void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
+ bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
+ void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
+ XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
+ void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
+ uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
+ void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
private:
- XGL_DYNAMIC_RS_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_RS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_copy_struct_wrapper
+class xgl_draw_indirect_cmd_struct_wrapper
{
public:
- xgl_buffer_copy_struct_wrapper();
- xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct);
- xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct);
+ xgl_draw_indirect_cmd_struct_wrapper();
+ xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
+ xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
- virtual ~xgl_buffer_copy_struct_wrapper();
+ virtual ~xgl_draw_indirect_cmd_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_SIZE get_srcOffset() { return m_struct.srcOffset; }
- void set_srcOffset(XGL_GPU_SIZE inValue) { m_struct.srcOffset = inValue; }
- XGL_GPU_SIZE get_destOffset() { return m_struct.destOffset; }
- void set_destOffset(XGL_GPU_SIZE inValue) { m_struct.destOffset = inValue; }
- XGL_GPU_SIZE get_copySize() { return m_struct.copySize; }
- void set_copySize(XGL_GPU_SIZE inValue) { m_struct.copySize = inValue; }
+ uint32_t get_vertexCount() { return m_struct.vertexCount; }
+ void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
+ uint32_t get_instanceCount() { return m_struct.instanceCount; }
+ void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
+ uint32_t get_firstVertex() { return m_struct.firstVertex; }
+ void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
+ uint32_t get_firstInstance() { return m_struct.firstInstance; }
+ void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
private:
- XGL_BUFFER_COPY m_struct;
- const XGL_BUFFER_COPY* m_origStructAddr;
+ XGL_DRAW_INDIRECT_CMD m_struct;
+ const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_color_attachment_bind_info_struct_wrapper
+class xgl_color_attachment_view_create_info_struct_wrapper
{
public:
- xgl_color_attachment_bind_info_struct_wrapper();
- xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
- xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+ xgl_color_attachment_view_create_info_struct_wrapper();
+ xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+ xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
- virtual ~xgl_color_attachment_bind_info_struct_wrapper();
+ virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
- XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
- void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ uint32_t get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+ void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+ void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
private:
- XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
- const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
+ XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_view_create_info_struct_wrapper
+class xgl_pipeline_cb_attachment_state_struct_wrapper
{
public:
- xgl_buffer_view_create_info_struct_wrapper();
- xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
- xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+ xgl_pipeline_cb_attachment_state_struct_wrapper();
+ xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+ xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
- virtual ~xgl_buffer_view_create_info_struct_wrapper();
+ virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_BUFFER get_buffer() { return m_struct.buffer; }
- void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
- XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
- void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
- XGL_GPU_SIZE get_stride() { return m_struct.stride; }
- void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
+ bool32_t get_blendEnable() { return m_struct.blendEnable; }
+ void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
XGL_FORMAT get_format() { return m_struct.format; }
void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
- void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
- XGL_GPU_SIZE get_offset() { return m_struct.offset; }
- void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
- XGL_GPU_SIZE get_range() { return m_struct.range; }
- void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
+ XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
+ void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
+ XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
+ void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
+ XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
+ void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
+ XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
+ void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
+ XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
+ void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
+ XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
+ void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
+ uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
+ void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
private:
- XGL_BUFFER_VIEW_CREATE_INFO m_struct;
- const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
+ XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
+ const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_queue_semaphore_open_info_struct_wrapper
+class xgl_vertex_input_binding_description_struct_wrapper
{
public:
- xgl_queue_semaphore_open_info_struct_wrapper();
- xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
- xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+ xgl_vertex_input_binding_description_struct_wrapper();
+ xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+ xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
- virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
+ virtual ~xgl_vertex_input_binding_description_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
- void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
+ uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
+ void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
+ XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
+ void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
private:
- XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
- const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
+ XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
+ const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_cb_state_create_info_struct_wrapper
+class xgl_pipeline_shader_stage_create_info_struct_wrapper
{
public:
- xgl_pipeline_cb_state_create_info_struct_wrapper();
- xgl_pipeline_cb_state_create_info_struct_wrapper(XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_cb_state_create_info_struct_wrapper(const XGL_PIPELINE_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_shader_stage_create_info_struct_wrapper();
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
+ xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
- virtual ~xgl_pipeline_cb_state_create_info_struct_wrapper();
+ virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- bool32_t get_alphaToCoverageEnable() { return m_struct.alphaToCoverageEnable; }
- void set_alphaToCoverageEnable(bool32_t inValue) { m_struct.alphaToCoverageEnable = inValue; }
- bool32_t get_logicOpEnable() { return m_struct.logicOpEnable; }
- void set_logicOpEnable(bool32_t inValue) { m_struct.logicOpEnable = inValue; }
- XGL_LOGIC_OP get_logicOp() { return m_struct.logicOp; }
- void set_logicOp(XGL_LOGIC_OP inValue) { m_struct.logicOp = inValue; }
- uint32_t get_attachmentCount() { return m_struct.attachmentCount; }
- void set_attachmentCount(uint32_t inValue) { m_struct.attachmentCount = inValue; }
+ XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
private:
- XGL_PIPELINE_CB_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_CB_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_dynamic_cb_state_create_info_struct_wrapper
+class xgl_fence_create_info_struct_wrapper
{
public:
- xgl_dynamic_cb_state_create_info_struct_wrapper();
- xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_fence_create_info_struct_wrapper();
+ xgl_fence_create_info_struct_wrapper(XGL_FENCE_CREATE_INFO* pInStruct);
+ xgl_fence_create_info_struct_wrapper(const XGL_FENCE_CREATE_INFO* pInStruct);
- virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
+ virtual ~xgl_fence_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_FENCE_CREATE_INFO m_struct;
+ const XGL_FENCE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_memory_requirements_struct_wrapper
+class xgl_framebuffer_create_info_struct_wrapper
{
public:
- xgl_buffer_memory_requirements_struct_wrapper();
- xgl_buffer_memory_requirements_struct_wrapper(XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
- xgl_buffer_memory_requirements_struct_wrapper(const XGL_BUFFER_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_framebuffer_create_info_struct_wrapper();
+ xgl_framebuffer_create_info_struct_wrapper(XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
+ xgl_framebuffer_create_info_struct_wrapper(const XGL_FRAMEBUFFER_CREATE_INFO* pInStruct);
- virtual ~xgl_buffer_memory_requirements_struct_wrapper();
+ virtual ~xgl_framebuffer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
+ void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
+ const XGL_DEPTH_STENCIL_BIND_INFO* get_pDepthStencilAttachment() { return m_struct.pDepthStencilAttachment; }
+ uint32_t get_sampleCount() { return m_struct.sampleCount; }
+ void set_sampleCount(uint32_t inValue) { m_struct.sampleCount = inValue; }
+ uint32_t get_width() { return m_struct.width; }
+ void set_width(uint32_t inValue) { m_struct.width = inValue; }
+ uint32_t get_height() { return m_struct.height; }
+ void set_height(uint32_t inValue) { m_struct.height = inValue; }
+ uint32_t get_layers() { return m_struct.layers; }
+ void set_layers(uint32_t inValue) { m_struct.layers = inValue; }
private:
- XGL_BUFFER_MEMORY_REQUIREMENTS m_struct;
- const XGL_BUFFER_MEMORY_REQUIREMENTS* m_origStructAddr;
+ XGL_FRAMEBUFFER_CREATE_INFO m_struct;
+ const XGL_FRAMEBUFFER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_sampler_image_view_info_struct_wrapper
+class xgl_extent2d_struct_wrapper
{
public:
- xgl_sampler_image_view_info_struct_wrapper();
- xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
- xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
+ xgl_extent2d_struct_wrapper();
+ xgl_extent2d_struct_wrapper(XGL_EXTENT2D* pInStruct);
+ xgl_extent2d_struct_wrapper(const XGL_EXTENT2D* pInStruct);
- virtual ~xgl_sampler_image_view_info_struct_wrapper();
+ virtual ~xgl_extent2d_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_SAMPLER get_pSampler() { return m_struct.pSampler; }
- void set_pSampler(XGL_SAMPLER inValue) { m_struct.pSampler = inValue; }
- const XGL_IMAGE_VIEW_ATTACH_INFO* get_pImageView() { return m_struct.pImageView; }
+ int32_t get_width() { return m_struct.width; }
+ void set_width(int32_t inValue) { m_struct.width = inValue; }
+ int32_t get_height() { return m_struct.height; }
+ void set_height(int32_t inValue) { m_struct.height = inValue; }
private:
- XGL_SAMPLER_IMAGE_VIEW_INFO m_struct;
- const XGL_SAMPLER_IMAGE_VIEW_INFO* m_origStructAddr;
+ XGL_EXTENT2D m_struct;
+ const XGL_EXTENT2D* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_descriptor_set_layout_create_info_struct_wrapper
+class xgl_compute_pipeline_create_info_struct_wrapper
{
public:
- xgl_descriptor_set_layout_create_info_struct_wrapper();
- xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
- xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
+ xgl_compute_pipeline_create_info_struct_wrapper();
+ xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
- virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
+ virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
- XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
- void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
- XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
- void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
+ XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
+ void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+ void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
+ uint32_t get_localSizeX() { return m_struct.localSizeX; }
+ void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
+ uint32_t get_localSizeY() { return m_struct.localSizeY; }
+ void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
+ uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
+ void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
private:
- XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
- const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
+ XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_event_wait_info_struct_wrapper
+class xgl_image_subresource_range_struct_wrapper
{
public:
- xgl_event_wait_info_struct_wrapper();
- xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
- xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
+ xgl_image_subresource_range_struct_wrapper();
+ xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+ xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
- virtual ~xgl_event_wait_info_struct_wrapper();
+ virtual ~xgl_image_subresource_range_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_eventCount() { return m_struct.eventCount; }
- void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
- XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
- void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
- uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
- void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
+ XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+ void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+ uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
+ void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
+ uint32_t get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
private:
- XGL_EVENT_WAIT_INFO m_struct;
- const XGL_EVENT_WAIT_INFO* m_origStructAddr;
+ XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
+ const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_descriptor_region_create_info_struct_wrapper
+class xgl_pipeline_tess_state_create_info_struct_wrapper
{
public:
- xgl_descriptor_region_create_info_struct_wrapper();
- xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
- xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+ xgl_pipeline_tess_state_create_info_struct_wrapper();
+ xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_descriptor_region_create_info_struct_wrapper();
+ virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
+ void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
+ float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
+ void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
+ float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
+ void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
private:
- XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
- const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
+ XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_alloc_info_struct_wrapper
+class xgl_offset2d_struct_wrapper
{
public:
- xgl_memory_alloc_info_struct_wrapper();
- xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
- xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
+ xgl_offset2d_struct_wrapper();
+ xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
+ xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
- virtual ~xgl_memory_alloc_info_struct_wrapper();
+ virtual ~xgl_offset2d_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
- void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
- XGL_FLAGS get_memProps() { return m_struct.memProps; }
- void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
- XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
- void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
- XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
- void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
+ int32_t get_x() { return m_struct.x; }
+ void set_x(int32_t inValue) { m_struct.x = inValue; }
+ int32_t get_y() { return m_struct.y; }
+ void set_y(int32_t inValue) { m_struct.y = inValue; }
private:
- XGL_MEMORY_ALLOC_INFO m_struct;
- const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
+ XGL_OFFSET2D m_struct;
+ const XGL_OFFSET2D* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_open_info_struct_wrapper
+class xgl_queue_semaphore_create_info_struct_wrapper
{
public:
- xgl_memory_open_info_struct_wrapper();
- xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
- xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
+ xgl_queue_semaphore_create_info_struct_wrapper();
+ xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+ xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
- virtual ~xgl_memory_open_info_struct_wrapper();
+ virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
- void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
+ uint32_t get_initialCount() { return m_struct.initialCount; }
+ void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_MEMORY_OPEN_INFO m_struct;
- const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
+ XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_graphics_pipeline_create_info_struct_wrapper
+class xgl_clear_color_value_struct_wrapper
{
public:
- xgl_graphics_pipeline_create_info_struct_wrapper();
- xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
- xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_clear_color_value_struct_wrapper();
+ xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
+ xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
- virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
+ virtual ~xgl_clear_color_value_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
- XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
- void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
private:
- XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
- const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
+ XGL_CLEAR_COLOR_VALUE m_struct;
+ const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_shader_stage_create_info_struct_wrapper
+class xgl_buffer_memory_barrier_struct_wrapper
{
public:
- xgl_pipeline_shader_stage_create_info_struct_wrapper();
- xgl_pipeline_shader_stage_create_info_struct_wrapper(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
- xgl_pipeline_shader_stage_create_info_struct_wrapper(const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInStruct);
-
- virtual ~xgl_pipeline_shader_stage_create_info_struct_wrapper();
+ xgl_buffer_memory_barrier_struct_wrapper();
+ xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+ xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+
+ virtual ~xgl_buffer_memory_barrier_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_PIPELINE_SHADER get_shader() { return m_struct.shader; }
- void set_shader(XGL_PIPELINE_SHADER inValue) { m_struct.shader = inValue; }
+ XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+ void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+ XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+ void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+ XGL_BUFFER get_buffer() { return m_struct.buffer; }
+ void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
private:
- XGL_PIPELINE_SHADER_STAGE_CREATE_INFO m_struct;
- const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* m_origStructAddr;
+ XGL_BUFFER_MEMORY_BARRIER m_struct;
+ const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_barrier_struct_wrapper
+class xgl_pipeline_rs_state_create_info_struct_wrapper
{
public:
- xgl_pipeline_barrier_struct_wrapper();
- xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
- xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
+ xgl_pipeline_rs_state_create_info_struct_wrapper();
+ xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_pipeline_barrier_struct_wrapper();
+ virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_eventCount() { return m_struct.eventCount; }
- void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
- XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
- void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
- uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
- void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
+ bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
+ void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
+ bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
+ void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
+ bool32_t get_programPointSize() { return m_struct.programPointSize; }
+ void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
+ XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
+ void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
+ XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
+ void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
+ XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
+ void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
+ XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
+ void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
+ XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
+ void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
private:
- XGL_PIPELINE_BARRIER m_struct;
- const XGL_PIPELINE_BARRIER* m_origStructAddr;
+ XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_barrier_struct_wrapper
+class xgl_image_create_info_struct_wrapper
{
public:
- xgl_memory_barrier_struct_wrapper();
- xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
- xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
+ xgl_image_create_info_struct_wrapper();
+ xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
+ xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
- virtual ~xgl_memory_barrier_struct_wrapper();
+ virtual ~xgl_image_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
- void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
- XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
- void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
+ XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
+ void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+ uint32_t get_mipLevels() { return m_struct.mipLevels; }
+ void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+ XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
+ void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_MEMORY_BARRIER m_struct;
- const XGL_MEMORY_BARRIER* m_origStructAddr;
+ XGL_IMAGE_CREATE_INFO m_struct;
+ const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_ia_state_create_info_struct_wrapper
+class xgl_update_images_struct_wrapper
{
public:
- xgl_pipeline_ia_state_create_info_struct_wrapper();
- xgl_pipeline_ia_state_create_info_struct_wrapper(XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_ia_state_create_info_struct_wrapper(const XGL_PIPELINE_IA_STATE_CREATE_INFO* pInStruct);
+ xgl_update_images_struct_wrapper();
+ xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
+ xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
- virtual ~xgl_pipeline_ia_state_create_info_struct_wrapper();
+ virtual ~xgl_update_images_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_PRIMITIVE_TOPOLOGY get_topology() { return m_struct.topology; }
- void set_topology(XGL_PRIMITIVE_TOPOLOGY inValue) { m_struct.topology = inValue; }
- bool32_t get_disableVertexReuse() { return m_struct.disableVertexReuse; }
- void set_disableVertexReuse(bool32_t inValue) { m_struct.disableVertexReuse = inValue; }
- bool32_t get_primitiveRestartEnable() { return m_struct.primitiveRestartEnable; }
- void set_primitiveRestartEnable(bool32_t inValue) { m_struct.primitiveRestartEnable = inValue; }
- uint32_t get_primitiveRestartIndex() { return m_struct.primitiveRestartIndex; }
- void set_primitiveRestartIndex(uint32_t inValue) { m_struct.primitiveRestartIndex = inValue; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_PIPELINE_IA_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_IA_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_UPDATE_IMAGES m_struct;
+ const XGL_UPDATE_IMAGES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_cb_attachment_state_struct_wrapper
+class xgl_cmd_buffer_begin_info_struct_wrapper
{
public:
- xgl_pipeline_cb_attachment_state_struct_wrapper();
- xgl_pipeline_cb_attachment_state_struct_wrapper(XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
- xgl_pipeline_cb_attachment_state_struct_wrapper(const XGL_PIPELINE_CB_ATTACHMENT_STATE* pInStruct);
+ xgl_cmd_buffer_begin_info_struct_wrapper();
+ xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+ xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
- virtual ~xgl_pipeline_cb_attachment_state_struct_wrapper();
+ virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- bool32_t get_blendEnable() { return m_struct.blendEnable; }
- void set_blendEnable(bool32_t inValue) { m_struct.blendEnable = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_BLEND get_srcBlendColor() { return m_struct.srcBlendColor; }
- void set_srcBlendColor(XGL_BLEND inValue) { m_struct.srcBlendColor = inValue; }
- XGL_BLEND get_destBlendColor() { return m_struct.destBlendColor; }
- void set_destBlendColor(XGL_BLEND inValue) { m_struct.destBlendColor = inValue; }
- XGL_BLEND_FUNC get_blendFuncColor() { return m_struct.blendFuncColor; }
- void set_blendFuncColor(XGL_BLEND_FUNC inValue) { m_struct.blendFuncColor = inValue; }
- XGL_BLEND get_srcBlendAlpha() { return m_struct.srcBlendAlpha; }
- void set_srcBlendAlpha(XGL_BLEND inValue) { m_struct.srcBlendAlpha = inValue; }
- XGL_BLEND get_destBlendAlpha() { return m_struct.destBlendAlpha; }
- void set_destBlendAlpha(XGL_BLEND inValue) { m_struct.destBlendAlpha = inValue; }
- XGL_BLEND_FUNC get_blendFuncAlpha() { return m_struct.blendFuncAlpha; }
- void set_blendFuncAlpha(XGL_BLEND_FUNC inValue) { m_struct.blendFuncAlpha = inValue; }
- uint8_t get_channelWriteMask() { return m_struct.channelWriteMask; }
- void set_channelWriteMask(uint8_t inValue) { m_struct.channelWriteMask = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_PIPELINE_CB_ATTACHMENT_STATE m_struct;
- const XGL_PIPELINE_CB_ATTACHMENT_STATE* m_origStructAddr;
+ XGL_CMD_BUFFER_BEGIN_INFO m_struct;
+ const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_cmd_buffer_create_info_struct_wrapper
+class xgl_image_view_create_info_struct_wrapper
{
public:
- xgl_cmd_buffer_create_info_struct_wrapper();
- xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
- xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+ xgl_image_view_create_info_struct_wrapper();
+ xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+ xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
- virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
+ virtual ~xgl_image_view_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
- void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+ void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+ void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
+ void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
+ float get_minLod() { return m_struct.minLod; }
+ void set_minLod(float inValue) { m_struct.minLod = inValue; }
private:
- XGL_CMD_BUFFER_CREATE_INFO m_struct;
- const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
+ XGL_IMAGE_VIEW_CREATE_INFO m_struct;
+ const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_application_info_struct_wrapper
+class xgl_graphics_pipeline_create_info_struct_wrapper
{
public:
- xgl_application_info_struct_wrapper();
- xgl_application_info_struct_wrapper(XGL_APPLICATION_INFO* pInStruct);
- xgl_application_info_struct_wrapper(const XGL_APPLICATION_INFO* pInStruct);
+ xgl_graphics_pipeline_create_info_struct_wrapper();
+ xgl_graphics_pipeline_create_info_struct_wrapper(XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_graphics_pipeline_create_info_struct_wrapper(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInStruct);
- virtual ~xgl_application_info_struct_wrapper();
+ virtual ~xgl_graphics_pipeline_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- const char* get_pAppName() { return m_struct.pAppName; }
- uint32_t get_appVersion() { return m_struct.appVersion; }
- void set_appVersion(uint32_t inValue) { m_struct.appVersion = inValue; }
- const char* get_pEngineName() { return m_struct.pEngineName; }
- uint32_t get_engineVersion() { return m_struct.engineVersion; }
- void set_engineVersion(uint32_t inValue) { m_struct.engineVersion = inValue; }
- uint32_t get_apiVersion() { return m_struct.apiVersion; }
- void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
+ void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
private:
- XGL_APPLICATION_INFO m_struct;
- const XGL_APPLICATION_INFO* m_origStructAddr;
+ XGL_GRAPHICS_PIPELINE_CREATE_INFO m_struct;
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_rs_state_create_info_struct_wrapper
+class xgl_rect_struct_wrapper
{
public:
- xgl_pipeline_rs_state_create_info_struct_wrapper();
- xgl_pipeline_rs_state_create_info_struct_wrapper(XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_rs_state_create_info_struct_wrapper(const XGL_PIPELINE_RS_STATE_CREATE_INFO* pInStruct);
+ xgl_rect_struct_wrapper();
+ xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
+ xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
- virtual ~xgl_pipeline_rs_state_create_info_struct_wrapper();
+ virtual ~xgl_rect_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- bool32_t get_depthClipEnable() { return m_struct.depthClipEnable; }
- void set_depthClipEnable(bool32_t inValue) { m_struct.depthClipEnable = inValue; }
- bool32_t get_rasterizerDiscardEnable() { return m_struct.rasterizerDiscardEnable; }
- void set_rasterizerDiscardEnable(bool32_t inValue) { m_struct.rasterizerDiscardEnable = inValue; }
- bool32_t get_programPointSize() { return m_struct.programPointSize; }
- void set_programPointSize(bool32_t inValue) { m_struct.programPointSize = inValue; }
- XGL_COORDINATE_ORIGIN get_pointOrigin() { return m_struct.pointOrigin; }
- void set_pointOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.pointOrigin = inValue; }
- XGL_PROVOKING_VERTEX_CONVENTION get_provokingVertex() { return m_struct.provokingVertex; }
- void set_provokingVertex(XGL_PROVOKING_VERTEX_CONVENTION inValue) { m_struct.provokingVertex = inValue; }
- XGL_FILL_MODE get_fillMode() { return m_struct.fillMode; }
- void set_fillMode(XGL_FILL_MODE inValue) { m_struct.fillMode = inValue; }
- XGL_CULL_MODE get_cullMode() { return m_struct.cullMode; }
- void set_cullMode(XGL_CULL_MODE inValue) { m_struct.cullMode = inValue; }
- XGL_FACE_ORIENTATION get_frontFace() { return m_struct.frontFace; }
- void set_frontFace(XGL_FACE_ORIENTATION inValue) { m_struct.frontFace = inValue; }
+ XGL_OFFSET2D get_offset() { return m_struct.offset; }
+ void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
private:
- XGL_PIPELINE_RS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_RS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_RECT m_struct;
+ const XGL_RECT* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_color_attachment_view_create_info_struct_wrapper
+class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
{
public:
- xgl_color_attachment_view_create_info_struct_wrapper();
- xgl_color_attachment_view_create_info_struct_wrapper(XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
- xgl_color_attachment_view_create_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pInStruct);
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+ xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
- virtual ~xgl_color_attachment_view_create_info_struct_wrapper();
+ virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- uint32_t get_mipLevel() { return m_struct.mipLevel; }
- void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
- void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
- void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+ XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
+ void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
private:
- XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO m_struct;
- const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* m_origStructAddr;
+ XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
+ const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_memory_bind_info_struct_wrapper
+class xgl_device_queue_create_info_struct_wrapper
{
public:
- xgl_image_memory_bind_info_struct_wrapper();
- xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
- xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
+ xgl_device_queue_create_info_struct_wrapper();
+ xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+ xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
- virtual ~xgl_image_memory_bind_info_struct_wrapper();
+ virtual ~xgl_device_queue_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
- void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
- XGL_OFFSET3D get_offset() { return m_struct.offset; }
- void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+ uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
+ void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
+ uint32_t get_queueCount() { return m_struct.queueCount; }
+ void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
private:
- XGL_IMAGE_MEMORY_BIND_INFO m_struct;
- const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
+ XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
+ const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_subresource_struct_wrapper
+class xgl_memory_open_info_struct_wrapper
{
public:
- xgl_image_subresource_struct_wrapper();
- xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct);
- xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct);
+ xgl_memory_open_info_struct_wrapper();
+ xgl_memory_open_info_struct_wrapper(XGL_MEMORY_OPEN_INFO* pInStruct);
+ xgl_memory_open_info_struct_wrapper(const XGL_MEMORY_OPEN_INFO* pInStruct);
- virtual ~xgl_image_subresource_struct_wrapper();
+ virtual ~xgl_memory_open_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
- void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
- uint32_t get_mipLevel() { return m_struct.mipLevel; }
- void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
- uint32_t get_arraySlice() { return m_struct.arraySlice; }
- void set_arraySlice(uint32_t inValue) { m_struct.arraySlice = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_GPU_MEMORY get_sharedMem() { return m_struct.sharedMem; }
+ void set_sharedMem(XGL_GPU_MEMORY inValue) { m_struct.sharedMem = inValue; }
private:
- XGL_IMAGE_SUBRESOURCE m_struct;
- const XGL_IMAGE_SUBRESOURCE* m_origStructAddr;
+ XGL_MEMORY_OPEN_INFO m_struct;
+ const XGL_MEMORY_OPEN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_draw_indirect_cmd_struct_wrapper
+class xgl_update_as_copy_struct_wrapper
{
public:
- xgl_draw_indirect_cmd_struct_wrapper();
- xgl_draw_indirect_cmd_struct_wrapper(XGL_DRAW_INDIRECT_CMD* pInStruct);
- xgl_draw_indirect_cmd_struct_wrapper(const XGL_DRAW_INDIRECT_CMD* pInStruct);
+ xgl_update_as_copy_struct_wrapper();
+ xgl_update_as_copy_struct_wrapper(XGL_UPDATE_AS_COPY* pInStruct);
+ xgl_update_as_copy_struct_wrapper(const XGL_UPDATE_AS_COPY* pInStruct);
- virtual ~xgl_draw_indirect_cmd_struct_wrapper();
+ virtual ~xgl_update_as_copy_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_vertexCount() { return m_struct.vertexCount; }
- void set_vertexCount(uint32_t inValue) { m_struct.vertexCount = inValue; }
- uint32_t get_instanceCount() { return m_struct.instanceCount; }
- void set_instanceCount(uint32_t inValue) { m_struct.instanceCount = inValue; }
- uint32_t get_firstVertex() { return m_struct.firstVertex; }
- void set_firstVertex(uint32_t inValue) { m_struct.firstVertex = inValue; }
- uint32_t get_firstInstance() { return m_struct.firstInstance; }
- void set_firstInstance(uint32_t inValue) { m_struct.firstInstance = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ XGL_DESCRIPTOR_SET get_descriptorSet() { return m_struct.descriptorSet; }
+ void set_descriptorSet(XGL_DESCRIPTOR_SET inValue) { m_struct.descriptorSet = inValue; }
+ uint32_t get_descriptorIndex() { return m_struct.descriptorIndex; }
+ void set_descriptorIndex(uint32_t inValue) { m_struct.descriptorIndex = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_DRAW_INDIRECT_CMD m_struct;
- const XGL_DRAW_INDIRECT_CMD* m_origStructAddr;
+ XGL_UPDATE_AS_COPY m_struct;
+ const XGL_UPDATE_AS_COPY* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_view_create_info_struct_wrapper
+class xgl_image_copy_struct_wrapper
{
public:
- xgl_image_view_create_info_struct_wrapper();
- xgl_image_view_create_info_struct_wrapper(XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
- xgl_image_view_create_info_struct_wrapper(const XGL_IMAGE_VIEW_CREATE_INFO* pInStruct);
+ xgl_image_copy_struct_wrapper();
+ xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
+ xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
- virtual ~xgl_image_view_create_info_struct_wrapper();
+ virtual ~xgl_image_copy_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- XGL_IMAGE_VIEW_TYPE get_viewType() { return m_struct.viewType; }
- void set_viewType(XGL_IMAGE_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
- void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_subresourceRange() { return m_struct.subresourceRange; }
- void set_subresourceRange(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.subresourceRange = inValue; }
- float get_minLod() { return m_struct.minLod; }
- void set_minLod(float inValue) { m_struct.minLod = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
private:
- XGL_IMAGE_VIEW_CREATE_INFO m_struct;
- const XGL_IMAGE_VIEW_CREATE_INFO* m_origStructAddr;
+ XGL_IMAGE_COPY m_struct;
+ const XGL_IMAGE_COPY* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_cmd_buffer_begin_info_struct_wrapper
+class xgl_image_resolve_struct_wrapper
{
public:
- xgl_cmd_buffer_begin_info_struct_wrapper();
- xgl_cmd_buffer_begin_info_struct_wrapper(XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
- xgl_cmd_buffer_begin_info_struct_wrapper(const XGL_CMD_BUFFER_BEGIN_INFO* pInStruct);
+ xgl_image_resolve_struct_wrapper();
+ xgl_image_resolve_struct_wrapper(XGL_IMAGE_RESOLVE* pInStruct);
+ xgl_image_resolve_struct_wrapper(const XGL_IMAGE_RESOLVE* pInStruct);
- virtual ~xgl_cmd_buffer_begin_info_struct_wrapper();
+ virtual ~xgl_image_resolve_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
+ void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
+ XGL_OFFSET2D get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_OFFSET2D inValue) { m_struct.srcOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
+ void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
+ XGL_OFFSET2D get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_OFFSET2D inValue) { m_struct.destOffset = inValue; }
+ XGL_EXTENT2D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
private:
- XGL_CMD_BUFFER_BEGIN_INFO m_struct;
- const XGL_CMD_BUFFER_BEGIN_INFO* m_origStructAddr;
+ XGL_IMAGE_RESOLVE m_struct;
+ const XGL_IMAGE_RESOLVE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_copy_struct_wrapper
+class xgl_color_attachment_bind_info_struct_wrapper
{
public:
- xgl_image_copy_struct_wrapper();
- xgl_image_copy_struct_wrapper(XGL_IMAGE_COPY* pInStruct);
- xgl_image_copy_struct_wrapper(const XGL_IMAGE_COPY* pInStruct);
+ xgl_color_attachment_bind_info_struct_wrapper();
+ xgl_color_attachment_bind_info_struct_wrapper(XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
+ xgl_color_attachment_bind_info_struct_wrapper(const XGL_COLOR_ATTACHMENT_BIND_INFO* pInStruct);
- virtual ~xgl_image_copy_struct_wrapper();
+ virtual ~xgl_color_attachment_bind_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_SUBRESOURCE get_srcSubresource() { return m_struct.srcSubresource; }
- void set_srcSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.srcSubresource = inValue; }
- XGL_OFFSET3D get_srcOffset() { return m_struct.srcOffset; }
- void set_srcOffset(XGL_OFFSET3D inValue) { m_struct.srcOffset = inValue; }
- XGL_IMAGE_SUBRESOURCE get_destSubresource() { return m_struct.destSubresource; }
- void set_destSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.destSubresource = inValue; }
- XGL_OFFSET3D get_destOffset() { return m_struct.destOffset; }
- void set_destOffset(XGL_OFFSET3D inValue) { m_struct.destOffset = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+ XGL_COLOR_ATTACHMENT_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_COLOR_ATTACHMENT_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+ void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
private:
- XGL_IMAGE_COPY m_struct;
- const XGL_IMAGE_COPY* m_origStructAddr;
+ XGL_COLOR_ATTACHMENT_BIND_INFO m_struct;
+ const XGL_COLOR_ATTACHMENT_BIND_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_vp_state_create_info_struct_wrapper
+class xgl_dynamic_ds_state_create_info_struct_wrapper
{
public:
- xgl_pipeline_vp_state_create_info_struct_wrapper();
- xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_ds_state_create_info_struct_wrapper();
+ xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_pipeline_vp_state_create_info_struct_wrapper();
+ virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_numViewports() { return m_struct.numViewports; }
- void set_numViewports(uint32_t inValue) { m_struct.numViewports = inValue; }
- XGL_COORDINATE_ORIGIN get_clipOrigin() { return m_struct.clipOrigin; }
- void set_clipOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.clipOrigin = inValue; }
- XGL_DEPTH_MODE get_depthMode() { return m_struct.depthMode; }
- void set_depthMode(XGL_DEPTH_MODE inValue) { m_struct.depthMode = inValue; }
+ float get_minDepth() { return m_struct.minDepth; }
+ void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
+ float get_maxDepth() { return m_struct.maxDepth; }
+ void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
+ uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
+ void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
+ uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
+ void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
+ uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
+ void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
+ uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
+ void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
private:
- XGL_PIPELINE_VP_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_VP_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_physical_gpu_memory_properties_struct_wrapper
+class xgl_pipeline_ds_state_create_info_struct_wrapper
{
public:
- xgl_physical_gpu_memory_properties_struct_wrapper();
- xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
- xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+ xgl_pipeline_ds_state_create_info_struct_wrapper();
+ xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
+ virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
- void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
- bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
- void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
-
-
-private:
- XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
- const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
- uint32_t m_indent;
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
+ void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
+ bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
+ void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
+ XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
+ void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
+ bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
+ void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
+ bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
+ void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
+ XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
+ void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
+ XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
+ void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
+
+
+private:
+ XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
+ uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_alloc_buffer_info_struct_wrapper
+class xgl_pipeline_barrier_struct_wrapper
{
public:
- xgl_memory_alloc_buffer_info_struct_wrapper();
- xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
- xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
+ xgl_pipeline_barrier_struct_wrapper();
+ xgl_pipeline_barrier_struct_wrapper(XGL_PIPELINE_BARRIER* pInStruct);
+ xgl_pipeline_barrier_struct_wrapper(const XGL_PIPELINE_BARRIER* pInStruct);
- virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
+ virtual ~xgl_pipeline_barrier_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ uint32_t get_eventCount() { return m_struct.eventCount; }
+ void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+ XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+ void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+ uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+ void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
private:
- XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
- const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
+ XGL_PIPELINE_BARRIER m_struct;
+ const XGL_PIPELINE_BARRIER* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_compute_pipeline_create_info_struct_wrapper
+class xgl_physical_gpu_memory_properties_struct_wrapper
{
public:
- xgl_compute_pipeline_create_info_struct_wrapper();
- xgl_compute_pipeline_create_info_struct_wrapper(XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
- xgl_compute_pipeline_create_info_struct_wrapper(const XGL_COMPUTE_PIPELINE_CREATE_INFO* pInStruct);
+ xgl_physical_gpu_memory_properties_struct_wrapper();
+ xgl_physical_gpu_memory_properties_struct_wrapper(XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
+ xgl_physical_gpu_memory_properties_struct_wrapper(const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* pInStruct);
- virtual ~xgl_compute_pipeline_create_info_struct_wrapper();
+ virtual ~xgl_physical_gpu_memory_properties_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_PIPELINE_SHADER get_cs() { return m_struct.cs; }
- void set_cs(XGL_PIPELINE_SHADER inValue) { m_struct.cs = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
- XGL_DESCRIPTOR_SET_LAYOUT get_lastSetLayout() { return m_struct.lastSetLayout; }
- void set_lastSetLayout(XGL_DESCRIPTOR_SET_LAYOUT inValue) { m_struct.lastSetLayout = inValue; }
- uint32_t get_localSizeX() { return m_struct.localSizeX; }
- void set_localSizeX(uint32_t inValue) { m_struct.localSizeX = inValue; }
- uint32_t get_localSizeY() { return m_struct.localSizeY; }
- void set_localSizeY(uint32_t inValue) { m_struct.localSizeY = inValue; }
- uint32_t get_localSizeZ() { return m_struct.localSizeZ; }
- void set_localSizeZ(uint32_t inValue) { m_struct.localSizeZ = inValue; }
+ bool32_t get_supportsMigration() { return m_struct.supportsMigration; }
+ void set_supportsMigration(bool32_t inValue) { m_struct.supportsMigration = inValue; }
+ bool32_t get_supportsPinning() { return m_struct.supportsPinning; }
+ void set_supportsPinning(bool32_t inValue) { m_struct.supportsPinning = inValue; }
private:
- XGL_COMPUTE_PIPELINE_CREATE_INFO m_struct;
- const XGL_COMPUTE_PIPELINE_CREATE_INFO* m_origStructAddr;
+ XGL_PHYSICAL_GPU_MEMORY_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_MEMORY_PROPERTIES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_channel_mapping_struct_wrapper
+class xgl_memory_alloc_image_info_struct_wrapper
{
public:
- xgl_channel_mapping_struct_wrapper();
- xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
- xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
+ xgl_memory_alloc_image_info_struct_wrapper();
+ xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+ xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
- virtual ~xgl_channel_mapping_struct_wrapper();
+ virtual ~xgl_memory_alloc_image_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
- void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
- XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
- void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
- XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
- void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
- XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
- void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
+ XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
+ void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
+ uint32_t get_samples() { return m_struct.samples; }
+ void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
private:
- XGL_CHANNEL_MAPPING m_struct;
- const XGL_CHANNEL_MAPPING* m_origStructAddr;
+ XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
+ const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_peer_image_open_info_struct_wrapper
+class xgl_update_sampler_textures_struct_wrapper
{
public:
- xgl_peer_image_open_info_struct_wrapper();
- xgl_peer_image_open_info_struct_wrapper(XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
- xgl_peer_image_open_info_struct_wrapper(const XGL_PEER_IMAGE_OPEN_INFO* pInStruct);
+ xgl_update_sampler_textures_struct_wrapper();
+ xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+ xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
- virtual ~xgl_peer_image_open_info_struct_wrapper();
+ virtual ~xgl_update_sampler_textures_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE get_originalImage() { return m_struct.originalImage; }
- void set_originalImage(XGL_IMAGE inValue) { m_struct.originalImage = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_index() { return m_struct.index; }
+ void set_index(uint32_t inValue) { m_struct.index = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_PEER_IMAGE_OPEN_INFO m_struct;
- const XGL_PEER_IMAGE_OPEN_INFO* m_origStructAddr;
+ XGL_UPDATE_SAMPLER_TEXTURES m_struct;
+ const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_dynamic_vp_state_create_info_struct_wrapper
+class xgl_peer_memory_open_info_struct_wrapper
{
public:
- xgl_dynamic_vp_state_create_info_struct_wrapper();
- xgl_dynamic_vp_state_create_info_struct_wrapper(XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_vp_state_create_info_struct_wrapper(const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInStruct);
+ xgl_peer_memory_open_info_struct_wrapper();
+ xgl_peer_memory_open_info_struct_wrapper(XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
+ xgl_peer_memory_open_info_struct_wrapper(const XGL_PEER_MEMORY_OPEN_INFO* pInStruct);
- virtual ~xgl_dynamic_vp_state_create_info_struct_wrapper();
+ virtual ~xgl_peer_memory_open_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_viewportAndScissorCount() { return m_struct.viewportAndScissorCount; }
- void set_viewportAndScissorCount(uint32_t inValue) { m_struct.viewportAndScissorCount = inValue; }
+ XGL_GPU_MEMORY get_originalMem() { return m_struct.originalMem; }
+ void set_originalMem(XGL_GPU_MEMORY inValue) { m_struct.originalMem = inValue; }
private:
- XGL_DYNAMIC_VP_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_VP_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_PEER_MEMORY_OPEN_INFO m_struct;
+ const XGL_PEER_MEMORY_OPEN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_physical_gpu_performance_struct_wrapper
+class xgl_descriptor_type_count_struct_wrapper
{
public:
- xgl_physical_gpu_performance_struct_wrapper();
- xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
- xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+ xgl_descriptor_type_count_struct_wrapper();
+ xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+ xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
- virtual ~xgl_physical_gpu_performance_struct_wrapper();
+ virtual ~xgl_descriptor_type_count_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- float get_maxGpuClock() { return m_struct.maxGpuClock; }
- void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
- float get_aluPerClock() { return m_struct.aluPerClock; }
- void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
- float get_texPerClock() { return m_struct.texPerClock; }
- void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
- float get_primsPerClock() { return m_struct.primsPerClock; }
- void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
- float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
- void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
+ XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
+ void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
- const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
+ XGL_DESCRIPTOR_TYPE_COUNT m_struct;
+ const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_render_pass_create_info_struct_wrapper
+class xgl_dispatch_indirect_cmd_struct_wrapper
{
public:
- xgl_render_pass_create_info_struct_wrapper();
- xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct);
- xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct);
+ xgl_dispatch_indirect_cmd_struct_wrapper();
+ xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+ xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
- virtual ~xgl_render_pass_create_info_struct_wrapper();
+ virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ uint32_t get_x() { return m_struct.x; }
+ void set_x(uint32_t inValue) { m_struct.x = inValue; }
+ uint32_t get_y() { return m_struct.y; }
+ void set_y(uint32_t inValue) { m_struct.y = inValue; }
+ uint32_t get_z() { return m_struct.z; }
+ void set_z(uint32_t inValue) { m_struct.z = inValue; }
+
+
+private:
+ XGL_DISPATCH_INDIRECT_CMD m_struct;
+ const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_descriptor_region_create_info_struct_wrapper
+{
+public:
+ xgl_descriptor_region_create_info_struct_wrapper();
+ xgl_descriptor_region_create_info_struct_wrapper(XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+ xgl_descriptor_region_create_info_struct_wrapper(const XGL_DESCRIPTOR_REGION_CREATE_INFO* pInStruct);
+
+ virtual ~xgl_descriptor_region_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_RECT get_renderArea() { return m_struct.renderArea; }
- void set_renderArea(XGL_RECT inValue) { m_struct.renderArea = inValue; }
- XGL_FRAMEBUFFER get_framebuffer() { return m_struct.framebuffer; }
- void set_framebuffer(XGL_FRAMEBUFFER inValue) { m_struct.framebuffer = inValue; }
- uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
- void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
- XGL_ATTACHMENT_LOAD_OP get_depthLoadOp() { return m_struct.depthLoadOp; }
- void set_depthLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.depthLoadOp = inValue; }
- float get_depthLoadClearValue() { return m_struct.depthLoadClearValue; }
- void set_depthLoadClearValue(float inValue) { m_struct.depthLoadClearValue = inValue; }
- XGL_ATTACHMENT_STORE_OP get_depthStoreOp() { return m_struct.depthStoreOp; }
- void set_depthStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.depthStoreOp = inValue; }
- XGL_ATTACHMENT_LOAD_OP get_stencilLoadOp() { return m_struct.stencilLoadOp; }
- void set_stencilLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.stencilLoadOp = inValue; }
- uint32_t get_stencilLoadClearValue() { return m_struct.stencilLoadClearValue; }
- void set_stencilLoadClearValue(uint32_t inValue) { m_struct.stencilLoadClearValue = inValue; }
- XGL_ATTACHMENT_STORE_OP get_stencilStoreOp() { return m_struct.stencilStoreOp; }
- void set_stencilStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.stencilStoreOp = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_RENDER_PASS_CREATE_INFO m_struct;
- const XGL_RENDER_PASS_CREATE_INFO* m_origStructAddr;
+ XGL_DESCRIPTOR_REGION_CREATE_INFO m_struct;
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_dynamic_ds_state_create_info_struct_wrapper
+class xgl_depth_stencil_view_create_info_struct_wrapper
{
public:
- xgl_dynamic_ds_state_create_info_struct_wrapper();
- xgl_dynamic_ds_state_create_info_struct_wrapper(XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
- xgl_dynamic_ds_state_create_info_struct_wrapper(const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_depth_stencil_view_create_info_struct_wrapper();
+ xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+ xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
- virtual ~xgl_dynamic_ds_state_create_info_struct_wrapper();
+ virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- float get_minDepth() { return m_struct.minDepth; }
- void set_minDepth(float inValue) { m_struct.minDepth = inValue; }
- float get_maxDepth() { return m_struct.maxDepth; }
- void set_maxDepth(float inValue) { m_struct.maxDepth = inValue; }
- uint32_t get_stencilReadMask() { return m_struct.stencilReadMask; }
- void set_stencilReadMask(uint32_t inValue) { m_struct.stencilReadMask = inValue; }
- uint32_t get_stencilWriteMask() { return m_struct.stencilWriteMask; }
- void set_stencilWriteMask(uint32_t inValue) { m_struct.stencilWriteMask = inValue; }
- uint32_t get_stencilFrontRef() { return m_struct.stencilFrontRef; }
- void set_stencilFrontRef(uint32_t inValue) { m_struct.stencilFrontRef = inValue; }
- uint32_t get_stencilBackRef() { return m_struct.stencilBackRef; }
- void set_stencilBackRef(uint32_t inValue) { m_struct.stencilBackRef = inValue; }
+ XGL_IMAGE get_image() { return m_struct.image; }
+ void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
+ uint32_t get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+ uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
+ void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
+ uint32_t get_arraySize() { return m_struct.arraySize; }
+ void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
+ void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
+ XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
+ void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_DYNAMIC_DS_STATE_CREATE_INFO m_struct;
- const XGL_DYNAMIC_DS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_create_info_struct_wrapper
+class xgl_query_pool_create_info_struct_wrapper
{
public:
- xgl_buffer_create_info_struct_wrapper();
- xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
- xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
+ xgl_query_pool_create_info_struct_wrapper();
+ xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+ xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
- virtual ~xgl_buffer_create_info_struct_wrapper();
+ virtual ~xgl_query_pool_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_GPU_SIZE get_size() { return m_struct.size; }
- void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
+ void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
+ uint32_t get_slots() { return m_struct.slots; }
+ void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
private:
- XGL_BUFFER_CREATE_INFO m_struct;
- const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
+ XGL_QUERY_POOL_CREATE_INFO m_struct;
+ const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_cmd_buffer_graphics_begin_info_struct_wrapper
+class xgl_cmd_buffer_create_info_struct_wrapper
{
public:
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
- xgl_cmd_buffer_graphics_begin_info_struct_wrapper(const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pInStruct);
+ xgl_cmd_buffer_create_info_struct_wrapper();
+ xgl_cmd_buffer_create_info_struct_wrapper(XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
+ xgl_cmd_buffer_create_info_struct_wrapper(const XGL_CMD_BUFFER_CREATE_INFO* pInStruct);
- virtual ~xgl_cmd_buffer_graphics_begin_info_struct_wrapper();
+ virtual ~xgl_cmd_buffer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_RENDER_PASS get_renderPass() { return m_struct.renderPass; }
- void set_renderPass(XGL_RENDER_PASS inValue) { m_struct.renderPass = inValue; }
+ XGL_QUEUE_TYPE get_queueType() { return m_struct.queueType; }
+ void set_queueType(XGL_QUEUE_TYPE inValue) { m_struct.queueType = inValue; }
+ XGL_FLAGS get_flags() { return m_struct.flags; }
+ void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO m_struct;
- const XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* m_origStructAddr;
+ XGL_CMD_BUFFER_CREATE_INFO m_struct;
+ const XGL_CMD_BUFFER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_rect_struct_wrapper
+class xgl_depth_stencil_bind_info_struct_wrapper
{
public:
- xgl_rect_struct_wrapper();
- xgl_rect_struct_wrapper(XGL_RECT* pInStruct);
- xgl_rect_struct_wrapper(const XGL_RECT* pInStruct);
+ xgl_depth_stencil_bind_info_struct_wrapper();
+ xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+ xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
- virtual ~xgl_rect_struct_wrapper();
+ virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_OFFSET2D get_offset() { return m_struct.offset; }
- void set_offset(XGL_OFFSET2D inValue) { m_struct.offset = inValue; }
- XGL_EXTENT2D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT2D inValue) { m_struct.extent = inValue; }
+ XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+ void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
private:
- XGL_RECT m_struct;
- const XGL_RECT* m_origStructAddr;
+ XGL_DEPTH_STENCIL_BIND_INFO m_struct;
+ const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_memory_barrier_struct_wrapper
+class xgl_memory_requirements_struct_wrapper
{
public:
- xgl_buffer_memory_barrier_struct_wrapper();
- xgl_buffer_memory_barrier_struct_wrapper(XGL_BUFFER_MEMORY_BARRIER* pInStruct);
- xgl_buffer_memory_barrier_struct_wrapper(const XGL_BUFFER_MEMORY_BARRIER* pInStruct);
+ xgl_memory_requirements_struct_wrapper();
+ xgl_memory_requirements_struct_wrapper(XGL_MEMORY_REQUIREMENTS* pInStruct);
+ xgl_memory_requirements_struct_wrapper(const XGL_MEMORY_REQUIREMENTS* pInStruct);
- virtual ~xgl_buffer_memory_barrier_struct_wrapper();
+ virtual ~xgl_memory_requirements_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
- void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
- XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
- void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
- XGL_BUFFER get_buffer() { return m_struct.buffer; }
- void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
- XGL_GPU_SIZE get_offset() { return m_struct.offset; }
- void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
XGL_GPU_SIZE get_size() { return m_struct.size; }
void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_GPU_SIZE get_alignment() { return m_struct.alignment; }
+ void set_alignment(XGL_GPU_SIZE inValue) { m_struct.alignment = inValue; }
+ XGL_GPU_SIZE get_granularity() { return m_struct.granularity; }
+ void set_granularity(XGL_GPU_SIZE inValue) { m_struct.granularity = inValue; }
+ XGL_FLAGS get_memProps() { return m_struct.memProps; }
+ void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+ XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+ void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
private:
- XGL_BUFFER_MEMORY_BARRIER m_struct;
- const XGL_BUFFER_MEMORY_BARRIER* m_origStructAddr;
+ XGL_MEMORY_REQUIREMENTS m_struct;
+ const XGL_MEMORY_REQUIREMENTS* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_ds_state_create_info_struct_wrapper
+class xgl_queue_semaphore_open_info_struct_wrapper
{
public:
- xgl_pipeline_ds_state_create_info_struct_wrapper();
- xgl_pipeline_ds_state_create_info_struct_wrapper(XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_ds_state_create_info_struct_wrapper(const XGL_PIPELINE_DS_STATE_CREATE_INFO* pInStruct);
+ xgl_queue_semaphore_open_info_struct_wrapper();
+ xgl_queue_semaphore_open_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
+ xgl_queue_semaphore_open_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pInStruct);
- virtual ~xgl_pipeline_ds_state_create_info_struct_wrapper();
+ virtual ~xgl_queue_semaphore_open_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- bool32_t get_depthTestEnable() { return m_struct.depthTestEnable; }
- void set_depthTestEnable(bool32_t inValue) { m_struct.depthTestEnable = inValue; }
- bool32_t get_depthWriteEnable() { return m_struct.depthWriteEnable; }
- void set_depthWriteEnable(bool32_t inValue) { m_struct.depthWriteEnable = inValue; }
- XGL_COMPARE_FUNC get_depthFunc() { return m_struct.depthFunc; }
- void set_depthFunc(XGL_COMPARE_FUNC inValue) { m_struct.depthFunc = inValue; }
- bool32_t get_depthBoundsEnable() { return m_struct.depthBoundsEnable; }
- void set_depthBoundsEnable(bool32_t inValue) { m_struct.depthBoundsEnable = inValue; }
- bool32_t get_stencilTestEnable() { return m_struct.stencilTestEnable; }
- void set_stencilTestEnable(bool32_t inValue) { m_struct.stencilTestEnable = inValue; }
- XGL_STENCIL_OP_STATE get_front() { return m_struct.front; }
- void set_front(XGL_STENCIL_OP_STATE inValue) { m_struct.front = inValue; }
- XGL_STENCIL_OP_STATE get_back() { return m_struct.back; }
- void set_back(XGL_STENCIL_OP_STATE inValue) { m_struct.back = inValue; }
+ XGL_QUEUE_SEMAPHORE get_sharedSemaphore() { return m_struct.sharedSemaphore; }
+ void set_sharedSemaphore(XGL_QUEUE_SEMAPHORE inValue) { m_struct.sharedSemaphore = inValue; }
private:
- XGL_PIPELINE_DS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_DS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_QUEUE_SEMAPHORE_OPEN_INFO m_struct;
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_descriptor_type_count_struct_wrapper
+class xgl_memory_barrier_struct_wrapper
{
public:
- xgl_descriptor_type_count_struct_wrapper();
- xgl_descriptor_type_count_struct_wrapper(XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
- xgl_descriptor_type_count_struct_wrapper(const XGL_DESCRIPTOR_TYPE_COUNT* pInStruct);
+ xgl_memory_barrier_struct_wrapper();
+ xgl_memory_barrier_struct_wrapper(XGL_MEMORY_BARRIER* pInStruct);
+ xgl_memory_barrier_struct_wrapper(const XGL_MEMORY_BARRIER* pInStruct);
- virtual ~xgl_descriptor_type_count_struct_wrapper();
+ virtual ~xgl_memory_barrier_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_DESCRIPTOR_TYPE get_type() { return m_struct.type; }
- void set_type(XGL_DESCRIPTOR_TYPE inValue) { m_struct.type = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_FLAGS get_outputMask() { return m_struct.outputMask; }
+ void set_outputMask(XGL_FLAGS inValue) { m_struct.outputMask = inValue; }
+ XGL_FLAGS get_inputMask() { return m_struct.inputMask; }
+ void set_inputMask(XGL_FLAGS inValue) { m_struct.inputMask = inValue; }
private:
- XGL_DESCRIPTOR_TYPE_COUNT m_struct;
- const XGL_DESCRIPTOR_TYPE_COUNT* m_origStructAddr;
+ XGL_MEMORY_BARRIER m_struct;
+ const XGL_MEMORY_BARRIER* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_update_sampler_textures_struct_wrapper
+class xgl_physical_gpu_performance_struct_wrapper
{
public:
- xgl_update_sampler_textures_struct_wrapper();
- xgl_update_sampler_textures_struct_wrapper(XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
- xgl_update_sampler_textures_struct_wrapper(const XGL_UPDATE_SAMPLER_TEXTURES* pInStruct);
+ xgl_physical_gpu_performance_struct_wrapper();
+ xgl_physical_gpu_performance_struct_wrapper(XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
+ xgl_physical_gpu_performance_struct_wrapper(const XGL_PHYSICAL_GPU_PERFORMANCE* pInStruct);
- virtual ~xgl_update_sampler_textures_struct_wrapper();
+ virtual ~xgl_physical_gpu_performance_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ float get_maxGpuClock() { return m_struct.maxGpuClock; }
+ void set_maxGpuClock(float inValue) { m_struct.maxGpuClock = inValue; }
+ float get_aluPerClock() { return m_struct.aluPerClock; }
+ void set_aluPerClock(float inValue) { m_struct.aluPerClock = inValue; }
+ float get_texPerClock() { return m_struct.texPerClock; }
+ void set_texPerClock(float inValue) { m_struct.texPerClock = inValue; }
+ float get_primsPerClock() { return m_struct.primsPerClock; }
+ void set_primsPerClock(float inValue) { m_struct.primsPerClock = inValue; }
+ float get_pixelsPerClock() { return m_struct.pixelsPerClock; }
+ void set_pixelsPerClock(float inValue) { m_struct.pixelsPerClock = inValue; }
private:
- XGL_UPDATE_SAMPLER_TEXTURES m_struct;
- const XGL_UPDATE_SAMPLER_TEXTURES* m_origStructAddr;
+ XGL_PHYSICAL_GPU_PERFORMANCE m_struct;
+ const XGL_PHYSICAL_GPU_PERFORMANCE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_query_pool_create_info_struct_wrapper
+class xgl_channel_mapping_struct_wrapper
{
public:
- xgl_query_pool_create_info_struct_wrapper();
- xgl_query_pool_create_info_struct_wrapper(XGL_QUERY_POOL_CREATE_INFO* pInStruct);
- xgl_query_pool_create_info_struct_wrapper(const XGL_QUERY_POOL_CREATE_INFO* pInStruct);
+ xgl_channel_mapping_struct_wrapper();
+ xgl_channel_mapping_struct_wrapper(XGL_CHANNEL_MAPPING* pInStruct);
+ xgl_channel_mapping_struct_wrapper(const XGL_CHANNEL_MAPPING* pInStruct);
- virtual ~xgl_query_pool_create_info_struct_wrapper();
+ virtual ~xgl_channel_mapping_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_QUERY_TYPE get_queryType() { return m_struct.queryType; }
- void set_queryType(XGL_QUERY_TYPE inValue) { m_struct.queryType = inValue; }
- uint32_t get_slots() { return m_struct.slots; }
- void set_slots(uint32_t inValue) { m_struct.slots = inValue; }
+ XGL_CHANNEL_SWIZZLE get_r() { return m_struct.r; }
+ void set_r(XGL_CHANNEL_SWIZZLE inValue) { m_struct.r = inValue; }
+ XGL_CHANNEL_SWIZZLE get_g() { return m_struct.g; }
+ void set_g(XGL_CHANNEL_SWIZZLE inValue) { m_struct.g = inValue; }
+ XGL_CHANNEL_SWIZZLE get_b() { return m_struct.b; }
+ void set_b(XGL_CHANNEL_SWIZZLE inValue) { m_struct.b = inValue; }
+ XGL_CHANNEL_SWIZZLE get_a() { return m_struct.a; }
+ void set_a(XGL_CHANNEL_SWIZZLE inValue) { m_struct.a = inValue; }
private:
- XGL_QUERY_POOL_CREATE_INFO m_struct;
- const XGL_QUERY_POOL_CREATE_INFO* m_origStructAddr;
+ XGL_CHANNEL_MAPPING m_struct;
+ const XGL_CHANNEL_MAPPING* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_event_create_info_struct_wrapper
+class xgl_clear_color_struct_wrapper
{
public:
- xgl_event_create_info_struct_wrapper();
- xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
- xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
+ xgl_clear_color_struct_wrapper();
+ xgl_clear_color_struct_wrapper(XGL_CLEAR_COLOR* pInStruct);
+ xgl_clear_color_struct_wrapper(const XGL_CLEAR_COLOR* pInStruct);
- virtual ~xgl_event_create_info_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
-
-
-private:
- XGL_EVENT_CREATE_INFO m_struct;
- const XGL_EVENT_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_offset2d_struct_wrapper
-{
-public:
- xgl_offset2d_struct_wrapper();
- xgl_offset2d_struct_wrapper(XGL_OFFSET2D* pInStruct);
- xgl_offset2d_struct_wrapper(const XGL_OFFSET2D* pInStruct);
-
- virtual ~xgl_offset2d_struct_wrapper();
+ virtual ~xgl_clear_color_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_x() { return m_struct.x; }
- void set_x(int32_t inValue) { m_struct.x = inValue; }
- int32_t get_y() { return m_struct.y; }
- void set_y(int32_t inValue) { m_struct.y = inValue; }
+ XGL_CLEAR_COLOR_VALUE get_color() { return m_struct.color; }
+ void set_color(XGL_CLEAR_COLOR_VALUE inValue) { m_struct.color = inValue; }
+ bool32_t get_useRawValue() { return m_struct.useRawValue; }
+ void set_useRawValue(bool32_t inValue) { m_struct.useRawValue = inValue; }
private:
- XGL_OFFSET2D m_struct;
- const XGL_OFFSET2D* m_origStructAddr;
+ XGL_CLEAR_COLOR m_struct;
+ const XGL_CLEAR_COLOR* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_update_buffers_struct_wrapper
+class xgl_dynamic_cb_state_create_info_struct_wrapper
{
public:
- xgl_update_buffers_struct_wrapper();
- xgl_update_buffers_struct_wrapper(XGL_UPDATE_BUFFERS* pInStruct);
- xgl_update_buffers_struct_wrapper(const XGL_UPDATE_BUFFERS* pInStruct);
+ xgl_dynamic_cb_state_create_info_struct_wrapper();
+ xgl_dynamic_cb_state_create_info_struct_wrapper(XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
+ xgl_dynamic_cb_state_create_info_struct_wrapper(const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_update_buffers_struct_wrapper();
+ virtual ~xgl_dynamic_cb_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
private:
- XGL_UPDATE_BUFFERS m_struct;
- const XGL_UPDATE_BUFFERS* m_origStructAddr;
+ XGL_DYNAMIC_CB_STATE_CREATE_INFO m_struct;
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_ref_struct_wrapper
+class xgl_buffer_view_create_info_struct_wrapper
{
public:
- xgl_memory_ref_struct_wrapper();
- xgl_memory_ref_struct_wrapper(XGL_MEMORY_REF* pInStruct);
- xgl_memory_ref_struct_wrapper(const XGL_MEMORY_REF* pInStruct);
+ xgl_buffer_view_create_info_struct_wrapper();
+ xgl_buffer_view_create_info_struct_wrapper(XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
+ xgl_buffer_view_create_info_struct_wrapper(const XGL_BUFFER_VIEW_CREATE_INFO* pInStruct);
- virtual ~xgl_memory_ref_struct_wrapper();
+ virtual ~xgl_buffer_view_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_GPU_MEMORY get_mem() { return m_struct.mem; }
- void set_mem(XGL_GPU_MEMORY inValue) { m_struct.mem = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_BUFFER get_buffer() { return m_struct.buffer; }
+ void set_buffer(XGL_BUFFER inValue) { m_struct.buffer = inValue; }
+ XGL_BUFFER_VIEW_TYPE get_viewType() { return m_struct.viewType; }
+ void set_viewType(XGL_BUFFER_VIEW_TYPE inValue) { m_struct.viewType = inValue; }
+ XGL_GPU_SIZE get_stride() { return m_struct.stride; }
+ void set_stride(XGL_GPU_SIZE inValue) { m_struct.stride = inValue; }
+ XGL_FORMAT get_format() { return m_struct.format; }
+ void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
+ XGL_CHANNEL_MAPPING get_channels() { return m_struct.channels; }
+ void set_channels(XGL_CHANNEL_MAPPING inValue) { m_struct.channels = inValue; }
+ XGL_GPU_SIZE get_offset() { return m_struct.offset; }
+ void set_offset(XGL_GPU_SIZE inValue) { m_struct.offset = inValue; }
+ XGL_GPU_SIZE get_range() { return m_struct.range; }
+ void set_range(XGL_GPU_SIZE inValue) { m_struct.range = inValue; }
private:
- XGL_MEMORY_REF m_struct;
- const XGL_MEMORY_REF* m_origStructAddr;
+ XGL_BUFFER_VIEW_CREATE_INFO m_struct;
+ const XGL_BUFFER_VIEW_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_buffer_view_attach_info_struct_wrapper
+class xgl_sampler_create_info_struct_wrapper
{
public:
- xgl_buffer_view_attach_info_struct_wrapper();
- xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
- xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+ xgl_sampler_create_info_struct_wrapper();
+ xgl_sampler_create_info_struct_wrapper(XGL_SAMPLER_CREATE_INFO* pInStruct);
+ xgl_sampler_create_info_struct_wrapper(const XGL_SAMPLER_CREATE_INFO* pInStruct);
- virtual ~xgl_buffer_view_attach_info_struct_wrapper();
+ virtual ~xgl_sampler_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_BUFFER_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
+ XGL_TEX_FILTER get_magFilter() { return m_struct.magFilter; }
+ void set_magFilter(XGL_TEX_FILTER inValue) { m_struct.magFilter = inValue; }
+ XGL_TEX_FILTER get_minFilter() { return m_struct.minFilter; }
+ void set_minFilter(XGL_TEX_FILTER inValue) { m_struct.minFilter = inValue; }
+ XGL_TEX_MIPMAP_MODE get_mipMode() { return m_struct.mipMode; }
+ void set_mipMode(XGL_TEX_MIPMAP_MODE inValue) { m_struct.mipMode = inValue; }
+ XGL_TEX_ADDRESS get_addressU() { return m_struct.addressU; }
+ void set_addressU(XGL_TEX_ADDRESS inValue) { m_struct.addressU = inValue; }
+ XGL_TEX_ADDRESS get_addressV() { return m_struct.addressV; }
+ void set_addressV(XGL_TEX_ADDRESS inValue) { m_struct.addressV = inValue; }
+ XGL_TEX_ADDRESS get_addressW() { return m_struct.addressW; }
+ void set_addressW(XGL_TEX_ADDRESS inValue) { m_struct.addressW = inValue; }
+ float get_mipLodBias() { return m_struct.mipLodBias; }
+ void set_mipLodBias(float inValue) { m_struct.mipLodBias = inValue; }
+ uint32_t get_maxAnisotropy() { return m_struct.maxAnisotropy; }
+ void set_maxAnisotropy(uint32_t inValue) { m_struct.maxAnisotropy = inValue; }
+ XGL_COMPARE_FUNC get_compareFunc() { return m_struct.compareFunc; }
+ void set_compareFunc(XGL_COMPARE_FUNC inValue) { m_struct.compareFunc = inValue; }
+ float get_minLod() { return m_struct.minLod; }
+ void set_minLod(float inValue) { m_struct.minLod = inValue; }
+ float get_maxLod() { return m_struct.maxLod; }
+ void set_maxLod(float inValue) { m_struct.maxLod = inValue; }
+ XGL_BORDER_COLOR_TYPE get_borderColorType() { return m_struct.borderColorType; }
+ void set_borderColorType(XGL_BORDER_COLOR_TYPE inValue) { m_struct.borderColorType = inValue; }
private:
- XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
- const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
+ XGL_SAMPLER_CREATE_INFO m_struct;
+ const XGL_SAMPLER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_vertex_input_create_info_struct_wrapper
+class xgl_event_wait_info_struct_wrapper
{
public:
- xgl_pipeline_vertex_input_create_info_struct_wrapper();
- xgl_pipeline_vertex_input_create_info_struct_wrapper(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
- xgl_pipeline_vertex_input_create_info_struct_wrapper(const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pInStruct);
+ xgl_event_wait_info_struct_wrapper();
+ xgl_event_wait_info_struct_wrapper(XGL_EVENT_WAIT_INFO* pInStruct);
+ xgl_event_wait_info_struct_wrapper(const XGL_EVENT_WAIT_INFO* pInStruct);
- virtual ~xgl_pipeline_vertex_input_create_info_struct_wrapper();
+ virtual ~xgl_event_wait_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_bindingCount() { return m_struct.bindingCount; }
- void set_bindingCount(uint32_t inValue) { m_struct.bindingCount = inValue; }
- uint32_t get_attributeCount() { return m_struct.attributeCount; }
- void set_attributeCount(uint32_t inValue) { m_struct.attributeCount = inValue; }
+ uint32_t get_eventCount() { return m_struct.eventCount; }
+ void set_eventCount(uint32_t inValue) { m_struct.eventCount = inValue; }
+ XGL_WAIT_EVENT get_waitEvent() { return m_struct.waitEvent; }
+ void set_waitEvent(XGL_WAIT_EVENT inValue) { m_struct.waitEvent = inValue; }
+ uint32_t get_memBarrierCount() { return m_struct.memBarrierCount; }
+ void set_memBarrierCount(uint32_t inValue) { m_struct.memBarrierCount = inValue; }
private:
- XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_struct;
- const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* m_origStructAddr;
+ XGL_EVENT_WAIT_INFO m_struct;
+ const XGL_EVENT_WAIT_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_gpu_compatibility_info_struct_wrapper
+class xgl_buffer_image_copy_struct_wrapper
{
public:
- xgl_gpu_compatibility_info_struct_wrapper();
- xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct);
- xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+ xgl_buffer_image_copy_struct_wrapper();
+ xgl_buffer_image_copy_struct_wrapper(XGL_BUFFER_IMAGE_COPY* pInStruct);
+ xgl_buffer_image_copy_struct_wrapper(const XGL_BUFFER_IMAGE_COPY* pInStruct);
- virtual ~xgl_gpu_compatibility_info_struct_wrapper();
+ virtual ~xgl_buffer_image_copy_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; }
- void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; }
+ XGL_GPU_SIZE get_bufferOffset() { return m_struct.bufferOffset; }
+ void set_bufferOffset(XGL_GPU_SIZE inValue) { m_struct.bufferOffset = inValue; }
+ XGL_IMAGE_SUBRESOURCE get_imageSubresource() { return m_struct.imageSubresource; }
+ void set_imageSubresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.imageSubresource = inValue; }
+ XGL_OFFSET3D get_imageOffset() { return m_struct.imageOffset; }
+ void set_imageOffset(XGL_OFFSET3D inValue) { m_struct.imageOffset = inValue; }
+ XGL_EXTENT3D get_imageExtent() { return m_struct.imageExtent; }
+ void set_imageExtent(XGL_EXTENT3D inValue) { m_struct.imageExtent = inValue; }
private:
- XGL_GPU_COMPATIBILITY_INFO m_struct;
- const XGL_GPU_COMPATIBILITY_INFO* m_origStructAddr;
+ XGL_BUFFER_IMAGE_COPY m_struct;
+ const XGL_BUFFER_IMAGE_COPY* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_shader_create_info_struct_wrapper
+class xgl_event_create_info_struct_wrapper
{
public:
- xgl_shader_create_info_struct_wrapper();
- xgl_shader_create_info_struct_wrapper(XGL_SHADER_CREATE_INFO* pInStruct);
- xgl_shader_create_info_struct_wrapper(const XGL_SHADER_CREATE_INFO* pInStruct);
+ xgl_event_create_info_struct_wrapper();
+ xgl_event_create_info_struct_wrapper(XGL_EVENT_CREATE_INFO* pInStruct);
+ xgl_event_create_info_struct_wrapper(const XGL_EVENT_CREATE_INFO* pInStruct);
- virtual ~xgl_shader_create_info_struct_wrapper();
+ virtual ~xgl_event_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- size_t get_codeSize() { return m_struct.codeSize; }
- void set_codeSize(size_t inValue) { m_struct.codeSize = inValue; }
- const void* get_pCode() { return m_struct.pCode; }
XGL_FLAGS get_flags() { return m_struct.flags; }
void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_SHADER_CREATE_INFO m_struct;
- const XGL_SHADER_CREATE_INFO* m_origStructAddr;
+ XGL_EVENT_CREATE_INFO m_struct;
+ const XGL_EVENT_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_offset3d_struct_wrapper
+class xgl_physical_gpu_properties_struct_wrapper
{
public:
- xgl_offset3d_struct_wrapper();
- xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
- xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
+ xgl_physical_gpu_properties_struct_wrapper();
+ xgl_physical_gpu_properties_struct_wrapper(XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
+ xgl_physical_gpu_properties_struct_wrapper(const XGL_PHYSICAL_GPU_PROPERTIES* pInStruct);
- virtual ~xgl_offset3d_struct_wrapper();
+ virtual ~xgl_physical_gpu_properties_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- int32_t get_x() { return m_struct.x; }
- void set_x(int32_t inValue) { m_struct.x = inValue; }
- int32_t get_y() { return m_struct.y; }
- void set_y(int32_t inValue) { m_struct.y = inValue; }
- int32_t get_z() { return m_struct.z; }
- void set_z(int32_t inValue) { m_struct.z = inValue; }
+ uint32_t get_apiVersion() { return m_struct.apiVersion; }
+ void set_apiVersion(uint32_t inValue) { m_struct.apiVersion = inValue; }
+ uint32_t get_driverVersion() { return m_struct.driverVersion; }
+ void set_driverVersion(uint32_t inValue) { m_struct.driverVersion = inValue; }
+ uint32_t get_vendorId() { return m_struct.vendorId; }
+ void set_vendorId(uint32_t inValue) { m_struct.vendorId = inValue; }
+ uint32_t get_deviceId() { return m_struct.deviceId; }
+ void set_deviceId(uint32_t inValue) { m_struct.deviceId = inValue; }
+ XGL_PHYSICAL_GPU_TYPE get_gpuType() { return m_struct.gpuType; }
+ void set_gpuType(XGL_PHYSICAL_GPU_TYPE inValue) { m_struct.gpuType = inValue; }
+ uint32_t get_maxMemRefsPerSubmission() { return m_struct.maxMemRefsPerSubmission; }
+ void set_maxMemRefsPerSubmission(uint32_t inValue) { m_struct.maxMemRefsPerSubmission = inValue; }
+ XGL_GPU_SIZE get_maxInlineMemoryUpdateSize() { return m_struct.maxInlineMemoryUpdateSize; }
+ void set_maxInlineMemoryUpdateSize(XGL_GPU_SIZE inValue) { m_struct.maxInlineMemoryUpdateSize = inValue; }
+ uint32_t get_maxBoundDescriptorSets() { return m_struct.maxBoundDescriptorSets; }
+ void set_maxBoundDescriptorSets(uint32_t inValue) { m_struct.maxBoundDescriptorSets = inValue; }
+ uint32_t get_maxThreadGroupSize() { return m_struct.maxThreadGroupSize; }
+ void set_maxThreadGroupSize(uint32_t inValue) { m_struct.maxThreadGroupSize = inValue; }
+ uint64_t get_timestampFrequency() { return m_struct.timestampFrequency; }
+ void set_timestampFrequency(uint64_t inValue) { m_struct.timestampFrequency = inValue; }
+ bool32_t get_multiColorAttachmentClears() { return m_struct.multiColorAttachmentClears; }
+ void set_multiColorAttachmentClears(bool32_t inValue) { m_struct.multiColorAttachmentClears = inValue; }
+ uint32_t get_maxDescriptorSets() { return m_struct.maxDescriptorSets; }
+ void set_maxDescriptorSets(uint32_t inValue) { m_struct.maxDescriptorSets = inValue; }
+ uint32_t get_maxViewports() { return m_struct.maxViewports; }
+ void set_maxViewports(uint32_t inValue) { m_struct.maxViewports = inValue; }
+ uint32_t get_maxColorAttachments() { return m_struct.maxColorAttachments; }
+ void set_maxColorAttachments(uint32_t inValue) { m_struct.maxColorAttachments = inValue; }
private:
- XGL_OFFSET3D m_struct;
- const XGL_OFFSET3D* m_origStructAddr;
+ XGL_PHYSICAL_GPU_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_PROPERTIES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_layer_create_info_struct_wrapper
+class xgl_image_view_attach_info_struct_wrapper
{
public:
- xgl_layer_create_info_struct_wrapper();
- xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
- xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
+ xgl_image_view_attach_info_struct_wrapper();
+ xgl_image_view_attach_info_struct_wrapper(XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
+ xgl_image_view_attach_info_struct_wrapper(const XGL_IMAGE_VIEW_ATTACH_INFO* pInStruct);
- virtual ~xgl_layer_create_info_struct_wrapper();
+ virtual ~xgl_image_view_attach_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_layerCount() { return m_struct.layerCount; }
- void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
+ XGL_IMAGE_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_IMAGE_VIEW inValue) { m_struct.view = inValue; }
+ XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
+ void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
private:
- XGL_LAYER_CREATE_INFO m_struct;
- const XGL_LAYER_CREATE_INFO* m_origStructAddr;
+ XGL_IMAGE_VIEW_ATTACH_INFO m_struct;
+ const XGL_IMAGE_VIEW_ATTACH_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_depth_stencil_view_create_info_struct_wrapper
+class xgl_memory_alloc_buffer_info_struct_wrapper
{
public:
- xgl_depth_stencil_view_create_info_struct_wrapper();
- xgl_depth_stencil_view_create_info_struct_wrapper(XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
- xgl_depth_stencil_view_create_info_struct_wrapper(const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pInStruct);
+ xgl_memory_alloc_buffer_info_struct_wrapper();
+ xgl_memory_alloc_buffer_info_struct_wrapper(XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
+ xgl_memory_alloc_buffer_info_struct_wrapper(const XGL_MEMORY_ALLOC_BUFFER_INFO* pInStruct);
- virtual ~xgl_depth_stencil_view_create_info_struct_wrapper();
+ virtual ~xgl_memory_alloc_buffer_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE get_image() { return m_struct.image; }
- void set_image(XGL_IMAGE inValue) { m_struct.image = inValue; }
- uint32_t get_mipLevel() { return m_struct.mipLevel; }
- void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- XGL_IMAGE get_msaaResolveImage() { return m_struct.msaaResolveImage; }
- void set_msaaResolveImage(XGL_IMAGE inValue) { m_struct.msaaResolveImage = inValue; }
- XGL_IMAGE_SUBRESOURCE_RANGE get_msaaResolveSubResource() { return m_struct.msaaResolveSubResource; }
- void set_msaaResolveSubResource(XGL_IMAGE_SUBRESOURCE_RANGE inValue) { m_struct.msaaResolveSubResource = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
private:
- XGL_DEPTH_STENCIL_VIEW_CREATE_INFO m_struct;
- const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* m_origStructAddr;
+ XGL_MEMORY_ALLOC_BUFFER_INFO m_struct;
+ const XGL_MEMORY_ALLOC_BUFFER_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_depth_stencil_bind_info_struct_wrapper
+class xgl_buffer_copy_struct_wrapper
{
public:
- xgl_depth_stencil_bind_info_struct_wrapper();
- xgl_depth_stencil_bind_info_struct_wrapper(XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
- xgl_depth_stencil_bind_info_struct_wrapper(const XGL_DEPTH_STENCIL_BIND_INFO* pInStruct);
+ xgl_buffer_copy_struct_wrapper();
+ xgl_buffer_copy_struct_wrapper(XGL_BUFFER_COPY* pInStruct);
+ xgl_buffer_copy_struct_wrapper(const XGL_BUFFER_COPY* pInStruct);
- virtual ~xgl_depth_stencil_bind_info_struct_wrapper();
+ virtual ~xgl_buffer_copy_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_DEPTH_STENCIL_VIEW get_view() { return m_struct.view; }
- void set_view(XGL_DEPTH_STENCIL_VIEW inValue) { m_struct.view = inValue; }
- XGL_IMAGE_LAYOUT get_layout() { return m_struct.layout; }
- void set_layout(XGL_IMAGE_LAYOUT inValue) { m_struct.layout = inValue; }
+ XGL_GPU_SIZE get_srcOffset() { return m_struct.srcOffset; }
+ void set_srcOffset(XGL_GPU_SIZE inValue) { m_struct.srcOffset = inValue; }
+ XGL_GPU_SIZE get_destOffset() { return m_struct.destOffset; }
+ void set_destOffset(XGL_GPU_SIZE inValue) { m_struct.destOffset = inValue; }
+ XGL_GPU_SIZE get_copySize() { return m_struct.copySize; }
+ void set_copySize(XGL_GPU_SIZE inValue) { m_struct.copySize = inValue; }
private:
- XGL_DEPTH_STENCIL_BIND_INFO m_struct;
- const XGL_DEPTH_STENCIL_BIND_INFO* m_origStructAddr;
+ XGL_BUFFER_COPY m_struct;
+ const XGL_BUFFER_COPY* m_origStructAddr;
+ uint32_t m_indent;
+ const char m_dummy_prefix;
+ void display_struct_members();
+
+};
+
+
+//class declaration
+class xgl_image_memory_bind_info_struct_wrapper
+{
+public:
+ xgl_image_memory_bind_info_struct_wrapper();
+ xgl_image_memory_bind_info_struct_wrapper(XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
+ xgl_image_memory_bind_info_struct_wrapper(const XGL_IMAGE_MEMORY_BIND_INFO* pInStruct);
+
+ virtual ~xgl_image_memory_bind_info_struct_wrapper();
+
+ void display_txt();
+ void display_single_txt();
+ void display_full_txt();
+
+ void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_IMAGE_SUBRESOURCE get_subresource() { return m_struct.subresource; }
+ void set_subresource(XGL_IMAGE_SUBRESOURCE inValue) { m_struct.subresource = inValue; }
+ XGL_OFFSET3D get_offset() { return m_struct.offset; }
+ void set_offset(XGL_OFFSET3D inValue) { m_struct.offset = inValue; }
+ XGL_EXTENT3D get_extent() { return m_struct.extent; }
+ void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
+
+
+private:
+ XGL_IMAGE_MEMORY_BIND_INFO m_struct;
+ const XGL_IMAGE_MEMORY_BIND_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_subresource_range_struct_wrapper
+class xgl_pipeline_shader_struct_wrapper
{
public:
- xgl_image_subresource_range_struct_wrapper();
- xgl_image_subresource_range_struct_wrapper(XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
- xgl_image_subresource_range_struct_wrapper(const XGL_IMAGE_SUBRESOURCE_RANGE* pInStruct);
+ xgl_pipeline_shader_struct_wrapper();
+ xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
+ xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
- virtual ~xgl_image_subresource_range_struct_wrapper();
+ virtual ~xgl_pipeline_shader_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
- void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
- uint32_t get_baseMipLevel() { return m_struct.baseMipLevel; }
- void set_baseMipLevel(uint32_t inValue) { m_struct.baseMipLevel = inValue; }
- uint32_t get_mipLevels() { return m_struct.mipLevels; }
- void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
- uint32_t get_baseArraySlice() { return m_struct.baseArraySlice; }
- void set_baseArraySlice(uint32_t inValue) { m_struct.baseArraySlice = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
+ XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
+ void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
+ XGL_SHADER get_shader() { return m_struct.shader; }
+ void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
+ uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
+ void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
private:
- XGL_IMAGE_SUBRESOURCE_RANGE m_struct;
- const XGL_IMAGE_SUBRESOURCE_RANGE* m_origStructAddr;
+ XGL_PIPELINE_SHADER m_struct;
+ const XGL_PIPELINE_SHADER* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_update_images_struct_wrapper
+class xgl_offset3d_struct_wrapper
{
public:
- xgl_update_images_struct_wrapper();
- xgl_update_images_struct_wrapper(XGL_UPDATE_IMAGES* pInStruct);
- xgl_update_images_struct_wrapper(const XGL_UPDATE_IMAGES* pInStruct);
+ xgl_offset3d_struct_wrapper();
+ xgl_offset3d_struct_wrapper(XGL_OFFSET3D* pInStruct);
+ xgl_offset3d_struct_wrapper(const XGL_OFFSET3D* pInStruct);
- virtual ~xgl_update_images_struct_wrapper();
+ virtual ~xgl_offset3d_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
- void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ int32_t get_x() { return m_struct.x; }
+ void set_x(int32_t inValue) { m_struct.x = inValue; }
+ int32_t get_y() { return m_struct.y; }
+ void set_y(int32_t inValue) { m_struct.y = inValue; }
+ int32_t get_z() { return m_struct.z; }
+ void set_z(int32_t inValue) { m_struct.z = inValue; }
private:
- XGL_UPDATE_IMAGES m_struct;
- const XGL_UPDATE_IMAGES* m_origStructAddr;
+ XGL_OFFSET3D m_struct;
+ const XGL_OFFSET3D* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_dispatch_indirect_cmd_struct_wrapper
+class xgl_buffer_view_attach_info_struct_wrapper
{
public:
- xgl_dispatch_indirect_cmd_struct_wrapper();
- xgl_dispatch_indirect_cmd_struct_wrapper(XGL_DISPATCH_INDIRECT_CMD* pInStruct);
- xgl_dispatch_indirect_cmd_struct_wrapper(const XGL_DISPATCH_INDIRECT_CMD* pInStruct);
+ xgl_buffer_view_attach_info_struct_wrapper();
+ xgl_buffer_view_attach_info_struct_wrapper(XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
+ xgl_buffer_view_attach_info_struct_wrapper(const XGL_BUFFER_VIEW_ATTACH_INFO* pInStruct);
- virtual ~xgl_dispatch_indirect_cmd_struct_wrapper();
+ virtual ~xgl_buffer_view_attach_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_x() { return m_struct.x; }
- void set_x(uint32_t inValue) { m_struct.x = inValue; }
- uint32_t get_y() { return m_struct.y; }
- void set_y(uint32_t inValue) { m_struct.y = inValue; }
- uint32_t get_z() { return m_struct.z; }
- void set_z(uint32_t inValue) { m_struct.z = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_BUFFER_VIEW get_view() { return m_struct.view; }
+ void set_view(XGL_BUFFER_VIEW inValue) { m_struct.view = inValue; }
private:
- XGL_DISPATCH_INDIRECT_CMD m_struct;
- const XGL_DISPATCH_INDIRECT_CMD* m_origStructAddr;
+ XGL_BUFFER_VIEW_ATTACH_INFO m_struct;
+ const XGL_BUFFER_VIEW_ATTACH_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_clear_color_value_struct_wrapper
+class xgl_sampler_image_view_info_struct_wrapper
{
public:
- xgl_clear_color_value_struct_wrapper();
- xgl_clear_color_value_struct_wrapper(XGL_CLEAR_COLOR_VALUE* pInStruct);
- xgl_clear_color_value_struct_wrapper(const XGL_CLEAR_COLOR_VALUE* pInStruct);
+ xgl_sampler_image_view_info_struct_wrapper();
+ xgl_sampler_image_view_info_struct_wrapper(XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
+ xgl_sampler_image_view_info_struct_wrapper(const XGL_SAMPLER_IMAGE_VIEW_INFO* pInStruct);
- virtual ~xgl_clear_color_value_struct_wrapper();
+ virtual ~xgl_sampler_image_view_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
+ XGL_SAMPLER get_pSampler() { return m_struct.pSampler; }
+ void set_pSampler(XGL_SAMPLER inValue) { m_struct.pSampler = inValue; }
+ const XGL_IMAGE_VIEW_ATTACH_INFO* get_pImageView() { return m_struct.pImageView; }
private:
- XGL_CLEAR_COLOR_VALUE m_struct;
- const XGL_CLEAR_COLOR_VALUE* m_origStructAddr;
+ XGL_SAMPLER_IMAGE_VIEW_INFO m_struct;
+ const XGL_SAMPLER_IMAGE_VIEW_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_memory_alloc_image_info_struct_wrapper
+class xgl_image_subresource_struct_wrapper
{
public:
- xgl_memory_alloc_image_info_struct_wrapper();
- xgl_memory_alloc_image_info_struct_wrapper(XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
- xgl_memory_alloc_image_info_struct_wrapper(const XGL_MEMORY_ALLOC_IMAGE_INFO* pInStruct);
+ xgl_image_subresource_struct_wrapper();
+ xgl_image_subresource_struct_wrapper(XGL_IMAGE_SUBRESOURCE* pInStruct);
+ xgl_image_subresource_struct_wrapper(const XGL_IMAGE_SUBRESOURCE* pInStruct);
- virtual ~xgl_memory_alloc_image_info_struct_wrapper();
+ virtual ~xgl_image_subresource_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_IMAGE_FORMAT_CLASS get_formatClass() { return m_struct.formatClass; }
- void set_formatClass(XGL_IMAGE_FORMAT_CLASS inValue) { m_struct.formatClass = inValue; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
+ XGL_IMAGE_ASPECT get_aspect() { return m_struct.aspect; }
+ void set_aspect(XGL_IMAGE_ASPECT inValue) { m_struct.aspect = inValue; }
+ uint32_t get_mipLevel() { return m_struct.mipLevel; }
+ void set_mipLevel(uint32_t inValue) { m_struct.mipLevel = inValue; }
+ uint32_t get_arraySlice() { return m_struct.arraySlice; }
+ void set_arraySlice(uint32_t inValue) { m_struct.arraySlice = inValue; }
private:
- XGL_MEMORY_ALLOC_IMAGE_INFO m_struct;
- const XGL_MEMORY_ALLOC_IMAGE_INFO* m_origStructAddr;
+ XGL_IMAGE_SUBRESOURCE m_struct;
+ const XGL_IMAGE_SUBRESOURCE* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_device_queue_create_info_struct_wrapper
+class xgl_layer_create_info_struct_wrapper
{
public:
- xgl_device_queue_create_info_struct_wrapper();
- xgl_device_queue_create_info_struct_wrapper(XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
- xgl_device_queue_create_info_struct_wrapper(const XGL_DEVICE_QUEUE_CREATE_INFO* pInStruct);
+ xgl_layer_create_info_struct_wrapper();
+ xgl_layer_create_info_struct_wrapper(XGL_LAYER_CREATE_INFO* pInStruct);
+ xgl_layer_create_info_struct_wrapper(const XGL_LAYER_CREATE_INFO* pInStruct);
- virtual ~xgl_device_queue_create_info_struct_wrapper();
+ virtual ~xgl_layer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_queueNodeIndex() { return m_struct.queueNodeIndex; }
- void set_queueNodeIndex(uint32_t inValue) { m_struct.queueNodeIndex = inValue; }
- uint32_t get_queueCount() { return m_struct.queueCount; }
- void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_layerCount() { return m_struct.layerCount; }
+ void set_layerCount(uint32_t inValue) { m_struct.layerCount = inValue; }
private:
- XGL_DEVICE_QUEUE_CREATE_INFO m_struct;
- const XGL_DEVICE_QUEUE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_stencil_op_state_struct_wrapper
-{
-public:
- xgl_stencil_op_state_struct_wrapper();
- xgl_stencil_op_state_struct_wrapper(XGL_STENCIL_OP_STATE* pInStruct);
- xgl_stencil_op_state_struct_wrapper(const XGL_STENCIL_OP_STATE* pInStruct);
-
- virtual ~xgl_stencil_op_state_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STENCIL_OP get_stencilFailOp() { return m_struct.stencilFailOp; }
- void set_stencilFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilFailOp = inValue; }
- XGL_STENCIL_OP get_stencilPassOp() { return m_struct.stencilPassOp; }
- void set_stencilPassOp(XGL_STENCIL_OP inValue) { m_struct.stencilPassOp = inValue; }
- XGL_STENCIL_OP get_stencilDepthFailOp() { return m_struct.stencilDepthFailOp; }
- void set_stencilDepthFailOp(XGL_STENCIL_OP inValue) { m_struct.stencilDepthFailOp = inValue; }
- XGL_COMPARE_FUNC get_stencilFunc() { return m_struct.stencilFunc; }
- void set_stencilFunc(XGL_COMPARE_FUNC inValue) { m_struct.stencilFunc = inValue; }
-
-
-private:
- XGL_STENCIL_OP_STATE m_struct;
- const XGL_STENCIL_OP_STATE* m_origStructAddr;
+ XGL_LAYER_CREATE_INFO m_struct;
+ const XGL_LAYER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_shader_struct_wrapper
+class xgl_pipeline_vp_state_create_info_struct_wrapper
{
public:
- xgl_pipeline_shader_struct_wrapper();
- xgl_pipeline_shader_struct_wrapper(XGL_PIPELINE_SHADER* pInStruct);
- xgl_pipeline_shader_struct_wrapper(const XGL_PIPELINE_SHADER* pInStruct);
+ xgl_pipeline_vp_state_create_info_struct_wrapper();
+ xgl_pipeline_vp_state_create_info_struct_wrapper(XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
+ xgl_pipeline_vp_state_create_info_struct_wrapper(const XGL_PIPELINE_VP_STATE_CREATE_INFO* pInStruct);
- virtual ~xgl_pipeline_shader_struct_wrapper();
+ virtual ~xgl_pipeline_vp_state_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_PIPELINE_SHADER_STAGE get_stage() { return m_struct.stage; }
- void set_stage(XGL_PIPELINE_SHADER_STAGE inValue) { m_struct.stage = inValue; }
- XGL_SHADER get_shader() { return m_struct.shader; }
- void set_shader(XGL_SHADER inValue) { m_struct.shader = inValue; }
- uint32_t get_linkConstBufferCount() { return m_struct.linkConstBufferCount; }
- void set_linkConstBufferCount(uint32_t inValue) { m_struct.linkConstBufferCount = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ uint32_t get_numViewports() { return m_struct.numViewports; }
+ void set_numViewports(uint32_t inValue) { m_struct.numViewports = inValue; }
+ XGL_COORDINATE_ORIGIN get_clipOrigin() { return m_struct.clipOrigin; }
+ void set_clipOrigin(XGL_COORDINATE_ORIGIN inValue) { m_struct.clipOrigin = inValue; }
+ XGL_DEPTH_MODE get_depthMode() { return m_struct.depthMode; }
+ void set_depthMode(XGL_DEPTH_MODE inValue) { m_struct.depthMode = inValue; }
private:
- XGL_PIPELINE_SHADER m_struct;
- const XGL_PIPELINE_SHADER* m_origStructAddr;
+ XGL_PIPELINE_VP_STATE_CREATE_INFO m_struct;
+ const XGL_PIPELINE_VP_STATE_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_queue_semaphore_create_info_struct_wrapper
+class xgl_buffer_create_info_struct_wrapper
{
public:
- xgl_queue_semaphore_create_info_struct_wrapper();
- xgl_queue_semaphore_create_info_struct_wrapper(XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
- xgl_queue_semaphore_create_info_struct_wrapper(const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pInStruct);
+ xgl_buffer_create_info_struct_wrapper();
+ xgl_buffer_create_info_struct_wrapper(XGL_BUFFER_CREATE_INFO* pInStruct);
+ xgl_buffer_create_info_struct_wrapper(const XGL_BUFFER_CREATE_INFO* pInStruct);
- virtual ~xgl_queue_semaphore_create_info_struct_wrapper();
+ virtual ~xgl_buffer_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_initialCount() { return m_struct.initialCount; }
- void set_initialCount(uint32_t inValue) { m_struct.initialCount = inValue; }
+ XGL_GPU_SIZE get_size() { return m_struct.size; }
+ void set_size(XGL_GPU_SIZE inValue) { m_struct.size = inValue; }
+ XGL_FLAGS get_usage() { return m_struct.usage; }
+ void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
XGL_FLAGS get_flags() { return m_struct.flags; }
void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
private:
- XGL_QUEUE_SEMAPHORE_CREATE_INFO m_struct;
- const XGL_QUEUE_SEMAPHORE_CREATE_INFO* m_origStructAddr;
- uint32_t m_indent;
- const char m_dummy_prefix;
- void display_struct_members();
-
-};
-
-
-//class declaration
-class xgl_pipeline_statistics_data_struct_wrapper
-{
-public:
- xgl_pipeline_statistics_data_struct_wrapper();
- xgl_pipeline_statistics_data_struct_wrapper(XGL_PIPELINE_STATISTICS_DATA* pInStruct);
- xgl_pipeline_statistics_data_struct_wrapper(const XGL_PIPELINE_STATISTICS_DATA* pInStruct);
-
- virtual ~xgl_pipeline_statistics_data_struct_wrapper();
-
- void display_txt();
- void display_single_txt();
- void display_full_txt();
-
- void set_indent(uint32_t indent) { m_indent = indent; }
- uint64_t get_fsInvocations() { return m_struct.fsInvocations; }
- void set_fsInvocations(uint64_t inValue) { m_struct.fsInvocations = inValue; }
- uint64_t get_cPrimitives() { return m_struct.cPrimitives; }
- void set_cPrimitives(uint64_t inValue) { m_struct.cPrimitives = inValue; }
- uint64_t get_cInvocations() { return m_struct.cInvocations; }
- void set_cInvocations(uint64_t inValue) { m_struct.cInvocations = inValue; }
- uint64_t get_vsInvocations() { return m_struct.vsInvocations; }
- void set_vsInvocations(uint64_t inValue) { m_struct.vsInvocations = inValue; }
- uint64_t get_gsInvocations() { return m_struct.gsInvocations; }
- void set_gsInvocations(uint64_t inValue) { m_struct.gsInvocations = inValue; }
- uint64_t get_gsPrimitives() { return m_struct.gsPrimitives; }
- void set_gsPrimitives(uint64_t inValue) { m_struct.gsPrimitives = inValue; }
- uint64_t get_iaPrimitives() { return m_struct.iaPrimitives; }
- void set_iaPrimitives(uint64_t inValue) { m_struct.iaPrimitives = inValue; }
- uint64_t get_iaVertices() { return m_struct.iaVertices; }
- void set_iaVertices(uint64_t inValue) { m_struct.iaVertices = inValue; }
- uint64_t get_tcsInvocations() { return m_struct.tcsInvocations; }
- void set_tcsInvocations(uint64_t inValue) { m_struct.tcsInvocations = inValue; }
- uint64_t get_tesInvocations() { return m_struct.tesInvocations; }
- void set_tesInvocations(uint64_t inValue) { m_struct.tesInvocations = inValue; }
- uint64_t get_csInvocations() { return m_struct.csInvocations; }
- void set_csInvocations(uint64_t inValue) { m_struct.csInvocations = inValue; }
-
-
-private:
- XGL_PIPELINE_STATISTICS_DATA m_struct;
- const XGL_PIPELINE_STATISTICS_DATA* m_origStructAddr;
+ XGL_BUFFER_CREATE_INFO m_struct;
+ const XGL_BUFFER_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_vertex_input_attribute_description_struct_wrapper
+class xgl_render_pass_create_info_struct_wrapper
{
public:
- xgl_vertex_input_attribute_description_struct_wrapper();
- xgl_vertex_input_attribute_description_struct_wrapper(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
- xgl_vertex_input_attribute_description_struct_wrapper(const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pInStruct);
+ xgl_render_pass_create_info_struct_wrapper();
+ xgl_render_pass_create_info_struct_wrapper(XGL_RENDER_PASS_CREATE_INFO* pInStruct);
+ xgl_render_pass_create_info_struct_wrapper(const XGL_RENDER_PASS_CREATE_INFO* pInStruct);
- virtual ~xgl_vertex_input_attribute_description_struct_wrapper();
+ virtual ~xgl_render_pass_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_binding() { return m_struct.binding; }
- void set_binding(uint32_t inValue) { m_struct.binding = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- uint32_t get_offsetInBytes() { return m_struct.offsetInBytes; }
- void set_offsetInBytes(uint32_t inValue) { m_struct.offsetInBytes = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_RECT get_renderArea() { return m_struct.renderArea; }
+ void set_renderArea(XGL_RECT inValue) { m_struct.renderArea = inValue; }
+ XGL_FRAMEBUFFER get_framebuffer() { return m_struct.framebuffer; }
+ void set_framebuffer(XGL_FRAMEBUFFER inValue) { m_struct.framebuffer = inValue; }
+ uint32_t get_colorAttachmentCount() { return m_struct.colorAttachmentCount; }
+ void set_colorAttachmentCount(uint32_t inValue) { m_struct.colorAttachmentCount = inValue; }
+ XGL_ATTACHMENT_LOAD_OP get_depthLoadOp() { return m_struct.depthLoadOp; }
+ void set_depthLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.depthLoadOp = inValue; }
+ float get_depthLoadClearValue() { return m_struct.depthLoadClearValue; }
+ void set_depthLoadClearValue(float inValue) { m_struct.depthLoadClearValue = inValue; }
+ XGL_ATTACHMENT_STORE_OP get_depthStoreOp() { return m_struct.depthStoreOp; }
+ void set_depthStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.depthStoreOp = inValue; }
+ XGL_ATTACHMENT_LOAD_OP get_stencilLoadOp() { return m_struct.stencilLoadOp; }
+ void set_stencilLoadOp(XGL_ATTACHMENT_LOAD_OP inValue) { m_struct.stencilLoadOp = inValue; }
+ uint32_t get_stencilLoadClearValue() { return m_struct.stencilLoadClearValue; }
+ void set_stencilLoadClearValue(uint32_t inValue) { m_struct.stencilLoadClearValue = inValue; }
+ XGL_ATTACHMENT_STORE_OP get_stencilStoreOp() { return m_struct.stencilStoreOp; }
+ void set_stencilStoreOp(XGL_ATTACHMENT_STORE_OP inValue) { m_struct.stencilStoreOp = inValue; }
private:
- XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION m_struct;
- const XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* m_origStructAddr;
+ XGL_RENDER_PASS_CREATE_INFO m_struct;
+ const XGL_RENDER_PASS_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_vertex_input_binding_description_struct_wrapper
+class xgl_descriptor_set_layout_create_info_struct_wrapper
{
public:
- xgl_vertex_input_binding_description_struct_wrapper();
- xgl_vertex_input_binding_description_struct_wrapper(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
- xgl_vertex_input_binding_description_struct_wrapper(const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pInStruct);
+ xgl_descriptor_set_layout_create_info_struct_wrapper();
+ xgl_descriptor_set_layout_create_info_struct_wrapper(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
+ xgl_descriptor_set_layout_create_info_struct_wrapper(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInStruct);
- virtual ~xgl_vertex_input_binding_description_struct_wrapper();
+ virtual ~xgl_descriptor_set_layout_create_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- uint32_t get_strideInBytes() { return m_struct.strideInBytes; }
- void set_strideInBytes(uint32_t inValue) { m_struct.strideInBytes = inValue; }
- XGL_VERTEX_INPUT_STEP_RATE get_stepRate() { return m_struct.stepRate; }
- void set_stepRate(XGL_VERTEX_INPUT_STEP_RATE inValue) { m_struct.stepRate = inValue; }
+ XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
+ void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
+ const void* get_pNext() { return m_struct.pNext; }
+ XGL_DESCRIPTOR_TYPE get_descriptorType() { return m_struct.descriptorType; }
+ void set_descriptorType(XGL_DESCRIPTOR_TYPE inValue) { m_struct.descriptorType = inValue; }
+ uint32_t get_count() { return m_struct.count; }
+ void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ XGL_FLAGS get_stageFlags() { return m_struct.stageFlags; }
+ void set_stageFlags(XGL_FLAGS inValue) { m_struct.stageFlags = inValue; }
+ XGL_SAMPLER get_immutableSampler() { return m_struct.immutableSampler; }
+ void set_immutableSampler(XGL_SAMPLER inValue) { m_struct.immutableSampler = inValue; }
private:
- XGL_VERTEX_INPUT_BINDING_DESCRIPTION m_struct;
- const XGL_VERTEX_INPUT_BINDING_DESCRIPTION* m_origStructAddr;
+ XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO m_struct;
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_update_samplers_struct_wrapper
+class xgl_gpu_compatibility_info_struct_wrapper
{
public:
- xgl_update_samplers_struct_wrapper();
- xgl_update_samplers_struct_wrapper(XGL_UPDATE_SAMPLERS* pInStruct);
- xgl_update_samplers_struct_wrapper(const XGL_UPDATE_SAMPLERS* pInStruct);
+ xgl_gpu_compatibility_info_struct_wrapper();
+ xgl_gpu_compatibility_info_struct_wrapper(XGL_GPU_COMPATIBILITY_INFO* pInStruct);
+ xgl_gpu_compatibility_info_struct_wrapper(const XGL_GPU_COMPATIBILITY_INFO* pInStruct);
- virtual ~xgl_update_samplers_struct_wrapper();
+ virtual ~xgl_gpu_compatibility_info_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_index() { return m_struct.index; }
- void set_index(uint32_t inValue) { m_struct.index = inValue; }
- uint32_t get_count() { return m_struct.count; }
- void set_count(uint32_t inValue) { m_struct.count = inValue; }
+ XGL_FLAGS get_compatibilityFlags() { return m_struct.compatibilityFlags; }
+ void set_compatibilityFlags(XGL_FLAGS inValue) { m_struct.compatibilityFlags = inValue; }
private:
- XGL_UPDATE_SAMPLERS m_struct;
- const XGL_UPDATE_SAMPLERS* m_origStructAddr;
+ XGL_GPU_COMPATIBILITY_INFO m_struct;
+ const XGL_GPU_COMPATIBILITY_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_image_create_info_struct_wrapper
+class xgl_memory_alloc_info_struct_wrapper
{
public:
- xgl_image_create_info_struct_wrapper();
- xgl_image_create_info_struct_wrapper(XGL_IMAGE_CREATE_INFO* pInStruct);
- xgl_image_create_info_struct_wrapper(const XGL_IMAGE_CREATE_INFO* pInStruct);
+ xgl_memory_alloc_info_struct_wrapper();
+ xgl_memory_alloc_info_struct_wrapper(XGL_MEMORY_ALLOC_INFO* pInStruct);
+ xgl_memory_alloc_info_struct_wrapper(const XGL_MEMORY_ALLOC_INFO* pInStruct);
- virtual ~xgl_image_create_info_struct_wrapper();
+ virtual ~xgl_memory_alloc_info_struct_wrapper();
void display_txt();
void display_single_txt();
XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
const void* get_pNext() { return m_struct.pNext; }
- XGL_IMAGE_TYPE get_imageType() { return m_struct.imageType; }
- void set_imageType(XGL_IMAGE_TYPE inValue) { m_struct.imageType = inValue; }
- XGL_FORMAT get_format() { return m_struct.format; }
- void set_format(XGL_FORMAT inValue) { m_struct.format = inValue; }
- XGL_EXTENT3D get_extent() { return m_struct.extent; }
- void set_extent(XGL_EXTENT3D inValue) { m_struct.extent = inValue; }
- uint32_t get_mipLevels() { return m_struct.mipLevels; }
- void set_mipLevels(uint32_t inValue) { m_struct.mipLevels = inValue; }
- uint32_t get_arraySize() { return m_struct.arraySize; }
- void set_arraySize(uint32_t inValue) { m_struct.arraySize = inValue; }
- uint32_t get_samples() { return m_struct.samples; }
- void set_samples(uint32_t inValue) { m_struct.samples = inValue; }
- XGL_IMAGE_TILING get_tiling() { return m_struct.tiling; }
- void set_tiling(XGL_IMAGE_TILING inValue) { m_struct.tiling = inValue; }
- XGL_FLAGS get_usage() { return m_struct.usage; }
- void set_usage(XGL_FLAGS inValue) { m_struct.usage = inValue; }
- XGL_FLAGS get_flags() { return m_struct.flags; }
- void set_flags(XGL_FLAGS inValue) { m_struct.flags = inValue; }
+ XGL_GPU_SIZE get_allocationSize() { return m_struct.allocationSize; }
+ void set_allocationSize(XGL_GPU_SIZE inValue) { m_struct.allocationSize = inValue; }
+ XGL_FLAGS get_memProps() { return m_struct.memProps; }
+ void set_memProps(XGL_FLAGS inValue) { m_struct.memProps = inValue; }
+ XGL_MEMORY_TYPE get_memType() { return m_struct.memType; }
+ void set_memType(XGL_MEMORY_TYPE inValue) { m_struct.memType = inValue; }
+ XGL_MEMORY_PRIORITY get_memPriority() { return m_struct.memPriority; }
+ void set_memPriority(XGL_MEMORY_PRIORITY inValue) { m_struct.memPriority = inValue; }
private:
- XGL_IMAGE_CREATE_INFO m_struct;
- const XGL_IMAGE_CREATE_INFO* m_origStructAddr;
+ XGL_MEMORY_ALLOC_INFO m_struct;
+ const XGL_MEMORY_ALLOC_INFO* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
//class declaration
-class xgl_pipeline_tess_state_create_info_struct_wrapper
+class xgl_physical_gpu_queue_properties_struct_wrapper
{
public:
- xgl_pipeline_tess_state_create_info_struct_wrapper();
- xgl_pipeline_tess_state_create_info_struct_wrapper(XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
- xgl_pipeline_tess_state_create_info_struct_wrapper(const XGL_PIPELINE_TESS_STATE_CREATE_INFO* pInStruct);
+ xgl_physical_gpu_queue_properties_struct_wrapper();
+ xgl_physical_gpu_queue_properties_struct_wrapper(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
+ xgl_physical_gpu_queue_properties_struct_wrapper(const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* pInStruct);
- virtual ~xgl_pipeline_tess_state_create_info_struct_wrapper();
+ virtual ~xgl_physical_gpu_queue_properties_struct_wrapper();
void display_txt();
void display_single_txt();
void display_full_txt();
void set_indent(uint32_t indent) { m_indent = indent; }
- XGL_STRUCTURE_TYPE get_sType() { return m_struct.sType; }
- void set_sType(XGL_STRUCTURE_TYPE inValue) { m_struct.sType = inValue; }
- const void* get_pNext() { return m_struct.pNext; }
- uint32_t get_patchControlPoints() { return m_struct.patchControlPoints; }
- void set_patchControlPoints(uint32_t inValue) { m_struct.patchControlPoints = inValue; }
- float get_optimalTessFactor() { return m_struct.optimalTessFactor; }
- void set_optimalTessFactor(float inValue) { m_struct.optimalTessFactor = inValue; }
- float get_fixedTessFactor() { return m_struct.fixedTessFactor; }
- void set_fixedTessFactor(float inValue) { m_struct.fixedTessFactor = inValue; }
+ XGL_FLAGS get_queueFlags() { return m_struct.queueFlags; }
+ void set_queueFlags(XGL_FLAGS inValue) { m_struct.queueFlags = inValue; }
+ uint32_t get_queueCount() { return m_struct.queueCount; }
+ void set_queueCount(uint32_t inValue) { m_struct.queueCount = inValue; }
+ uint32_t get_maxAtomicCounters() { return m_struct.maxAtomicCounters; }
+ void set_maxAtomicCounters(uint32_t inValue) { m_struct.maxAtomicCounters = inValue; }
+ bool32_t get_supportsTimestamps() { return m_struct.supportsTimestamps; }
+ void set_supportsTimestamps(bool32_t inValue) { m_struct.supportsTimestamps = inValue; }
private:
- XGL_PIPELINE_TESS_STATE_CREATE_INFO m_struct;
- const XGL_PIPELINE_TESS_STATE_CREATE_INFO* m_origStructAddr;
+ XGL_PHYSICAL_GPU_QUEUE_PROPERTIES m_struct;
+ const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES* m_origStructAddr;
uint32_t m_indent;
const char m_dummy_prefix;
void display_struct_members();
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff