diff --git a/patches/vkd3d-latest/0005-Updated-vkd3d-to-78343dcf87d3a911264c6c9a87a9146c43c.patch b/patches/vkd3d-latest/0005-Updated-vkd3d-to-78343dcf87d3a911264c6c9a87a9146c43c.patch new file mode 100644 index 00000000..4a1cdfbc --- /dev/null +++ b/patches/vkd3d-latest/0005-Updated-vkd3d-to-78343dcf87d3a911264c6c9a87a9146c43c.patch @@ -0,0 +1,332 @@ +From 21b8243f4b07d2ad878fcb9b80580f0e908ca573 Mon Sep 17 00:00:00 2001 +From: Alistair Leslie-Hughes +Date: Wed, 3 Jan 2024 19:06:40 +1100 +Subject: [PATCH] Updated vkd3d to 78343dcf87d3a911264c6c9a87a9146c43c859c3. + +--- + libs/vkd3d/include/vkd3d_shader.h | 2 + + libs/vkd3d/libs/vkd3d-shader/spirv.c | 87 +++++++++++++------ + .../libs/vkd3d-shader/vkd3d_shader_private.h | 7 ++ + libs/vkd3d/libs/vkd3d/state.c | 11 +++ + 4 files changed, 81 insertions(+), 26 deletions(-) + +diff --git a/libs/vkd3d/include/vkd3d_shader.h b/libs/vkd3d/include/vkd3d_shader.h +index a6bf8964183..b1a1fff6451 100644 +--- a/libs/vkd3d/include/vkd3d_shader.h ++++ b/libs/vkd3d/include/vkd3d_shader.h +@@ -1569,6 +1569,8 @@ enum vkd3d_shader_component_type + VKD3D_SHADER_COMPONENT_BOOL = 0x4, + /** 64-bit IEEE floating-point. */ + VKD3D_SHADER_COMPONENT_DOUBLE = 0x5, ++ /** 64-bit unsigned integer. \since 1.11 */ ++ VKD3D_SHADER_COMPONENT_UINT64 = 0x6, + + VKD3D_FORCE_32_BIT_ENUM(VKD3D_SHADER_COMPONENT_TYPE), + }; +diff --git a/libs/vkd3d/libs/vkd3d-shader/spirv.c b/libs/vkd3d/libs/vkd3d-shader/spirv.c +index f77bc25329d..9e3cd7549ba 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/spirv.c ++++ b/libs/vkd3d/libs/vkd3d-shader/spirv.c +@@ -1797,6 +1797,8 @@ static uint32_t vkd3d_spirv_get_type_id(struct vkd3d_spirv_builder *builder, + break; + case VKD3D_SHADER_COMPONENT_DOUBLE: + return vkd3d_spirv_get_op_type_float(builder, 64); ++ case VKD3D_SHADER_COMPONENT_UINT64: ++ return vkd3d_spirv_get_op_type_int(builder, 64, 0); + default: + FIXME("Unhandled component type %#x.\n", component_type); + return 0; +@@ -1830,6 +1832,8 @@ static uint32_t vkd3d_spirv_get_type_id_for_data_type(struct vkd3d_spirv_builder + break; + case VKD3D_DATA_DOUBLE: + return vkd3d_spirv_get_op_type_float(builder, 64); ++ case VKD3D_DATA_UINT64: ++ return vkd3d_spirv_get_op_type_int(builder, 64, 0); + case VKD3D_DATA_BOOL: + return vkd3d_spirv_get_op_type_bool(builder); + default: +@@ -2988,7 +2992,7 @@ static uint32_t spirv_compiler_get_constant64(struct spirv_compiler *compiler, + assert(0 < component_count && component_count <= VKD3D_DVEC2_SIZE); + type_id = vkd3d_spirv_get_type_id(builder, component_type, component_count); + +- if (component_type != VKD3D_SHADER_COMPONENT_DOUBLE) ++ if (component_type != VKD3D_SHADER_COMPONENT_DOUBLE && component_type != VKD3D_SHADER_COMPONENT_UINT64) + { + FIXME("Unhandled component_type %#x.\n", component_type); + return vkd3d_spirv_get_op_undef(builder, type_id); +@@ -3048,6 +3052,13 @@ static uint32_t spirv_compiler_get_constant_double_vector(struct spirv_compiler + component_count, (const uint64_t *)values); + } + ++static uint32_t spirv_compiler_get_constant_uint64_vector(struct spirv_compiler *compiler, ++ uint64_t value, unsigned int component_count) ++{ ++ const uint64_t values[] = {value, value}; ++ return spirv_compiler_get_constant64(compiler, VKD3D_SHADER_COMPONENT_UINT64, component_count, values); ++} ++ + static uint32_t spirv_compiler_get_type_id_for_reg(struct spirv_compiler *compiler, + const struct vkd3d_shader_register *reg, uint32_t write_mask) + { +@@ -3932,7 +3943,7 @@ static uint32_t spirv_compiler_emit_load_reg(struct spirv_compiler *compiler, + assert(reg_info.component_type != VKD3D_SHADER_COMPONENT_DOUBLE); + spirv_compiler_emit_dereference_register(compiler, reg, ®_info); + +- write_mask32 = (reg->data_type == VKD3D_DATA_DOUBLE) ? vsir_write_mask_32_from_64(write_mask) : write_mask; ++ write_mask32 = data_type_is_64_bit(reg->data_type) ? vsir_write_mask_32_from_64(write_mask) : write_mask; + + /* Intermediate value (no storage class). */ + if (reg_info.storage_class == SpvStorageClassMax) +@@ -4000,7 +4011,7 @@ static uint32_t spirv_compiler_emit_neg(struct spirv_compiler *compiler, + type_id = spirv_compiler_get_type_id_for_reg(compiler, reg, write_mask); + if (reg->data_type == VKD3D_DATA_FLOAT || reg->data_type == VKD3D_DATA_DOUBLE) + return vkd3d_spirv_build_op_fnegate(builder, type_id, val_id); +- else if (reg->data_type == VKD3D_DATA_INT || reg->data_type == VKD3D_DATA_UINT) ++ else if (data_type_is_integer(reg->data_type)) + return vkd3d_spirv_build_op_snegate(builder, type_id, val_id); + + FIXME("Unhandled data type %#x.\n", reg->data_type); +@@ -4148,7 +4159,7 @@ static void spirv_compiler_emit_store_reg(struct spirv_compiler *compiler, + component_type = vkd3d_component_type_from_data_type(reg->data_type); + if (component_type != reg_info.component_type) + { +- if (reg->data_type == VKD3D_DATA_DOUBLE) ++ if (data_type_is_64_bit(reg->data_type)) + src_write_mask = vsir_write_mask_32_from_64(write_mask); + type_id = vkd3d_spirv_get_type_id(builder, reg_info.component_type, + vsir_write_mask_component_count(src_write_mask)); +@@ -4287,14 +4298,18 @@ static void spirv_compiler_decorate_builtin(struct spirv_compiler *compiler, + } + + static void spirv_compiler_emit_interpolation_decorations(struct spirv_compiler *compiler, +- uint32_t id, enum vkd3d_shader_interpolation_mode mode) ++ enum vkd3d_shader_component_type component_type, uint32_t id, enum vkd3d_shader_interpolation_mode mode) + { + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + + switch (mode) + { + case VKD3DSIM_NONE: +- break; ++ /* VUID-StandaloneSpirv-Flat-04744: integer or double types must be ++ * decorated 'Flat' for fragment shaders. */ ++ if (compiler->shader_type != VKD3D_SHADER_TYPE_PIXEL || component_type == VKD3D_SHADER_COMPONENT_FLOAT) ++ break; ++ /* fall through */ + case VKD3DSIM_CONSTANT: + vkd3d_spirv_build_op_decorate(builder, id, SpvDecorationFlat, NULL, 0); + break; +@@ -4322,7 +4337,8 @@ static void spirv_compiler_emit_interpolation_decorations(struct spirv_compiler + } + + static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, +- enum vkd3d_shader_conditional_op condition, unsigned int component_count, uint32_t val_id) ++ enum vkd3d_shader_conditional_op condition, enum vkd3d_data_type data_type, ++ unsigned int component_count, uint32_t val_id) + { + struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; + uint32_t type_id; +@@ -4333,7 +4349,9 @@ static uint32_t spirv_compiler_emit_int_to_bool(struct spirv_compiler *compiler, + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_BOOL, component_count); + op = condition & VKD3D_SHADER_CONDITIONAL_OP_Z ? SpvOpIEqual : SpvOpINotEqual; + return vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, op, type_id, val_id, +- spirv_compiler_get_constant_uint_vector(compiler, 0, component_count)); ++ data_type == VKD3D_DATA_UINT64 ++ ? spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count) ++ : spirv_compiler_get_constant_uint_vector(compiler, 0, component_count)); + } + + static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, +@@ -4348,6 +4366,19 @@ static uint32_t spirv_compiler_emit_bool_to_int(struct spirv_compiler *compiler, + return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); + } + ++static uint32_t spirv_compiler_emit_bool_to_int64(struct spirv_compiler *compiler, ++ unsigned int component_count, uint32_t val_id, bool signedness) ++{ ++ struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; ++ uint32_t type_id, true_id, false_id; ++ ++ true_id = spirv_compiler_get_constant_uint64_vector(compiler, signedness ? UINT64_MAX : 1, ++ component_count); ++ false_id = spirv_compiler_get_constant_uint64_vector(compiler, 0, component_count); ++ type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_UINT64, component_count); ++ return vkd3d_spirv_build_op_select(builder, type_id, val_id, true_id, false_id); ++} ++ + static uint32_t spirv_compiler_emit_bool_to_float(struct spirv_compiler *compiler, + unsigned int component_count, uint32_t val_id, bool signedness) + { +@@ -4874,7 +4905,8 @@ static uint32_t spirv_compiler_emit_input(struct spirv_compiler *compiler, + if (component_idx) + vkd3d_spirv_build_op_decorate1(builder, input_id, SpvDecorationComponent, component_idx); + +- spirv_compiler_emit_interpolation_decorations(compiler, input_id, signature_element->interpolation_mode); ++ spirv_compiler_emit_interpolation_decorations(compiler, component_type, input_id, ++ signature_element->interpolation_mode); + } + + var_id = input_id; +@@ -6670,12 +6702,14 @@ static SpvOp spirv_compiler_map_alu_instruction(const struct vkd3d_shader_instru + {VKD3DSIH_ISHR, SpvOpShiftRightArithmetic}, + {VKD3DSIH_ITOD, SpvOpConvertSToF}, + {VKD3DSIH_ITOF, SpvOpConvertSToF}, ++ {VKD3DSIH_ITOI, SpvOpSConvert}, + {VKD3DSIH_MUL, SpvOpFMul}, + {VKD3DSIH_NOT, SpvOpNot}, + {VKD3DSIH_OR, SpvOpBitwiseOr}, + {VKD3DSIH_USHR, SpvOpShiftRightLogical}, + {VKD3DSIH_UTOD, SpvOpConvertUToF}, + {VKD3DSIH_UTOF, SpvOpConvertUToF}, ++ {VKD3DSIH_UTOU, SpvOpUConvert}, + {VKD3DSIH_XOR, SpvOpBitwiseXor}, + }; + unsigned int i; +@@ -6727,6 +6761,10 @@ static void spirv_compiler_emit_bool_cast(struct spirv_compiler *compiler, + { + val_id = spirv_compiler_emit_bool_to_int(compiler, 1, val_id, instruction->handler_idx == VKD3DSIH_ITOI); + } ++ else if (dst->reg.data_type == VKD3D_DATA_UINT64) ++ { ++ val_id = spirv_compiler_emit_bool_to_int64(compiler, 1, val_id, instruction->handler_idx == VKD3DSIH_ITOI); ++ } + else + { + WARN("Unhandled data type %u.\n", dst->reg.data_type); +@@ -6980,7 +7018,7 @@ static void spirv_compiler_emit_movc(struct spirv_compiler *compiler, + + if (src[0].reg.data_type != VKD3D_DATA_BOOL) + condition_id = spirv_compiler_emit_int_to_bool(compiler, +- VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); ++ VKD3D_SHADER_CONDITIONAL_OP_NZ, src[0].reg.data_type, component_count, condition_id); + val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src1_id, src2_id); + + spirv_compiler_emit_store_dst(compiler, dst, val_id); +@@ -7005,7 +7043,7 @@ static void spirv_compiler_emit_swapc(struct spirv_compiler *compiler, + type_id = vkd3d_spirv_get_type_id(builder, VKD3D_SHADER_COMPONENT_FLOAT, component_count); + + condition_id = spirv_compiler_emit_int_to_bool(compiler, +- VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, condition_id); ++ VKD3D_SHADER_CONDITIONAL_OP_NZ, src[0].reg.data_type, component_count, condition_id); + + val_id = vkd3d_spirv_build_op_select(builder, type_id, condition_id, src2_id, src1_id); + spirv_compiler_emit_store_dst(compiler, &dst[0], val_id); +@@ -7167,13 +7205,6 @@ static void spirv_compiler_emit_int_div(struct spirv_compiler *compiler, + div_op = instruction->handler_idx == VKD3DSIH_IDIV ? SpvOpSDiv : SpvOpUDiv; + mod_op = instruction->handler_idx == VKD3DSIH_IDIV ? SpvOpSRem : SpvOpUMod; + +- if (dst[0].reg.data_type == VKD3D_DATA_UINT64 || dst[1].reg.data_type == VKD3D_DATA_UINT64) +- { +- FIXME("Unsupported 64-bit result.\n"); +- spirv_compiler_error(compiler, VKD3D_SHADER_ERROR_SPV_UNSUPPORTED_FEATURE, +- "Bool cast to 64-bit integer is not supported."); +- } +- + if (dst[0].reg.type != VKD3DSPR_NULL) + { + component_count = vsir_write_mask_component_count(dst[0].write_mask); +@@ -7183,9 +7214,11 @@ static void spirv_compiler_emit_int_div(struct spirv_compiler *compiler, + src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst[0].write_mask); + + condition_id = spirv_compiler_emit_int_to_bool(compiler, +- VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, src1_id); +- uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, +- 0xffffffff, component_count); ++ VKD3D_SHADER_CONDITIONAL_OP_NZ, src[1].reg.data_type, component_count, src1_id); ++ if (dst[0].reg.data_type == VKD3D_DATA_UINT64) ++ uint_max_id = spirv_compiler_get_constant_uint64_vector(compiler, UINT64_MAX, component_count); ++ else ++ uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count); + + val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, div_op, type_id, src0_id, src1_id); + /* The SPIR-V spec says: "The resulting value is undefined if Operand 2 is 0." */ +@@ -7205,9 +7238,11 @@ static void spirv_compiler_emit_int_div(struct spirv_compiler *compiler, + src1_id = spirv_compiler_emit_load_src(compiler, &src[1], dst[1].write_mask); + + condition_id = spirv_compiler_emit_int_to_bool(compiler, +- VKD3D_SHADER_CONDITIONAL_OP_NZ, component_count, src1_id); +- uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, +- 0xffffffff, component_count); ++ VKD3D_SHADER_CONDITIONAL_OP_NZ, src[1].reg.data_type, component_count, src1_id); ++ if (dst[1].reg.data_type == VKD3D_DATA_UINT64) ++ uint_max_id = spirv_compiler_get_constant_uint64_vector(compiler, UINT64_MAX, component_count); ++ else ++ uint_max_id = spirv_compiler_get_constant_uint_vector(compiler, 0xffffffff, component_count); + } + + val_id = vkd3d_spirv_build_op_tr2(builder, &builder->function_stream, mod_op, type_id, src0_id, src1_id); +@@ -7498,7 +7533,7 @@ static uint32_t spirv_compiler_emit_conditional_branch(struct spirv_compiler *co + uint32_t condition_id, merge_block_id; + + condition_id = spirv_compiler_emit_load_src(compiler, src, VKD3DSP_WRITEMASK_0); +- condition_id = spirv_compiler_emit_int_to_bool(compiler, instruction->flags, 1, condition_id); ++ condition_id = spirv_compiler_emit_int_to_bool(compiler, instruction->flags, src->reg.data_type, 1, condition_id); + + merge_block_id = vkd3d_spirv_alloc_id(builder); + +@@ -7631,7 +7666,7 @@ static int spirv_compiler_emit_control_flow_instruction(struct spirv_compiler *c + return VKD3D_ERROR_OUT_OF_MEMORY; + + val_id = spirv_compiler_emit_load_src(compiler, src, VKD3DSP_WRITEMASK_0); +- condition_id = spirv_compiler_emit_int_to_bool(compiler, instruction->flags, 1, val_id); ++ condition_id = spirv_compiler_emit_int_to_bool(compiler, instruction->flags, src->reg.data_type, 1, val_id); + + true_label = vkd3d_spirv_alloc_id(builder); + merge_block_id = vkd3d_spirv_alloc_id(builder); +diff --git a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h +index 274faf296e8..ce7d74a72dc 100644 +--- a/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h ++++ b/libs/vkd3d/libs/vkd3d-shader/vkd3d_shader_private.h +@@ -620,6 +620,11 @@ static inline bool data_type_is_bool(enum vkd3d_data_type data_type) + return data_type == VKD3D_DATA_BOOL; + } + ++static inline bool data_type_is_64_bit(enum vkd3d_data_type data_type) ++{ ++ return data_type == VKD3D_DATA_DOUBLE || data_type == VKD3D_DATA_UINT64; ++} ++ + enum vsir_dimension + { + VSIR_DIMENSION_NONE, +@@ -1455,6 +1460,8 @@ static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_ty + return VKD3D_SHADER_COMPONENT_INT; + case VKD3D_DATA_DOUBLE: + return VKD3D_SHADER_COMPONENT_DOUBLE; ++ case VKD3D_DATA_UINT64: ++ return VKD3D_SHADER_COMPONENT_UINT64; + case VKD3D_DATA_BOOL: + return VKD3D_SHADER_COMPONENT_BOOL; + default: +diff --git a/libs/vkd3d/libs/vkd3d/state.c b/libs/vkd3d/libs/vkd3d/state.c +index 626d6d62b3c..1457ddf9c7f 100644 +--- a/libs/vkd3d/libs/vkd3d/state.c ++++ b/libs/vkd3d/libs/vkd3d/state.c +@@ -2129,6 +2129,16 @@ static inline unsigned int typed_uav_compile_option(const struct d3d12_device *d + : VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV_READ_FORMAT_R32; + } + ++static unsigned int feature_flags_compile_option(const struct d3d12_device *device) ++{ ++ unsigned int flags = 0; ++ ++ if (device->feature_options1.Int64ShaderOps) ++ flags |= VKD3D_SHADER_COMPILE_OPTION_FEATURE_INT64; ++ ++ return flags; ++} ++ + static HRESULT create_shader_stage(struct d3d12_device *device, + struct VkPipelineShaderStageCreateInfo *stage_desc, enum VkShaderStageFlagBits stage, + const D3D12_SHADER_BYTECODE *code, const struct vkd3d_shader_interface_info *shader_interface) +@@ -2145,6 +2155,7 @@ static HRESULT create_shader_stage(struct d3d12_device *device, + {VKD3D_SHADER_COMPILE_OPTION_API_VERSION, VKD3D_SHADER_API_VERSION_1_10}, + {VKD3D_SHADER_COMPILE_OPTION_TYPED_UAV, typed_uav_compile_option(device)}, + {VKD3D_SHADER_COMPILE_OPTION_WRITE_TESS_GEOM_POINT_SIZE, 0}, ++ {VKD3D_SHADER_COMPILE_OPTION_FEATURE, feature_flags_compile_option(device)}, + }; + + stage_desc->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; +-- +2.43.0 + diff --git a/staging/upstream-commit b/staging/upstream-commit index d2df6950..9259ab5e 100644 --- a/staging/upstream-commit +++ b/staging/upstream-commit @@ -1 +1 @@ -bba97115d1a0991e4a95e8b209cb502dd434042a +a2f98478c36908fd7a368cc633b6064aca053ab6