Updated vkd3d-latest patchset

Squash and update.

patches/vkd3d-latest/0002-Updated-vkd3d-to-cbce3a8631116ec10895e6c9c4a00b89b05.patch

@@ -0,0 +1,214 @@
+From d682beb0dff9eff34d01f2e517145d17d561ef01 Mon Sep 17 00:00:00 2001
+From: Alistair Leslie-Hughes <leslie_alistair@hotmail.com>
+Date: Thu, 10 Apr 2025 07:44:42 +1000
+Subject: [PATCH 2/2] Updated vkd3d to
+ cbce3a8631116ec10895e6c9c4a00b89b051f6b0.
+
+---
+ libs/vkd3d/libs/vkd3d-shader/fx.c           | 44 ++++++++++++++++-----
+ libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c | 10 ++++-
+ libs/vkd3d/libs/vkd3d-shader/msl.c          |  2 +-
+ libs/vkd3d/libs/vkd3d-shader/tpf.c          | 20 +++++++---
+ 4 files changed, 58 insertions(+), 18 deletions(-)
+
+diff --git a/libs/vkd3d/libs/vkd3d-shader/fx.c b/libs/vkd3d/libs/vkd3d-shader/fx.c
+index debcb261811..c93f01039ef 100644
+--- a/libs/vkd3d/libs/vkd3d-shader/fx.c
++++ b/libs/vkd3d/libs/vkd3d-shader/fx.c
+@@ -2420,6 +2420,23 @@ static inline enum hlsl_base_type hlsl_type_from_fx_type(enum state_property_com
+      }
+ }
+ 
++static inline bool hlsl_type_state_compatible(struct hlsl_type *lhs, enum hlsl_base_type rhs)
++{
++    if (!hlsl_is_numeric_type(lhs))
++        return false;
++    switch (lhs->e.numeric.type)
++    {
++        case HLSL_TYPE_INT:
++        case HLSL_TYPE_UINT:
++            return rhs == HLSL_TYPE_INT || rhs == HLSL_TYPE_UINT;
++
++        default:
++            return lhs->e.numeric.type == rhs;
++    }
++
++    vkd3d_unreachable();
++}
++
+ static const struct rhs_named_value filter_values[] =
+ {
+     { "MIN_MAG_MIP_POINT", 0x00 },
+@@ -2664,9 +2681,9 @@ static void resolve_fx_4_state_block_values(struct hlsl_ir_var *var, struct hlsl
+     struct replace_state_context replace_context;
+     const struct fx_4_state *state = NULL;
+     struct hlsl_type *state_type = NULL;
+-    struct hlsl_ir_node *node, *cast;
+     struct hlsl_ctx *ctx = fx->ctx;
+     enum hlsl_base_type base_type;
++    struct hlsl_ir_node *node;
+     unsigned int i;
+ 
+     if (type->class == HLSL_CLASS_BLEND_STATE && ctx->profile->major_version == 5)
+@@ -2803,9 +2820,15 @@ static void resolve_fx_4_state_block_values(struct hlsl_ir_var *var, struct hlsl
+     if (state_type)
+     {
+         node = entry->args->node;
+-        if (!(cast = hlsl_new_cast(ctx, node, state_type, &var->loc)))
+-            return;
+-        list_add_after(&node->entry, &cast->entry);
++        if (state->type == FX_UINT8 || !hlsl_type_state_compatible(node->data_type, base_type))
++        {
++            struct hlsl_ir_node *cast;
++
++            if (!(cast = hlsl_new_cast(ctx, node, state_type, &var->loc)))
++                return;
++            list_add_after(&node->entry, &cast->entry);
++            node = cast;
++        }
+ 
+         /* FX_UINT8 values are using 32-bits in the binary. Mask higher 24 bits for those. */
+         if (state->type == FX_UINT8)
+@@ -2814,15 +2837,18 @@ static void resolve_fx_4_state_block_values(struct hlsl_ir_var *var, struct hlsl
+ 
+             if (!(mask = hlsl_new_uint_constant(ctx, 0xff, &var->loc)))
+                 return;
+-            list_add_after(&cast->entry, &mask->entry);
++            list_add_after(&node->entry, &mask->entry);
+ 
+-            if (!(cast = hlsl_new_binary_expr(ctx, HLSL_OP2_BIT_AND, cast, mask)))
++            if (!(node = hlsl_new_binary_expr(ctx, HLSL_OP2_BIT_AND, node, mask)))
+                 return;
+-            list_add_after(&mask->entry, &cast->entry);
++            list_add_after(&mask->entry, &node->entry);
+         }
+ 
+-        hlsl_src_remove(entry->args);
+-        hlsl_src_from_node(entry->args, cast);
++        if (node != entry->args->node)
++        {
++            hlsl_src_remove(entry->args);
++            hlsl_src_from_node(entry->args, node);
++        }
+ 
+         hlsl_run_const_passes(ctx, entry->instrs);
+     }
+diff --git a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c
+index ba56ba90403..dc7607a1393 100644
+--- a/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c
++++ b/libs/vkd3d/libs/vkd3d-shader/hlsl_codegen.c
+@@ -6407,7 +6407,9 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var
+                 || semantic == VKD3D_SHADER_SV_PRIMITIVE_ID)
+             vip_allocation = true;
+ 
+-        if (semantic == VKD3D_SHADER_SV_IS_FRONT_FACE || semantic == VKD3D_SHADER_SV_SAMPLE_INDEX)
++        if (semantic == VKD3D_SHADER_SV_IS_FRONT_FACE || semantic == VKD3D_SHADER_SV_SAMPLE_INDEX
++                || (version.type == VKD3D_SHADER_TYPE_DOMAIN && !output && !is_primitive)
++                || (ctx->is_patch_constant_func && output))
+             special_interpolation = true;
+     }
+ 
+@@ -6443,6 +6445,8 @@ static void allocate_semantic_registers(struct hlsl_ctx *ctx, struct hlsl_ir_fun
+     bool is_pixel_shader = ctx->profile->type == VKD3D_SHADER_TYPE_PIXEL;
+     struct hlsl_ir_var *var;
+ 
++    in_prim_allocator.prioritize_smaller_writemasks = true;
++    patch_constant_out_patch_allocator.prioritize_smaller_writemasks = true;
+     input_allocator.prioritize_smaller_writemasks = true;
+     output_allocator.prioritize_smaller_writemasks = true;
+ 
+@@ -6470,6 +6474,8 @@ static void allocate_semantic_registers(struct hlsl_ctx *ctx, struct hlsl_ir_fun
+             allocate_semantic_register(ctx, var, &output_allocator, true, !is_pixel_shader);
+     }
+ 
++    vkd3d_free(in_prim_allocator.allocations);
++    vkd3d_free(patch_constant_out_patch_allocator.allocations);
+     vkd3d_free(input_allocator.allocations);
+     vkd3d_free(output_allocator.allocations);
+ }
+@@ -9770,7 +9776,7 @@ static void sm4_generate_vsir_instr_dcl_semantic(struct hlsl_ctx *ctx, struct vs
+     else
+     {
+         if (semantic == VKD3D_SHADER_SV_NONE || version->type == VKD3D_SHADER_TYPE_PIXEL
+-                || version->type == VKD3D_SHADER_TYPE_HULL)
++                || (version->type == VKD3D_SHADER_TYPE_HULL && !ctx->is_patch_constant_func))
+             opcode = VKD3DSIH_DCL_OUTPUT;
+         else
+             opcode = VKD3DSIH_DCL_OUTPUT_SIV;
+diff --git a/libs/vkd3d/libs/vkd3d-shader/msl.c b/libs/vkd3d/libs/vkd3d-shader/msl.c
+index a5d952cd525..d477bfa1c1b 100644
+--- a/libs/vkd3d/libs/vkd3d-shader/msl.c
++++ b/libs/vkd3d/libs/vkd3d-shader/msl.c
+@@ -1292,7 +1292,7 @@ static int msl_generator_init(struct msl_generator *gen, struct vsir_program *pr
+     {
+         msl_compiler_error(gen, VKD3D_SHADER_ERROR_MSL_INTERNAL,
+                 "Internal compiler error: Unhandled shader type %#x.", type);
+-        return VKD3D_ERROR_INVALID_SHADER;
++        gen->prefix = "unknown";
+     }
+     gen->interface_info = vkd3d_find_struct(compile_info->next, INTERFACE_INFO);
+ 
+diff --git a/libs/vkd3d/libs/vkd3d-shader/tpf.c b/libs/vkd3d/libs/vkd3d-shader/tpf.c
+index 23dab35a288..3be1d743acf 100644
+--- a/libs/vkd3d/libs/vkd3d-shader/tpf.c
++++ b/libs/vkd3d/libs/vkd3d-shader/tpf.c
+@@ -3116,8 +3116,12 @@ bool sm4_sysval_semantic_from_semantic_name(enum vkd3d_shader_sysval_semantic *s
+         {"sv_domainlocation",           false, VKD3D_SHADER_TYPE_DOMAIN,    ~0u},
+         {"sv_position",                 false, VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_NONE},
+         {"sv_primitiveid",              false, VKD3D_SHADER_TYPE_DOMAIN,    ~0u},
++        {"sv_rendertargetarrayindex",   false, VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_NONE},
++        {"sv_viewportarrayindex",       false, VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_NONE},
+ 
+         {"sv_position",                 true,  VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_POSITION},
++        {"sv_rendertargetarrayindex",   true,  VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX},
++        {"sv_viewportarrayindex",       true,  VKD3D_SHADER_TYPE_DOMAIN,    VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX},
+ 
+         {"sv_primitiveid",              false, VKD3D_SHADER_TYPE_GEOMETRY,  VKD3D_SHADER_SV_PRIMITIVE_ID},
+         {"sv_gsinstanceid",             false, VKD3D_SHADER_TYPE_GEOMETRY,  ~0u},
+@@ -3131,6 +3135,8 @@ bool sm4_sysval_semantic_from_semantic_name(enum vkd3d_shader_sysval_semantic *s
+         {"sv_primitiveid",              false, VKD3D_SHADER_TYPE_HULL,      ~0u},
+ 
+         {"sv_position",                 true,  VKD3D_SHADER_TYPE_HULL,      VKD3D_SHADER_SV_POSITION},
++        {"sv_rendertargetarrayindex",   true,  VKD3D_SHADER_TYPE_HULL,      VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX},
++        {"sv_viewportarrayindex",       true,  VKD3D_SHADER_TYPE_HULL,      VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX},
+ 
+         {"position",                    false, VKD3D_SHADER_TYPE_PIXEL,     VKD3D_SHADER_SV_POSITION},
+         {"sv_position",                 false, VKD3D_SHADER_TYPE_PIXEL,     VKD3D_SHADER_SV_POSITION},
+@@ -3164,6 +3170,10 @@ bool sm4_sysval_semantic_from_semantic_name(enum vkd3d_shader_sysval_semantic *s
+         if (!ascii_strcasecmp(semantic_name, "sv_position")
+                 || (semantic_compat_mapping && !ascii_strcasecmp(semantic_name, "position")))
+             *sysval_semantic = VKD3D_SHADER_SV_POSITION;
++        else if (!ascii_strcasecmp(semantic_name, "sv_rendertargetarrayindex"))
++            *sysval_semantic = VKD3D_SHADER_SV_RENDER_TARGET_ARRAY_INDEX;
++        else if (!ascii_strcasecmp(semantic_name, "sv_viewportarrayindex"))
++            *sysval_semantic = VKD3D_SHADER_SV_VIEWPORT_ARRAY_INDEX;
+         else if (has_sv_prefix)
+             return false;
+         else
+@@ -3179,11 +3189,6 @@ bool sm4_sysval_semantic_from_semantic_name(enum vkd3d_shader_sysval_semantic *s
+                 return get_tessfactor_sysval_semantic(sysval_semantic, domain, semantic_idx);
+             if (!ascii_strcasecmp(semantic_name, "sv_insidetessfactor"))
+                 return get_insidetessfactor_sysval_semantic(sysval_semantic, domain, semantic_idx);
+-            if (!ascii_strcasecmp(semantic_name, "sv_position"))
+-            {
+-                *sysval_semantic = VKD3D_SHADER_SV_NONE;
+-                return true;
+-            }
+         }
+         else
+         {
+@@ -3214,7 +3219,10 @@ bool sm4_sysval_semantic_from_semantic_name(enum vkd3d_shader_sysval_semantic *s
+                 && (semantic_compat_mapping || has_sv_prefix)
+                 && version->type == semantics[i].shader_type)
+         {
+-            *sysval_semantic = semantics[i].semantic;
++            if (is_patch_constant_func && output && semantics[i].semantic != ~0u)
++                *sysval_semantic = VKD3D_SHADER_SV_NONE;
++            else
++                *sysval_semantic = semantics[i].semantic;
+             return true;
+         }
+     }
+-- 
+2.47.2
+