vkd3d: Also add RE workaround for RE2 DXR.

Signed-off-by: Hans-Kristian Arntzen <post@arntzen-software.no>

include/private/vkd3d_string.h

@@ -30,6 +30,7 @@ WCHAR *vkd3d_dup_demangled_entry_point(const char *str);
 char *vkd3d_dup_demangled_entry_point_ascii(const char *str);
 
 bool vkd3d_export_strequal(const WCHAR *a, const WCHAR *b);
+bool vkd3d_export_strequal_mixed(const WCHAR *a, const char *b);
 bool vkd3d_export_strequal_substr(const WCHAR *a, size_t n, const WCHAR *b);
 
 char *vkd3d_strdup(const char *str);

include/shader-debug/GNUmakefile

@@ -6,6 +6,12 @@ COMP_SOURCES := $(wildcard $(M)/*.comp)
 TESC_SOURCES := $(wildcard $(M)/*.tesc)
 TESE_SOURCES := $(wildcard $(M)/*.tese)
 GEOM_SOURCES := $(wildcard $(M)/*.geom)
+RGEN_SOURCES := $(wildcard $(M)/*.rgen)
+RINT_SOURCES := $(wildcard $(M)/*.rint)
+RAHIT_SOURCES := $(wildcard $(M)/*.rahit)
+RCHIT_SOURCES := $(wildcard $(M)/*.rchit)
+RMISS_SOURCES := $(wildcard $(M)/*.rmiss)
+RCALL_SOURCES := $(wildcard $(M)/*.rcall)
 
 SPV_OBJECTS := \
 			   $(VERT_SOURCES:.vert=.spv) \
@@ -13,25 +19,49 @@ SPV_OBJECTS := \
 			   $(COMP_SOURCES:.comp=.spv) \
 			   $(TESC_SOURCES:.tesc=.spv) \
 			   $(TESE_SOURCES:.tese=.spv) \
-			   $(GEOM_SOURCES:.geom=.spv)
+			   $(GEOM_SOURCES:.geom=.spv) \
+			   $(RGEN_SOURCES:.rgen=.spv) \
+			   $(RINT_SOURCES:.rint=.spv) \
+			   $(RAHIT_SOURCES:.rahit=.spv) \
+			   $(RCHIT_SOURCES:.rchit=.spv) \
+			   $(RMISS_SOURCES:.rmiss=.spv) \
+			   $(RCALL_SOURCES:.rcall=.spv)
 
 %.spv: %.vert
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 $(GLSLC_FLAGS)
 
 %.spv: %.frag
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 -DDEBUG_CHANNEL_HELPER_LANES
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 -DDEBUG_CHANNEL_HELPER_LANES $(GLSLC_FLAGS)
 
 %.spv: %.comp
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 $(GLSLC_FLAGS)
 
 %.spv: %.geom
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 $(GLSLC_FLAGS)
 
 %.spv: %.tesc
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 $(GLSLC_FLAGS)
 
 %.spv: %.tese
-	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 $(GLSLC_FLAGS)
+
+%.spv: %.rgen
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
+
+%.spv: %.rint
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
+
+%.spv: %.rahit
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
+
+%.spv: %.rchit
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
+
+%.spv: %.rmiss
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
+
+%.spv: %.rcall
+	glslc -o $@ $< -I$(INCLUDE_DIR) --target-env=vulkan1.1 --target-spv=spv1.4 $(GLSLC_FLAGS)
 
 all: $(SPV_OBJECTS)
 

include/vkd3d.h

@@ -87,6 +87,8 @@ extern "C" {
 #define VKD3D_CONFIG_FLAG_BREADCRUMBS (1ull << 25)
 #define VKD3D_CONFIG_FLAG_PIPELINE_LIBRARY_APP_CACHE_ONLY (1ull << 26)
 #define VKD3D_CONFIG_FLAG_SHADER_CACHE_SYNC (1ull << 27)
+#define VKD3D_CONFIG_FLAG_ALLOW_SBT_COLLECTION (1ull << 28)
+#define VKD3D_CONFIG_FLAG_FORCE_NATIVE_FP16 (1ull << 29)
 
 typedef HRESULT (*PFN_vkd3d_signal_event)(HANDLE event);
 

include/vkd3d_shader.h

@@ -752,7 +752,11 @@ int vkd3d_shader_compile_dxbc(const struct vkd3d_shader_code *dxbc,
 void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *code);
 
 int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *root_signature);
+        struct vkd3d_versioned_root_signature_desc *root_signature,
+        vkd3d_shader_hash_t *compatibility_hash);
+int vkd3d_shader_parse_root_signature_raw(const char *data, unsigned int data_size,
+        struct vkd3d_versioned_root_signature_desc *desc,
+        vkd3d_shader_hash_t *compatibility_hash);
 void vkd3d_shader_free_root_signature(struct vkd3d_versioned_root_signature_desc *root_signature);
 
 /* FIXME: Add support for returning error messages (ID3DBlob). */
@@ -778,19 +782,65 @@ void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature
 struct vkd3d_shader_library_entry_point
 {
     unsigned int identifier;
+    VkShaderStageFlagBits stage;
     WCHAR *mangled_entry_point;
     WCHAR *plain_entry_point;
     char *real_entry_point;
-    VkShaderStageFlagBits stage;
 };
 
-int vkd3d_shader_dxil_append_library_entry_points(
+enum vkd3d_shader_subobject_kind
+{
+    /* Matches DXIL for simplicity. */
+    VKD3D_SHADER_SUBOBJECT_KIND_STATE_OBJECT_CONFIG = 0,
+    VKD3D_SHADER_SUBOBJECT_KIND_GLOBAL_ROOT_SIGNATURE = 1,
+    VKD3D_SHADER_SUBOBJECT_KIND_LOCAL_ROOT_SIGNATURE = 2,
+    VKD3D_SHADER_SUBOBJECT_KIND_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 8,
+    VKD3D_SHADER_SUBOBJECT_KIND_RAYTRACING_SHADER_CONFIG = 9,
+    VKD3D_SHADER_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG = 10,
+    VKD3D_SHADER_SUBOBJECT_KIND_HIT_GROUP = 11,
+    VKD3D_SHADER_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG1 = 12,
+};
+
+struct vkd3d_shader_library_subobject
+{
+    enum vkd3d_shader_subobject_kind kind;
+    unsigned int dxil_identifier;
+
+    /* All const pointers here point directly to the DXBC blob,
+     * so they do not need to be freed.
+     * Fortunately for us, the C strings are zero-terminated in the blob itself. */
+
+    /* In the blob, ASCII is used as identifier, where API uses wide strings, sigh ... */
+    const char *name;
+
+    union
+    {
+        D3D12_RAYTRACING_PIPELINE_CONFIG1 pipeline_config;
+        D3D12_RAYTRACING_SHADER_CONFIG shader_config;
+        D3D12_STATE_OBJECT_CONFIG object_config;
+
+        /* Duped strings because API wants wide strings for no good reason. */
+        D3D12_HIT_GROUP_DESC hit_group;
+        D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION association;
+
+        struct
+        {
+            const void *data;
+            size_t size;
+        } payload;
+    } data;
+};
+
+int vkd3d_shader_dxil_append_library_entry_points_and_subobjects(
         const D3D12_DXIL_LIBRARY_DESC *library_desc,
         unsigned int identifier,
         struct vkd3d_shader_library_entry_point **entry_points,
-        size_t *entry_point_size, size_t *entry_point_count);
+        size_t *entry_point_size, size_t *entry_point_count,
+        struct vkd3d_shader_library_subobject **subobjects,
+        size_t *subobjects_size, size_t *subobjects_count);
 
 void vkd3d_shader_dxil_free_library_entry_points(struct vkd3d_shader_library_entry_point *entry_points, size_t count);
+void vkd3d_shader_dxil_free_library_subobjects(struct vkd3d_shader_library_subobject *subobjects, size_t count);
 
 int vkd3d_shader_compile_dxil_export(const struct vkd3d_shader_code *dxil,
         const char *export,
@@ -816,7 +866,8 @@ typedef int (*PFN_vkd3d_shader_compile_dxbc)(const struct vkd3d_shader_code *dxb
 typedef void (*PFN_vkd3d_shader_free_shader_code)(struct vkd3d_shader_code *code);
 
 typedef int (*PFN_vkd3d_shader_parse_root_signature)(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *root_signature);
+        struct vkd3d_versioned_root_signature_desc *root_signature,
+        vkd3d_shader_hash_t *compatibility_hash);
 typedef void (*PFN_vkd3d_shader_free_root_signature)(struct vkd3d_versioned_root_signature_desc *root_signature);
 
 typedef int (*PFN_vkd3d_shader_serialize_root_signature)(

libs/vkd3d-common/string.c

@@ -82,6 +82,21 @@ bool vkd3d_export_strequal(const WCHAR *a, const WCHAR *b)
     return *a == *b;
 }
 
+bool vkd3d_export_strequal_mixed(const WCHAR *a, const char *b)
+{
+    if (!a || !b)
+        return false;
+
+    while (*a != '\0' && *b != '\0')
+    {
+        if (*a != *b)
+            return false;
+        a++;
+        b++;
+    }
+    return *a == *b;
+}
+
 bool vkd3d_export_strequal_substr(const WCHAR *a, size_t expected_n, const WCHAR *b)
 {
     size_t n = 0;

libs/vkd3d-shader/dxbc.c

@@ -2755,8 +2755,9 @@ static int shader_parse_static_samplers(struct root_signature_parser_context *co
     return VKD3D_OK;
 }
 
-static int shader_parse_root_signature(const char *data, unsigned int data_size,
-        struct vkd3d_versioned_root_signature_desc *desc)
+int vkd3d_shader_parse_root_signature_raw(const char *data, unsigned int data_size,
+        struct vkd3d_versioned_root_signature_desc *desc,
+        vkd3d_shader_hash_t *compatibility_hash)
 {
     struct vkd3d_root_signature_desc *v_1_0 = &desc->v_1_0;
     struct root_signature_parser_context context;
@@ -2764,6 +2765,8 @@ static int shader_parse_root_signature(const char *data, unsigned int data_size,
     const char *ptr = data;
     int ret;
 
+    memset(desc, 0, sizeof(*desc));
+
     context.data = data;
     context.data_size = data_size;
 
@@ -2835,28 +2838,46 @@ static int shader_parse_root_signature(const char *data, unsigned int data_size,
     read_uint32(&ptr, &v_1_0->flags);
     TRACE("Flags %#x.\n", v_1_0->flags);
 
+    if (compatibility_hash)
+    {
+        struct vkd3d_shader_code code = { data, data_size };
+        *compatibility_hash = vkd3d_shader_hash(&code);
+    }
+
     return VKD3D_OK;
 }
 
 static int rts0_handler(const char *data, DWORD data_size, DWORD tag, void *context)
 {
-    struct vkd3d_versioned_root_signature_desc *desc = context;
+    struct vkd3d_shader_code *payload = context;
 
     if (tag != TAG_RTS0)
         return VKD3D_OK;
 
-    return shader_parse_root_signature(data, data_size, desc);
+    payload->code = data;
+    payload->size = data_size;
+    return VKD3D_OK;
 }
 
 int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *root_signature)
+        struct vkd3d_versioned_root_signature_desc *root_signature,
+        vkd3d_shader_hash_t *compatibility_hash)
 {
+    struct vkd3d_shader_code raw_payload;
     int ret;
 
     TRACE("dxbc {%p, %zu}, root_signature %p.\n", dxbc->code, dxbc->size, root_signature);
 
-    memset(root_signature, 0, sizeof(*root_signature));
-    if ((ret = parse_dxbc(dxbc->code, dxbc->size, rts0_handler, root_signature)) < 0)
+    memset(&raw_payload, 0, sizeof(raw_payload));
+
+    if ((ret = parse_dxbc(dxbc->code, dxbc->size, rts0_handler, &raw_payload)) < 0)
+        return ret;
+
+    if (!raw_payload.code)
+        return VKD3D_OK;
+
+    if ((ret = vkd3d_shader_parse_root_signature_raw(raw_payload.code, raw_payload.size,
+            root_signature, compatibility_hash)) < 0)
     {
         vkd3d_shader_free_root_signature(root_signature);
         return ret;

libs/vkd3d-shader/dxil.c

@@ -1352,6 +1352,31 @@ void vkd3d_shader_dxil_free_library_entry_points(struct vkd3d_shader_library_ent
     vkd3d_free(entry_points);
 }
 
+void vkd3d_shader_dxil_free_library_subobjects(struct vkd3d_shader_library_subobject *subobjects, size_t count)
+{
+    size_t i, j;
+
+    for (i = 0; i < count; i++)
+    {
+        if (subobjects[i].kind == VKD3D_SHADER_SUBOBJECT_KIND_SUBOBJECT_TO_EXPORTS_ASSOCIATION)
+        {
+            for (j = 0; j < subobjects[i].data.association.NumExports; j++)
+                vkd3d_free((void*)subobjects[i].data.association.pExports[j]);
+            vkd3d_free((void*)subobjects[i].data.association.pExports);
+            vkd3d_free((void*)subobjects[i].data.association.SubobjectToAssociate);
+        }
+        else if (subobjects[i].kind == VKD3D_SHADER_SUBOBJECT_KIND_HIT_GROUP)
+        {
+            vkd3d_free((void*)subobjects[i].data.hit_group.HitGroupExport);
+            vkd3d_free((void*)subobjects[i].data.hit_group.AnyHitShaderImport);
+            vkd3d_free((void*)subobjects[i].data.hit_group.ClosestHitShaderImport);
+            vkd3d_free((void*)subobjects[i].data.hit_group.IntersectionShaderImport);
+        }
+    }
+
+    vkd3d_free(subobjects);
+}
+
 static VkShaderStageFlagBits convert_stage(dxil_spv_shader_stage stage)
 {
     /* Only interested in RT entry_points. There is no way yet to use lib_6_3+ for non-RT. */
@@ -1396,20 +1421,95 @@ static bool vkd3d_dxil_build_entry(struct vkd3d_shader_library_entry_point *entr
     return true;
 }
 
-int vkd3d_shader_dxil_append_library_entry_points(
+static void vkd3d_shader_dxil_copy_subobject(unsigned int identifier,
+        struct vkd3d_shader_library_subobject *subobject,
+        const dxil_spv_rdat_subobject *dxil_subobject)
+{
+    unsigned int i;
+
+    /* Reuse same enums as DXIL. */
+    subobject->kind = (enum vkd3d_shader_subobject_kind)dxil_subobject->kind;
+    subobject->name = dxil_subobject->subobject_name;
+    subobject->dxil_identifier = identifier;
+
+    switch (dxil_subobject->kind)
+    {
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_GLOBAL_ROOT_SIGNATURE:
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_LOCAL_ROOT_SIGNATURE:
+            subobject->data.payload.data = dxil_subobject->payload;
+            subobject->data.payload.size = dxil_subobject->payload_size;
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG:
+            /* Normalize the kind. */
+            subobject->kind = VKD3D_SHADER_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG1;
+            subobject->data.pipeline_config.MaxTraceRecursionDepth = dxil_subobject->args[0];
+            subobject->data.pipeline_config.Flags = 0;
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG1:
+            subobject->kind = VKD3D_SHADER_SUBOBJECT_KIND_RAYTRACING_PIPELINE_CONFIG1;
+            subobject->data.pipeline_config.MaxTraceRecursionDepth = dxil_subobject->args[0];
+            subobject->data.pipeline_config.Flags = dxil_subobject->args[1];
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_RAYTRACING_SHADER_CONFIG:
+            subobject->data.shader_config.MaxPayloadSizeInBytes = dxil_subobject->args[0];
+            subobject->data.shader_config.MaxAttributeSizeInBytes = dxil_subobject->args[1];
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_HIT_GROUP:
+            /* Enum aliases. */
+            subobject->data.hit_group.Type = (D3D12_HIT_GROUP_TYPE)dxil_subobject->hit_group_type;
+            assert(dxil_subobject->num_exports == 3);
+            /* Implementation simplifies a lot if we can reuse the D3D12 type here. */
+            subobject->data.hit_group.HitGroupExport = vkd3d_dup_entry_point(dxil_subobject->subobject_name);
+            subobject->data.hit_group.AnyHitShaderImport = dxil_subobject->exports[0] && *dxil_subobject->exports[0] != '\0' ?
+                    vkd3d_dup_entry_point(dxil_subobject->exports[0]) : NULL;
+            subobject->data.hit_group.ClosestHitShaderImport = dxil_subobject->exports[1] && *dxil_subobject->exports[1] != '\0' ?
+                    vkd3d_dup_entry_point(dxil_subobject->exports[1]) : NULL;
+            subobject->data.hit_group.IntersectionShaderImport = dxil_subobject->exports[2] && *dxil_subobject->exports[2] != '\0' ?
+                    vkd3d_dup_entry_point(dxil_subobject->exports[2]) : NULL;
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_STATE_OBJECT_CONFIG:
+            subobject->data.object_config.Flags = dxil_subobject->args[0];
+            break;
+
+        case DXIL_SPV_RDAT_SUBOBJECT_KIND_SUBOBJECT_TO_EXPORTS_ASSOCIATION:
+            assert(dxil_subobject->num_exports >= 1);
+            subobject->data.association.SubobjectToAssociate = vkd3d_dup_entry_point(dxil_subobject->exports[0]);
+            subobject->data.association.pExports = vkd3d_malloc((dxil_subobject->num_exports - 1) * sizeof(LPCWSTR));
+            subobject->data.association.NumExports = dxil_subobject->num_exports - 1;
+            for (i = 1; i < dxil_subobject->num_exports; i++)
+                subobject->data.association.pExports[i - 1] = vkd3d_dup_entry_point(dxil_subobject->exports[i]);
+            break;
+
+        default:
+            FIXME("Unrecognized RDAT subobject type: %u.\n", dxil_subobject->kind);
+            break;
+    }
+}
+
+int vkd3d_shader_dxil_append_library_entry_points_and_subobjects(
         const D3D12_DXIL_LIBRARY_DESC *library_desc,
         unsigned int identifier,
         struct vkd3d_shader_library_entry_point **entry_points,
-        size_t *entry_point_size, size_t *entry_point_count)
+        size_t *entry_point_size, size_t *entry_point_count,
+        struct vkd3d_shader_library_subobject **subobjects,
+        size_t *subobjects_size, size_t *subobjects_count)
 {
     struct vkd3d_shader_library_entry_point new_entry;
+    struct vkd3d_shader_library_subobject *subobject;
     dxil_spv_parsed_blob blob = NULL;
     struct vkd3d_shader_code code;
+    dxil_spv_rdat_subobject sub;
     dxil_spv_shader_stage stage;
     const char *mangled_entry;
     char *ascii_entry = NULL;
     vkd3d_shader_hash_t hash;
-    unsigned int count, i;
+    unsigned int count, i, j;
+    unsigned int rdat_count;
     int ret = VKD3D_OK;
 
     memset(&new_entry, 0, sizeof(new_entry));
@@ -1430,6 +1530,8 @@ int vkd3d_shader_dxil_append_library_entry_points(
         goto end;
     }
 
+    rdat_count = dxil_spv_parsed_blob_get_num_rdat_subobjects(blob);
+
     if (library_desc->NumExports)
     {
         for (i = 0; i < library_desc->NumExports; i++)
@@ -1439,24 +1541,44 @@ int vkd3d_shader_dxil_append_library_entry_points(
             else
                 ascii_entry = vkd3d_strdup_w_utf8(library_desc->pExports[i].Name, 0);
 
-            stage = dxil_spv_parsed_blob_get_shader_stage_for_entry(blob, ascii_entry);
-            if (stage == DXIL_SPV_STAGE_UNKNOWN)
+            /* An export can point to a subobject or an entry point. */
+            for (j = 0; j < rdat_count; j++)
             {
-                ret = VKD3D_ERROR_INVALID_ARGUMENT;
-                goto end;
+                dxil_spv_parsed_blob_get_rdat_subobject(blob, j, &sub);
+                /* Subobject names are not mangled. */
+                if (strcmp(sub.subobject_name, ascii_entry) == 0)
+                    break;
             }
 
-            new_entry.real_entry_point = ascii_entry;
-            new_entry.plain_entry_point = vkd3d_wstrdup(library_desc->pExports[i].Name);
-            new_entry.mangled_entry_point = NULL;
-            new_entry.identifier = identifier;
-            new_entry.stage = convert_stage(stage);
-            ascii_entry = NULL;
+            if (j < rdat_count)
+            {
+                vkd3d_array_reserve((void**)subobjects, subobjects_size,
+                        *subobjects_count + 1, sizeof(**subobjects));
+                subobject = &(*subobjects)[*subobjects_count];
+                vkd3d_shader_dxil_copy_subobject(identifier, subobject, &sub);
+                *subobjects_count += 1;
+            }
+            else
+            {
+                stage = dxil_spv_parsed_blob_get_shader_stage_for_entry(blob, ascii_entry);
+                if (stage == DXIL_SPV_STAGE_UNKNOWN)
+                {
+                    ret = VKD3D_ERROR_INVALID_ARGUMENT;
+                    goto end;
+                }
 
-            vkd3d_array_reserve((void**)entry_points, entry_point_size,
-                    *entry_point_count + 1, sizeof(new_entry));
-            (*entry_points)[(*entry_point_count)++] = new_entry;
-            memset(&new_entry, 0, sizeof(new_entry));
+                new_entry.real_entry_point = ascii_entry;
+                new_entry.plain_entry_point = vkd3d_wstrdup(library_desc->pExports[i].Name);
+                new_entry.mangled_entry_point = NULL;
+                new_entry.identifier = identifier;
+                new_entry.stage = convert_stage(stage);
+                ascii_entry = NULL;
+
+                vkd3d_array_reserve((void**)entry_points, entry_point_size,
+                        *entry_point_count + 1, sizeof(new_entry));
+                (*entry_points)[(*entry_point_count)++] = new_entry;
+                memset(&new_entry, 0, sizeof(new_entry));
+            }
         }
     }
     else
@@ -1489,6 +1611,21 @@ int vkd3d_shader_dxil_append_library_entry_points(
             (*entry_points)[(*entry_point_count)++] = new_entry;
             memset(&new_entry, 0, sizeof(new_entry));
         }
+
+        if (rdat_count)
+        {
+            /* All subobjects are also exported. */
+            vkd3d_array_reserve((void**)subobjects, subobjects_size,
+                    *subobjects_count + rdat_count, sizeof(**subobjects));
+
+            for (i = 0; i < rdat_count; i++)
+            {
+                dxil_spv_parsed_blob_get_rdat_subobject(blob, i, &sub);
+                subobject = &(*subobjects)[*subobjects_count];
+                vkd3d_shader_dxil_copy_subobject(identifier, subobject, &sub);
+                *subobjects_count += 1;
+            }
+        }
     }
 
 end:

libs/vkd3d/breadcrumbs.c

@@ -82,6 +82,8 @@ static const char *vkd3d_breadcrumb_command_type_to_str(enum vkd3d_breadcrumb_co
             return "root_desc";
         case VKD3D_BREADCRUMB_COMMAND_ROOT_CONST:
             return "root_const";
+        case VKD3D_BREADCRUMB_COMMAND_TAG:
+            return "tag";
 
         default:
             return "?";
@@ -306,6 +308,10 @@ static void vkd3d_breadcrumb_tracer_report_command_list(
         {
             ERR(" Set arg: %"PRIu64" (#%"PRIx64")\n", cmd->word_64bit, cmd->word_64bit);
         }
+        else if (cmd->type == VKD3D_BREADCRUMB_COMMAND_TAG)
+        {
+            ERR("     Tag: %s\n", cmd->tag);
+        }
         else
         {
             ERR("  Command: %s\n", vkd3d_breadcrumb_command_type_to_str(cmd->type));

libs/vkd3d/command.c

@@ -10186,10 +10186,19 @@ static void STDMETHODCALLTYPE d3d12_command_list_SetPipelineState1(d3d12_command
     if ((vkd3d_config_flags & VKD3D_CONFIG_FLAG_BREADCRUMBS) && state)
     {
         struct vkd3d_breadcrumb_command cmd;
-        cmd.type = VKD3D_BREADCRUMB_COMMAND_SET_SHADER_HASH;
-        cmd.shader.stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
-        cmd.shader.hash = 0;
-        vkd3d_breadcrumb_tracer_add_command(list, &cmd);
+        size_t i;
+
+        for (i = 0; i < state->breadcrumb_shaders_count; i++)
+        {
+            cmd.type = VKD3D_BREADCRUMB_COMMAND_SET_SHADER_HASH;
+            cmd.shader.stage = state->breadcrumb_shaders[i].stage;
+            cmd.shader.hash = state->breadcrumb_shaders[i].hash;
+            vkd3d_breadcrumb_tracer_add_command(list, &cmd);
+
+            cmd.type = VKD3D_BREADCRUMB_COMMAND_TAG;
+            cmd.tag = state->breadcrumb_shaders[i].name;
+            vkd3d_breadcrumb_tracer_add_command(list, &cmd);
+        }
     }
 #endif
 }
@@ -10240,6 +10249,21 @@ static void STDMETHODCALLTYPE d3d12_command_list_DispatchRays(d3d12_command_list
             &raygen_table, &miss_table, &hit_table, &callable_table,
             desc->Width, desc->Height, desc->Depth));
 
+    VKD3D_BREADCRUMB_AUX32(desc->Width);
+    VKD3D_BREADCRUMB_AUX32(desc->Height);
+    VKD3D_BREADCRUMB_AUX32(desc->Depth);
+    VKD3D_BREADCRUMB_AUX64(raygen_table.deviceAddress);
+    VKD3D_BREADCRUMB_AUX64(raygen_table.size);
+    VKD3D_BREADCRUMB_AUX32(raygen_table.stride);
+    VKD3D_BREADCRUMB_AUX64(miss_table.deviceAddress);
+    VKD3D_BREADCRUMB_AUX64(miss_table.size);
+    VKD3D_BREADCRUMB_AUX32(miss_table.stride);
+    VKD3D_BREADCRUMB_AUX64(hit_table.deviceAddress);
+    VKD3D_BREADCRUMB_AUX64(hit_table.size);
+    VKD3D_BREADCRUMB_AUX32(hit_table.stride);
+    VKD3D_BREADCRUMB_AUX64(callable_table.deviceAddress);
+    VKD3D_BREADCRUMB_AUX64(callable_table.size);
+    VKD3D_BREADCRUMB_AUX32(callable_table.stride);
     VKD3D_BREADCRUMB_COMMAND(TRACE_RAYS);
 }
 

libs/vkd3d/device.c

@@ -482,6 +482,14 @@ static void vkd3d_init_debug_messenger_callback(struct vkd3d_instance *instance)
     instance->vk_debug_callback = callback;
 }
 
+/* Could be a flag style enum if needed. */
+enum vkd3d_application_feature_override
+{
+    VKD3D_APPLICATION_FEATURE_OVERRIDE_NONE = 0,
+    VKD3D_APPLICATION_FEATURE_OVERRIDE_PROMOTE_DXR_TO_ULTIMATE,
+};
+
+static enum vkd3d_application_feature_override vkd3d_application_feature_override;
 uint64_t vkd3d_config_flags;
 struct vkd3d_shader_quirk_info vkd3d_shader_quirk_info;
 
@@ -491,6 +499,7 @@ struct vkd3d_instance_application_meta
     const char *name;
     uint64_t global_flags_add;
     uint64_t global_flags_remove;
+    enum vkd3d_application_feature_override override;
 };
 static const struct vkd3d_instance_application_meta application_override[] = {
     /* MSVC fails to compile empty array. */
@@ -511,6 +520,16 @@ static const struct vkd3d_instance_application_meta application_override[] = {
     /* Serious Sam 4 (257420).
      * Invariant workarounds cause graphical glitches when rendering foliage on NV. */
     { VKD3D_STRING_COMPARE_EXACT, "Sam4.exe", VKD3D_CONFIG_FLAG_FORCE_NO_INVARIANT_POSITION, 0 },
+    /* Cyberpunk 2077 (1091500). */
+    { VKD3D_STRING_COMPARE_EXACT, "Cyberpunk2077.exe", VKD3D_CONFIG_FLAG_ALLOW_SBT_COLLECTION, 0 },
+    /* Resident Evil: Village (1196590).
+     * Game relies on mesh + sampler feedback to be exposed to use DXR.
+     * Likely used as a proxy for Turing+ to avoid potential software fallbacks on Pascal. */
+    { VKD3D_STRING_COMPARE_EXACT, "re8.exe",
+            VKD3D_CONFIG_FLAG_FORCE_NATIVE_FP16, 0, VKD3D_APPLICATION_FEATURE_OVERRIDE_PROMOTE_DXR_TO_ULTIMATE },
+    /* Resident Evil 2 remake (883710). Same as RE: Village. */
+    { VKD3D_STRING_COMPARE_EXACT, "re2.exe",
+            VKD3D_CONFIG_FLAG_FORCE_NATIVE_FP16, 0, VKD3D_APPLICATION_FEATURE_OVERRIDE_PROMOTE_DXR_TO_ULTIMATE },
     { VKD3D_STRING_COMPARE_NEVER, NULL, 0, 0 }
 };
 
@@ -559,6 +578,7 @@ static void vkd3d_instance_apply_application_workarounds(void)
             vkd3d_config_flags &= ~application_override[i].global_flags_remove;
             INFO("Detected game %s, adding config 0x%"PRIx64", removing masks 0x%"PRIx64".\n",
                  app, application_override[i].global_flags_add, application_override[i].global_flags_remove);
+            vkd3d_application_feature_override = application_override[i].override;
             break;
         }
     }
@@ -654,6 +674,7 @@ static const struct vkd3d_debug_option vkd3d_config_options[] =
     {"breadcrumbs", VKD3D_CONFIG_FLAG_BREADCRUMBS},
     {"pipeline_library_app_cache", VKD3D_CONFIG_FLAG_PIPELINE_LIBRARY_APP_CACHE_ONLY},
     {"shader_cache_sync", VKD3D_CONFIG_FLAG_SHADER_CACHE_SYNC},
+    {"allow_sbt_collection", VKD3D_CONFIG_FLAG_ALLOW_SBT_COLLECTION},
 };
 
 static void vkd3d_config_flags_init_once(void)
@@ -4871,7 +4892,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CreateStateObject(d3d12_device_ifa
     TRACE("iface %p, desc %p, iid %s, state_object %p!\n",
             iface, desc, debugstr_guid(iid), state_object);
 
-    if (FAILED(hr = d3d12_state_object_create(device, desc, &state)))
+    if (FAILED(hr = d3d12_state_object_create(device, desc, NULL, &state)))
         return hr;
 
     return return_interface(&state->ID3D12StateObject_iface, &IID_ID3D12StateObject, iid, state_object);
@@ -4939,13 +4960,23 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_SetBackgroundProcessingMode(d3d12_
     return E_NOTIMPL;
 }
 
-static HRESULT STDMETHODCALLTYPE d3d12_device_AddToStateObject(d3d12_device_iface *iface, const D3D12_STATE_OBJECT_DESC *addition,
-        ID3D12StateObject *state_object, REFIID riid, void **new_state_object)
+static HRESULT STDMETHODCALLTYPE d3d12_device_AddToStateObject(d3d12_device_iface *iface,
+        const D3D12_STATE_OBJECT_DESC *addition,
+        ID3D12StateObject *parent_state, REFIID riid, void **new_state_object)
 {
-    FIXME("iface %p, addition %p, state_object %p, riid %s, new_state_object %p stub!\n",
-            iface, addition, state_object, debugstr_guid(riid), new_state_object);
+    struct d3d12_device *device = impl_from_ID3D12Device(iface);
+    struct d3d12_state_object *parent;
+    struct d3d12_state_object *state;
+    HRESULT hr;
 
-    return E_NOTIMPL;
+    TRACE("iface %p, addition %p, state_object %p, riid %s, new_state_object %p stub!\n",
+            iface, addition, parent_state, debugstr_guid(riid), new_state_object);
+
+    parent = impl_from_ID3D12StateObject(parent_state);
+    if (FAILED(hr = d3d12_state_object_add(device, addition, parent, &state)))
+        return hr;
+
+    return return_interface(&state->ID3D12StateObject_iface, &IID_ID3D12StateObject, riid, new_state_object);
 }
 
 static HRESULT STDMETHODCALLTYPE d3d12_device_CreateProtectedResourceSession1(d3d12_device_iface *iface,
@@ -5898,6 +5929,27 @@ static void d3d12_device_caps_init_shader_model(struct d3d12_device *device)
     }
 }
 
+static void d3d12_device_caps_override_application(struct d3d12_device *device)
+{
+    /* Some games rely on certain features to be exposed before they let the primary feature
+     * be exposed. */
+    switch (vkd3d_application_feature_override)
+    {
+        case VKD3D_APPLICATION_FEATURE_OVERRIDE_PROMOTE_DXR_TO_ULTIMATE:
+            if (device->d3d12_caps.options5.RaytracingTier >= D3D12_RAYTRACING_TIER_1_0)
+            {
+                device->d3d12_caps.options7.MeshShaderTier = D3D12_MESH_SHADER_TIER_1;
+                device->d3d12_caps.options7.SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_1_0;
+                INFO("DXR enabled. Application also requires Mesh/Sampler feedback to be exposed (but unused). "
+                     "Enabling these features automatically.\n");
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
 static void d3d12_device_caps_override(struct d3d12_device *device)
 {
     D3D_FEATURE_LEVEL fl_override = (D3D_FEATURE_LEVEL)0;
@@ -5988,6 +6040,7 @@ static void d3d12_device_caps_init(struct d3d12_device *device)
     d3d12_device_caps_init_feature_level(device);
 
     d3d12_device_caps_override(device);
+    d3d12_device_caps_override_application(device);
 }
 
 static void vkd3d_init_shader_extensions(struct d3d12_device *device)
@@ -6041,7 +6094,8 @@ static void vkd3d_init_shader_extensions(struct d3d12_device *device)
     }
 
     if (device->d3d12_caps.options4.Native16BitShaderOpsSupported &&
-            device->device_info.driver_properties.driverID == VK_DRIVER_ID_MESA_RADV)
+            (device->device_info.driver_properties.driverID == VK_DRIVER_ID_MESA_RADV ||
+                    (vkd3d_config_flags & VKD3D_CONFIG_FLAG_FORCE_NATIVE_FP16)))
     {
         /* Native FP16 is buggy on NV for now. */
         device->vk_info.shader_extensions[device->vk_info.shader_extension_count++] =

libs/vkd3d/state.c

@@ -1469,8 +1469,36 @@ fail:
     return hr;
 }
 
-HRESULT d3d12_root_signature_create(struct d3d12_device *device,
-        const void *bytecode, size_t bytecode_length, struct d3d12_root_signature **root_signature)
+HRESULT d3d12_root_signature_create_empty(struct d3d12_device *device,
+        struct d3d12_root_signature **root_signature)
+{
+    struct d3d12_root_signature *object;
+    D3D12_ROOT_SIGNATURE_DESC1 desc;
+    HRESULT hr;
+
+    if (!(object = vkd3d_malloc(sizeof(*object))))
+        return E_OUTOFMEMORY;
+
+    memset(&desc, 0, sizeof(desc));
+    hr = d3d12_root_signature_init(object, device, &desc);
+
+    /* For pipeline libraries, (and later DXR to some degree), we need a way to
+     * compare root signature objects. */
+    object->compatibility_hash = 0;
+
+    if (FAILED(hr))
+    {
+        vkd3d_free(object);
+        return hr;
+    }
+
+    *root_signature = object;
+    return S_OK;
+}
+
+static HRESULT d3d12_root_signature_create_from_blob(struct d3d12_device *device,
+        const void *bytecode, size_t bytecode_length, bool raw_payload,
+        struct d3d12_root_signature **root_signature)
 {
     const struct vkd3d_shader_code dxbc = {bytecode, bytecode_length};
     union
@@ -1478,14 +1506,26 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
         D3D12_VERSIONED_ROOT_SIGNATURE_DESC d3d12;
         struct vkd3d_versioned_root_signature_desc vkd3d;
     } root_signature_desc;
+    vkd3d_shader_hash_t compatibility_hash;
     struct d3d12_root_signature *object;
     HRESULT hr;
     int ret;
 
-    if ((ret = vkd3d_parse_root_signature_v_1_1(&dxbc, &root_signature_desc.vkd3d)) < 0)
+    if (raw_payload)
     {
-        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
-        return hresult_from_vkd3d_result(ret);
+        if ((ret = vkd3d_parse_root_signature_v_1_1_from_raw_payload(&dxbc, &root_signature_desc.vkd3d, &compatibility_hash)))
+        {
+            WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
+            return hresult_from_vkd3d_result(ret);
+        }
+    }
+    else
+    {
+        if ((ret = vkd3d_parse_root_signature_v_1_1(&dxbc, &root_signature_desc.vkd3d, &compatibility_hash)) < 0)
+        {
+            WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
+            return hresult_from_vkd3d_result(ret);
+        }
     }
 
     if (!(object = vkd3d_malloc(sizeof(*object))))
@@ -1498,7 +1538,7 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
 
     /* For pipeline libraries, (and later DXR to some degree), we need a way to
      * compare root signature objects. */
-    object->compatibility_hash = vkd3d_shader_hash(&dxbc);
+    object->compatibility_hash = compatibility_hash;
 
     vkd3d_shader_free_root_signature(&root_signature_desc.vkd3d);
     if (FAILED(hr))
@@ -1514,6 +1554,20 @@ HRESULT d3d12_root_signature_create(struct d3d12_device *device,
     return S_OK;
 }
 
+HRESULT d3d12_root_signature_create(struct d3d12_device *device,
+        const void *bytecode, size_t bytecode_length,
+        struct d3d12_root_signature **root_signature)
+{
+    return d3d12_root_signature_create_from_blob(device, bytecode, bytecode_length, false, root_signature);
+}
+
+HRESULT d3d12_root_signature_create_raw(struct d3d12_device *device,
+        const void *payload, size_t payload_length,
+        struct d3d12_root_signature **root_signature)
+{
+    return d3d12_root_signature_create_from_blob(device, payload, payload_length, true, root_signature);
+}
+
 unsigned int d3d12_root_signature_get_shader_interface_flags(const struct d3d12_root_signature *root_signature)
 {
     unsigned int flags = 0;

libs/vkd3d/vkd3d_main.c

@@ -165,15 +165,28 @@ static CONST_VTBL struct ID3D12RootSignatureDeserializerVtbl d3d12_root_signatur
 
 static int vkd3d_parse_root_signature_for_version(const struct vkd3d_shader_code *dxbc,
         struct vkd3d_versioned_root_signature_desc *out_desc,
-        enum vkd3d_root_signature_version target_version)
+        enum vkd3d_root_signature_version target_version,
+        bool raw_payload,
+        vkd3d_shader_hash_t *compatibility_hash)
 {
     struct vkd3d_versioned_root_signature_desc desc, converted_desc;
     int ret;
 
-    if ((ret = vkd3d_shader_parse_root_signature(dxbc, &desc)) < 0)
+    if (raw_payload)
     {
-        WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
-        return ret;
+        if ((ret = vkd3d_shader_parse_root_signature_raw(dxbc->code, dxbc->size, &desc, compatibility_hash)) < 0)
+        {
+            WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
+            return ret;
+        }
+    }
+    else
+    {
+        if ((ret = vkd3d_shader_parse_root_signature(dxbc, &desc, compatibility_hash)) < 0)
+        {
+            WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
+            return ret;
+        }
     }
 
     if (desc.version == target_version)
@@ -197,15 +210,27 @@ static int vkd3d_parse_root_signature_for_version(const struct vkd3d_shader_code
 }
 
 int vkd3d_parse_root_signature_v_1_0(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *out_desc)
+        struct vkd3d_versioned_root_signature_desc *out_desc,
+        vkd3d_shader_hash_t *compatibility_hash)
 {
-    return vkd3d_parse_root_signature_for_version(dxbc, out_desc, VKD3D_ROOT_SIGNATURE_VERSION_1_0);
+    return vkd3d_parse_root_signature_for_version(dxbc, out_desc, VKD3D_ROOT_SIGNATURE_VERSION_1_0, false,
+            compatibility_hash);
 }
 
 int vkd3d_parse_root_signature_v_1_1(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *out_desc)
+        struct vkd3d_versioned_root_signature_desc *out_desc,
+        vkd3d_shader_hash_t *compatibility_hash)
 {
-    return vkd3d_parse_root_signature_for_version(dxbc, out_desc, VKD3D_ROOT_SIGNATURE_VERSION_1_1);
+    return vkd3d_parse_root_signature_for_version(dxbc, out_desc, VKD3D_ROOT_SIGNATURE_VERSION_1_1, false,
+            compatibility_hash);
+}
+
+int vkd3d_parse_root_signature_v_1_1_from_raw_payload(const struct vkd3d_shader_code *dxbc,
+        struct vkd3d_versioned_root_signature_desc *out_desc,
+        vkd3d_shader_hash_t *compatibility_hash)
+{
+    return vkd3d_parse_root_signature_for_version(dxbc, out_desc, VKD3D_ROOT_SIGNATURE_VERSION_1_1, true,
+            compatibility_hash);
 }
 
 static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signature_deserializer *deserializer,
@@ -216,7 +241,7 @@ static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signatur
     deserializer->ID3D12RootSignatureDeserializer_iface.lpVtbl = &d3d12_root_signature_deserializer_vtbl;
     deserializer->refcount = 1;
 
-    if ((ret = vkd3d_parse_root_signature_v_1_0(dxbc, &deserializer->desc.vkd3d)) < 0)
+    if ((ret = vkd3d_parse_root_signature_v_1_0(dxbc, &deserializer->desc.vkd3d, NULL)) < 0)
         return hresult_from_vkd3d_result(ret);
 
     return S_OK;
@@ -394,7 +419,7 @@ static HRESULT d3d12_versioned_root_signature_deserializer_init(struct d3d12_ver
     deserializer->ID3D12VersionedRootSignatureDeserializer_iface.lpVtbl = &d3d12_versioned_root_signature_deserializer_vtbl;
     deserializer->refcount = 1;
 
-    if ((ret = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc.vkd3d)) < 0)
+    if ((ret = vkd3d_shader_parse_root_signature(dxbc, &deserializer->desc.vkd3d, NULL)) < 0)
     {
         WARN("Failed to parse root signature, vkd3d result %d.\n", ret);
         return hresult_from_vkd3d_result(ret);

libs/vkd3d/vkd3d_private.h

@@ -1397,6 +1397,10 @@ struct d3d12_root_signature
 
 HRESULT d3d12_root_signature_create(struct d3d12_device *device, const void *bytecode,
         size_t bytecode_length, struct d3d12_root_signature **root_signature);
+HRESULT d3d12_root_signature_create_raw(struct d3d12_device *device, const void *payload,
+        size_t payload_size, struct d3d12_root_signature **root_signature);
+HRESULT d3d12_root_signature_create_empty(struct d3d12_device *device,
+        struct d3d12_root_signature **root_signature);
 /* Private ref counts, for pipeline library. */
 void d3d12_root_signature_inc_ref(struct d3d12_root_signature *state);
 void d3d12_root_signature_dec_ref(struct d3d12_root_signature *state);
@@ -1419,9 +1423,14 @@ HRESULT vkd3d_create_pipeline_layout(struct d3d12_device *device,
         VkPipelineLayout *pipeline_layout);
 
 int vkd3d_parse_root_signature_v_1_0(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *desc);
+        struct vkd3d_versioned_root_signature_desc *desc,
+        vkd3d_shader_hash_t *compatibility_hash);
 int vkd3d_parse_root_signature_v_1_1(const struct vkd3d_shader_code *dxbc,
-        struct vkd3d_versioned_root_signature_desc *desc);
+        struct vkd3d_versioned_root_signature_desc *desc,
+        vkd3d_shader_hash_t *compatibility_hash);
+int vkd3d_parse_root_signature_v_1_1_from_raw_payload(const struct vkd3d_shader_code *dxbc,
+        struct vkd3d_versioned_root_signature_desc *desc,
+        vkd3d_shader_hash_t *compatibility_hash);
 
 VkShaderStageFlags vkd3d_vk_stage_flags_from_visibility(D3D12_SHADER_VISIBILITY visibility);
 enum vkd3d_shader_visibility vkd3d_shader_visibility_from_d3d12(D3D12_SHADER_VISIBILITY visibility);
@@ -2501,6 +2510,7 @@ enum vkd3d_breadcrumb_command_type
     VKD3D_BREADCRUMB_COMMAND_IBO,
     VKD3D_BREADCRUMB_COMMAND_ROOT_DESC,
     VKD3D_BREADCRUMB_COMMAND_ROOT_CONST,
+    VKD3D_BREADCRUMB_COMMAND_TAG,
 };
 
 #ifdef VKD3D_ENABLE_BREADCRUMBS
@@ -2524,6 +2534,8 @@ struct vkd3d_breadcrumb_command
         uint32_t word_32bit;
         uint64_t word_64bit;
         uint32_t count;
+        /* Pointer must remain alive. */
+        const char *tag;
     };
 };
 
@@ -3406,6 +3418,14 @@ struct d3d12_state_object_identifier
 
     /* The index into vkGetShaderStackSize and friends for pGroups[]. */
     uint32_t group_index;
+
+    /* For AddToStateObject(). We need to return the identifier pointer
+     * for the parent, not the child. This makes it easy to validate that
+     * we observe the same SBT handles as specified by DXR 1.1. */
+
+    /* If -1, ignore, otherwise, redirect. */
+    int inherited_collection_index;
+    uint32_t inherited_collection_export_index;
 };
 
 struct d3d12_state_object_stack_info
@@ -3418,6 +3438,15 @@ struct d3d12_state_object_stack_info
     uint32_t max_closest;
 };
 
+#ifdef VKD3D_ENABLE_BREADCRUMBS
+struct d3d12_state_object_breadcrumb_shader
+{
+    vkd3d_shader_hash_t hash;
+    VkShaderStageFlagBits stage;
+    char name[64];
+};
+#endif
+
 struct d3d12_state_object
 {
     d3d12_state_object_iface ID3D12StateObject_iface;
@@ -3439,7 +3468,14 @@ struct d3d12_state_object
     /* Normally stages_count == entry_points_count, but entry_points is the entry points we
      * export externally, and stages_count matches pStages[] size for purposes of index fixups. */
 
+    /* Can be bound. */
     VkPipeline pipeline;
+    /* Can be used as a library. */
+    VkPipeline pipeline_library;
+
+    /* Can be inherited by AddToStateObject(). */
+    D3D12_RAYTRACING_PIPELINE_CONFIG1 pipeline_config;
+    D3D12_RAYTRACING_SHADER_CONFIG shader_config;
 
     struct
     {
@@ -3448,6 +3484,8 @@ struct d3d12_state_object
         VkDescriptorSet desc_set;
         VkDescriptorPool desc_pool;
         uint32_t set_index;
+        uint64_t compatibility_hash;
+        bool owned_handles;
     } local_static_sampler;
 
     UINT64 pipeline_stack_size;
@@ -3456,10 +3494,23 @@ struct d3d12_state_object
     struct d3d12_state_object **collections;
     size_t collections_count;
 
+    struct d3d12_root_signature *global_root_signature;
+
+#ifdef VKD3D_ENABLE_BREADCRUMBS
+    /* For breadcrumbs. */
+    struct d3d12_state_object_breadcrumb_shader *breadcrumb_shaders;
+    size_t breadcrumb_shaders_size;
+    size_t breadcrumb_shaders_count;
+#endif
+
     struct vkd3d_private_store private_store;
 };
 
 HRESULT d3d12_state_object_create(struct d3d12_device *device, const D3D12_STATE_OBJECT_DESC *desc,
+        struct d3d12_state_object *parent,
+        struct d3d12_state_object **object);
+HRESULT d3d12_state_object_add(struct d3d12_device *device, const D3D12_STATE_OBJECT_DESC *desc,
+        struct d3d12_state_object *parent,
         struct d3d12_state_object **object);
 
 static inline struct d3d12_state_object *impl_from_ID3D12StateObject(ID3D12StateObject *iface)

tests/d3d12_tests.h

@@ -294,6 +294,7 @@ decl_test(test_integer_blending_pipeline_state);
 decl_test(test_discard_resource_uav);
 decl_test(test_unbound_rtv_rendering);
 decl_test(test_raytracing_local_rs_static_sampler);
+decl_test(test_raytracing_local_rs_static_sampler_collection);
 decl_test(test_rayquery);
 decl_test(test_typed_srv_uav_cast);
 decl_test(test_typed_srv_cast_clear);
@@ -307,3 +308,9 @@ decl_test(test_shader_waveop_maximal_convergence);
 decl_test(test_uav_3d_sliced_view);
 decl_test(test_pipeline_no_ps_nonzero_rts);
 decl_test(test_root_descriptor_offset_sign);
+decl_test(test_raytracing_no_global_root_signature);
+decl_test(test_raytracing_missing_required_objects);
+decl_test(test_raytracing_reject_duplicate_objects);
+decl_test(test_raytracing_embedded_subobjects);
+decl_test(test_raytracing_default_association_tiebreak);
+decl_test(test_raytracing_collection_identifiers);