Shader Model 6 introduces a 16-bit float (half) type, and 16-bit and 64-bit integer types. Storing extra info in the type enum simplifies checking if a type is any integer, floating point or numeric type, and the declaration of SPIR-V types. The benefits depend on using enum vkd3d_data_type in the backend instead of vkd3d_shader_component_type.
Patch 2 is difficult to split because types typically flow through to vkd3d_spirv_get_type_id(), so partial changes would require new calls to conversion functions which would be deleted again later.
-- v3: vkd3d-shader/spirv: Use a helper function to check if a data type is floating point. vkd3d-shader/spirv: Use vkd3d_spirv_get_op_constant() for 64-bit types. vkd3d-shader/spirv: Use enum vkd3d_data_type instead of vkd3d_shader_component_type. vkd3d-shader: Encode type info in enum vkd3d_data_type values.
From: Conor McCarthy cmccarthy@codeweavers.com
Shader Model 6 introduces a 16-bit float (half) type, and 16-bit and 64-bit integer types. Storing extra info in the type enum simplifies checking if a type is any integer, floating point or numeric type, and the declaration of SPIR-V types. --- libs/vkd3d-shader/d3d_asm.c | 38 +++++++++------ libs/vkd3d-shader/vkd3d_shader_private.h | 59 ++++++++++++++++++------ 2 files changed, 68 insertions(+), 29 deletions(-)
diff --git a/libs/vkd3d-shader/d3d_asm.c b/libs/vkd3d-shader/d3d_asm.c index d72402eb..dbd764f9 100644 --- a/libs/vkd3d-shader/d3d_asm.c +++ b/libs/vkd3d-shader/d3d_asm.c @@ -601,19 +601,13 @@ static void shader_dump_data_type(struct vkd3d_d3d_asm_compiler *compiler, const { static const char *const data_type_names[] = { - [VKD3D_DATA_FLOAT ] = "float", - [VKD3D_DATA_INT ] = "int", - [VKD3D_DATA_RESOURCE ] = "resource", - [VKD3D_DATA_SAMPLER ] = "sampler", - [VKD3D_DATA_UAV ] = "uav", - [VKD3D_DATA_UINT ] = "uint", - [VKD3D_DATA_UNORM ] = "unorm", - [VKD3D_DATA_SNORM ] = "snorm", - [VKD3D_DATA_OPAQUE ] = "opaque", - [VKD3D_DATA_MIXED ] = "mixed", - [VKD3D_DATA_DOUBLE ] = "double", - [VKD3D_DATA_CONTINUED] = "<continued>", - [VKD3D_DATA_UNUSED ] = "<unused>", + [VKD3D_DATA_CLASS_RESOURCE ] = "resource", + [VKD3D_DATA_CLASS_SAMPLER ] = "sampler", + [VKD3D_DATA_CLASS_UAV ] = "uav", + [VKD3D_DATA_CLASS_OPAQUE ] = "opaque", + [VKD3D_DATA_CLASS_MIXED ] = "mixed", + [VKD3D_DATA_CLASS_CONTINUED] = "<continued>", + [VKD3D_DATA_CLASS_UNUSED ] = "<unused>", }; const char *name; int i; @@ -622,8 +616,22 @@ static void shader_dump_data_type(struct vkd3d_d3d_asm_compiler *compiler, const
for (i = 0; i < 4; i++) { - if (type[i] < ARRAY_SIZE(data_type_names)) - name = data_type_names[type[i]]; + enum vkd3d_data_type_class class = data_type_get_class(type[i]); + if (data_type_class_is_numeric(class)) + { + switch (type[i]) + { + case VKD3D_DATA_FLOAT: name = "float"; break; + case VKD3D_DATA_INT: name = "int"; break; + case VKD3D_DATA_UINT: name = "uint"; break; + case VKD3D_DATA_UNORM: name = "unorm"; break; + case VKD3D_DATA_SNORM: name = "snorm"; break; + case VKD3D_DATA_DOUBLE: name = "double"; break; + default: vkd3d_unreachable(); + } + } + else if (class < ARRAY_SIZE(data_type_names)) + name = data_type_names[class]; else name = "unknown"; vkd3d_string_buffer_printf(&compiler->buffer, "%s%s", i == 0 ? "" : ",", name); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 0e93f3a5..cc9ec576 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -522,24 +522,55 @@ enum vkd3d_shader_register_precision VKD3D_SHADER_REGISTER_PRECISION_INVALID = ~0u, };
+#define DATA_TYPE_WIDTH_MASK 0xffu +#define DATA_TYPE_CLASS_SHIFT 8u +#define DATA_TYPE_CLASS_MASK (0x3fu << DATA_TYPE_CLASS_SHIFT) +#define DATA_TYPE_NORM_SHIFT 14u +#define DATA_TYPE_NORM_MASK (1u << DATA_TYPE_NORM_SHIFT) +#define DATA_TYPE_IS_SIGNED_SHIFT 15u +#define DATA_TYPE_IS_SIGNED_MASK (1u << DATA_TYPE_IS_SIGNED_SHIFT) + +enum vkd3d_data_type_class +{ + VKD3D_DATA_CLASS_FLOAT, + VKD3D_DATA_CLASS_INT, + VKD3D_DATA_CLASS_RESOURCE, + VKD3D_DATA_CLASS_SAMPLER, + VKD3D_DATA_CLASS_UAV, + VKD3D_DATA_CLASS_OPAQUE, + VKD3D_DATA_CLASS_MIXED, + VKD3D_DATA_CLASS_CONTINUED, + VKD3D_DATA_CLASS_UNUSED, +}; + enum vkd3d_data_type { - VKD3D_DATA_FLOAT, - VKD3D_DATA_INT, - VKD3D_DATA_RESOURCE, - VKD3D_DATA_SAMPLER, - VKD3D_DATA_UAV, - VKD3D_DATA_UINT, - VKD3D_DATA_UNORM, - VKD3D_DATA_SNORM, - VKD3D_DATA_OPAQUE, - VKD3D_DATA_MIXED, - VKD3D_DATA_DOUBLE, - VKD3D_DATA_CONTINUED, - VKD3D_DATA_UNUSED, - VKD3D_DATA_UINT8, + VKD3D_DATA_FLOAT = (VKD3D_DATA_CLASS_FLOAT << DATA_TYPE_CLASS_SHIFT) | 32, + VKD3D_DATA_INT = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_IS_SIGNED_MASK, + VKD3D_DATA_RESOURCE = VKD3D_DATA_CLASS_RESOURCE << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_SAMPLER = VKD3D_DATA_CLASS_SAMPLER << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_UAV = VKD3D_DATA_CLASS_UAV << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_UINT = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 32, + VKD3D_DATA_UNORM = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK, + VKD3D_DATA_SNORM = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 32 | DATA_TYPE_NORM_MASK | DATA_TYPE_IS_SIGNED_MASK, + VKD3D_DATA_OPAQUE = VKD3D_DATA_CLASS_OPAQUE << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_MIXED = VKD3D_DATA_CLASS_MIXED << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_DOUBLE = (VKD3D_DATA_CLASS_FLOAT << DATA_TYPE_CLASS_SHIFT) | 64, + VKD3D_DATA_CONTINUED = VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_UNUSED = VKD3D_DATA_CLASS_UNUSED << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_UINT8 = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 8, };
+static inline bool data_type_class_is_numeric(enum vkd3d_data_type_class class) +{ + return class <= VKD3D_DATA_CLASS_INT; +} + +static inline enum vkd3d_data_type_class data_type_get_class(enum vkd3d_data_type type) +{ + return (type & DATA_TYPE_CLASS_MASK) >> DATA_TYPE_CLASS_SHIFT; +} + enum vkd3d_immconst_type { VKD3D_IMMCONST_SCALAR,
From: Conor McCarthy cmccarthy@codeweavers.com
Using two different type systems is a little messy, and enum vkd3d_data_type now has the advantage of containing numeric type info, which simplifies introduction of 16-bit and 64-bit integers. --- libs/vkd3d-shader/d3dbc.c | 2 +- libs/vkd3d-shader/dxbc.c | 6 +- libs/vkd3d-shader/ir.c | 2 +- libs/vkd3d-shader/spirv.c | 565 +++++++++++------------ libs/vkd3d-shader/vkd3d_shader_main.c | 2 +- libs/vkd3d-shader/vkd3d_shader_private.h | 29 +- 6 files changed, 299 insertions(+), 307 deletions(-)
diff --git a/libs/vkd3d-shader/d3dbc.c b/libs/vkd3d-shader/d3dbc.c index 369112ce..c862a069 100644 --- a/libs/vkd3d-shader/d3dbc.c +++ b/libs/vkd3d-shader/d3dbc.c @@ -550,7 +550,7 @@ static bool add_signature_element(struct vkd3d_shader_sm1_parser *sm1, bool outp element->semantic_index = index; element->stream_index = 0; element->sysval_semantic = sysval; - element->component_type = VKD3D_SHADER_COMPONENT_FLOAT; + element->data_type = VKD3D_DATA_FLOAT; element->register_index = register_index; element->register_count = 1; element->mask = mask; diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 716b7bdb..fb96d6d5 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -328,6 +328,7 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s const char *data = section->data.code; uint32_t count, header_size; struct signature_element *e; + uint32_t component_type; const char *ptr = data; unsigned int i;
@@ -389,7 +390,8 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s } read_dword(&ptr, &e[i].semantic_index); read_dword(&ptr, &e[i].sysval_semantic); - read_dword(&ptr, &e[i].component_type); + read_dword(&ptr, &component_type); + e[i].data_type = vkd3d_data_type_from_component_type(component_type); read_dword(&ptr, &e[i].register_index); e[i].register_count = 1; read_dword(&ptr, &mask); @@ -414,7 +416,7 @@ static int shader_parse_signature(const struct vkd3d_shader_dxbc_section_desc *s TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, " "type %u, register idx: %u, use_mask %#x, input_mask %#x, precision %u.\n", e[i].stream_index, debugstr_a(e[i].semantic_name), e[i].semantic_index, e[i].sysval_semantic, - e[i].component_type, e[i].register_index, e[i].used_mask, e[i].mask, e[i].min_precision); + component_type, e[i].register_index, e[i].used_mask, e[i].mask, e[i].min_precision); }
s->elements = e; diff --git a/libs/vkd3d-shader/ir.c b/libs/vkd3d-shader/ir.c index 9eefb82c..47838834 100644 --- a/libs/vkd3d-shader/ir.c +++ b/libs/vkd3d-shader/ir.c @@ -334,7 +334,7 @@ static void shader_dst_param_io_init(struct vkd3d_shader_dst_param *param, const param->write_mask = e->mask; param->modifiers = 0; param->shift = 0; - shader_register_init(¶m->reg, reg_type, vkd3d_data_type_from_component_type(e->component_type), idx_count); + shader_register_init(¶m->reg, reg_type, e->data_type, idx_count); }
static enum vkd3d_result control_point_normaliser_emit_hs_input(struct control_point_normaliser *normaliser, diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 9725a5c7..d327ad27 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1710,38 +1710,34 @@ static uint32_t vkd3d_spirv_build_op_glsl_std450_nclamp(struct vkd3d_spirv_build }
static uint32_t vkd3d_spirv_get_type_id(struct vkd3d_spirv_builder *builder, - enum vkd3d_shader_component_type component_type, unsigned int component_count) + enum vkd3d_data_type data_type, unsigned int component_count) { - uint32_t scalar_id; + uint32_t scalar_id, width = data_type_get_width(data_type);
if (component_count == 1) { - switch (component_type) + switch (data_type_get_class(data_type)) { - case VKD3D_SHADER_COMPONENT_VOID: + case VKD3D_DATA_CLASS_VOID: return vkd3d_spirv_get_op_type_void(builder); break; - case VKD3D_SHADER_COMPONENT_FLOAT: - return vkd3d_spirv_get_op_type_float(builder, 32); + case VKD3D_DATA_CLASS_FLOAT: + return vkd3d_spirv_get_op_type_float(builder, width); break; - case VKD3D_SHADER_COMPONENT_INT: - case VKD3D_SHADER_COMPONENT_UINT: - return vkd3d_spirv_get_op_type_int(builder, 32, component_type == VKD3D_SHADER_COMPONENT_INT); + case VKD3D_DATA_CLASS_INT: + return vkd3d_spirv_get_op_type_int(builder, width, data_type_is_signed(data_type)); break; - case VKD3D_SHADER_COMPONENT_BOOL: + case VKD3D_DATA_CLASS_BOOL: return vkd3d_spirv_get_op_type_bool(builder); break; - case VKD3D_SHADER_COMPONENT_DOUBLE: - return vkd3d_spirv_get_op_type_float(builder, 64); default: - FIXME("Unhandled component type %#x.\n", component_type); - return 0; + vkd3d_unreachable(); } } else { - assert(component_type != VKD3D_SHADER_COMPONENT_VOID); - scalar_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + assert(data_type != VKD3D_DATA_VOID); + scalar_id = vkd3d_spirv_get_type_id(builder, data_type, 1); return vkd3d_spirv_get_op_type_vector(builder, scalar_id, component_count); } } @@ -1960,7 +1956,7 @@ struct vkd3d_symbol_register_data { SpvStorageClass storage_class; uint32_t member_idx; - enum vkd3d_shader_component_type component_type; + enum vkd3d_data_type data_type; unsigned int write_mask; unsigned int structure_stride; unsigned int binding_base_idx; @@ -1970,7 +1966,7 @@ struct vkd3d_symbol_register_data struct vkd3d_symbol_resource_data { struct vkd3d_shader_register_range range; - enum vkd3d_shader_component_type sampled_type; + enum vkd3d_data_type sampled_type; uint32_t type_id; const struct vkd3d_spirv_resource_type *resource_type_info; unsigned int structure_stride; @@ -2069,13 +2065,13 @@ static void vkd3d_symbol_make_register(struct vkd3d_symbol *symbol,
static void vkd3d_symbol_set_register_info(struct vkd3d_symbol *symbol, uint32_t val_id, SpvStorageClass storage_class, - enum vkd3d_shader_component_type component_type, DWORD write_mask) + enum vkd3d_data_type data_type, DWORD write_mask) { symbol->id = val_id; symbol->descriptor_array = NULL; symbol->info.reg.storage_class = storage_class; symbol->info.reg.member_idx = 0; - symbol->info.reg.component_type = component_type; + symbol->info.reg.data_type = data_type; symbol->info.reg.write_mask = write_mask; symbol->info.reg.structure_stride = 0; symbol->info.reg.binding_base_idx = 0; @@ -2253,7 +2249,7 @@ struct spirv_compiler struct vkd3d_shader_output_info { uint32_t id; - enum vkd3d_shader_component_type component_type; + enum vkd3d_data_type data_type; uint32_t array_element_mask; } *output_info; uint32_t private_output_variable[MAX_REG_OUTPUT + 1]; /* 1 entry for oDepth */ @@ -2765,24 +2761,19 @@ static const struct vkd3d_symbol *spirv_compiler_put_symbol(struct spirv_compile }
static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, - enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint32_t *values) + enum vkd3d_data_type data_type, unsigned int component_count, const uint32_t *values) { uint32_t type_id, scalar_type_id, component_ids[VKD3D_VEC4_SIZE]; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; unsigned int i;
assert(0 < component_count && component_count <= VKD3D_VEC4_SIZE); - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
- switch (component_type) + if (!data_type_is_numeric(data_type) || data_type_get_width(data_type) != 32) { - case VKD3D_SHADER_COMPONENT_UINT: - case VKD3D_SHADER_COMPONENT_INT: - case VKD3D_SHADER_COMPONENT_FLOAT: - break; - default: - FIXME("Unhandled component_type %#x.\n", component_type); - return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); + FIXME("Unhandled data type %#x.\n", data_type); + return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); }
if (component_count == 1) @@ -2791,7 +2782,7 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, } else { - scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); for (i = 0; i < component_count; ++i) component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, values[i]); return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count); @@ -2799,18 +2790,18 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, }
static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, - enum vkd3d_shader_component_type component_type, unsigned int component_count, const uint64_t *values) + enum vkd3d_data_type data_type, unsigned int component_count, const uint64_t *values) { uint32_t type_id, scalar_type_id, component_ids[VKD3D_DVEC2_SIZE]; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; unsigned int i;
assert(0 < component_count && component_count <= VKD3D_DVEC2_SIZE); - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
- if (component_type != VKD3D_SHADER_COMPONENT_DOUBLE) + if (data_type != VKD3D_DATA_DOUBLE) { - FIXME("Unhandled component_type %#x.\n", component_type); + FIXME("Unhandled data_type %#x.\n", data_type); return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); }
@@ -2820,7 +2811,7 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, } else { - scalar_type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); for (i = 0; i < component_count; ++i) component_ids[i] = vkd3d_spirv_get_op_constant64(builder, scalar_type_id, values[i]); return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count); @@ -2830,41 +2821,40 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, static uint32_t spirv_compiler_get_constant_uint(struct spirv_compiler *compiler, uint32_t value) { - return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_UINT, 1, &value); + return spirv_compiler_get_constant(compiler, VKD3D_DATA_UINT, 1, &value); }
static uint32_t spirv_compiler_get_constant_float(struct spirv_compiler *compiler, float value) { - return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_FLOAT, 1, (uint32_t *)&value); + return spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, 1, (uint32_t *)&value); }
static uint32_t spirv_compiler_get_constant_vector(struct spirv_compiler *compiler, - enum vkd3d_shader_component_type component_type, unsigned int component_count, uint32_t value) + enum vkd3d_data_type data_type, unsigned int component_count, uint32_t value) { const uint32_t values[] = {value, value, value, value}; - return spirv_compiler_get_constant(compiler, component_type, component_count, values); + return spirv_compiler_get_constant(compiler, data_type, component_count, values); }
static uint32_t spirv_compiler_get_constant_uint_vector(struct spirv_compiler *compiler, uint32_t value, unsigned int component_count) { - return spirv_compiler_get_constant_vector(compiler, VKD3D_SHADER_COMPONENT_UINT, component_count, value); + return spirv_compiler_get_constant_vector(compiler, VKD3D_DATA_UINT, component_count, value); }
static uint32_t spirv_compiler_get_constant_float_vector(struct spirv_compiler *compiler, float value, unsigned int component_count) { const float values[] = {value, value, value, value}; - return spirv_compiler_get_constant(compiler, VKD3D_SHADER_COMPONENT_FLOAT, - component_count, (const uint32_t *)values); + return spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, component_count, (const uint32_t *)values); }
static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler *compiler, double value, unsigned int component_count) { const double values[] = {value, value}; - return spirv_compiler_get_constant64(compiler, VKD3D_SHADER_COMPONENT_DOUBLE, + return spirv_compiler_get_constant64(compiler, VKD3D_DATA_DOUBLE, component_count, (const uint64_t *)values); }
@@ -2873,9 +2863,7 @@ static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compil { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder;
- return vkd3d_spirv_get_type_id(builder, - vkd3d_component_type_from_data_type(reg->data_type), - vkd3d_write_mask_component_count(write_mask)); + return vkd3d_spirv_get_type_id(builder, reg->data_type, vkd3d_write_mask_component_count(write_mask)); }
static uint32_t spirv_compiler_get_type_id_for_dst(struct spirv_compiler *compiler, @@ -2979,19 +2967,19 @@ static void spirv_compiler_emit_register_debug_name(struct vkd3d_spirv_builder *
static uint32_t spirv_compiler_emit_variable(struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, - enum vkd3d_shader_component_type component_type, unsigned int component_count) + enum vkd3d_data_type data_type, unsigned int component_count) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t type_id, ptr_type_id;
- type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id); return vkd3d_spirv_build_op_variable(builder, stream, ptr_type_id, storage_class, 0); }
static uint32_t spirv_compiler_emit_array_variable(struct spirv_compiler *compiler, struct vkd3d_spirv_stream *stream, SpvStorageClass storage_class, - enum vkd3d_shader_component_type component_type, unsigned int component_count, + enum vkd3d_data_type data_type, unsigned int component_count, const unsigned int *array_lengths, unsigned int length_count) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -2999,10 +2987,9 @@ static uint32_t spirv_compiler_emit_array_variable(struct spirv_compiler *compil unsigned int i;
if (!length_count) - return spirv_compiler_emit_variable(compiler, - stream, storage_class, component_type, component_count); + return spirv_compiler_emit_variable(compiler, stream, storage_class, data_type, component_count);
- type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); for (i = 0; i < length_count; ++i) { if (!array_lengths[i]) @@ -3086,7 +3073,7 @@ static uint32_t spirv_compiler_emit_spec_constant(struct spirv_compiler *compile info = get_spec_constant_info(name); default_value = info ? info->default_value : 0;
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); id = vkd3d_spirv_build_op_spec_constant(builder, type_id, default_value); vkd3d_spirv_build_op_decorate1(builder, id, SpvDecorationSpecId, spec_id);
@@ -3142,7 +3129,7 @@ default_parameter: }
static uint32_t spirv_compiler_emit_construct_vector(struct spirv_compiler *compiler, - enum vkd3d_shader_component_type component_type, unsigned int component_count, + enum vkd3d_data_type data_type, unsigned int component_count, uint32_t val_id, unsigned int val_component_idx, unsigned int val_component_count) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -3152,7 +3139,7 @@ static uint32_t spirv_compiler_emit_construct_vector(struct spirv_compiler *comp
assert(val_component_idx < val_component_count);
- type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); if (val_component_count == 1) { for (i = 0; i < component_count; ++i) @@ -3185,7 +3172,7 @@ static uint32_t spirv_compiler_emit_register_addressing(struct spirv_compiler *c addr_id = spirv_compiler_emit_load_src(compiler, reg_index->rel_addr, VKD3DSP_WRITEMASK_0); if (reg_index->offset) { - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); addr_id = vkd3d_spirv_build_op_iadd(builder, type_id, addr_id, spirv_compiler_get_constant_uint(compiler, reg_index->offset)); } @@ -3197,7 +3184,7 @@ struct vkd3d_shader_register_info uint32_t id; const struct vkd3d_symbol *descriptor_array; SpvStorageClass storage_class; - enum vkd3d_shader_component_type component_type; + enum vkd3d_data_type data_type; unsigned int write_mask; uint32_t member_idx; unsigned int structure_stride; @@ -3220,7 +3207,7 @@ static bool spirv_compiler_get_register_info(const struct spirv_compiler *compil register_info->storage_class = SpvStorageClassPrivate; register_info->descriptor_array = NULL; register_info->member_idx = 0; - register_info->component_type = VKD3D_SHADER_COMPONENT_FLOAT; + register_info->data_type = VKD3D_DATA_FLOAT; register_info->write_mask = VKD3DSP_WRITEMASK_ALL; register_info->structure_stride = 0; register_info->binding_base_idx = 0; @@ -3241,7 +3228,7 @@ static bool spirv_compiler_get_register_info(const struct spirv_compiler *compil register_info->descriptor_array = symbol->descriptor_array; register_info->storage_class = symbol->info.reg.storage_class; register_info->member_idx = symbol->info.reg.member_idx; - register_info->component_type = symbol->info.reg.component_type; + register_info->data_type = symbol->info.reg.data_type; register_info->write_mask = symbol->info.reg.write_mask; register_info->structure_stride = symbol->info.reg.structure_stride; register_info->binding_base_idx = symbol->info.reg.binding_base_idx; @@ -3330,7 +3317,7 @@ static uint32_t spirv_compiler_get_descriptor_index(struct spirv_compiler *compi struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t type_id, ptr_type_id, ptr_id, offset_id, index_ids[2];
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); if (!(offset_id = compiler->descriptor_offset_ids[push_constant_index])) { index_ids[0] = compiler->descriptor_offsets_member_id; @@ -3397,7 +3384,7 @@ static void spirv_compiler_emit_dereference_register(struct spirv_compiler *comp if (index_count) { component_count = vkd3d_write_mask_component_count(register_info->write_mask); - type_id = vkd3d_spirv_get_type_id(builder, register_info->component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, register_info->data_type, component_count); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, register_info->storage_class, type_id); register_info->id = vkd3d_spirv_build_op_access_chain(builder, ptr_type_id, register_info->id, indexes, index_count); @@ -3419,7 +3406,7 @@ static uint32_t spirv_compiler_get_register_id(struct spirv_compiler *compiler, }
return spirv_compiler_emit_variable(compiler, &builder->global_stream, - SpvStorageClassPrivate, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + SpvStorageClassPrivate, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); }
static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask, @@ -3429,7 +3416,7 @@ static bool vkd3d_swizzle_is_equal(unsigned int dst_write_mask, }
static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler, - uint32_t val_id, unsigned int val_write_mask, enum vkd3d_shader_component_type component_type, + uint32_t val_id, unsigned int val_write_mask, enum vkd3d_data_type data_type, unsigned int swizzle, unsigned int write_mask) { unsigned int i, component_idx, component_count, val_component_count; @@ -3443,7 +3430,7 @@ static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler, && (component_count == 1 || vkd3d_swizzle_is_equal(val_write_mask, swizzle, write_mask))) return val_id;
- type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
if (component_count == 1) { @@ -3477,7 +3464,7 @@ static uint32_t spirv_compiler_emit_swizzle(struct spirv_compiler *compiler,
static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compiler, uint32_t vector1_id, uint32_t vector2_id, unsigned int swizzle, unsigned int write_mask, - enum vkd3d_shader_component_type component_type, unsigned int component_count) + enum vkd3d_data_type data_type, unsigned int component_count) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t components[VKD3D_VEC4_SIZE]; @@ -3494,7 +3481,7 @@ static uint32_t spirv_compiler_emit_vector_shuffle(struct spirv_compiler *compil components[i] = VKD3D_VEC4_SIZE + vkd3d_swizzle_get_component(swizzle, i); }
- type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); return vkd3d_spirv_build_op_vector_shuffle(builder, type_id, vector1_id, vector2_id, components, component_count); } @@ -3522,8 +3509,7 @@ static uint32_t spirv_compiler_emit_load_constant(struct spirv_compiler *compile } }
- return spirv_compiler_get_constant(compiler, - vkd3d_component_type_from_data_type(reg->data_type), component_count, values); + return spirv_compiler_get_constant(compiler, reg->data_type, component_count, values); }
static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compiler, @@ -3549,8 +3535,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi } }
- return spirv_compiler_get_constant64(compiler, - vkd3d_component_type_from_data_type(reg->data_type), component_count, values); + return spirv_compiler_get_constant64(compiler, reg->data_type, component_count, values); }
static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, @@ -3560,8 +3545,8 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t type_id, ptr_type_id, index, reg_id, val_id; unsigned int component_idx, reg_component_count; - enum vkd3d_shader_component_type component_type; unsigned int skipped_component_mask; + enum vkd3d_data_type data_type;
assert(reg->type != VKD3DSPR_IMMCONST && reg->type != VKD3DSPR_IMMCONST64); assert(vkd3d_write_mask_component_count(write_mask) == 1); @@ -3571,7 +3556,7 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, skipped_component_mask = ~reg_info->write_mask & ((VKD3DSP_WRITEMASK_0 << component_idx) - 1); if (skipped_component_mask) component_idx -= vkd3d_write_mask_component_count(skipped_component_mask); - component_type = vkd3d_component_type_from_data_type(reg->data_type); + data_type = reg->data_type;
reg_component_count = vkd3d_write_mask_component_count(reg_info->write_mask);
@@ -3581,7 +3566,7 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler, component_idx, reg->type, reg->idx[0].offset, reg_info->write_mask); }
- type_id = vkd3d_spirv_get_type_id(builder, reg_info->component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, reg_info->data_type, 1); reg_id = reg_info->id; if (reg_component_count != 1) { @@ -3592,9 +3577,9 @@ static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
val_id = vkd3d_spirv_build_op_load(builder, type_id, reg_id, SpvMemoryAccessMaskNone);
- if (component_type != reg_info->component_type) + if (data_type != reg_info->data_type) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); }
@@ -3605,8 +3590,8 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, DWORD swizzle, DWORD write_mask) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - enum vkd3d_shader_component_type component_type; struct vkd3d_shader_register_info reg_info; + enum vkd3d_data_type data_type; unsigned int component_count; unsigned int write_mask32; uint32_t type_id, val_id; @@ -3617,13 +3602,13 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, return spirv_compiler_emit_load_constant64(compiler, reg, swizzle, write_mask);
component_count = vkd3d_write_mask_component_count(write_mask); - component_type = vkd3d_component_type_from_data_type(reg->data_type); + data_type = reg->data_type; if (!spirv_compiler_get_register_info(compiler, reg, ®_info)) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); } - assert(reg_info.component_type != VKD3D_SHADER_COMPONENT_DOUBLE); + assert(reg_info.data_type != VKD3D_DATA_DOUBLE); spirv_compiler_emit_dereference_register(compiler, reg, ®_info);
write_mask32 = (reg->data_type == VKD3D_DATA_DOUBLE) ? vkd3d_write_mask_32_from_64(write_mask) : write_mask; @@ -3640,16 +3625,16 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, else { type_id = vkd3d_spirv_get_type_id(builder, - reg_info.component_type, vkd3d_write_mask_component_count(reg_info.write_mask)); + reg_info.data_type, vkd3d_write_mask_component_count(reg_info.write_mask)); val_id = vkd3d_spirv_build_op_load(builder, type_id, reg_info.id, SpvMemoryAccessMaskNone); }
val_id = spirv_compiler_emit_swizzle(compiler, - val_id, reg_info.write_mask, reg_info.component_type, swizzle, write_mask32); + val_id, reg_info.write_mask, reg_info.data_type, swizzle, write_mask32);
- if (component_type != reg_info.component_type) + if (data_type != reg_info.data_type) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); }
@@ -3734,16 +3719,16 @@ static uint32_t spirv_compiler_emit_load_src(struct spirv_compiler *compiler, }
static uint32_t spirv_compiler_emit_load_src_with_type(struct spirv_compiler *compiler, - const struct vkd3d_shader_src_param *src, DWORD write_mask, enum vkd3d_shader_component_type component_type) + const struct vkd3d_shader_src_param *src, DWORD write_mask, enum vkd3d_data_type data_type) { struct vkd3d_shader_src_param src_param = *src;
- src_param.reg.data_type = vkd3d_data_type_from_component_type(component_type); + src_param.reg.data_type = data_type; return spirv_compiler_emit_load_src(compiler, &src_param, write_mask); }
static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler, - uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_shader_component_type component_type, + uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_data_type data_type, SpvStorageClass storage_class, unsigned int write_mask, uint32_t val_id) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -3752,7 +3737,7 @@ static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler,
if (vkd3d_write_mask_component_count(dst_write_mask) > 1) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, storage_class, type_id); component_idx = vkd3d_write_mask_get_component_idx(write_mask); component_idx -= vkd3d_write_mask_get_component_idx(dst_write_mask); @@ -3764,7 +3749,7 @@ static void spirv_compiler_emit_store_scalar(struct spirv_compiler *compiler, }
static void spirv_compiler_emit_store(struct spirv_compiler *compiler, - uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_shader_component_type component_type, + uint32_t dst_id, unsigned int dst_write_mask, enum vkd3d_data_type data_type, SpvStorageClass storage_class, unsigned int write_mask, uint32_t val_id) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -3780,7 +3765,7 @@ static void spirv_compiler_emit_store(struct spirv_compiler *compiler,
if (dst_component_count == 1 && component_count != 1) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); val_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, val_id, vkd3d_write_mask_get_component_idx(dst_write_mask)); write_mask &= dst_write_mask; @@ -3790,12 +3775,12 @@ static void spirv_compiler_emit_store(struct spirv_compiler *compiler, if (component_count == 1) { return spirv_compiler_emit_store_scalar(compiler, - dst_id, dst_write_mask, component_type, storage_class, write_mask, val_id); + dst_id, dst_write_mask, data_type, storage_class, write_mask, val_id); }
if (dst_component_count != component_count) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, dst_component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, dst_component_count); dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);
assert(component_count <= ARRAY_SIZE(components)); @@ -3822,9 +3807,9 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, unsigned int write_mask, uint32_t val_id) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - enum vkd3d_shader_component_type component_type; struct vkd3d_shader_register_info reg_info; unsigned int src_write_mask = write_mask; + enum vkd3d_data_type data_type; uint32_t type_id;
assert(reg->type != VKD3DSPR_IMMCONST && reg->type != VKD3DSPR_IMMCONST64); @@ -3833,19 +3818,19 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, return; spirv_compiler_emit_dereference_register(compiler, reg, ®_info);
- component_type = vkd3d_component_type_from_data_type(reg->data_type); - if (component_type != reg_info.component_type) + data_type = reg->data_type; + if (data_type != reg_info.data_type) { if (reg->data_type == VKD3D_DATA_DOUBLE) src_write_mask = vkd3d_write_mask_32_from_64(write_mask); - type_id = vkd3d_spirv_get_type_id(builder, reg_info.component_type, + type_id = vkd3d_spirv_get_type_id(builder, reg_info.data_type, vkd3d_write_mask_component_count(src_write_mask)); val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); - component_type = reg_info.component_type; + data_type = reg_info.data_type; }
spirv_compiler_emit_store(compiler, - reg_info.id, reg_info.write_mask, component_type, reg_info.storage_class, src_write_mask, val_id); + reg_info.id, reg_info.write_mask, data_type, reg_info.storage_class, src_write_mask, val_id); }
static uint32_t spirv_compiler_emit_sat(struct spirv_compiler *compiler, @@ -3886,21 +3871,20 @@ static void spirv_compiler_emit_store_dst(struct spirv_compiler *compiler,
static void spirv_compiler_emit_store_dst_swizzled(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, - enum vkd3d_shader_component_type component_type, DWORD swizzle) + enum vkd3d_data_type data_type, DWORD swizzle) { struct vkd3d_shader_dst_param typed_dst = *dst; val_id = spirv_compiler_emit_swizzle(compiler, - val_id, VKD3DSP_WRITEMASK_ALL, component_type, swizzle, dst->write_mask); + val_id, VKD3DSP_WRITEMASK_ALL, data_type, swizzle, dst->write_mask); /* XXX: The register data type could be fixed by the shader parser. For SM5 * shaders the data types are stored in instructions modifiers. */ - typed_dst.reg.data_type = vkd3d_data_type_from_component_type(component_type); + typed_dst.reg.data_type = data_type; spirv_compiler_emit_store_dst(compiler, &typed_dst, val_id); }
static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *compiler, - const struct vkd3d_shader_dst_param *dst, enum vkd3d_shader_component_type component_type, - uint32_t *component_ids) + const struct vkd3d_shader_dst_param *dst, enum vkd3d_data_type data_type, uint32_t *component_ids) { unsigned int component_count = vkd3d_write_mask_component_count(dst->write_mask); struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -3908,7 +3892,7 @@ static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *comp
if (component_count > 1) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, component_ids, component_count); } @@ -3921,7 +3905,7 @@ static void spirv_compiler_emit_store_dst_components(struct spirv_compiler *comp
static void spirv_compiler_emit_store_dst_scalar(struct spirv_compiler *compiler, const struct vkd3d_shader_dst_param *dst, uint32_t val_id, - enum vkd3d_shader_component_type component_type, DWORD swizzle) + enum vkd3d_data_type data_type, DWORD swizzle) { unsigned int component_count = vkd3d_write_mask_component_count(dst->write_mask); uint32_t component_ids[VKD3D_VEC4_SIZE]; @@ -3935,7 +3919,7 @@ static void spirv_compiler_emit_store_dst_scalar(struct spirv_compiler *compiler
component_ids[i] = val_id; } - spirv_compiler_emit_store_dst_components(compiler, dst, component_type, component_ids); + spirv_compiler_emit_store_dst_components(compiler, dst, data_type, component_ids); }
static void spirv_compiler_decorate_builtin(struct spirv_compiler *compiler, @@ -4018,7 +4002,7 @@ static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler,
assert(!(condition & ~(VKD3D_SHADER_CONDITIONAL_OP_NZ | VKD3D_SHADER_CONDITIONAL_OP_Z)));
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, component_count); op = condition & VKD3D_SHADER_CONDITIONAL_OP_Z ? SpvOpIEqual : SpvOpINotEqual; return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, val_id, spirv_compiler_get_constant_uint_vector(compiler, 0, component_count)); @@ -4032,7 +4016,7 @@ static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler,
true_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count); false_id = spirv_compiler_get_constant_uint_vector(compiler, 0, component_count); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, component_count); return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); }
@@ -4048,11 +4032,11 @@ static uint32_t spirv_compiler_emit_draw_parameter_fixup(struct spirv_compiler * vkd3d_spirv_enable_capability(builder, SpvCapabilityDrawParameters);
base_var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream, - SpvStorageClassInput, VKD3D_SHADER_COMPONENT_INT, 1); + SpvStorageClassInput, VKD3D_DATA_INT, 1); vkd3d_spirv_add_iface_variable(builder, base_var_id); spirv_compiler_decorate_builtin(compiler, base_var_id, base);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, 1); base_id = vkd3d_spirv_build_op_load(builder, type_id, base_var_id, SpvMemoryAccessMaskNone);
@@ -4088,17 +4072,17 @@ static uint32_t frag_coord_fixup(struct spirv_compiler *compiler, struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; uint32_t type_id, w_id;
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 1); w_id = vkd3d_spirv_build_op_composite_extract1(builder, type_id, frag_coord_id, 3); w_id = vkd3d_spirv_build_op_fdiv(builder, type_id, spirv_compiler_get_constant_float(compiler, 1.0f), w_id); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); return vkd3d_spirv_build_op_composite_insert1(builder, type_id, w_id, frag_coord_id, 3); }
struct vkd3d_spirv_builtin { - enum vkd3d_shader_component_type component_type; + enum vkd3d_data_type data_type; unsigned int component_count; SpvBuiltIn spirv_builtin; vkd3d_spirv_builtin_fixup_pfn fixup_pfn; @@ -4118,45 +4102,43 @@ static const struct } vkd3d_system_value_builtins[] = { - {VKD3D_SIV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexId}, - VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5}, - {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceId}, - VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5}, + {VKD3D_SIV_VERTEX_ID, {VKD3D_DATA_INT, 1, SpvBuiltInVertexId}, VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5}, + {VKD3D_SIV_INSTANCE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInInstanceId}, VKD3D_SHADER_SPIRV_ENVIRONMENT_OPENGL_4_5},
- {VKD3D_SIV_POSITION, {VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInPosition}}, - {VKD3D_SIV_VERTEX_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}}, - {VKD3D_SIV_INSTANCE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}}, + {VKD3D_SIV_POSITION, {VKD3D_DATA_FLOAT, 4, SpvBuiltInPosition}}, + {VKD3D_SIV_VERTEX_ID, {VKD3D_DATA_INT, 1, SpvBuiltInVertexIndex, sv_vertex_id_fixup}}, + {VKD3D_SIV_INSTANCE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInInstanceIndex, sv_instance_id_fixup}},
- {VKD3D_SIV_PRIMITIVE_ID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}}, + {VKD3D_SIV_PRIMITIVE_ID, {VKD3D_DATA_INT, 1, SpvBuiltInPrimitiveId}},
- {VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLayer}}, - {VKD3D_SIV_VIEWPORT_ARRAY_INDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInViewportIndex}}, + {VKD3D_SIV_RENDER_TARGET_ARRAY_INDEX, {VKD3D_DATA_INT, 1, SpvBuiltInLayer}}, + {VKD3D_SIV_VIEWPORT_ARRAY_INDEX, {VKD3D_DATA_INT, 1, SpvBuiltInViewportIndex}},
- {VKD3D_SIV_IS_FRONT_FACE, {VKD3D_SHADER_COMPONENT_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}}, + {VKD3D_SIV_IS_FRONT_FACE, {VKD3D_DATA_BOOL, 1, SpvBuiltInFrontFacing, sv_front_face_fixup}},
- {VKD3D_SIV_SAMPLE_INDEX, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleId}}, + {VKD3D_SIV_SAMPLE_INDEX, {VKD3D_DATA_UINT, 1, SpvBuiltInSampleId}},
- {VKD3D_SIV_CLIP_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}}, - {VKD3D_SIV_CULL_DISTANCE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}}, + {VKD3D_SIV_CLIP_DISTANCE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInClipDistance, NULL, 1}}, + {VKD3D_SIV_CULL_DISTANCE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInCullDistance, NULL, 1}},
- {VKD3D_SIV_QUAD_U0_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, - {VKD3D_SIV_QUAD_V0_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, - {VKD3D_SIV_QUAD_U1_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, - {VKD3D_SIV_QUAD_V1_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 3}}, - {VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}}, - {VKD3D_SIV_QUAD_V_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 1}}, + {VKD3D_SIV_QUAD_U0_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, + {VKD3D_SIV_QUAD_V0_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, + {VKD3D_SIV_QUAD_U1_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, + {VKD3D_SIV_QUAD_V1_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 3}}, + {VKD3D_SIV_QUAD_U_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}}, + {VKD3D_SIV_QUAD_V_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 1}},
- {VKD3D_SIV_TRIANGLE_U_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, - {VKD3D_SIV_TRIANGLE_V_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, - {VKD3D_SIV_TRIANGLE_W_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, - {VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}}, + {VKD3D_SIV_TRIANGLE_U_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, + {VKD3D_SIV_TRIANGLE_V_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, + {VKD3D_SIV_TRIANGLE_W_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 2}}, + {VKD3D_SIV_TRIANGLE_INNER_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelInner, NULL, 2, 0}},
- {VKD3D_SIV_LINE_DENSITY_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, - {VKD3D_SIV_LINE_DETAIL_TESS_FACTOR, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, + {VKD3D_SIV_LINE_DENSITY_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 0}}, + {VKD3D_SIV_LINE_DETAIL_TESS_FACTOR, {VKD3D_DATA_FLOAT, 1, SpvBuiltInTessLevelOuter, NULL, 4, 1}}, }; static const struct vkd3d_spirv_builtin vkd3d_pixel_shader_position_builtin = { - VKD3D_SHADER_COMPONENT_FLOAT, 4, SpvBuiltInFragCoord, frag_coord_fixup, + VKD3D_DATA_FLOAT, 4, SpvBuiltInFragCoord, frag_coord_fixup, }; static const struct { @@ -4165,26 +4147,26 @@ static const struct } vkd3d_register_builtins[] = { - {VKD3DSPR_THREADID, {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInGlobalInvocationId}}, - {VKD3DSPR_LOCALTHREADID, {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInLocalInvocationId}}, - {VKD3DSPR_LOCALTHREADINDEX, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInLocalInvocationIndex}}, - {VKD3DSPR_THREADGROUPID, {VKD3D_SHADER_COMPONENT_INT, 3, SpvBuiltInWorkgroupId}}, + {VKD3DSPR_THREADID, {VKD3D_DATA_INT, 3, SpvBuiltInGlobalInvocationId}}, + {VKD3DSPR_LOCALTHREADID, {VKD3D_DATA_INT, 3, SpvBuiltInLocalInvocationId}}, + {VKD3DSPR_LOCALTHREADINDEX, {VKD3D_DATA_INT, 1, SpvBuiltInLocalInvocationIndex}}, + {VKD3DSPR_THREADGROUPID, {VKD3D_DATA_INT, 3, SpvBuiltInWorkgroupId}},
- {VKD3DSPR_GSINSTID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInvocationId}}, - {VKD3DSPR_OUTPOINTID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInInvocationId}}, + {VKD3DSPR_GSINSTID, {VKD3D_DATA_INT, 1, SpvBuiltInInvocationId}}, + {VKD3DSPR_OUTPOINTID, {VKD3D_DATA_INT, 1, SpvBuiltInInvocationId}},
- {VKD3DSPR_PRIMID, {VKD3D_SHADER_COMPONENT_INT, 1, SpvBuiltInPrimitiveId}}, + {VKD3DSPR_PRIMID, {VKD3D_DATA_INT, 1, SpvBuiltInPrimitiveId}},
- {VKD3DSPR_TESSCOORD, {VKD3D_SHADER_COMPONENT_FLOAT, 3, SpvBuiltInTessCoord}}, + {VKD3DSPR_TESSCOORD, {VKD3D_DATA_FLOAT, 3, SpvBuiltInTessCoord}},
- {VKD3DSPR_COVERAGE, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleMask, NULL, 1}}, - {VKD3DSPR_SAMPLEMASK, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInSampleMask, NULL, 1}}, + {VKD3DSPR_COVERAGE, {VKD3D_DATA_UINT, 1, SpvBuiltInSampleMask, NULL, 1}}, + {VKD3DSPR_SAMPLEMASK, {VKD3D_DATA_UINT, 1, SpvBuiltInSampleMask, NULL, 1}},
- {VKD3DSPR_DEPTHOUT, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}}, - {VKD3DSPR_DEPTHOUTGE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}}, - {VKD3DSPR_DEPTHOUTLE, {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInFragDepth}}, + {VKD3DSPR_DEPTHOUT, {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}}, + {VKD3DSPR_DEPTHOUTGE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}}, + {VKD3DSPR_DEPTHOUTLE, {VKD3D_DATA_FLOAT, 1, SpvBuiltInFragDepth}},
- {VKD3DSPR_OUTSTENCILREF, {VKD3D_SHADER_COMPONENT_UINT, 1, SpvBuiltInFragStencilRefEXT}}, + {VKD3DSPR_OUTSTENCILREF, {VKD3D_DATA_UINT, 1, SpvBuiltInFragStencilRefEXT}}, };
static void spirv_compiler_emit_register_execution_mode(struct spirv_compiler *compiler, @@ -4292,7 +4274,7 @@ static uint32_t spirv_compiler_emit_load_invocation_id(struct spirv_compiler *co uint32_t type_id, id;
id = spirv_compiler_get_invocation_id(compiler); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, 1); return vkd3d_spirv_build_op_load(builder, type_id, id, SpvMemoryAccessMaskNone); }
@@ -4406,13 +4388,12 @@ static uint32_t spirv_compiler_emit_builtin_variable_v(struct spirv_compiler *co sizes[0] = max(sizes[0], builtin->spirv_array_size);
id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, storage_class, - builtin->component_type, builtin->component_count, array_sizes, size_count); + builtin->data_type, builtin->component_count, array_sizes, size_count); vkd3d_spirv_add_iface_variable(builder, id); spirv_compiler_decorate_builtin(compiler, id, builtin->spirv_builtin);
if (compiler->shader_type == VKD3D_SHADER_TYPE_PIXEL && storage_class == SpvStorageClassInput - && builtin->component_type != VKD3D_SHADER_COMPONENT_FLOAT - && builtin->component_type != VKD3D_SHADER_COMPONENT_BOOL) + && builtin->data_type != VKD3D_DATA_FLOAT && builtin->data_type != VKD3D_DATA_BOOL) vkd3d_spirv_build_op_decorate(builder, id, SpvDecorationFlat, NULL, 0);
return id; @@ -4468,13 +4449,13 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, unsigned int component_idx, input_component_count; const struct signature_element *signature_element; const struct shader_signature *shader_signature; - enum vkd3d_shader_component_type component_type; uint32_t type_id, ptr_type_id, float_type_id; const struct vkd3d_spirv_builtin *builtin; unsigned int write_mask, reg_write_mask; struct vkd3d_symbol *symbol = NULL; uint32_t val_id, input_id, var_id; struct vkd3d_symbol reg_symbol; + enum vkd3d_data_type data_type; SpvStorageClass storage_class; struct rb_entry *entry = NULL; bool use_private_var = false; @@ -4501,13 +4482,13 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
if (builtin) { - component_type = builtin->component_type; + data_type = builtin->data_type; input_component_count = builtin->component_count; component_idx = 0; } else { - component_type = signature_element->component_type; + data_type = signature_element->data_type; input_component_count = vkd3d_write_mask_component_count(signature_element->mask); component_idx = vkd3d_write_mask_get_component_idx(signature_element->mask); } @@ -4550,7 +4531,7 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, unsigned int location = signature_element->register_index;
input_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, - storage_class, component_type, input_component_count, array_sizes, 2); + storage_class, data_type, input_component_count, array_sizes, 2); vkd3d_spirv_add_iface_variable(builder, input_id); if (reg->type == VKD3DSPR_PATCHCONST) { @@ -4569,11 +4550,11 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, { storage_class = SpvStorageClassPrivate; var_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, - storage_class, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, array_sizes, 2); + storage_class, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, array_sizes, 2); }
vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - use_private_var ? VKD3D_SHADER_COMPONENT_FLOAT : component_type, + use_private_var ? VKD3D_DATA_FLOAT : data_type, use_private_var ? VKD3DSP_WRITEMASK_ALL : reg_write_mask); reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1]; assert(!builtin || !builtin->spirv_array_size || use_private_var || array_sizes[0] || array_sizes[1]); @@ -4583,7 +4564,7 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler,
if (use_private_var) { - type_id = vkd3d_spirv_get_type_id(builder, component_type, input_component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, input_component_count); for (i = 0; i < max(array_sizes[0], 1); ++i) { struct vkd3d_shader_register dst_reg = *reg; @@ -4612,15 +4593,15 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, if (builtin && builtin->fixup_pfn) val_id = builtin->fixup_pfn(compiler, val_id);
- if (component_type != VKD3D_SHADER_COMPONENT_FLOAT) + if (data_type != VKD3D_DATA_FLOAT) { - float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, input_component_count); + float_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, input_component_count); val_id = vkd3d_spirv_build_op_bitcast(builder, float_type_id, val_id); }
val_id = spirv_compiler_emit_swizzle(compiler, val_id, vkd3d_write_mask_from_component_count(input_component_count), - VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx); + VKD3D_DATA_FLOAT, VKD3D_SHADER_NO_SWIZZLE, dst->write_mask >> component_idx);
spirv_compiler_emit_store_reg(compiler, &dst_reg, dst->write_mask, val_id); } @@ -4657,8 +4638,7 @@ static void spirv_compiler_emit_input_register(struct spirv_compiler *compiler, input_id = spirv_compiler_emit_builtin_variable(compiler, builtin, SpvStorageClassInput, 0);
write_mask = vkd3d_write_mask_from_component_count(builtin->component_count); - vkd3d_symbol_set_register_info(®_symbol, input_id, - SpvStorageClassInput, builtin->component_type, write_mask); + vkd3d_symbol_set_register_info(®_symbol, input_id, SpvStorageClassInput, builtin->data_type, write_mask); reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size; spirv_compiler_put_symbol(compiler, ®_symbol); spirv_compiler_emit_register_debug_name(builder, input_id, reg); @@ -4770,13 +4750,13 @@ static void spirv_compiler_emit_shader_signature_outputs(struct spirv_compiler * { case VKD3D_SHADER_SV_CLIP_DISTANCE: compiler->output_info[i].id = clip_distance_id; - compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT; + compiler->output_info[i].data_type = VKD3D_DATA_FLOAT; compiler->output_info[i].array_element_mask = clip_distance_mask; break;
case VKD3D_SHADER_SV_CULL_DISTANCE: compiler->output_info[i].id = cull_distance_id; - compiler->output_info[i].component_type = VKD3D_SHADER_COMPONENT_FLOAT; + compiler->output_info[i].data_type = VKD3D_DATA_FLOAT; compiler->output_info[i].array_element_mask = cull_distance_mask; break;
@@ -4809,8 +4789,7 @@ static void spirv_compiler_emit_output_register(struct spirv_compiler *compiler,
vkd3d_symbol_make_register(®_symbol, reg); write_mask = vkd3d_write_mask_from_component_count(builtin->component_count); - vkd3d_symbol_set_register_info(®_symbol, output_id, - SpvStorageClassOutput, builtin->component_type, write_mask); + vkd3d_symbol_set_register_info(®_symbol, output_id, SpvStorageClassOutput, builtin->data_type, write_mask); reg_symbol.info.reg.is_aggregate = builtin->spirv_array_size; spirv_compiler_put_symbol(compiler, ®_symbol); spirv_compiler_emit_register_execution_mode(compiler, reg); @@ -4849,11 +4828,11 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg = &dst->reg; unsigned int component_idx, output_component_count; const struct signature_element *signature_element; - enum vkd3d_shader_component_type component_type; const struct shader_signature *shader_signature; const struct vkd3d_spirv_builtin *builtin; unsigned int write_mask, reg_write_mask; bool use_private_variable = false; + enum vkd3d_data_type data_type; struct vkd3d_symbol reg_symbol; SpvStorageClass storage_class; unsigned int array_sizes[2]; @@ -4876,14 +4855,14 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, output_component_count = vkd3d_write_mask_component_count(write_mask); if (builtin) { - component_type = builtin->component_type; + data_type = builtin->data_type; if (!builtin->spirv_array_size) output_component_count = builtin->component_count; component_idx = 0; } else { - component_type = signature_element->component_type; + data_type = signature_element->data_type; }
storage_class = SpvStorageClassOutput; @@ -4931,7 +4910,7 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, location += shader_signature_next_location(&compiler->output_signature);
id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, - storage_class, component_type, output_component_count, array_sizes, 2); + storage_class, data_type, output_component_count, array_sizes, 2); vkd3d_spirv_add_iface_variable(builder, id);
if (is_dual_source_blending(compiler) && signature_element->register_index < 2) @@ -4954,18 +4933,18 @@ static void spirv_compiler_emit_output(struct spirv_compiler *compiler, spirv_compiler_decorate_xfb_output(compiler, id, output_component_count, signature_element);
compiler->output_info[element_idx].id = id; - compiler->output_info[element_idx].component_type = component_type; + compiler->output_info[element_idx].data_type = data_type;
var_id = id; if (use_private_variable) { storage_class = SpvStorageClassPrivate; var_id = spirv_compiler_emit_variable(compiler, &builder->global_stream, - storage_class, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + storage_class, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); }
vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - use_private_variable ? VKD3D_SHADER_COMPONENT_FLOAT : component_type, + use_private_variable ? VKD3D_DATA_FLOAT : data_type, use_private_variable ? VKD3DSP_WRITEMASK_ALL : reg_write_mask); reg_symbol.info.reg.is_aggregate = array_sizes[0] || array_sizes[1]; assert(!builtin || !builtin->spirv_array_size || use_private_variable || array_sizes[0] || array_sizes[1]); @@ -5038,9 +5017,9 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi if (!write_mask) return;
- if (output_info->component_type != VKD3D_SHADER_COMPONENT_FLOAT) + if (output_info->data_type != VKD3D_DATA_FLOAT) { - type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, output_info->data_type, VKD3D_VEC4_SIZE); val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); }
@@ -5050,23 +5029,22 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi { /* Set values to 0 for not initialized shader output components. */ write_mask |= uninit_mask; - zero_id = spirv_compiler_get_constant_vector(compiler, - output_info->component_type, VKD3D_VEC4_SIZE, 0); + zero_id = spirv_compiler_get_constant_vector(compiler, output_info->data_type, VKD3D_VEC4_SIZE, 0); val_id = spirv_compiler_emit_vector_shuffle(compiler, - zero_id, val_id, swizzle, uninit_mask, output_info->component_type, + zero_id, val_id, swizzle, uninit_mask, output_info->data_type, vkd3d_write_mask_component_count(write_mask)); } else { val_id = spirv_compiler_emit_swizzle(compiler, - val_id, VKD3DSP_WRITEMASK_ALL, output_info->component_type, swizzle, write_mask); + val_id, VKD3DSP_WRITEMASK_ALL, output_info->data_type, swizzle, write_mask); }
output_id = output_info->id; if (output_index_id) { type_id = vkd3d_spirv_get_type_id(builder, - output_info->component_type, vkd3d_write_mask_component_count(dst_write_mask)); + output_info->data_type, vkd3d_write_mask_component_count(dst_write_mask)); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id); output_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, output_id, output_index_id); } @@ -5074,11 +5052,11 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi if (!output_info->array_element_mask) { spirv_compiler_emit_store(compiler, - output_id, dst_write_mask, output_info->component_type, SpvStorageClassOutput, write_mask, val_id); + output_id, dst_write_mask, output_info->data_type, SpvStorageClassOutput, write_mask, val_id); return; }
- type_id = vkd3d_spirv_get_type_id(builder, output_info->component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, output_info->data_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassOutput, type_id); mask = output_info->array_element_mask; array_idx = spirv_compiler_get_output_array_index(compiler, output); @@ -5091,9 +5069,9 @@ static void spirv_compiler_emit_store_shader_output(struct spirv_compiler *compi chain_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, output_id, spirv_compiler_get_constant_uint(compiler, index)); object_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask, - output_info->component_type, VKD3D_SHADER_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i); + output_info->data_type, VKD3D_SHADER_NO_SWIZZLE, VKD3DSP_WRITEMASK_0 << i); spirv_compiler_emit_store(compiler, chain_id, VKD3DSP_WRITEMASK_0, - output_info->component_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id); + output_info->data_type, SpvStorageClassOutput, VKD3DSP_WRITEMASK_0 << i, object_id); ++index; } } @@ -5120,7 +5098,7 @@ static void spirv_compiler_emit_shader_epilogue_function(struct spirv_compiler * function_id = compiler->epilogue_function_id;
void_id = vkd3d_spirv_get_op_type_void(builder); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 4); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 4); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id); for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i) { @@ -5278,7 +5256,7 @@ static void spirv_compiler_emit_temps(struct spirv_compiler *compiler, uint32_t for (i = 0; i < compiler->temp_count; ++i) { id = spirv_compiler_emit_variable(compiler, &builder->global_stream, - SpvStorageClassPrivate, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + SpvStorageClassPrivate, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); if (!i) compiler->temp_id = id; assert(id == compiler->temp_id + i); @@ -5312,7 +5290,7 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil vkd3d_spirv_begin_function_stream_insertion(builder, function_location);
id = spirv_compiler_emit_array_variable(compiler, &builder->function_stream, - SpvStorageClassFunction, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, &temp->register_size, 1); + SpvStorageClassFunction, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, &temp->register_size, 1);
spirv_compiler_emit_register_debug_name(builder, id, ®);
@@ -5320,7 +5298,7 @@ static void spirv_compiler_emit_dcl_indexable_temp(struct spirv_compiler *compil
vkd3d_symbol_make_register(®_symbol, ®); vkd3d_symbol_set_register_info(®_symbol, id, - SpvStorageClassFunction, VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); + SpvStorageClassFunction, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL); spirv_compiler_put_symbol(compiler, ®_symbol); }
@@ -5347,7 +5325,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com if (!(member_ids = vkd3d_calloc(count, sizeof(*member_ids)))) return;
- vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE);
for (i = 0, j = 0; i < compiler->shader_interface.push_constant_buffer_count; ++i) { @@ -5364,7 +5342,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com
if (compiler->offset_info.descriptor_table_count) { - uint32_t type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + uint32_t type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); length_id = spirv_compiler_get_constant_uint(compiler, compiler->offset_info.descriptor_table_count); member_ids[j] = vkd3d_spirv_build_op_type_array(builder, type_id, length_id); vkd3d_spirv_build_op_decorate1(builder, member_ids[j], SpvDecorationArrayStride, 4); @@ -5396,7 +5374,7 @@ static void spirv_compiler_emit_push_constant_buffers(struct spirv_compiler *com
vkd3d_symbol_make_register(®_symbol, &cb->reg); vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); + VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL); reg_symbol.info.reg.member_idx = j; spirv_compiler_put_symbol(compiler, ®_symbol);
@@ -5507,7 +5485,7 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi return; }
- vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + vec4_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); length_id = spirv_compiler_get_constant_uint(compiler, cb->size); array_type_id = vkd3d_spirv_build_op_type_array(builder, vec4_id, length_id); vkd3d_spirv_build_op_decorate1(builder, array_type_id, SpvDecorationArrayStride, 16); @@ -5521,8 +5499,7 @@ static void spirv_compiler_emit_dcl_constant_buffer(struct spirv_compiler *compi reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, false, &var_info);
vkd3d_symbol_make_register(®_symbol, reg); - vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); + vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL); reg_symbol.descriptor_array = var_info.array_symbol; reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx; spirv_compiler_put_symbol(compiler, ®_symbol); @@ -5541,9 +5518,8 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi if (!(elements = vkd3d_calloc(icb->vec4_count, sizeof(*elements)))) return; for (i = 0; i < icb->vec4_count; ++i) - elements[i] = spirv_compiler_get_constant(compiler, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE, &icb->data[4 * i]); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + elements[i] = spirv_compiler_get_constant(compiler, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE, &icb->data[4 * i]); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); length_id = spirv_compiler_get_constant_uint(compiler, icb->vec4_count); type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id); const_id = vkd3d_spirv_build_op_constant_composite(builder, type_id, elements, icb->vec4_count); @@ -5557,7 +5533,7 @@ static void spirv_compiler_emit_dcl_immediate_constant_buffer(struct spirv_compi reg.type = VKD3DSPR_IMMCONSTBUFFER; vkd3d_symbol_make_register(®_symbol, ®); vkd3d_symbol_set_register_info(®_symbol, icb_id, SpvStorageClassPrivate, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); + VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL); spirv_compiler_put_symbol(compiler, ®_symbol); }
@@ -5584,8 +5560,7 @@ static void spirv_compiler_emit_dcl_sampler(struct spirv_compiler *compiler, &sampler->range, VKD3D_SHADER_RESOURCE_NONE, false, &var_info);
vkd3d_symbol_make_register(®_symbol, reg); - vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - VKD3D_SHADER_COMPONENT_FLOAT, VKD3DSP_WRITEMASK_ALL); + vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, VKD3D_DATA_FLOAT, VKD3DSP_WRITEMASK_ALL); reg_symbol.descriptor_array = var_info.array_symbol; reg_symbol.info.reg.binding_base_idx = var_info.binding_base_idx; spirv_compiler_put_symbol(compiler, ®_symbol); @@ -5608,7 +5583,7 @@ static const struct vkd3d_spirv_resource_type *spirv_compiler_enable_resource_ty return resource_type_info; }
-static SpvImageFormat image_format_for_image_read(enum vkd3d_shader_component_type data_type) +static SpvImageFormat image_format_for_image_read(enum vkd3d_data_type data_type) { /* The following formats are supported by Direct3D 11 hardware for UAV * typed loads. A newer hardware may support more formats for UAV typed @@ -5616,11 +5591,11 @@ static SpvImageFormat image_format_for_image_read(enum vkd3d_shader_component_ty */ switch (data_type) { - case VKD3D_SHADER_COMPONENT_FLOAT: + case VKD3D_DATA_FLOAT: return SpvImageFormatR32f; - case VKD3D_SHADER_COMPONENT_INT: + case VKD3D_DATA_INT: return SpvImageFormatR32i; - case VKD3D_SHADER_COMPONENT_UINT: + case VKD3D_DATA_UINT: return SpvImageFormatR32ui; default: FIXME("Unhandled type %#x.\n", data_type); @@ -5650,7 +5625,7 @@ static const struct vkd3d_shader_descriptor_info *spirv_compiler_get_descriptor_
static uint32_t spirv_compiler_get_image_type_id(struct spirv_compiler *compiler, const struct vkd3d_shader_register *reg, const struct vkd3d_shader_register_range *range, - const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_shader_component_type data_type, + const struct vkd3d_spirv_resource_type *resource_type_info, enum vkd3d_data_type data_type, bool raw_structured, uint32_t depth) { struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -5680,7 +5655,7 @@ static uint32_t spirv_compiler_get_image_type_id(struct spirv_compiler *compiler
static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compiler *compiler, const struct vkd3d_shader_register *resource, const struct vkd3d_shader_register_range *resource_range, - enum vkd3d_shader_resource_type resource_type, enum vkd3d_shader_component_type sampled_type, + enum vkd3d_shader_resource_type resource_type, enum vkd3d_data_type sampled_type, unsigned int structure_stride, bool raw, const struct vkd3d_spirv_resource_type *resource_type_info) { const struct vkd3d_shader_interface_info *shader_interface = &compiler->shader_interface; @@ -5766,7 +5741,7 @@ static void spirv_compiler_emit_combined_sampler_declarations(struct spirv_compi
static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *compiler, const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type, - enum vkd3d_data_type resource_data_type, unsigned int structure_stride, bool raw) + enum vkd3d_data_type sampled_type, unsigned int structure_stride, bool raw) { struct vkd3d_descriptor_variable_info var_info, counter_var_info = {0}; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; @@ -5774,7 +5749,6 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp uint32_t counter_type_id, type_id, var_id, counter_var_id = 0; const struct vkd3d_shader_register *reg = &resource->reg.reg; const struct vkd3d_spirv_resource_type *resource_type_info; - enum vkd3d_shader_component_type sampled_type; struct vkd3d_symbol resource_symbol; bool is_uav;
@@ -5786,8 +5760,6 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp return; }
- sampled_type = vkd3d_component_type_from_data_type(resource_data_type); - if (spirv_compiler_has_combined_sampler(compiler, resource, NULL)) { spirv_compiler_emit_combined_sampler_declarations(compiler, reg, &resource->range, @@ -5834,7 +5806,7 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp { assert(structure_stride); /* counters are valid only for structured buffers */
- counter_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + counter_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); if (spirv_compiler_is_opengl_target(compiler)) { vkd3d_spirv_enable_capability(builder, SpvCapabilityAtomicStorage); @@ -5938,7 +5910,7 @@ static void spirv_compiler_emit_workgroup_memory(struct spirv_compiler *compiler const SpvStorageClass storage_class = SpvStorageClassWorkgroup; struct vkd3d_symbol reg_symbol;
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); length_id = spirv_compiler_get_constant_uint(compiler, size); array_type_id = vkd3d_spirv_get_op_type_array(builder, type_id, length_id);
@@ -5949,8 +5921,7 @@ static void spirv_compiler_emit_workgroup_memory(struct spirv_compiler *compiler spirv_compiler_emit_register_debug_name(builder, var_id, reg);
vkd3d_symbol_make_register(®_symbol, reg); - vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, - VKD3D_SHADER_COMPONENT_UINT, VKD3DSP_WRITEMASK_0); + vkd3d_symbol_set_register_info(®_symbol, var_id, storage_class, VKD3D_DATA_UINT, VKD3DSP_WRITEMASK_0); reg_symbol.info.reg.structure_stride = structure_stride; spirv_compiler_put_symbol(compiler, ®_symbol); } @@ -6082,7 +6053,7 @@ static void spirv_compiler_emit_dcl_input_primitive(struct spirv_compiler *compi
static void spirv_compiler_emit_point_size(struct spirv_compiler *compiler) { - static const struct vkd3d_spirv_builtin point_size = {VKD3D_SHADER_COMPONENT_FLOAT, 1, SpvBuiltInPointSize}; + static const struct vkd3d_spirv_builtin point_size = {VKD3D_DATA_FLOAT, 1, SpvBuiltInPointSize};
/* Set the point size. Point sprites are not supported in d3d10+, but * point primitives can still be used with e.g. stream output. Vulkan @@ -6295,11 +6266,11 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile const struct shader_signature *output_signature = &compiler->output_signature; const struct shader_signature *input_signature = &compiler->input_signature; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - enum vkd3d_shader_component_type component_type; struct vkd3d_shader_src_param invocation; struct vkd3d_shader_register input_reg; uint32_t type_id, output_ptr_type_id; uint32_t input_id, output_id, dst_id; + enum vkd3d_data_type data_type; unsigned int component_count; unsigned int array_sizes[2]; uint32_t invocation_id; @@ -6331,21 +6302,21 @@ static void spirv_compiler_emit_default_control_point_phase(struct spirv_compile const struct signature_element *input = &input_signature->elements[i];
assert(input->mask == output->mask); - assert(input->component_type == output->component_type); + assert(input->data_type == output->data_type);
input_reg.idx[1].offset = i; input_id = spirv_compiler_get_register_id(compiler, &input_reg);
- component_type = output->component_type; + data_type = output->data_type; component_count = vkd3d_write_mask_component_count(output->mask); - type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); if ((array_sizes[0] = (input->register_count > 1) ? input->register_count : 0)) type_id = vkd3d_spirv_get_op_type_array(builder, type_id, spirv_compiler_get_constant_uint(compiler, array_sizes[0]));
array_sizes[1] = compiler->output_control_point_count; output_id = spirv_compiler_emit_array_variable(compiler, &builder->global_stream, SpvStorageClassOutput, - component_type, component_count, array_sizes, 2); + data_type, component_count, array_sizes, 2); vkd3d_spirv_add_iface_variable(builder, output_id); vkd3d_spirv_build_op_decorate1(builder, output_id, SpvDecorationLocation, output->register_index); vkd3d_spirv_build_op_name(builder, output_id, "vocp%u", output->register_index); @@ -6395,7 +6366,7 @@ static void spirv_compiler_emit_shader_epilogue_invocation(struct spirv_compiler if ((function_id = compiler->epilogue_function_id)) { void_id = vkd3d_spirv_get_op_type_void(builder); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 4); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 4); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassPrivate, type_id); for (i = 0, count = 0; i < ARRAY_SIZE(compiler->private_output_variable); ++i) { @@ -6532,7 +6503,7 @@ static void spirv_compiler_emit_alu_instruction(struct spirv_compiler *compiler, || instruction->handler_idx == VKD3DSIH_USHR) { uint32_t mask_id = spirv_compiler_get_constant_vector(compiler, - VKD3D_SHADER_COMPONENT_UINT, vkd3d_write_mask_component_count(dst->write_mask), 0x1f); + VKD3D_DATA_UINT, vkd3d_write_mask_component_count(dst->write_mask), 0x1f); src_ids[1] = vkd3d_spirv_build_op_and(builder, type_id, src_ids[1], mask_id); }
@@ -6647,8 +6618,7 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler, spirv_compiler_get_register_info(compiler, &dst->reg, &dst_reg_info); spirv_compiler_get_register_info(compiler, &src->reg, &src_reg_info);
- if (dst_reg_info.component_type != src_reg_info.component_type - || dst_reg_info.write_mask != src_reg_info.write_mask) + if (dst_reg_info.data_type != src_reg_info.data_type || dst_reg_info.write_mask != src_reg_info.write_mask) goto general_implementation;
if (vkd3d_swizzle_is_equal(dst_reg_info.write_mask, src->swizzle, src_reg_info.write_mask)) @@ -6667,7 +6637,7 @@ static void spirv_compiler_emit_mov(struct spirv_compiler *compiler, dst_id = spirv_compiler_get_register_id(compiler, &dst->reg); src_id = spirv_compiler_get_register_id(compiler, &src->reg);
- type_id = vkd3d_spirv_get_type_id(builder, dst_reg_info.component_type, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, dst_reg_info.data_type, VKD3D_VEC4_SIZE); val_id = vkd3d_spirv_build_op_load(builder, type_id, src_id, SpvMemoryAccessMaskNone); dst_val_id = vkd3d_spirv_build_op_load(builder, type_id, dst_id, SpvMemoryAccessMaskNone);
@@ -6730,7 +6700,7 @@ static void spirv_compiler_emit_swapc(struct spirv_compiler *compiler, src2_id = spirv_compiler_emit_load_src(compiler, &src[2], dst->write_mask);
component_count = vkd3d_write_mask_component_count(dst->write_mask); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, component_count);
condition_id = spirv_compiler_emit_int_to_bool(compiler, VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); @@ -6747,13 +6717,13 @@ static void spirv_compiler_emit_dot(struct spirv_compiler *compiler, struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_dst_param *dst = instruction->dst; const struct vkd3d_shader_src_param *src = instruction->src; - enum vkd3d_shader_component_type component_type; uint32_t type_id, val_id, src_ids[2]; unsigned int component_count, i; + enum vkd3d_data_type data_type; DWORD write_mask;
component_count = vkd3d_write_mask_component_count(dst->write_mask); - component_type = vkd3d_component_type_from_data_type(dst->reg.data_type); + data_type = dst->reg.data_type;
if (instruction->handler_idx == VKD3DSIH_DP4) write_mask = VKD3DSP_WRITEMASK_ALL; @@ -6766,15 +6736,12 @@ static void spirv_compiler_emit_dot(struct spirv_compiler *compiler, for (i = 0; i < ARRAY_SIZE(src_ids); ++i) src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], write_mask);
- type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1);
val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, SpvOpDot, type_id, src_ids[0], src_ids[1]); if (component_count > 1) - { - val_id = spirv_compiler_emit_construct_vector(compiler, - component_type, component_count, val_id, 0, 1); - } + val_id = spirv_compiler_emit_construct_vector(compiler, data_type, component_count, val_id, 0, 1); if (instruction->flags & VKD3DSI_PRECISE_XYZW) vkd3d_spirv_build_op_decorate(builder, val_id, SpvDecorationNoContraction, NULL, 0);
@@ -6871,7 +6838,7 @@ static void spirv_compiler_emit_imad(struct spirv_compiler *compiler, unsigned int i, component_count;
component_count = vkd3d_write_mask_component_count(dst->write_mask); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_INT, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_INT, component_count);
for (i = 0; i < ARRAY_SIZE(src_ids); ++i) src_ids[i] = spirv_compiler_emit_load_src(compiler, &src[i], dst->write_mask); @@ -6942,16 +6909,16 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_dst_param *dst = instruction->dst; const struct vkd3d_shader_src_param *src = instruction->src; - enum vkd3d_shader_component_type component_type; unsigned int i, j, k, src_count; + enum vkd3d_data_type data_type; DWORD write_mask; SpvOp op;
src_count = instruction->src_count; assert(2 <= src_count && src_count <= ARRAY_SIZE(src_ids));
- component_type = vkd3d_component_type_from_data_type(dst->reg.data_type); - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + data_type = dst->reg.data_type; + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); mask_id = spirv_compiler_get_constant_uint(compiler, 0x1f);
switch (instruction->handler_idx) @@ -6973,7 +6940,7 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp for (j = 0; j < src_count; ++j) { src_ids[src_count - j - 1] = spirv_compiler_emit_load_src_with_type(compiler, - &src[j], write_mask, component_type); + &src[j], write_mask, data_type); }
/* In SPIR-V, the last two operands are Offset and Count. */ @@ -6986,7 +6953,7 @@ static void spirv_compiler_emit_bitfield_instruction(struct spirv_compiler *comp op, type_id, src_ids, src_count); }
- spirv_compiler_emit_store_dst_components(compiler, dst, component_type, constituents); + spirv_compiler_emit_store_dst_components(compiler, dst, data_type, constituents); }
static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler, @@ -7001,8 +6968,8 @@ static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler, DWORD write_mask;
instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2); - scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2); + scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 1);
/* FIXME: Consider a single UnpackHalf2x16 instruction per 2 components. */ assert(dst->write_mask & VKD3DSP_WRITEMASK_ALL); @@ -7018,8 +6985,7 @@ static void spirv_compiler_emit_f16tof32(struct spirv_compiler *compiler, scalar_type_id, result_id, 0); }
- spirv_compiler_emit_store_dst_components(compiler, - dst, vkd3d_component_type_from_data_type(dst->reg.data_type), components); + spirv_compiler_emit_store_dst_components(compiler, dst, dst->reg.data_type, components); }
static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler, @@ -7034,8 +7000,8 @@ static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler, DWORD write_mask;
instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2); - scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2); + scalar_type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); zero_id = spirv_compiler_get_constant_float(compiler, 0.0f);
/* FIXME: Consider a single PackHalf2x16 instruction per 2 components. */ @@ -7054,8 +7020,7 @@ static void spirv_compiler_emit_f32tof16(struct spirv_compiler *compiler, instr_set_id, GLSLstd450PackHalf2x16, &src_id, 1); }
- spirv_compiler_emit_store_dst_components(compiler, - dst, vkd3d_component_type_from_data_type(dst->reg.data_type), components); + spirv_compiler_emit_store_dst_components(compiler, dst, dst->reg.data_type, components); }
static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *compiler, @@ -7094,7 +7059,7 @@ static void spirv_compiler_emit_comparison_instruction(struct spirv_compiler *co src0_id = spirv_compiler_emit_load_src(compiler, &src[0], dst->write_mask); src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst->write_mask);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, component_count); result_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, src0_id, src1_id);
@@ -7600,7 +7565,7 @@ struct vkd3d_shader_image uint32_t image_id; uint32_t sampled_image_id;
- enum vkd3d_shader_component_type sampled_type; + enum vkd3d_data_type sampled_type; uint32_t image_type_id; const struct vkd3d_spirv_resource_type *resource_type_info; unsigned int structure_stride; @@ -7770,8 +7735,7 @@ static uint32_t spirv_compiler_emit_texel_offset(struct spirv_compiler *compiler const struct vkd3d_shader_texel_offset *offset = &instruction->texel_offset; unsigned int component_count = resource_type_info->offset_component_count; int32_t data[4] = {offset->u, offset->v, offset->w, 0}; - return spirv_compiler_get_constant(compiler, - VKD3D_SHADER_COMPONENT_INT, component_count, (const uint32_t *)data); + return spirv_compiler_get_constant(compiler, VKD3D_DATA_INT, component_count, (const uint32_t *)data); }
static void spirv_compiler_emit_ld(struct spirv_compiler *compiler, @@ -7838,7 +7802,7 @@ static void spirv_compiler_emit_lod(struct spirv_compiler *compiler, spirv_compiler_prepare_image(compiler, &image, &resource->reg, &sampler->reg, VKD3D_IMAGE_FLAG_SAMPLED);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2); coordinate_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_ALL); val_id = vkd3d_spirv_build_op_image_query_lod(builder, type_id, image.sampled_image_id, coordinate_id); @@ -8022,8 +7986,7 @@ static void spirv_compiler_emit_gather4(struct spirv_compiler *compiler, { component_idx = vkd3d_swizzle_get_component(sampler->swizzle, 0); /* Nvidia driver requires signed integer type. */ - component_id = spirv_compiler_get_constant(compiler, - VKD3D_SHADER_COMPONENT_INT, 1, &component_idx); + component_id = spirv_compiler_get_constant(compiler, VKD3D_DATA_INT, 1, &component_idx); val_id = vkd3d_spirv_build_op_image_gather(builder, sampled_type_id, image.sampled_image_id, coordinate_id, component_id, operands_mask, image_operands, image_operand_count); @@ -8087,7 +8050,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler texel_type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, texel_type_id);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, type_id, resource_symbol->info.resource.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0); @@ -8119,7 +8082,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler
spirv_compiler_prepare_image(compiler, &image, &resource->reg, NULL, VKD3D_IMAGE_FLAG_NONE);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, type_id, image.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0);
@@ -8143,7 +8106,7 @@ static void spirv_compiler_emit_ld_raw_structured_srv_uav(struct spirv_compiler } } assert(dst->reg.data_type == VKD3D_DATA_UINT); - spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_SHADER_COMPONENT_UINT, constituents); + spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_DATA_UINT, constituents); }
static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler, @@ -8163,7 +8126,7 @@ static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler, if (!spirv_compiler_get_register_info(compiler, &resource->reg, ®_info)) return;
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, type_id, reg_info.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0); @@ -8184,7 +8147,7 @@ static void spirv_compiler_emit_ld_tgsm(struct spirv_compiler *compiler, constituents[j++] = vkd3d_spirv_build_op_load(builder, type_id, ptr_id, SpvMemoryAccessMaskNone); } assert(dst->reg.data_type == VKD3D_DATA_UINT); - spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_SHADER_COMPONENT_UINT, constituents); + spirv_compiler_emit_store_dst_components(compiler, dst, VKD3D_DATA_UINT, constituents); }
static void spirv_compiler_emit_ld_raw_structured(struct spirv_compiler *compiler, @@ -8226,7 +8189,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler * type_id = vkd3d_spirv_get_type_id(builder, resource_symbol->info.resource.sampled_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, type_id);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, type_id, resource_symbol->info.resource.structure_stride, &src[0], VKD3DSP_WRITEMASK_0, &src[1], VKD3DSP_WRITEMASK_0); @@ -8254,7 +8217,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler * } else { - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); spirv_compiler_prepare_image(compiler, &image, &dst->reg, NULL, VKD3D_IMAGE_FLAG_NONE); assert((instruction->handler_idx == VKD3DSIH_STORE_STRUCTURED) != !image.structure_stride); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, @@ -8268,7 +8231,7 @@ static void spirv_compiler_emit_store_uav_raw_structured(struct spirv_compiler * for (component_idx = 0; component_idx < component_count; ++component_idx) { /* Mesa Vulkan drivers require the texel parameter to be a vector. */ - data_id = spirv_compiler_emit_construct_vector(compiler, VKD3D_SHADER_COMPONENT_UINT, + data_id = spirv_compiler_emit_construct_vector(compiler, VKD3D_DATA_UINT, VKD3D_VEC4_SIZE, val_id, component_idx, component_count);
coordinate_id = base_coordinate_id; @@ -8298,7 +8261,7 @@ static void spirv_compiler_emit_store_tgsm(struct spirv_compiler *compiler, if (!spirv_compiler_get_register_info(compiler, &dst->reg, ®_info)) return;
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id); assert((instruction->handler_idx == VKD3DSIH_STORE_STRUCTURED) != !reg_info.structure_stride); base_coordinate_id = spirv_compiler_emit_raw_structured_addressing(compiler, @@ -8445,7 +8408,7 @@ static void spirv_compiler_emit_uav_counter_instruction(struct spirv_compiler *c counter_id = resource_symbol->info.resource.uav_counter_id; assert(counter_id);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1);
if (resource_symbol->info.resource.uav_counter_array) { @@ -8553,11 +8516,11 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil const struct vkd3d_shader_src_param *src = instruction->src; const struct vkd3d_symbol *resource_symbol = NULL; uint32_t ptr_type_id, type_id, val_id, result_id; - enum vkd3d_shader_component_type component_type; const struct vkd3d_shader_dst_param *resource; uint32_t coordinate_id, sample_id, pointer_id; struct vkd3d_shader_register_info reg_info; struct vkd3d_shader_image image; + enum vkd3d_data_type data_type; unsigned int structure_stride; DWORD coordinate_mask; uint32_t operands[6]; @@ -8604,7 +8567,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil } }
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); if (structure_stride || raw) { assert(!raw != !structure_stride); @@ -8620,7 +8583,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil
if (resource->reg.type == VKD3DSPR_GROUPSHAREDMEM) { - component_type = VKD3D_SHADER_COMPONENT_UINT; + data_type = VKD3D_DATA_UINT; ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, reg_info.storage_class, type_id); pointer_id = vkd3d_spirv_build_op_access_chain1(builder, ptr_type_id, reg_info.id, coordinate_id); } @@ -8628,8 +8591,8 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil { if (spirv_compiler_use_storage_buffer(compiler, &resource_symbol->info.resource)) { - component_type = resource_symbol->info.resource.sampled_type; - type_id = vkd3d_spirv_get_type_id(builder, component_type, 1); + data_type = resource_symbol->info.resource.sampled_type; + type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassUniform, type_id); operands[0] = spirv_compiler_get_constant_uint(compiler, 0); operands[1] = coordinate_id; @@ -8637,7 +8600,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil } else { - component_type = image.sampled_type; + data_type = image.sampled_type; type_id = vkd3d_spirv_get_type_id(builder, image.sampled_type, 1); ptr_type_id = vkd3d_spirv_get_op_type_pointer(builder, SpvStorageClassImage, type_id); sample_id = spirv_compiler_get_constant_uint(compiler, 0); @@ -8646,7 +8609,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil } }
- val_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1], VKD3DSP_WRITEMASK_0, component_type); + val_id = spirv_compiler_emit_load_src_with_type(compiler, &src[1], VKD3DSP_WRITEMASK_0, data_type);
operands[i++] = pointer_id; operands[i++] = spirv_compiler_get_constant_uint(compiler, scope); @@ -8654,7 +8617,7 @@ static void spirv_compiler_emit_atomic_instruction(struct spirv_compiler *compil if (instruction->src_count >= 3) { operands[i++] = spirv_compiler_get_constant_uint(compiler, SpvMemorySemanticsMaskNone); - operands[i++] = spirv_compiler_emit_load_src_with_type(compiler, &src[2], VKD3DSP_WRITEMASK_0, component_type); + operands[i++] = spirv_compiler_emit_load_src_with_type(compiler, &src[2], VKD3DSP_WRITEMASK_0, data_type); } operands[i++] = val_id; result_id = vkd3d_spirv_build_op_trv(builder, &builder->function_stream, @@ -8680,7 +8643,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler, { resource_symbol = spirv_compiler_find_resource(compiler, &src->reg);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); val_id = vkd3d_spirv_build_op_array_length(builder, type_id, resource_symbol->id, 0); write_mask = VKD3DSP_WRITEMASK_0; } @@ -8690,7 +8653,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler,
spirv_compiler_prepare_image(compiler, &image, &src->reg, NULL, VKD3D_IMAGE_FLAG_NONE);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); val_id = vkd3d_spirv_build_op_image_query_size(builder, type_id, image.image_id); write_mask = VKD3DSP_WRITEMASK_0; } @@ -8700,7 +8663,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler, stride_id = spirv_compiler_get_constant_uint(compiler, image.structure_stride); constituents[0] = vkd3d_spirv_build_op_udiv(builder, type_id, val_id, stride_id); constituents[1] = stride_id; - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, ARRAY_SIZE(constituents)); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, ARRAY_SIZE(constituents)); val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, constituents, ARRAY_SIZE(constituents)); write_mask |= VKD3DSP_WRITEMASK_1; @@ -8712,7 +8675,7 @@ static void spirv_compiler_emit_bufinfo(struct spirv_compiler *compiler, }
val_id = spirv_compiler_emit_swizzle(compiler, val_id, write_mask, - VKD3D_SHADER_COMPONENT_UINT, src->swizzle, dst->write_mask); + VKD3D_DATA_UINT, src->swizzle, dst->write_mask); spirv_compiler_emit_store_dst(compiler, dst, val_id); }
@@ -8734,14 +8697,14 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler, size_component_count = image.resource_type_info->coordinate_component_count; if (image.resource_type_info->dim == SpvDimCube) --size_component_count; - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, size_component_count); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, size_component_count);
supports_mipmaps = src[1].reg.type != VKD3DSPR_UAV && !image.resource_type_info->ms; if (supports_mipmaps) { lod_id = spirv_compiler_emit_load_src(compiler, &src[0], VKD3DSP_WRITEMASK_0); val_id = vkd3d_spirv_build_op_image_query_size_lod(builder, type_id, image.image_id, lod_id); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); miplevel_count_id = vkd3d_spirv_build_op_image_query_levels(builder, type_id, image.image_id); } else @@ -8755,11 +8718,11 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler, for (i = 0; i < 3 - size_component_count; ++i) constituents[i + 1] = spirv_compiler_get_constant_uint(compiler, 0); constituents[i + 1] = miplevel_count_id; - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, VKD3D_VEC4_SIZE); val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, constituents, i + 2);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); if (instruction->flags == VKD3DSI_RESINFO_UINT) { val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); @@ -8771,7 +8734,7 @@ static void spirv_compiler_emit_resinfo(struct spirv_compiler *compiler, val_id = vkd3d_spirv_build_op_convert_utof(builder, type_id, val_id); } val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL, - VKD3D_SHADER_COMPONENT_FLOAT, src[1].swizzle, dst->write_mask); + VKD3D_DATA_FLOAT, src[1].swizzle, dst->write_mask);
spirv_compiler_emit_store_dst(compiler, dst, val_id); } @@ -8793,7 +8756,7 @@ static uint32_t spirv_compiler_emit_query_sample_count(struct spirv_compiler *co vkd3d_spirv_enable_capability(builder, SpvCapabilityImageQuery);
spirv_compiler_prepare_image(compiler, &image, &src->reg, NULL, VKD3D_IMAGE_FLAG_NONE); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); val_id = vkd3d_spirv_build_op_image_query_samples(builder, type_id, image.image_id); }
@@ -8815,10 +8778,10 @@ static void spirv_compiler_emit_sample_info(struct spirv_compiler *compiler, constituents[0] = val_id; for (i = 1; i < VKD3D_VEC4_SIZE; ++i) constituents[i] = spirv_compiler_get_constant_uint(compiler, 0); - type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, VKD3D_VEC4_SIZE); val_id = vkd3d_spirv_build_op_composite_construct(builder, type_id, constituents, VKD3D_VEC4_SIZE);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, VKD3D_VEC4_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, VKD3D_VEC4_SIZE); if (instruction->flags == VKD3DSI_SAMPLE_INFO_UINT) { val_id = vkd3d_spirv_build_op_bitcast(builder, type_id, val_id); @@ -8831,7 +8794,7 @@ static void spirv_compiler_emit_sample_info(struct spirv_compiler *compiler, }
val_id = spirv_compiler_emit_swizzle(compiler, val_id, VKD3DSP_WRITEMASK_ALL, - VKD3D_SHADER_COMPONENT_FLOAT, src->swizzle, dst->write_mask); + VKD3D_DATA_FLOAT, src->swizzle, dst->write_mask);
spirv_compiler_emit_store_dst(compiler, dst, val_id); } @@ -8891,13 +8854,13 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler, sample_count_id = spirv_compiler_emit_query_sample_count(compiler, &instruction->src[0]); sample_index_id = spirv_compiler_emit_load_src(compiler, &instruction->src[1], VKD3DSP_WRITEMASK_0);
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT, 1); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_UINT, 1); index_id = vkd3d_spirv_build_op_iadd(builder, type_id, sample_count_id, sample_index_id); index_id = vkd3d_spirv_build_op_isub(builder, type_id, index_id, spirv_compiler_get_constant_uint(compiler, 1));
/* Validate sample index. */ - bool_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, 1); + bool_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_BOOL, 1); id = vkd3d_spirv_build_op_logical_and(builder, bool_id, vkd3d_spirv_build_op_uless_than(builder, bool_id, sample_index_id, sample_count_id), vkd3d_spirv_build_op_uless_than_equal(builder, @@ -8905,7 +8868,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler, index_id = vkd3d_spirv_build_op_select(builder, type_id, id, index_id, spirv_compiler_get_constant_uint(compiler, 0));
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, 2); + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, 2); if (!(id = compiler->sample_positions_id)) { length_id = spirv_compiler_get_constant_uint(compiler, ARRAY_SIZE(standard_sample_positions)); @@ -8914,7 +8877,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler, for (i = 0; i < ARRAY_SIZE(standard_sample_positions); ++ i) { constituents[i] = spirv_compiler_get_constant(compiler, - VKD3D_SHADER_COMPONENT_FLOAT, 2, (const uint32_t *)standard_sample_positions[i]); + VKD3D_DATA_FLOAT, 2, (const uint32_t *)standard_sample_positions[i]); }
id = vkd3d_spirv_build_op_constant_composite(builder, array_type_id, constituents, ARRAY_SIZE(constituents)); @@ -8929,7 +8892,7 @@ static void spirv_compiler_emit_sample_position(struct spirv_compiler *compiler, id = vkd3d_spirv_build_op_load(builder, type_id, id, SpvMemoryAccessMaskNone);
id = spirv_compiler_emit_swizzle(compiler, id, VKD3DSP_WRITEMASK_0 | VKD3DSP_WRITEMASK_1, - VKD3D_SHADER_COMPONENT_FLOAT, instruction->src[0].swizzle, dst->write_mask); + VKD3D_DATA_FLOAT, instruction->src[0].swizzle, dst->write_mask); spirv_compiler_emit_store_dst(compiler, dst, id); }
@@ -8969,14 +8932,14 @@ static void spirv_compiler_emit_eval_attrib(struct spirv_compiler *compiler, src_ids[src_count++] = spirv_compiler_emit_load_src(compiler, &src[1], VKD3DSP_WRITEMASK_0); }
- type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_DATA_FLOAT, vkd3d_write_mask_component_count(register_info.write_mask));
instr_set_id = vkd3d_spirv_get_glsl_std450_instr_set(builder); val_id = vkd3d_spirv_build_op_ext_inst(builder, type_id, instr_set_id, op, src_ids, src_count);
val_id = spirv_compiler_emit_swizzle(compiler, val_id, register_info.write_mask, - VKD3D_SHADER_COMPONENT_FLOAT, src[0].swizzle, dst->write_mask); + VKD3D_DATA_FLOAT, src[0].swizzle, dst->write_mask);
spirv_compiler_emit_store_dst(compiler, dst, val_id); } diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index f26050bb..fa6c3220 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -565,7 +565,7 @@ static bool vkd3d_shader_signature_from_shader_signature(struct vkd3d_shader_sig d->semantic_index = e->semantic_index; d->stream_index = e->stream_index; d->sysval_semantic = e->sysval_semantic; - d->component_type = e->component_type; + d->component_type = vkd3d_component_type_from_data_type(e->data_type); d->register_index = e->register_index; if (e->register_count > 1) FIXME("Arrayed elements are not supported yet.\n"); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index cc9ec576..e96b38dd 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -541,6 +541,8 @@ enum vkd3d_data_type_class VKD3D_DATA_CLASS_MIXED, VKD3D_DATA_CLASS_CONTINUED, VKD3D_DATA_CLASS_UNUSED, + VKD3D_DATA_CLASS_VOID, + VKD3D_DATA_CLASS_BOOL, };
enum vkd3d_data_type @@ -559,6 +561,8 @@ enum vkd3d_data_type VKD3D_DATA_CONTINUED = VKD3D_DATA_CLASS_CONTINUED << DATA_TYPE_CLASS_SHIFT, VKD3D_DATA_UNUSED = VKD3D_DATA_CLASS_UNUSED << DATA_TYPE_CLASS_SHIFT, VKD3D_DATA_UINT8 = (VKD3D_DATA_CLASS_INT << DATA_TYPE_CLASS_SHIFT) | 8, + VKD3D_DATA_VOID = VKD3D_DATA_CLASS_VOID << DATA_TYPE_CLASS_SHIFT, + VKD3D_DATA_BOOL = VKD3D_DATA_CLASS_BOOL << DATA_TYPE_CLASS_SHIFT, };
static inline bool data_type_class_is_numeric(enum vkd3d_data_type_class class) @@ -571,6 +575,21 @@ static inline enum vkd3d_data_type_class data_type_get_class(enum vkd3d_data_typ return (type & DATA_TYPE_CLASS_MASK) >> DATA_TYPE_CLASS_SHIFT; }
+static inline bool data_type_is_numeric(enum vkd3d_data_type type) +{ + return data_type_class_is_numeric(data_type_get_class(type)); +} + +static inline unsigned int data_type_get_width(enum vkd3d_data_type type) +{ + return type & DATA_TYPE_WIDTH_MASK; +} + +static inline bool data_type_is_signed(enum vkd3d_data_type type) +{ + return !!(type & DATA_TYPE_IS_SIGNED_MASK); +} + enum vkd3d_immconst_type { VKD3D_IMMCONST_SCALAR, @@ -844,7 +863,7 @@ struct signature_element unsigned int semantic_index; unsigned int stream_index; enum vkd3d_shader_sysval_semantic sysval_semantic; - enum vkd3d_shader_component_type component_type; + enum vkd3d_data_type data_type; unsigned int register_index; unsigned int register_count; unsigned int mask; @@ -1262,6 +1281,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty { switch (data_type) { + case VKD3D_DATA_VOID: + return VKD3D_SHADER_COMPONENT_VOID; case VKD3D_DATA_FLOAT: case VKD3D_DATA_UNORM: case VKD3D_DATA_SNORM: @@ -1270,6 +1291,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty return VKD3D_SHADER_COMPONENT_UINT; case VKD3D_DATA_INT: return VKD3D_SHADER_COMPONENT_INT; + case VKD3D_DATA_BOOL: + return VKD3D_SHADER_COMPONENT_BOOL; case VKD3D_DATA_DOUBLE: return VKD3D_SHADER_COMPONENT_DOUBLE; default: @@ -1285,12 +1308,16 @@ static inline enum vkd3d_data_type vkd3d_data_type_from_component_type( { switch (component_type) { + case VKD3D_SHADER_COMPONENT_VOID: + return VKD3D_DATA_VOID; case VKD3D_SHADER_COMPONENT_FLOAT: return VKD3D_DATA_FLOAT; case VKD3D_SHADER_COMPONENT_UINT: return VKD3D_DATA_UINT; case VKD3D_SHADER_COMPONENT_INT: return VKD3D_DATA_INT; + case VKD3D_SHADER_COMPONENT_BOOL: + return VKD3D_DATA_BOOL; case VKD3D_SHADER_COMPONENT_DOUBLE: return VKD3D_DATA_DOUBLE; default:
From: Conor McCarthy cmccarthy@codeweavers.com
Storing width info in enum vkd3d_data_type makes a separate code path unnecessary. --- libs/vkd3d-shader/spirv.c | 69 ++++++++------------------------------- 1 file changed, 13 insertions(+), 56 deletions(-)
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index d327ad27..0170a180 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -1120,34 +1120,19 @@ static uint32_t vkd3d_spirv_get_op_type_pointer(struct vkd3d_spirv_builder *buil vkd3d_spirv_build_op_type_pointer); }
-/* Types larger than 32-bits are not supported. */ static uint32_t vkd3d_spirv_build_op_constant(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint32_t value) -{ - return vkd3d_spirv_build_op_tr1(builder, &builder->global_stream, - SpvOpConstant, result_type, value); -} - -static uint32_t vkd3d_spirv_get_op_constant(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint32_t value) -{ - return vkd3d_spirv_build_once2(builder, SpvOpConstant, result_type, value, - vkd3d_spirv_build_op_constant); -} - -static uint32_t vkd3d_spirv_build_op_constant64(struct vkd3d_spirv_builder *builder, uint32_t result_type, const uint32_t *values, unsigned int value_count) { - assert(value_count == 2); + assert(0 < value_count && value_count <= 2); return vkd3d_spirv_build_op_trv(builder, &builder->global_stream, SpvOpConstant, result_type, values, value_count); }
-static uint32_t vkd3d_spirv_get_op_constant64(struct vkd3d_spirv_builder *builder, - uint32_t result_type, uint64_t value) +static uint32_t vkd3d_spirv_get_op_constant(struct vkd3d_spirv_builder *builder, + uint32_t result_type, const uint32_t *values, unsigned int value_count) { return vkd3d_spirv_build_once1v(builder, SpvOpConstant, result_type, - (const uint32_t *)&value, 2, vkd3d_spirv_build_op_constant64); + values, value_count, vkd3d_spirv_build_op_constant); }
static uint32_t vkd3d_spirv_build_op_constant_composite(struct vkd3d_spirv_builder *builder, @@ -2765,55 +2750,28 @@ static uint32_t spirv_compiler_get_constant(struct spirv_compiler *compiler, { uint32_t type_id, scalar_type_id, component_ids[VKD3D_VEC4_SIZE]; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - unsigned int i; + unsigned int i, j, width, value_count;
assert(0 < component_count && component_count <= VKD3D_VEC4_SIZE); type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count);
- if (!data_type_is_numeric(data_type) || data_type_get_width(data_type) != 32) + if (!data_type_is_numeric(data_type)) { FIXME("Unhandled data type %#x.\n", data_type); return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); }
+ width = data_type_get_width(data_type); + value_count = max(width, 32u) / 32u; if (component_count == 1) { - return vkd3d_spirv_get_op_constant(builder, type_id, *values); + return vkd3d_spirv_get_op_constant(builder, type_id, values, value_count); } else { scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); - for (i = 0; i < component_count; ++i) - component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, values[i]); - return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count); - } -} - -static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, - enum vkd3d_data_type data_type, unsigned int component_count, const uint64_t *values) -{ - uint32_t type_id, scalar_type_id, component_ids[VKD3D_DVEC2_SIZE]; - struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; - unsigned int i; - - assert(0 < component_count && component_count <= VKD3D_DVEC2_SIZE); - type_id = vkd3d_spirv_get_type_id(builder, data_type, component_count); - - if (data_type != VKD3D_DATA_DOUBLE) - { - FIXME("Unhandled data_type %#x.\n", data_type); - return vkd3d_spirv_build_op_undef(builder, &builder->global_stream, type_id); - } - - if (component_count == 1) - { - return vkd3d_spirv_get_op_constant64(builder, type_id, *values); - } - else - { - scalar_type_id = vkd3d_spirv_get_type_id(builder, data_type, 1); - for (i = 0; i < component_count; ++i) - component_ids[i] = vkd3d_spirv_get_op_constant64(builder, scalar_type_id, values[i]); + for (i = 0, j = 0; i < component_count; ++i, j += value_count) + component_ids[i] = vkd3d_spirv_get_op_constant(builder, scalar_type_id, &values[j], value_count); return vkd3d_spirv_get_op_constant_composite(builder, type_id, component_ids, component_count); } } @@ -2854,8 +2812,7 @@ static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler double value, unsigned int component_count) { const double values[] = {value, value}; - return spirv_compiler_get_constant64(compiler, VKD3D_DATA_DOUBLE, - component_count, (const uint64_t *)values); + return spirv_compiler_get_constant(compiler, VKD3D_DATA_DOUBLE, component_count, (const uint32_t *)values); }
static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compiler, @@ -3535,7 +3492,7 @@ static uint32_t spirv_compiler_emit_load_constant64(struct spirv_compiler *compi } }
- return spirv_compiler_get_constant64(compiler, reg->data_type, component_count, values); + return spirv_compiler_get_constant(compiler, reg->data_type, component_count, (const uint32_t *)values); }
static uint32_t spirv_compiler_emit_load_scalar(struct spirv_compiler *compiler,
From: Conor McCarthy cmccarthy@codeweavers.com
--- libs/vkd3d-shader/spirv.c | 6 +++--- libs/vkd3d-shader/vkd3d_shader_private.h | 6 ++++++ 2 files changed, 9 insertions(+), 3 deletions(-)
diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 0170a180..0d6ad391 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -3620,7 +3620,7 @@ static uint32_t spirv_compiler_emit_abs(struct spirv_compiler *compiler, uint32_t type_id;
type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask); - if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE) + if (data_type_is_floating_point(reg->data_type)) return vkd3d_spirv_build_op_glsl_std450_fabs(builder, type_id, val_id);
FIXME("Unhandled data type %#x.\n", reg->data_type); @@ -3634,7 +3634,7 @@ static uint32_t spirv_compiler_emit_neg(struct spirv_compiler *compiler, uint32_t type_id;
type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask); - if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE) + if (data_type_is_floating_point(reg->data_type)) return vkd3d_spirv_build_op_fnegate(builder, type_id, val_id); else if (reg->data_type == VKD3D_DATA_INT) return vkd3d_spirv_build_op_snegate(builder, type_id, val_id); @@ -3809,7 +3809,7 @@ static uint32_t spirv_compiler_emit_sat(struct spirv_compiler *compiler, }
type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask); - if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE) + if (data_type_is_floating_point(reg->data_type)) return vkd3d_spirv_build_op_glsl_std450_nclamp(builder, type_id, val_id, zero_id, one_id);
FIXME("Unhandled data type %#x.\n", reg->data_type); diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index e96b38dd..16ea6afe 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -590,6 +590,12 @@ static inline bool data_type_is_signed(enum vkd3d_data_type type) return !!(type & DATA_TYPE_IS_SIGNED_MASK); }
+static inline bool data_type_is_floating_point(enum vkd3d_data_type type) +{ + return type == VKD3D_DATA_FLOAT || type == VKD3D_DATA_DOUBLE; +} + + enum vkd3d_immconst_type { VKD3D_IMMCONST_SCALAR,
-
Conor McCarthy -
Conor McCarthy (＠cmccarthy)