wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-09-13 09:16:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

vkd3d-shader/tpf: Return a vkd3d_shader_sysval_semantic from hlsl_sm4_usage_from_semantic().

Browse Source
This commit is contained in:
Henri Verbeet 2024-08-07 17:23:04 +02:00
parent f5205da8e9
commit 1c01560321
Notes: Henri Verbeet 2024-09-04 11:47:56 +02:00 
Approved-by: Elizabeth Figura (@zfigura)
Approved-by: Giovanni Mascellani (@giomasce)
Approved-by: Henri Verbeet (@hverbeet)
Merge-Request: https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/1028
3 changed files with 67 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libs/vkd3d-shader/hlsl.h
View File

@ -1536,8 +1536,8 @@ int d3dbc_compile(struct vsir_program *program, uint64_t config_flags,
struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_code *out, struct vkd3d_shader_message_context *message_context,
struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func); struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func);
bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, bool sysval_semantic_from_hlsl(enum vkd3d_shader_sysval_semantic *semantic,
const struct hlsl_semantic *semantic, bool output, D3D_NAME *usage); struct hlsl_ctx *ctx, const struct hlsl_semantic *hlsl_semantic, bool output);
bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic,
bool output, enum vkd3d_shader_register_type *type, bool *has_idx); bool output, enum vkd3d_shader_register_type *type, bool *has_idx);
int hlsl_sm4_write(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, struct vkd3d_shader_code *out); int hlsl_sm4_write(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_func, struct vkd3d_shader_code *out);

4
libs/vkd3d-shader/hlsl_codegen.c
View File

@ -5152,10 +5152,10 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var
} }
else else
{ {
D3D_NAME usage; enum vkd3d_shader_sysval_semantic semantic;
bool has_idx; bool has_idx;
if (!hlsl_sm4_usage_from_semantic(ctx, &var->semantic, output, &usage)) if (!sysval_semantic_from_hlsl(&semantic, ctx, &var->semantic, output))
{ {
hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC, hlsl_error(ctx, &var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_SEMANTIC,
"Invalid semantic '%s'.", var->semantic.name); "Invalid semantic '%s'.", var->semantic.name);

126
libs/vkd3d-shader/tpf.c
View File

@ -2782,8 +2782,8 @@ bool hlsl_sm4_register_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_sem
return false; return false;
} }
bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semantic *semantic, bool sysval_semantic_from_hlsl(enum vkd3d_shader_sysval_semantic *semantic,
bool output, D3D_NAME *usage) struct hlsl_ctx *ctx, const struct hlsl_semantic *hlsl_semantic, bool output)
{ {
unsigned int i; unsigned int i;
@ -2792,7 +2792,7 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant
const char *name; const char *name;
bool output; bool output;
enum vkd3d_shader_type shader_type; enum vkd3d_shader_type shader_type;
D3D_NAME usage; enum vkd3d_shader_sysval_semantic semantic;
} }
semantics[] = semantics[] =
{ {
@ -2800,46 +2800,46 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant
{"sv_groupid", false, VKD3D_SHADER_TYPE_COMPUTE, ~0u}, {"sv_groupid", false, VKD3D_SHADER_TYPE_COMPUTE, ~0u},
{"sv_groupthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, ~0u}, {"sv_groupthreadid", false, VKD3D_SHADER_TYPE_COMPUTE, ~0u},
{"position", false, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_POSITION}, {"position", false, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_POSITION},
{"sv_position", false, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_POSITION}, {"sv_position", false, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_POSITION},
{"sv_primitiveid", false, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_PRIMITIVE_ID}, {"sv_primitiveid", false, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_PRIMITIVE_ID},
{"position", true, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_POSITION}, {"position", true, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_POSITION},
{"sv_position", true, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_POSITION}, {"sv_position", true, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_POSITION},
{"sv_primitiveid", true, VKD3D_SHADER_TYPE_GEOMETRY, D3D_NAME_PRIMITIVE_ID}, {"sv_primitiveid", true, VKD3D_SHADER_TYPE_GEOMETRY, VKD3D_SHADER_SV_PRIMITIVE_ID},
{"position", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_POSITION}, {"position", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_POSITION},
{"sv_position", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_POSITION}, {"sv_position", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_POSITION},
{"sv_primitiveid", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_PRIMITIVE_ID}, {"sv_primitiveid", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_PRIMITIVE_ID},
{"sv_isfrontface", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_IS_FRONT_FACE}, {"sv_isfrontface", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_IS_FRONT_FACE},
{"sv_rendertargetarrayindex", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_RENDER_TARGET_ARRAY_INDEX}, {"sv_rendertargetarrayindex", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX},
{"sv_viewportarrayindex", false, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_VIEWPORT_ARRAY_INDEX}, {"sv_viewportarrayindex", false, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX},
{"color", true, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_TARGET}, {"color", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_TARGET},
{"depth", true, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_DEPTH}, {"depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_DEPTH},
{"sv_target", true, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_TARGET}, {"sv_target", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_TARGET},
{"sv_depth", true, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_DEPTH}, {"sv_depth", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_DEPTH},
{"sv_coverage", true, VKD3D_SHADER_TYPE_PIXEL, D3D_NAME_COVERAGE}, {"sv_coverage", true, VKD3D_SHADER_TYPE_PIXEL, VKD3D_SHADER_SV_COVERAGE},
{"sv_position", false, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_UNDEFINED}, {"sv_position", false, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_NONE},
{"sv_vertexid", false, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_VERTEX_ID}, {"sv_vertexid", false, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_VERTEX_ID},
{"sv_instanceid", false, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_INSTANCE_ID}, {"sv_instanceid", false, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_INSTANCE_ID},
{"position", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_POSITION}, {"position", true, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_POSITION},
{"sv_position", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_POSITION}, {"sv_position", true, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_POSITION},
{"sv_rendertargetarrayindex", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_RENDER_TARGET_ARRAY_INDEX}, {"sv_rendertargetarrayindex", true, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX},
{"sv_viewportarrayindex", true, VKD3D_SHADER_TYPE_VERTEX, D3D_NAME_VIEWPORT_ARRAY_INDEX}, {"sv_viewportarrayindex", true, VKD3D_SHADER_TYPE_VERTEX, VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX},
}; };
bool needs_compat_mapping = ascii_strncasecmp(semantic->name, "sv_", 3); bool needs_compat_mapping = ascii_strncasecmp(hlsl_semantic->name, "sv_", 3);
for (i = 0; i < ARRAY_SIZE(semantics); ++i) for (i = 0; i < ARRAY_SIZE(semantics); ++i)
{ {
if (!ascii_strcasecmp(semantic->name, semantics[i].name) if (!ascii_strcasecmp(hlsl_semantic->name, semantics[i].name)
&& output == semantics[i].output && output == semantics[i].output
&& (ctx->semantic_compat_mapping == needs_compat_mapping || !needs_compat_mapping) && (ctx->semantic_compat_mapping == needs_compat_mapping || !needs_compat_mapping)
&& ctx->profile->type == semantics[i].shader_type) && ctx->profile->type == semantics[i].shader_type)
{ {
*usage = semantics[i].usage; *semantic = semantics[i].semantic;
return true; return true;
} }
} }
@ -2847,7 +2847,7 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant
if (!needs_compat_mapping) if (!needs_compat_mapping)
return false; return false;
*usage = D3D_NAME_UNDEFINED; *semantic = VKD3D_SHADER_SV_NONE;
return true; return true;
} }
@ -2880,16 +2880,16 @@ static void write_sm4_signature(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc,
LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
{ {
unsigned int width = (1u << var->data_type->dimx) - 1, use_mask; unsigned int width = (1u << var->data_type->dimx) - 1, use_mask;
enum vkd3d_shader_sysval_semantic semantic;
uint32_t usage_idx, reg_idx; uint32_t usage_idx, reg_idx;
D3D_NAME usage;
bool has_idx; bool has_idx;
if ((output && !var->is_output_semantic) || (!output && !var->is_input_semantic)) if ((output && !var->is_output_semantic) || (!output && !var->is_input_semantic))
continue; continue;
ret = hlsl_sm4_usage_from_semantic(ctx, &var->semantic, output, &usage); ret = sysval_semantic_from_hlsl(&semantic, ctx, &var->semantic, output);
VKD3D_ASSERT(ret); VKD3D_ASSERT(ret);
if (usage == ~0u) if (semantic == ~0u)
continue; continue;
usage_idx = var->semantic.index; usage_idx = var->semantic.index;
@ -2908,12 +2908,12 @@ static void write_sm4_signature(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc,
use_mask = 0xf ^ use_mask; use_mask = 0xf ^ use_mask;
/* Special pixel shader semantics (TARGET, DEPTH, COVERAGE). */ /* Special pixel shader semantics (TARGET, DEPTH, COVERAGE). */
if (usage >= 64) if (semantic >= VKD3D_SHADER_SV_TARGET)
usage = 0; semantic = VKD3D_SHADER_SV_NONE;
put_u32(&buffer, 0); /* name */ put_u32(&buffer, 0); /* name */
put_u32(&buffer, usage_idx); put_u32(&buffer, usage_idx);
put_u32(&buffer, usage); put_u32(&buffer, semantic);
switch (var->data_type->e.numeric.type) switch (var->data_type->e.numeric.type)
{ {
case HLSL_TYPE_FLOAT: case HLSL_TYPE_FLOAT:
@ -2944,25 +2944,25 @@ static void write_sm4_signature(struct hlsl_ctx *ctx, struct dxbc_writer *dxbc,
i = 0; i = 0;
LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry) LIST_FOR_EACH_ENTRY(var, &ctx->extern_vars, struct hlsl_ir_var, extern_entry)
{ {
const char *semantic = var->semantic.name; enum vkd3d_shader_sysval_semantic semantic;
const char *name = var->semantic.name;
size_t string_offset; size_t string_offset;
D3D_NAME usage;
if ((output && !var->is_output_semantic) || (!output && !var->is_input_semantic)) if ((output && !var->is_output_semantic) || (!output && !var->is_input_semantic))
continue; continue;
hlsl_sm4_usage_from_semantic(ctx, &var->semantic, output, &usage); sysval_semantic_from_hlsl(&semantic, ctx, &var->semantic, output);
if (usage == ~0u) if (semantic == ~0u)
continue; continue;
if (usage == D3D_NAME_TARGET && !ascii_strcasecmp(semantic, "color")) if (semantic == VKD3D_SHADER_SV_TARGET && !ascii_strcasecmp(name, "color"))
string_offset = put_string(&buffer, "SV_Target"); string_offset = put_string(&buffer, "SV_Target");
else if (usage == D3D_NAME_DEPTH && !ascii_strcasecmp(semantic, "depth")) else if (semantic == VKD3D_SHADER_SV_DEPTH && !ascii_strcasecmp(name, "depth"))
string_offset = put_string(&buffer, "SV_Depth"); string_offset = put_string(&buffer, "SV_Depth");
else if (usage == D3D_NAME_POSITION && !ascii_strcasecmp(semantic, "position")) else if (semantic == VKD3D_SHADER_SV_POSITION && !ascii_strcasecmp(name, "position"))
string_offset = put_string(&buffer, "SV_Position"); string_offset = put_string(&buffer, "SV_Position");
else else
string_offset = put_string(&buffer, semantic); string_offset = put_string(&buffer, name);
set_u32(&buffer, (2 + i++ * 6) * sizeof(uint32_t), string_offset); set_u32(&buffer, (2 + i++ * 6) * sizeof(uint32_t), string_offset);
} }
@ -4412,7 +4412,7 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl
{ {
const struct hlsl_profile_info *profile = tpf->ctx->profile; const struct hlsl_profile_info *profile = tpf->ctx->profile;
const bool output = var->is_output_semantic; const bool output = var->is_output_semantic;
D3D_NAME usage; enum vkd3d_shader_sysval_semantic semantic;
bool has_idx; bool has_idx;
struct sm4_instruction instr = struct sm4_instruction instr =
@ -4445,22 +4445,22 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl
if (instr.dsts[0].reg.type == VKD3DSPR_DEPTHOUT) if (instr.dsts[0].reg.type == VKD3DSPR_DEPTHOUT)
instr.dsts[0].reg.dimension = VSIR_DIMENSION_SCALAR; instr.dsts[0].reg.dimension = VSIR_DIMENSION_SCALAR;
hlsl_sm4_usage_from_semantic(tpf->ctx, &var->semantic, output, &usage); sysval_semantic_from_hlsl(&semantic, tpf->ctx, &var->semantic, output);
if (usage == ~0u) if (semantic == ~0u)
usage = D3D_NAME_UNDEFINED; semantic = VKD3D_SHADER_SV_NONE;
if (var->is_input_semantic) if (var->is_input_semantic)
{ {
switch (usage) switch (semantic)
{ {
case D3D_NAME_UNDEFINED: case VKD3D_SHADER_SV_NONE:
instr.opcode = (profile->type == VKD3D_SHADER_TYPE_PIXEL) instr.opcode = (profile->type == VKD3D_SHADER_TYPE_PIXEL)
? VKD3D_SM4_OP_DCL_INPUT_PS : VKD3D_SM4_OP_DCL_INPUT; ? VKD3D_SM4_OP_DCL_INPUT_PS : VKD3D_SM4_OP_DCL_INPUT;
break; break;
case D3D_NAME_INSTANCE_ID: case VKD3D_SHADER_SV_INSTANCE_ID:
case D3D_NAME_PRIMITIVE_ID: case VKD3D_SHADER_SV_PRIMITIVE_ID:
case D3D_NAME_VERTEX_ID: case VKD3D_SHADER_SV_VERTEX_ID:
instr.opcode = (profile->type == VKD3D_SHADER_TYPE_PIXEL) instr.opcode = (profile->type == VKD3D_SHADER_TYPE_PIXEL)
? VKD3D_SM4_OP_DCL_INPUT_PS_SGV : VKD3D_SM4_OP_DCL_INPUT_SGV; ? VKD3D_SM4_OP_DCL_INPUT_PS_SGV : VKD3D_SM4_OP_DCL_INPUT_SGV;
break; break;
@ -4510,25 +4510,25 @@ static void write_sm4_dcl_semantic(const struct tpf_writer *tpf, const struct hl
} }
else else
{ {
if (usage == D3D_NAME_UNDEFINED || profile->type == VKD3D_SHADER_TYPE_PIXEL) if (semantic == VKD3D_SHADER_SV_NONE || profile->type == VKD3D_SHADER_TYPE_PIXEL)
instr.opcode = VKD3D_SM4_OP_DCL_OUTPUT; instr.opcode = VKD3D_SM4_OP_DCL_OUTPUT;
else else
instr.opcode = VKD3D_SM4_OP_DCL_OUTPUT_SIV; instr.opcode = VKD3D_SM4_OP_DCL_OUTPUT_SIV;
} }
switch (usage) switch (semantic)
{ {
case D3D_NAME_COVERAGE: case VKD3D_SHADER_SV_COVERAGE:
case D3D_NAME_DEPTH: case VKD3D_SHADER_SV_DEPTH:
case D3D_NAME_DEPTH_GREATER_EQUAL: case VKD3D_SHADER_SV_DEPTH_GREATER_EQUAL:
case D3D_NAME_DEPTH_LESS_EQUAL: case VKD3D_SHADER_SV_DEPTH_LESS_EQUAL:
case D3D_NAME_TARGET: case VKD3D_SHADER_SV_TARGET:
case D3D_NAME_UNDEFINED: case VKD3D_SHADER_SV_NONE:
break; break;
default: default:
instr.idx_count = 1; instr.idx_count = 1;
instr.idx[0] = usage; instr.idx[0] = semantic;
break; break;
} }