wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2025-09-12 18:50:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader: Represent resource data types as vkd3d_data_type in struct vkd3d_shader_descriptor_info1.

Browse Source
This commit is contained in:
Giovanni Mascellani
2025-04-03 22:46:57 +02:00
committed by Henri Verbeet
parent 4412a83655
commit 24e61cf74e
Notes: Henri Verbeet 2025-04-14 22:03:34 +02:00 
Approved-by: Henri Verbeet (@hverbeet)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/1446
5 changed files with 103 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
libs/vkd3d-shader/glsl.c
View File

@@ -787,7 +787,6 @@ static void shader_glsl_ld(struct vkd3d_glsl_generator *gen, const struct vkd3d_
unsigned int resource_id, resource_idx, resource_space, sample_count;
const struct glsl_resource_type_info *resource_type_info;
const struct vkd3d_shader_descriptor_info1 *d;
enum vkd3d_shader_component_type sampled_type;
enum vkd3d_shader_resource_type resource_type;
struct vkd3d_string_buffer *fetch;
enum vkd3d_data_type data_type;
@@ -810,8 +809,7 @@ static void shader_glsl_ld(struct vkd3d_glsl_generator *gen, const struct vkd3d_
resource_type = d->resource_type;
resource_space = d->register_space;
sample_count = d->sample_count;
sampled_type = vkd3d_component_type_from_resource_data_type(d->resource_data_type);
data_type = vkd3d_data_type_from_component_type(sampled_type);
data_type = d->resource_data_type;
}
else
{
@@ -903,7 +901,6 @@ static void shader_glsl_sample(struct vkd3d_glsl_generator *gen, const struct vk
unsigned int resource_id, resource_idx, resource_space;
unsigned int sampler_id, sampler_idx, sampler_space;
const struct vkd3d_shader_descriptor_info1 *d;
enum vkd3d_shader_component_type sampled_type;
enum vkd3d_shader_resource_type resource_type;
unsigned int component_idx, coord_size;
struct vkd3d_string_buffer *sample;
@@ -933,8 +930,7 @@ static void shader_glsl_sample(struct vkd3d_glsl_generator *gen, const struct vk
{
resource_type = d->resource_type;
resource_space = d->register_space;
sampled_type = vkd3d_component_type_from_resource_data_type(d->resource_data_type);
data_type = vkd3d_data_type_from_component_type(sampled_type);
data_type = d->resource_data_type;
}
else
{
@@ -1053,11 +1049,11 @@ static void shader_glsl_sample(struct vkd3d_glsl_generator *gen, const struct vk
static void shader_glsl_load_uav_typed(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
const struct glsl_resource_type_info *resource_type_info;
enum vkd3d_shader_component_type component_type;
const struct vkd3d_shader_descriptor_info1 *d;
enum vkd3d_shader_resource_type resource_type;
unsigned int uav_id, uav_idx, uav_space;
struct vkd3d_string_buffer *load;
enum vkd3d_data_type data_type;
struct glsl_src coord;
struct glsl_dst dst;
uint32_t coord_mask;
@@ -1072,7 +1068,7 @@ static void shader_glsl_load_uav_typed(struct vkd3d_glsl_generator *gen, const s
{
resource_type = d->resource_type;
uav_space = d->register_space;
component_type = vkd3d_component_type_from_resource_data_type(d->resource_data_type);
data_type = d->resource_data_type;
}
else
{
@@ -1080,7 +1076,7 @@ static void shader_glsl_load_uav_typed(struct vkd3d_glsl_generator *gen, const s
"Internal compiler error: Undeclared UAV descriptor %u.", uav_id);
uav_space = 0;
resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D;
component_type = VKD3D_SHADER_COMPONENT_FLOAT;
data_type = VKD3D_DATA_FLOAT;
}
if ((resource_type_info = shader_glsl_get_resource_type_info(resource_type)))
@@ -1103,8 +1099,7 @@ static void shader_glsl_load_uav_typed(struct vkd3d_glsl_generator *gen, const s
vkd3d_string_buffer_printf(load, ", %s)", coord.str->buffer);
shader_glsl_print_swizzle(load, ins->src[1].swizzle, ins->dst[0].write_mask);
shader_glsl_print_assignment_ext(gen, &dst,
vkd3d_data_type_from_component_type(component_type), "%s", load->buffer);
shader_glsl_print_assignment_ext(gen, &dst, data_type, "%s", load->buffer);
vkd3d_string_buffer_release(&gen->string_buffers, load);
glsl_src_cleanup(&coord, &gen->string_buffers);
@@ -1114,11 +1109,11 @@ static void shader_glsl_load_uav_typed(struct vkd3d_glsl_generator *gen, const s
static void shader_glsl_store_uav_typed(struct vkd3d_glsl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
const struct glsl_resource_type_info *resource_type_info;
enum vkd3d_shader_component_type component_type;
const struct vkd3d_shader_descriptor_info1 *d;
enum vkd3d_shader_resource_type resource_type;
unsigned int uav_id, uav_idx, uav_space;
struct vkd3d_string_buffer *image_data;
enum vkd3d_data_type data_type;
struct glsl_src image_coord;
uint32_t coord_mask;
@@ -1132,7 +1127,7 @@ static void shader_glsl_store_uav_typed(struct vkd3d_glsl_generator *gen, const
{
resource_type = d->resource_type;
uav_space = d->register_space;
component_type = vkd3d_component_type_from_resource_data_type(d->resource_data_type);
data_type = d->resource_data_type;
}
else
{
@@ -1140,7 +1135,7 @@ static void shader_glsl_store_uav_typed(struct vkd3d_glsl_generator *gen, const
"Internal compiler error: Undeclared UAV descriptor %u.", uav_id);
uav_space = 0;
resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D;
component_type = VKD3D_SHADER_COMPONENT_FLOAT;
data_type = VKD3D_DATA_FLOAT;
}
if ((resource_type_info = shader_glsl_get_resource_type_info(resource_type)))
@@ -1159,25 +1154,26 @@ static void shader_glsl_store_uav_typed(struct vkd3d_glsl_generator *gen, const
if (ins->src[1].reg.dimension == VSIR_DIMENSION_SCALAR)
{
switch (component_type)
switch (data_type)
{
case VKD3D_SHADER_COMPONENT_UINT:
case VKD3D_DATA_UINT:
vkd3d_string_buffer_printf(image_data, "uvec4(");
break;
case VKD3D_SHADER_COMPONENT_INT:
case VKD3D_DATA_INT:
vkd3d_string_buffer_printf(image_data, "ivec4(");
break;
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled component type %#x.", component_type);
"Internal compiler error: Unhandled data type %#x.", data_type);
/* fall through */
case VKD3D_SHADER_COMPONENT_FLOAT:
case VKD3D_DATA_FLOAT:
case VKD3D_DATA_UNORM:
case VKD3D_DATA_SNORM:
vkd3d_string_buffer_printf(image_data, "vec4(");
break;
}
}
shader_glsl_print_src(image_data, gen, &ins->src[1], VKD3DSP_WRITEMASK_ALL,
vkd3d_data_type_from_component_type(component_type));
shader_glsl_print_src(image_data, gen, &ins->src[1], VKD3DSP_WRITEMASK_ALL, data_type);
if (ins->src[1].reg.dimension == VSIR_DIMENSION_SCALAR)
vkd3d_string_buffer_printf(image_data, ", 0, 0, 0)");
@@ -1735,7 +1731,6 @@ static void shader_glsl_generate_uav_declaration(struct vkd3d_glsl_generator *ge
const struct vkd3d_shader_descriptor_binding *binding;
const struct vkd3d_shader_descriptor_offset *offset;
struct vkd3d_string_buffer *buffer = gen->buffer;
enum vkd3d_shader_component_type component_type;
unsigned int binding_idx;
if (uav->count != 1)
@@ -1792,22 +1787,24 @@ static void shader_glsl_generate_uav_declaration(struct vkd3d_glsl_generator *ge
image_type = "<unhandled image type>";
}
switch ((component_type = vkd3d_component_type_from_resource_data_type(uav->resource_data_type)))
switch (uav->resource_data_type)
{
case VKD3D_SHADER_COMPONENT_UINT:
case VKD3D_DATA_UINT:
image_type_prefix = "u";
read_format = "r32ui";
break;
case VKD3D_SHADER_COMPONENT_INT:
case VKD3D_DATA_INT:
image_type_prefix = "i";
read_format = "r32i";
break;
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled component type %#x for UAV %u.",
component_type, uav->register_id);
"Internal compiler error: Unhandled data type %#x for UAV %u.",
uav->resource_data_type, uav->register_id);
/* fall through */
case VKD3D_SHADER_COMPONENT_FLOAT:
case VKD3D_DATA_FLOAT:
case VKD3D_DATA_UNORM:
case VKD3D_DATA_SNORM:
image_type_prefix = "";
read_format = "r32f";
break;
@@ -1962,7 +1959,6 @@ static void shader_glsl_generate_sampler_declaration(struct vkd3d_glsl_generator
const struct glsl_resource_type_info *resource_type_info;
const struct vkd3d_shader_descriptor_binding *binding;
struct vkd3d_string_buffer *buffer = gen->buffer;
enum vkd3d_shader_component_type component_type;
const char *sampler_type, *sampler_type_prefix;
enum vkd3d_shader_resource_type resource_type;
unsigned int binding_idx;
@@ -2020,21 +2016,23 @@ static void shader_glsl_generate_sampler_declaration(struct vkd3d_glsl_generator
sampler_type = "<unhandled sampler type>";
}
switch ((component_type = vkd3d_component_type_from_resource_data_type(srv->resource_data_type)))
switch (srv->resource_data_type)
{
case VKD3D_SHADER_COMPONENT_UINT:
case VKD3D_DATA_UINT:
sampler_type_prefix = "u";
break;
case VKD3D_SHADER_COMPONENT_INT:
case VKD3D_DATA_INT:
sampler_type_prefix = "i";
break;
case VKD3D_SHADER_COMPONENT_FLOAT:
case VKD3D_DATA_FLOAT:
case VKD3D_DATA_UNORM:
case VKD3D_DATA_SNORM:
sampler_type_prefix = "";
break;
default:
vkd3d_glsl_compiler_error(gen, VKD3D_SHADER_ERROR_GLSL_INTERNAL,
"Internal compiler error: Unhandled component type %#x for combined resource/sampler "
"for resource %u, space %u and sampler %u, space %u.", component_type,
"Internal compiler error: Unhandled data type %#x for combined resource/sampler "
"for resource %u, space %u and sampler %u, space %u.", srv->resource_data_type,
crs->resource_index, crs->resource_space, crs->sampler_index, crs->sampler_space);
sampler_type_prefix = "";
break;

25
libs/vkd3d-shader/msl.c
View File

@@ -116,19 +116,19 @@ static void msl_print_indent(struct vkd3d_string_buffer *buffer, unsigned int in
}
static void msl_print_resource_datatype(struct msl_generator *gen,
struct vkd3d_string_buffer *buffer, enum vkd3d_shader_resource_data_type data_type)
struct vkd3d_string_buffer *buffer, enum vkd3d_data_type data_type)
{
switch (data_type)
{
case VKD3D_SHADER_RESOURCE_DATA_FLOAT:
case VKD3D_SHADER_RESOURCE_DATA_UNORM:
case VKD3D_SHADER_RESOURCE_DATA_SNORM:
case VKD3D_DATA_FLOAT:
case VKD3D_DATA_UNORM:
case VKD3D_DATA_SNORM:
vkd3d_string_buffer_printf(buffer, "float");
break;
case VKD3D_SHADER_RESOURCE_DATA_INT:
case VKD3D_DATA_INT:
vkd3d_string_buffer_printf(buffer, "int");
break;
case VKD3D_SHADER_RESOURCE_DATA_UINT:
case VKD3D_DATA_UINT:
vkd3d_string_buffer_printf(buffer, "uint");
break;
default:
@@ -258,9 +258,8 @@ static void msl_print_cbv_name(struct vkd3d_string_buffer *buffer, unsigned int
vkd3d_string_buffer_printf(buffer, "descriptors[%u].buf<vkd3d_vec4>()", binding);
}
static void msl_print_srv_name(struct vkd3d_string_buffer *buffer, struct msl_generator *gen,
unsigned int binding, const struct msl_resource_type_info *resource_type_info,
enum vkd3d_shader_resource_data_type resource_data_type)
static void msl_print_srv_name(struct vkd3d_string_buffer *buffer, struct msl_generator *gen, unsigned int binding,
const struct msl_resource_type_info *resource_type_info, enum vkd3d_data_type resource_data_type)
{
vkd3d_string_buffer_printf(buffer, "descriptors[%u].tex<texture%s<",
binding, resource_type_info->type_suffix);
@@ -707,13 +706,13 @@ static void msl_else(struct msl_generator *gen)
static void msl_ld(struct msl_generator *gen, const struct vkd3d_shader_instruction *ins)
{
const struct msl_resource_type_info *resource_type_info;
enum vkd3d_shader_resource_data_type resource_data_type;
unsigned int resource_id, resource_idx, resource_space;
const struct vkd3d_shader_descriptor_info1 *descriptor;
const struct vkd3d_shader_descriptor_binding *binding;
enum vkd3d_shader_resource_type resource_type;
struct msl_src coord, array_index, lod;
struct vkd3d_string_buffer *read;
enum vkd3d_data_type data_type;
uint32_t coord_mask;
struct msl_dst dst;
@@ -732,7 +731,7 @@ static void msl_ld(struct msl_generator *gen, const struct vkd3d_shader_instruct
{
resource_type = descriptor->resource_type;
resource_space = descriptor->register_space;
resource_data_type = descriptor->resource_data_type;
data_type = descriptor->resource_data_type;
}
else
{
@@ -740,7 +739,7 @@ static void msl_ld(struct msl_generator *gen, const struct vkd3d_shader_instruct
"Internal compiler error: Undeclared resource descriptor %u.", resource_id);
resource_space = 0;
resource_type = VKD3D_SHADER_RESOURCE_TEXTURE_2D;
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
data_type = VKD3D_DATA_FLOAT;
}
if ((resource_type_info = msl_get_resource_type_info(resource_type)))
@@ -771,7 +770,7 @@ static void msl_ld(struct msl_generator *gen, const struct vkd3d_shader_instruct
read = vkd3d_string_buffer_get(&gen->string_buffers);
vkd3d_string_buffer_printf(read, "as_type<uint4>(");
msl_print_srv_name(read, gen, binding->binding, resource_type_info, resource_data_type);
msl_print_srv_name(read, gen, binding->binding, resource_type_info, data_type);
vkd3d_string_buffer_printf(read, ".read(");
if (resource_type_info->read_coord_size > 1)
vkd3d_string_buffer_printf(read, "as_type<uint%zu>(%s)",

2
libs/vkd3d-shader/spirv.c
View File

@@ -7124,7 +7124,7 @@ static void spirv_compiler_emit_resource_declaration(struct spirv_compiler *comp
return;
}
sampled_type = vkd3d_component_type_from_resource_data_type(descriptor->resource_data_type);
sampled_type = vkd3d_component_type_from_data_type(descriptor->resource_data_type);
if (!is_uav && spirv_compiler_has_combined_sampler_for_resource(compiler, range))
{

121
libs/vkd3d-shader/vkd3d_shader_main.c
View File

@@ -1063,7 +1063,7 @@ static void vkd3d_shader_scan_record_uav_atomic_op(struct vkd3d_shader_scan_cont
static struct vkd3d_shader_descriptor_info1 *vkd3d_shader_scan_add_descriptor(struct vkd3d_shader_scan_context *context,
enum vkd3d_shader_descriptor_type type, const struct vkd3d_shader_register *reg,
const struct vkd3d_shader_register_range *range, enum vkd3d_shader_resource_type resource_type,
enum vkd3d_shader_resource_data_type resource_data_type)
enum vkd3d_data_type resource_data_type)
{
struct vkd3d_shader_scan_descriptor_info1 *info = context->scan_descriptor_info;
struct vkd3d_shader_descriptor_info1 *d;
@@ -1099,7 +1099,7 @@ static void vkd3d_shader_scan_constant_buffer_declaration(struct vkd3d_shader_sc
struct vkd3d_shader_descriptor_info1 *d;
if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV,
&cb->src.reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT)))
&cb->src.reg, &cb->range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT)))
return;
d->buffer_size = cb->size;
}
@@ -1111,7 +1111,7 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte
struct vkd3d_shader_descriptor_info1 *d;
if (!(d = vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER,
&sampler->src.reg, &sampler->range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT)))
&sampler->src.reg, &sampler->range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_DATA_UINT)))
return;
if (instruction->flags & VKD3DSI_SAMPLER_COMPARISON_MODE)
@@ -1122,9 +1122,9 @@ static void vkd3d_shader_scan_combined_sampler_declaration(
struct vkd3d_shader_scan_context *context, const struct vkd3d_shader_semantic *semantic)
{
vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, &semantic->resource.reg.reg,
&semantic->resource.range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_SHADER_RESOURCE_DATA_UINT);
&semantic->resource.range, VKD3D_SHADER_RESOURCE_NONE, VKD3D_DATA_UINT);
vkd3d_shader_scan_add_descriptor(context, VKD3D_SHADER_DESCRIPTOR_TYPE_SRV, &semantic->resource.reg.reg,
&semantic->resource.range, semantic->resource_type, VKD3D_SHADER_RESOURCE_DATA_FLOAT);
&semantic->resource.range, semantic->resource_type, VKD3D_DATA_FLOAT);
}
const struct vkd3d_shader_descriptor_info1 *vkd3d_shader_find_descriptor(
@@ -1214,8 +1214,8 @@ static void vkd3d_shader_scan_combined_sampler_usage(struct vkd3d_shader_scan_co
static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_context *context,
const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type,
enum vkd3d_shader_resource_data_type resource_data_type,
unsigned int sample_count, unsigned int structure_stride, bool raw, uint32_t flags)
enum vkd3d_data_type resource_data_type, unsigned int sample_count,
unsigned int structure_stride, bool raw, uint32_t flags)
{
struct vkd3d_shader_descriptor_info1 *d;
enum vkd3d_shader_descriptor_type type;
@@ -1239,59 +1239,16 @@ static void vkd3d_shader_scan_typed_resource_declaration(struct vkd3d_shader_sca
const struct vkd3d_shader_instruction *instruction)
{
const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic;
enum vkd3d_shader_resource_data_type resource_data_type;
if (semantic->resource_data_type[0] != semantic->resource_data_type[1] ||
semantic->resource_data_type[0] != semantic->resource_data_type[2] ||
semantic->resource_data_type[0] != semantic->resource_data_type[3])
FIXME("Resource data types are different (%d, %d, %d, %d).\n",
semantic->resource_data_type[0],
semantic->resource_data_type[1],
semantic->resource_data_type[2],
semantic->resource_data_type[3]);
if (semantic->resource_data_type[0] != semantic->resource_data_type[1]
|| semantic->resource_data_type[0] != semantic->resource_data_type[2]
|| semantic->resource_data_type[0] != semantic->resource_data_type[3])
FIXME("Resource data types are different (%#x, %#x, %#x, %#x).\n",
semantic->resource_data_type[0], semantic->resource_data_type[1],
semantic->resource_data_type[2], semantic->resource_data_type[3]);
switch (semantic->resource_data_type[0])
{
case VKD3D_DATA_UNORM:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_UNORM;
break;
case VKD3D_DATA_SNORM:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_SNORM;
break;
case VKD3D_DATA_INT:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_INT;
break;
case VKD3D_DATA_UINT:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_UINT;
break;
case VKD3D_DATA_FLOAT:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
break;
case VKD3D_DATA_MIXED:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_MIXED;
break;
case VKD3D_DATA_DOUBLE:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_DOUBLE;
break;
case VKD3D_DATA_CONTINUED:
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_CONTINUED;
break;
default:
ERR("Invalid resource data type %#x.\n", semantic->resource_data_type[0]);
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
break;
}
if (context->api_version < VKD3D_SHADER_API_VERSION_1_3
&& resource_data_type >= VKD3D_SHADER_RESOURCE_DATA_MIXED)
{
ERR("Invalid resource data type %#x for API version %#x.\n",
semantic->resource_data_type[0], context->api_version);
resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
}
vkd3d_shader_scan_resource_declaration(context, &semantic->resource,
semantic->resource_type, resource_data_type, semantic->sample_count, 0, false, instruction->flags);
vkd3d_shader_scan_resource_declaration(context, &semantic->resource, semantic->resource_type,
semantic->resource_data_type[0], semantic->sample_count, 0, false, instruction->flags);
}
static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *context,
@@ -1327,12 +1284,12 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte
case VKD3DSIH_DCL_RESOURCE_RAW:
case VKD3DSIH_DCL_UAV_RAW:
vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.raw_resource.resource,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0, 0, true, instruction->flags);
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0, 0, true, instruction->flags);
break;
case VKD3DSIH_DCL_RESOURCE_STRUCTURED:
case VKD3DSIH_DCL_UAV_STRUCTURED:
vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.structured_resource.resource,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0,
VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0,
instruction->declaration.structured_resource.byte_stride, false, instruction->flags);
break;
case VKD3DSIH_DCL_TESSELLATOR_OUTPUT_PRIMITIVE:
@@ -1543,8 +1500,34 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte
return VKD3D_OK;
}
static enum vkd3d_result convert_descriptor_info(struct vkd3d_shader_scan_descriptor_info *info,
const struct vkd3d_shader_scan_descriptor_info1 *info1)
static enum vkd3d_shader_resource_data_type vkd3d_resource_data_type_from_data_type(enum vkd3d_data_type data_type)
{
switch (data_type)
{
case VKD3D_DATA_UNORM:
return VKD3D_SHADER_RESOURCE_DATA_UNORM;
case VKD3D_DATA_SNORM:
return VKD3D_SHADER_RESOURCE_DATA_SNORM;
case VKD3D_DATA_INT:
return VKD3D_SHADER_RESOURCE_DATA_INT;
case VKD3D_DATA_UINT:
return VKD3D_SHADER_RESOURCE_DATA_UINT;
case VKD3D_DATA_FLOAT:
return VKD3D_SHADER_RESOURCE_DATA_FLOAT;
case VKD3D_DATA_MIXED:
return VKD3D_SHADER_RESOURCE_DATA_MIXED;
case VKD3D_DATA_DOUBLE:
return VKD3D_SHADER_RESOURCE_DATA_DOUBLE;
case VKD3D_DATA_CONTINUED:
return VKD3D_SHADER_RESOURCE_DATA_CONTINUED;
default:
ERR("Invalid resource data type %#x.\n", data_type);
return VKD3D_SHADER_RESOURCE_DATA_FLOAT;
}
}
static enum vkd3d_result convert_descriptor_info(struct vkd3d_shader_scan_context *context,
struct vkd3d_shader_scan_descriptor_info *info, const struct vkd3d_shader_scan_descriptor_info1 *info1)
{
unsigned int i;
@@ -1560,9 +1543,17 @@ static enum vkd3d_result convert_descriptor_info(struct vkd3d_shader_scan_descri
dst->register_space = src->register_space;
dst->register_index = src->register_index;
dst->resource_type = src->resource_type;
dst->resource_data_type = src->resource_data_type;
dst->resource_data_type = vkd3d_resource_data_type_from_data_type(src->resource_data_type);
dst->flags = src->flags;
dst->count = src->count;
if (context->api_version < VKD3D_SHADER_API_VERSION_1_3
&& dst->resource_data_type >= VKD3D_SHADER_RESOURCE_DATA_MIXED)
{
ERR("Invalid resource data type %#x for API version %#x.\n",
src->resource_data_type, context->api_version);
dst->resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT;
}
}
info->descriptor_count = info1->descriptor_count;
@@ -1629,7 +1620,7 @@ static int vsir_program_scan(struct vsir_program *program, const struct vkd3d_sh
if (size)
{
if ((d = vkd3d_shader_scan_add_descriptor(&context, VKD3D_SHADER_DESCRIPTOR_TYPE_CBV, &reg,
&range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT)))
&range, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT)))
d->buffer_size = size * 16;
}
}
@@ -1647,7 +1638,7 @@ static int vsir_program_scan(struct vsir_program *program, const struct vkd3d_sh
}
if (!ret && descriptor_info)
ret = convert_descriptor_info(descriptor_info, &program->descriptors);
ret = convert_descriptor_info(&context, descriptor_info, &program->descriptors);
if (!ret && tessellation_info)
{

26
libs/vkd3d-shader/vkd3d_shader_private.h
View File

@@ -1431,7 +1431,7 @@ struct vkd3d_shader_descriptor_info1
unsigned int register_index;
unsigned int register_id;
enum vkd3d_shader_resource_type resource_type;
enum vkd3d_shader_resource_data_type resource_data_type;
enum vkd3d_data_type resource_data_type;
unsigned int flags;
unsigned int sample_count;
unsigned int buffer_size;
@@ -1767,30 +1767,6 @@ static inline enum vkd3d_data_type vkd3d_data_type_from_component_type(
}
}
static inline enum vkd3d_shader_component_type vkd3d_component_type_from_resource_data_type(
enum vkd3d_shader_resource_data_type data_type)
{
switch (data_type)
{
case VKD3D_SHADER_RESOURCE_DATA_FLOAT:
case VKD3D_SHADER_RESOURCE_DATA_UNORM:
case VKD3D_SHADER_RESOURCE_DATA_SNORM:
return VKD3D_SHADER_COMPONENT_FLOAT;
case VKD3D_SHADER_RESOURCE_DATA_UINT:
return VKD3D_SHADER_COMPONENT_UINT;
case VKD3D_SHADER_RESOURCE_DATA_INT:
return VKD3D_SHADER_COMPONENT_INT;
case VKD3D_SHADER_RESOURCE_DATA_DOUBLE:
case VKD3D_SHADER_RESOURCE_DATA_CONTINUED:
return VKD3D_SHADER_COMPONENT_DOUBLE;
default:
FIXME("Unhandled data type %#x.\n", data_type);
/* fall-through */
case VKD3D_SHADER_RESOURCE_DATA_MIXED:
return VKD3D_SHADER_COMPONENT_UINT;
}
}
static inline bool component_type_is_64_bit(enum vkd3d_shader_component_type component_type)
{
return component_type == VKD3D_SHADER_COMPONENT_DOUBLE || component_type == VKD3D_SHADER_COMPONENT_UINT64;