vkd3d-shader/hlsl: Reinterpret minimum precision types as their regular counterparts.

Reinterpret min16float, min10float, min16int, min12int, and min16uint
as their regular counterparts: float, float, int, int, uint,
respectively.

A proper implementation would require adding minimum precision
indicators to all the dxbc-tpf instructions that use these types.
Consider the output of fxc 10.1 with the following shader:

    uniform int i;

    float4 main() : sv_target
    {
        min16float4 a = {0, 1, 2, i};
        min16int2 b = {4, i};
        min10float3 c = {6.4, 7, i};
        min12int d = 9.4;
        min16uint4x2 e = {14.4, 15, 16, 17, 18, 19, 20, i};

        return mul(e, b) + a + c.xyzx + d;
    }

However, if the graphics driver doesn't have minimum precision support,
it ignores the minimum precision indicators and runs at 32-bit
precision, which is equivalent as working with regular types.

libs/vkd3d-shader/hlsl.c

@@ -680,6 +680,7 @@ struct hlsl_type *hlsl_type_clone(struct hlsl_ctx *ctx, struct hlsl_type *old,
     if (!(type->modifiers & HLSL_MODIFIERS_MAJORITY_MASK))
         type->modifiers |= default_majority;
     type->sampler_dim = old->sampler_dim;
+    type->is_minimum_precision = old->is_minimum_precision;
     switch (old->type)
     {
         case HLSL_CLASS_ARRAY:
@@ -2392,7 +2393,7 @@ static int compare_function_rb(const void *key, const struct rb_entry *entry)
 
 static void declare_predefined_types(struct hlsl_ctx *ctx)
 {
-    unsigned int x, y, bt, i;
+    unsigned int x, y, bt, i, v;
     struct hlsl_type *type;
 
     static const char * const names[] =
@@ -2404,7 +2405,11 @@ static void declare_predefined_types(struct hlsl_ctx *ctx)
         "uint",
         "bool",
     };
-    char name[10];
+    char name[15];
+
+    static const char *const variants_float[] = {"min10float", "min16float"};
+    static const char *const variants_int[] = {"min12int", "min16int"};
+    static const char *const variants_uint[] = {"min16uint"};
 
     static const char *const sampler_names[] =
     {
@@ -2464,6 +2469,63 @@ static void declare_predefined_types(struct hlsl_ctx *ctx)
         }
     }
 
+    for (bt = 0; bt <= HLSL_TYPE_LAST_SCALAR; ++bt)
+    {
+        unsigned int n_variants = 0;
+        const char *const *variants;
+
+        switch (bt)
+        {
+            case HLSL_TYPE_FLOAT:
+                variants = variants_float;
+                n_variants = ARRAY_SIZE(variants_float);
+                break;
+
+            case HLSL_TYPE_INT:
+                variants = variants_int;
+                n_variants = ARRAY_SIZE(variants_int);
+                break;
+
+            case HLSL_TYPE_UINT:
+                variants = variants_uint;
+                n_variants = ARRAY_SIZE(variants_uint);
+                break;
+
+            default:
+                break;
+        }
+
+        for (v = 0; v < n_variants; ++v)
+        {
+            for (y = 1; y <= 4; ++y)
+            {
+                for (x = 1; x <= 4; ++x)
+                {
+                    sprintf(name, "%s%ux%u", variants[v], y, x);
+                    type = hlsl_new_type(ctx, name, HLSL_CLASS_MATRIX, bt, x, y);
+                    type->is_minimum_precision = 1;
+                    hlsl_scope_add_type(ctx->globals, type);
+
+                    if (y == 1)
+                    {
+                        sprintf(name, "%s%u", variants[v], x);
+                        type = hlsl_new_type(ctx, name, HLSL_CLASS_VECTOR, bt, x, y);
+                        type->is_minimum_precision = 1;
+                        hlsl_scope_add_type(ctx->globals, type);
+
+                        if (x == 1)
+                        {
+                            sprintf(name, "%s", variants[v]);
+                            type = hlsl_new_type(ctx, name, HLSL_CLASS_SCALAR, bt, x, y);
+                            type->is_minimum_precision = 1;
+                            hlsl_scope_add_type(ctx->globals, type);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     for (bt = 0; bt <= HLSL_SAMPLER_DIM_LAST_SAMPLER; ++bt)
     {
         type = hlsl_new_type(ctx, sampler_names[bt], HLSL_CLASS_OBJECT, HLSL_TYPE_SAMPLER, 1, 1);

libs/vkd3d-shader/hlsl.h

@@ -191,6 +191,8 @@ struct hlsl_type
     unsigned int reg_size;
     /* Offset where the type's description starts in the output bytecode, in bytes. */
     size_t bytecode_offset;
+
+    uint32_t is_minimum_precision : 1;
 };
 
 /* In HLSL, a semantic is a string linked to a variable (or a field) to be recognized across

libs/vkd3d-shader/hlsl.y

@@ -4197,7 +4197,8 @@ type:
                 YYABORT;
             }
 
-            $$ = hlsl_get_vector_type(ctx, $3->base_type, $5);
+            $$ = hlsl_type_clone(ctx, hlsl_get_vector_type(ctx, $3->base_type, $5), 0, 0);
+            $$->is_minimum_precision = $3->is_minimum_precision;
         }
     | KW_VECTOR
         {
@@ -4229,7 +4230,8 @@ type:
                 YYABORT;
             }
 
-            $$ = hlsl_get_matrix_type(ctx, $3->base_type, $7, $5);
+            $$ = hlsl_type_clone(ctx, hlsl_get_matrix_type(ctx, $3->base_type, $7, $5), 0, 0);
+            $$->is_minimum_precision = $3->is_minimum_precision;
         }
     | KW_MATRIX
         {
@@ -4298,6 +4300,18 @@ type:
     | TYPE_IDENTIFIER
         {
             $$ = hlsl_get_type(ctx->cur_scope, $1, true);
+            if ($$->is_minimum_precision)
+            {
+                if (ctx->profile->major_version < 4)
+                {
+                    hlsl_error(ctx, &@1, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE,
+                            "Target profile doesn't support minimum-precision types.");
+                }
+                else
+                {
+                    FIXME("Reinterpreting type %s.\n", $$->name);
+                }
+            }
             vkd3d_free($1);
         }
     | KW_STRUCT TYPE_IDENTIFIER

tests/minimum-precision.shader_test

@@ -2,7 +2,7 @@
 shader model >= 4.0
 
 
-[pixel shader todo]
+[pixel shader]
 float4 main() : sv_target
 {
     min16float4 a = {0, 1, 2, 3};
@@ -17,5 +17,5 @@ float4 main() : sv_target
 }
 
 [test]
-todo draw quad
-todo probe all rgba (197.0, 218.0, 238.0, 257.0)
+draw quad
+probe all rgba (197.0, 218.0, 238.0, 257.0)