[PATCH v3 0/1] MR381: vkd3d-shader/tpf: Convert some of the semantic names to system values names when in compatibility mode.

[Nikolay Sivov (＠nsivov)]

Signed-off-by: Nikolay Sivov

--
  v3: vkd3d-shader/tpf: Convert some of the semantic names to system values names when in compatibility mode.

https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/381

[PATCH v3 1/1] vkd3d-shader/tpf: Convert some of the semantic names to system values names when in compatibility mode.

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 include/vkd3d_shader.h              | 26 ++++++++++++++++
 libs/vkd3d-shader/hlsl.c            |  4 +++
 libs/vkd3d-shader/hlsl.h            |  2 ++
 libs/vkd3d-shader/tpf.c             | 48 +++++++++++++++--------------
 libs/vkd3d-utils/vkd3d_utils_main.c |  7 +++++
 programs/vkd3d-compiler/main.c      | 12 ++++++++
 6 files changed, 76 insertions(+), 23 deletions(-)

diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h
index f112e7c75..995dab7ee 100644
--- a/include/vkd3d_shader.h
+++ b/include/vkd3d_shader.h
@@ -154,6 +154,24 @@ enum vkd3d_shader_compile_option_pack_matrix_order
     VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER),
 };

+/** Individual options to enable various backward compatibility features. \since 1.10 */
+enum vkd3d_shader_compile_option_backward_compatibility
+{
+    /**
+     *  Causes compiler to convert SM1-3 semantics to corresponding System Value semantics,
+     *  when compiled for SM4+ targets.
+     *
+     *  This option does the following conversions:
+     *
+     *      - POSITION -> SV_Position for vertex shader outputs and pixel shader inputs;
+     *      - COLORN -> SV_TargetN for pixel shader outputs;
+     *      - DEPTH -> SV_Depth for pixel shader outputs.
+     */
+    VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES = 0x00000001,
+
+    VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY),
+};
+
 enum vkd3d_shader_compile_option_name
 {
     /**
@@ -193,6 +211,14 @@ enum vkd3d_shader_compile_option_name
      * \since 1.9
      */
     VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_ORDER = 0x00000007,
+    /**
+     * This option is used to enable various backward compatibility features.
+     *
+     * \a value is a mask of values from enum vkd3d_shader_compile_option_backward_compatibility.
+     *
+     * \since 1.10
+     */
+    VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY = 0x00000008,

VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPILE_OPTION_NAME),
 };
diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c
index b42e30888..2d383bc2f 100644
--- a/libs/vkd3d-shader/hlsl.c
+++ b/libs/vkd3d-shader/hlsl.c
@@ -3421,6 +3421,10 @@ static bool hlsl_ctx_init(struct hlsl_ctx *ctx, const struct vkd3d_shader_compil
             else if (option->value == VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_COLUMN_MAJOR)
                 ctx->matrix_majority = HLSL_MODIFIER_COLUMN_MAJOR;
         }
+        else if (option->name == VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY)
+        {
+            ctx->semantic_compat_mapping = option->value & VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES;
+        }
     }

return true;
diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h
index 59c543c7b..ef187f375 100644
--- a/libs/vkd3d-shader/hlsl.h
+++ b/libs/vkd3d-shader/hlsl.h
@@ -862,6 +862,8 @@ struct hlsl_ctx
     uint32_t in_state_block : 1;
     /* Whether the numthreads() attribute has been provided in the entry-point function. */
     uint32_t found_numthreads : 1;
+
+    bool semantic_compat_mapping;
 };

enum hlsl_error_level
diff --git a/libs/vkd3d-shader/tpf.c b/libs/vkd3d-shader/tpf.c
index 596a0c499..2583ff9ea 100644
--- a/libs/vkd3d-shader/tpf.c
+++ b/libs/vkd3d-shader/tpf.c
@@ -2729,52 +2729,54 @@ bool hlsl_sm4_usage_from_semantic(struct hlsl_ctx *ctx, const struct hlsl_semant
     {
         const char *name;
         bool output;
+        bool needs_compat_mapping;
         enum vkd3d_shader_type shader_type;
         D3DDECLUSAGE usage;
     }
     semantics[] =
     {
-        {"sv_dispatchthreadid",         false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},
-        {"sv_groupid",                  false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},
-        {"sv_groupthreadid",            false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},
+        {"sv_dispatchthreadid",         false, false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},
+        {"sv_groupid",                  false, false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},
+        {"sv_groupthreadid",            false, false, VKD3D_SHADER_TYPE_COMPUTE,   ~0u},

-        {"position",                    false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
-        {"sv_position",                 false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
-        {"sv_primitiveid",              false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_PRIMITIVE_ID},
+        {"position",                    false, false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
+        {"sv_position",                 false, false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
+        {"sv_primitiveid",              false, false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_PRIMITIVE_ID},

-        {"position",                    true,  VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
-        {"sv_position",                 true,  VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
-        {"sv_primitiveid",              true,  VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_PRIMITIVE_ID},
+        {"position",                    true,  false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
+        {"sv_position",                 true,  false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_POSITION},
+        {"sv_primitiveid",              true,  false, VKD3D_SHADER_TYPE_GEOMETRY,  D3D_NAME_PRIMITIVE_ID},

-        {"position",                    false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_POSITION},
-        {"sv_position",                 false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_POSITION},
-        {"sv_isfrontface",              false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_IS_FRONT_FACE},
+        {"position",                    false, true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_POSITION},
+        {"sv_position",                 false, false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_POSITION},
+        {"sv_isfrontface",              false, false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_IS_FRONT_FACE},

-        {"color",                       true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_TARGET},
-        {"depth",                       true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_DEPTH},
-        {"sv_target",                   true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_TARGET},
-        {"sv_depth",                    true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_DEPTH},
+        {"color",                       true,  true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_TARGET},
+        {"depth",                       true,  true,  VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_DEPTH},
+        {"sv_target",                   true,  false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_TARGET},
+        {"sv_depth",                    true,  false, VKD3D_SHADER_TYPE_PIXEL,     D3D_NAME_DEPTH},

-        {"sv_position",                 false, VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_UNDEFINED},
-        {"sv_vertexid",                 false, VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_VERTEX_ID},
+        {"sv_position",                 false, false, VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_UNDEFINED},
+        {"sv_vertexid",                 false, false, VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_VERTEX_ID},

-        {"position",                    true,  VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_POSITION},
-        {"sv_position",                 true,  VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_POSITION},
+        {"position",                    true,  true,  VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_POSITION},
+        {"sv_position",                 true,  false, VKD3D_SHADER_TYPE_VERTEX,    D3D_NAME_POSITION},
     };
+    bool is_system_value = !ascii_strncasecmp(semantic->name, "sv_", 3);

for (i = 0; i < ARRAY_SIZE(semantics); ++i)
     {
         if (!ascii_strcasecmp(semantic->name, semantics[i].name)
                 && output == semantics[i].output
-                && ctx->profile->type == semantics[i].shader_type
-                && !ascii_strncasecmp(semantic->name, "sv_", 3))
+                && (ctx->semantic_compat_mapping == semantics[i].needs_compat_mapping || is_system_value)
+                && ctx->profile->type == semantics[i].shader_type)
         {
             *usage = semantics[i].usage;
             return true;
         }
     }

-    if (!ascii_strncasecmp(semantic->name, "sv_", 3))
+    if (is_system_value)
         return false;

*usage = D3D_NAME_UNDEFINED;
diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c
index b0c025f46..f8eefe1b2 100644
--- a/libs/vkd3d-utils/vkd3d_utils_main.c
+++ b/libs/vkd3d-utils/vkd3d_utils_main.c
@@ -273,6 +273,13 @@ HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filen
             option->value |= VKD3D_SHADER_COMPILE_OPTION_PACK_MATRIX_COLUMN_MAJOR;
     }

+    if (flags & D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY)
+    {
+        option = &options[compile_info.option_count++];
+        option->name = VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY;
+        option->value = VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES;
+    }
+
     ret = vkd3d_shader_compile(&compile_info, &byte_code, &messages);

if (messages && messages_blob)
diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c
index 61e8d48a2..24cb7b372 100644
--- a/programs/vkd3d-compiler/main.c
+++ b/programs/vkd3d-compiler/main.c
@@ -47,6 +47,7 @@ enum
     OPTION_PRINT_SOURCE_TYPES,
     OPTION_PRINT_TARGET_TYPES,
     OPTION_PROFILE,
+    OPTION_SEMANTIC_COMPAT_MAP,
     OPTION_STRIP_DEBUG,
     OPTION_VERSION,
     OPTION_TEXT_FORMATTING,
@@ -188,6 +189,8 @@ static void print_usage(const char *program_name)
         "  --matrix-storage-order=<order>\n"
         "                        Specify default matrix storage order. Valid values are\n"
         "                        'column' (default) and 'row'.\n"
+        "  --semantic-compat-map Enable semantic mapping compatibility mode to use SM4+ system values\n"
+        "                        instead of SM1-3 style semantic names.\n"
         "  -e, --entry=<name>    Use <name> as the entry point (default is "main").\n"
         "  -E                    Preprocess the source code instead of compiling it.\n"
         "  -o, --output=<file>   Write the output to <file>. If <file> is '-' or no\n"
@@ -441,6 +444,7 @@ static bool parse_command_line(int argc, char **argv, struct options *options)
 {
     enum vkd3d_shader_compile_option_pack_matrix_order pack_matrix_order;
     enum vkd3d_shader_compile_option_buffer_uav buffer_uav;
+    unsigned int compat_options = 0;
     int option;

static struct option long_options[] =
@@ -456,6 +460,7 @@ static bool parse_command_line(int argc, char **argv, struct options *options)
         {"profile",              required_argument, NULL, OPTION_PROFILE},
         {"strip-debug",          no_argument,       NULL, OPTION_STRIP_DEBUG},
         {"version",              no_argument,       NULL, OPTION_VERSION},
+        {"semantic-compat-map",  no_argument,       NULL, OPTION_SEMANTIC_COMPAT_MAP},
         {NULL,                   0,                 NULL, 0},
     };

@@ -535,6 +540,10 @@ static bool parse_command_line(int argc, char **argv, struct options *options)
                 options->print_target_types = true;
                 break;

+            case OPTION_SEMANTIC_COMPAT_MAP:
+                compat_options |= VKD3D_SHADER_COMPILE_OPTION_BACKCOMPAT_MAP_SEMANTIC_NAMES;
+                break;
+
             case OPTION_STRIP_DEBUG:
                 add_compile_option(options, VKD3D_SHADER_COMPILE_OPTION_STRIP_DEBUG, 1);
                 break;
@@ -557,6 +566,9 @@ static bool parse_command_line(int argc, char **argv, struct options *options)
         }
     }

+    if (compat_options)
+        add_compile_option(options, VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY, compat_options);
+
     if (optind < argc)
         options->filename = argv[argc - 1];

[Henri Verbeet (＠hverbeet)]

> +    /**
> +     *  Causes compiler to convert SM1-3 semantics to corresponding System Value semantics,
> +     *  when compiled for SM4+ targets.

It may be worth pointing out that this option applies to HLSL sources.
> +        "  --semantic-compat-map Enable semantic mapping compatibility mode to use SM4+ system values\n"
> +        "                        instead of SM1-3 style semantic names.\n"

Likewise.
> +    if (compat_options)
> +        add_compile_option(options, VKD3D_SHADER_COMPILE_OPTION_BACKWARD_COMPATIBILITY, compat_options);

I think this requires bumping MAX_COMPILE_OPTIONS. We're probably also starting to reach the point where it makes more sense to dynamically allocate the "compile_options" array though.