spirv: fix image sample lod/clamp/offset translation (#402)

* spirv: fix image sample lod/clamp translation

* spirv: fix image sample offsets

* fix ImageSample opcodes & offset emission

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -21,14 +21,19 @@ struct ImageOperands {
     boost::container::static_vector<Id, 4> operands;
 };
 
-Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id bias_lc,
+Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id bias,
                               Id offset) {
     const auto& texture = ctx.images[handle & 0xFFFF];
     const Id image = ctx.OpLoad(texture.image_type, texture.id);
     const Id sampler = ctx.OpLoad(ctx.sampler_type, ctx.samplers[handle >> 16]);
     const Id sampled_image = ctx.OpSampledImage(texture.sampled_type, image, sampler);
     ImageOperands operands;
-    operands.Add(spv::ImageOperandsMask::Offset, offset);
+    if (Sirit::ValidId(bias)) {
+        operands.Add(spv::ImageOperandsMask::Bias, bias);
+    }
+    if (Sirit::ValidId(offset)) {
+        operands.Add(spv::ImageOperandsMask::Offset, offset);
+    }
     return ctx.OpImageSampleImplicitLod(ctx.F32[4], sampled_image, coords, operands.mask,
                                         operands.operands);
 }
@@ -39,27 +44,49 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id c
     const Id image = ctx.OpLoad(texture.image_type, texture.id);
     const Id sampler = ctx.OpLoad(ctx.sampler_type, ctx.samplers[handle >> 16]);
     const Id sampled_image = ctx.OpSampledImage(texture.sampled_type, image, sampler);
-    return ctx.OpImageSampleExplicitLod(ctx.F32[4], sampled_image, coords,
+    ImageOperands operands;
-                                        spv::ImageOperandsMask::Lod, lod);
+    if (Sirit::ValidId(lod)) {
+        operands.Add(spv::ImageOperandsMask::Lod, lod);
+    }
+    if (Sirit::ValidId(offset)) {
+        operands.Add(spv::ImageOperandsMask::Offset, offset);
+    }
+    return ctx.OpImageSampleExplicitLod(ctx.F32[4], sampled_image, coords, operands.mask,
+                                        operands.operands);
 }
 
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id dref,
-                                  Id bias_lc, const IR::Value& offset) {
+                                  Id bias, Id offset) {
     const auto& texture = ctx.images[handle & 0xFFFF];
     const Id image = ctx.OpLoad(texture.image_type, texture.id);
     const Id sampler = ctx.OpLoad(ctx.sampler_type, ctx.samplers[handle >> 16]);
     const Id sampled_image = ctx.OpSampledImage(texture.sampled_type, image, sampler);
-    return ctx.OpImageSampleDrefImplicitLod(ctx.F32[1], sampled_image, coords, dref);
+    ImageOperands operands;
+    if (Sirit::ValidId(bias)) {
+        operands.Add(spv::ImageOperandsMask::Bias, bias);
+    }
+    if (Sirit::ValidId(offset)) {
+        operands.Add(spv::ImageOperandsMask::Offset, offset);
+    }
+    return ctx.OpImageSampleDrefImplicitLod(ctx.F32[1], sampled_image, coords, dref, operands.mask,
+                                            operands.operands);
 }
 
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id dref,
-                                  Id bias_lc, Id offset) {
+                                  Id lod, Id offset) {
     const auto& texture = ctx.images[handle & 0xFFFF];
     const Id image = ctx.OpLoad(texture.image_type, texture.id);
     const Id sampler = ctx.OpLoad(ctx.sampler_type, ctx.samplers[handle >> 16]);
     const Id sampled_image = ctx.OpSampledImage(texture.sampled_type, image, sampler);
-    return ctx.OpImageSampleDrefExplicitLod(ctx.F32[1], sampled_image, coords, dref,
+    ImageOperands operands;
-                                            spv::ImageOperandsMask::Lod, ctx.ConstF32(0.f));
+    if (Sirit::ValidId(lod)) {
+        operands.Add(spv::ImageOperandsMask::Lod, lod);
+    }
+    if (Sirit::ValidId(offset)) {
+        operands.Add(spv::ImageOperandsMask::Offset, offset);
+    }
+    return ctx.OpImageSampleDrefExplicitLod(ctx.F32[1], sampled_image, coords, dref, operands.mask,
+                                            operands.operands);
 }
 
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id offset, Id offset2) {

src/shader_recompiler/backend/spirv/emit_spirv_instructions.h

@@ -357,14 +357,14 @@ Id EmitConvertF64U64(EmitContext& ctx, Id value);
 Id EmitConvertU16U32(EmitContext& ctx, Id value);
 Id EmitConvertU32U16(EmitContext& ctx, Id value);
 
-Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id bias_lc,
+Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id bias,
                               Id offset);
 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id lod,
                               Id offset);
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id dref,
-                                  Id bias_lc, const IR::Value& offset);
+                                  Id bias, Id offset);
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id dref,
-                                  Id bias_lc, Id offset);
+                                  Id lod, Id offset);
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id offset, Id offset2);
 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, u32 handle, Id coords, Id offset,
                        Id offset2, Id dref);

src/shader_recompiler/frontend/translate/vector_memory.cpp

@@ -135,8 +135,8 @@ void Translator::IMAGE_SAMPLE(const GcnInst& inst) {
 
     // Load first address components as denoted in 8.2.4 VGPR Usage Sea Islands Series Instruction
     // Set Architecture
-    const IR::Value offset =
+    const IR::U32 offset =
-        flags.test(MimgModifier::Offset) ? ir.GetVectorReg(addr_reg++) : IR::Value{};
+        flags.test(MimgModifier::Offset) ? ir.GetVectorReg<IR::U32>(addr_reg++) : IR::U32{};
     const IR::F32 bias =
         flags.test(MimgModifier::LodBias) ? ir.GetVectorReg<IR::F32>(addr_reg++) : IR::F32{};
     const IR::F32 dref =
@@ -168,18 +168,17 @@ void Translator::IMAGE_SAMPLE(const GcnInst& inst) {
 
     // Issue IR instruction, leaving unknown fields blank to patch later.
     const IR::Value texel = [&]() -> IR::Value {
-        const IR::F32 lod = flags.test(MimgModifier::Level0) ? ir.Imm32(0.f) : IR::F32{};
         if (!flags.test(MimgModifier::Pcf)) {
             if (explicit_lod) {
-                return ir.ImageSampleExplicitLod(handle, body, lod, offset, info);
+                return ir.ImageSampleExplicitLod(handle, body, offset, info);
             } else {
-                return ir.ImageSampleImplicitLod(handle, body, bias, offset, {}, info);
+                return ir.ImageSampleImplicitLod(handle, body, bias, offset, info);
             }
         }
         if (explicit_lod) {
-            return ir.ImageSampleDrefExplicitLod(handle, body, dref, lod, offset, info);
+            return ir.ImageSampleDrefExplicitLod(handle, body, dref, offset, info);
         }
-        return ir.ImageSampleDrefImplicitLod(handle, body, dref, bias, offset, {}, info);
+        return ir.ImageSampleDrefImplicitLod(handle, body, dref, bias, offset, info);
     }();
 
     for (u32 i = 0; i < 4; i++) {

src/shader_recompiler/ir/ir_emitter.cpp

@@ -16,18 +16,6 @@ namespace {
     UNREACHABLE_MSG("Invalid type = {}, functionName = {}, line = {}", u32(type), functionName,
                     lineNumber);
 }
-
-Value MakeLodClampPair(IREmitter& ir, const F32& bias_lod, const F32& lod_clamp) {
-    if (!bias_lod.IsEmpty() && !lod_clamp.IsEmpty()) {
-        return ir.CompositeConstruct(bias_lod, lod_clamp);
-    } else if (!bias_lod.IsEmpty()) {
-        return bias_lod;
-    } else if (!lod_clamp.IsEmpty()) {
-        return lod_clamp;
-    } else {
-        return Value{};
-    }
-}
 } // Anonymous namespace
 
 U1 IREmitter::Imm1(bool value) const {
@@ -1386,30 +1374,26 @@ Value IREmitter::ImageAtomicExchange(const Value& handle, const Value& coords, c
     return Inst(Opcode::ImageAtomicExchange32, Flags{info}, handle, coords, value);
 }
 
-Value IREmitter::ImageSampleImplicitLod(const Value& handle, const Value& coords, const F32& bias,
+Value IREmitter::ImageSampleImplicitLod(const Value& handle, const Value& body, const F32& bias,
-                                        const Value& offset, const F32& lod_clamp,
+                                        const U32& offset, TextureInstInfo info) {
+    return Inst(Opcode::ImageSampleImplicitLod, Flags{info}, handle, body, bias, offset);
+}
+
+Value IREmitter::ImageSampleExplicitLod(const Value& handle, const Value& body, const U32& offset,
                                         TextureInstInfo info) {
-    const Value bias_lc{MakeLodClampPair(*this, bias, lod_clamp)};
+    return Inst(Opcode::ImageSampleExplicitLod, Flags{info}, handle, body, IR::F32{}, offset);
-    return Inst(Opcode::ImageSampleImplicitLod, Flags{info}, handle, coords, bias_lc, offset);
 }
 
-Value IREmitter::ImageSampleExplicitLod(const Value& handle, const Value& coords, const F32& lod,
+F32 IREmitter::ImageSampleDrefImplicitLod(const Value& handle, const Value& body, const F32& dref,
-                                        const Value& offset, TextureInstInfo info) {
+                                          const F32& bias, const U32& offset,
-    return Inst(Opcode::ImageSampleExplicitLod, Flags{info}, handle, coords, lod, offset);
+                                          TextureInstInfo info) {
-}
+    return Inst<F32>(Opcode::ImageSampleDrefImplicitLod, Flags{info}, handle, body, dref, bias,
-
-F32 IREmitter::ImageSampleDrefImplicitLod(const Value& handle, const Value& coords, const F32& dref,
-                                          const F32& bias, const Value& offset,
-                                          const F32& lod_clamp, TextureInstInfo info) {
-    const Value bias_lc{MakeLodClampPair(*this, bias, lod_clamp)};
-    return Inst<F32>(Opcode::ImageSampleDrefImplicitLod, Flags{info}, handle, coords, dref, bias_lc,
                      offset);
 }
 
-F32 IREmitter::ImageSampleDrefExplicitLod(const Value& handle, const Value& coords, const F32& dref,
+F32 IREmitter::ImageSampleDrefExplicitLod(const Value& handle, const Value& body, const F32& dref,
-                                          const F32& lod, const Value& offset,
+                                          const U32& offset, TextureInstInfo info) {
-                                          TextureInstInfo info) {
+    return Inst<F32>(Opcode::ImageSampleDrefExplicitLod, Flags{info}, handle, body, dref, IR::F32{},
-    return Inst<F32>(Opcode::ImageSampleDrefExplicitLod, Flags{info}, handle, coords, dref, lod,
                      offset);
 }
 

src/shader_recompiler/ir/ir_emitter.h

@@ -241,19 +241,21 @@ public:
     [[nodiscard]] Value ImageAtomicExchange(const Value& handle, const Value& coords,
                                             const Value& value, TextureInstInfo info);
 
-    [[nodiscard]] Value ImageSampleImplicitLod(const Value& handle, const Value& coords,
+    [[nodiscard]] Value ImageSampleImplicitLod(const Value& handle, const Value& body,
-                                               const F32& bias, const Value& offset,
+                                               const F32& bias, const U32& offset,
-                                               const F32& lod_clamp, TextureInstInfo info);
-    [[nodiscard]] Value ImageSampleExplicitLod(const Value& handle, const Value& coords,
-                                               const F32& lod, const Value& offset,
                                                TextureInstInfo info);
-    [[nodiscard]] F32 ImageSampleDrefImplicitLod(const Value& handle, const Value& coords,
+
+    [[nodiscard]] Value ImageSampleExplicitLod(const Value& handle, const Value& body,
+                                               const U32& offset, TextureInstInfo info);
+
+    [[nodiscard]] F32 ImageSampleDrefImplicitLod(const Value& handle, const Value& body,
                                                  const F32& dref, const F32& bias,
-                                                 const Value& offset, const F32& lod_clamp,
+                                                 const U32& offset, TextureInstInfo info);
+
+    [[nodiscard]] F32 ImageSampleDrefExplicitLod(const Value& handle, const Value& body,
+                                                 const F32& dref, const U32& offset,
                                                  TextureInstInfo info);
-    [[nodiscard]] F32 ImageSampleDrefExplicitLod(const Value& handle, const Value& coords,
+
-                                                 const F32& dref, const F32& lod,
-                                                 const Value& offset, TextureInstInfo info);
     [[nodiscard]] Value ImageQueryDimension(const Value& handle, const IR::U32& lod,
                                             const IR::U1& skip_mips);
     [[nodiscard]] Value ImageQueryDimension(const Value& handle, const IR::U32& lod,

src/shader_recompiler/ir/opcodes.inc

@@ -298,10 +298,10 @@ OPCODE(ConvertU16U32,                                       U16,            U32,
 OPCODE(ConvertU32U16,                                       U32,            U16,                                                                            )
 
 // Image operations
-OPCODE(ImageSampleImplicitLod,                              F32x4,          Opaque,         Opaque,         Opaque,         Opaque,                         )
+OPCODE(ImageSampleImplicitLod,                              F32x4,          Opaque,         Opaque,         F32,            U32,                            )
-OPCODE(ImageSampleExplicitLod,                              F32x4,          Opaque,         Opaque,         Opaque,         Opaque,                         )
+OPCODE(ImageSampleExplicitLod,                              F32x4,          Opaque,         Opaque,         U32,            U32,                            )
-OPCODE(ImageSampleDrefImplicitLod,                          F32,            Opaque,         Opaque,         F32,            Opaque,         Opaque,         )
+OPCODE(ImageSampleDrefImplicitLod,                          F32,            Opaque,         Opaque,         Opaque,         F32,            U32,            )
-OPCODE(ImageSampleDrefExplicitLod,                          F32,            Opaque,         Opaque,         F32,            Opaque,         Opaque,         )
+OPCODE(ImageSampleDrefExplicitLod,                          F32,            Opaque,         Opaque,         Opaque,         U32,            U32,            )
 OPCODE(ImageGather,                                         F32x4,          Opaque,         Opaque,         Opaque,         Opaque,                         )
 OPCODE(ImageGatherDref,                                     F32x4,          Opaque,         Opaque,         Opaque,         Opaque,         F32,            )
 OPCODE(ImageFetch,                                          F32x4,          Opaque,         Opaque,         Opaque,         U32,            Opaque,         )

src/shader_recompiler/ir/passes/resource_tracking_pass.cpp

@@ -567,25 +567,47 @@ void PatchImageInstruction(IR::Block& block, IR::Inst& inst, Info& info, Descrip
 
     if (inst_info.has_offset) {
         // The offsets are six-bit signed integers: X=[5:0], Y=[13:8], and Z=[21:16].
-        const bool is_gather = inst.GetOpcode() == IR::Opcode::ImageGather ||
+        const u32 arg_pos = [&]() -> u32 {
-                               inst.GetOpcode() == IR::Opcode::ImageGatherDref;
+            switch (inst.GetOpcode()) {
-        const u32 arg_pos = is_gather ? 2 : (inst_info.is_depth ? 4 : 3);
+            case IR::Opcode::ImageGather:
+            case IR::Opcode::ImageGatherDref:
+                return 2;
+            case IR::Opcode::ImageSampleExplicitLod:
+            case IR::Opcode::ImageSampleImplicitLod:
+                return 3;
+            case IR::Opcode::ImageSampleDrefExplicitLod:
+            case IR::Opcode::ImageSampleDrefImplicitLod:
+                return 4;
+            default:
+                break;
+            }
+            return inst_info.is_depth ? 4 : 3;
+        }();
         const IR::Value arg = inst.Arg(arg_pos);
         ASSERT_MSG(arg.Type() == IR::Type::U32, "Unexpected offset type");
-        const auto sign_ext = [&](u32 value) { return ir.Imm32(s32(value << 24) >> 24); };
+        const auto f = [&](IR::Value value, u32 offset) -> auto {
-        union {
+            return ir.BitFieldExtract(IR::U32{arg}, ir.Imm32(offset), ir.Imm32(6), true);
-            u32 raw;
+        };
-            BitField<0, 6, u32> x;
+
-            BitField<8, 6, u32> y;
+        const auto x = f(arg, 0);
-            BitField<16, 6, u32> z;
+        const auto y = f(arg, 8);
-        } offset{arg.U32()};
+        const auto z = f(arg, 16);
-        const IR::Value value = ir.CompositeConstruct(sign_ext(offset.x), sign_ext(offset.y));
+        const IR::Value value = ir.CompositeConstruct(x, y, z);
         inst.SetArg(arg_pos, value);
     }
 
     if (inst_info.has_lod_clamp) {
-        // Final argument contains lod_clamp
+        const u32 arg_pos = [&]() -> u32 {
-        const u32 arg_pos = inst_info.is_depth ? 5 : 4;
+            switch (inst.GetOpcode()) {
+            case IR::Opcode::ImageSampleImplicitLod:
+                return 2;
+            case IR::Opcode::ImageSampleDrefImplicitLod:
+                return 3;
+            default:
+                break;
+            }
+            return inst_info.is_depth ? 5 : 4;
+        }();
         inst.SetArg(arg_pos, arg);
     }
     if (inst_info.explicit_lod) {
@@ -593,7 +615,8 @@ void PatchImageInstruction(IR::Block& block, IR::Inst& inst, Info& info, Descrip
                inst.GetOpcode() == IR::Opcode::ImageSampleExplicitLod ||
                inst.GetOpcode() == IR::Opcode::ImageSampleDrefExplicitLod);
         const u32 pos = inst.GetOpcode() == IR::Opcode::ImageSampleExplicitLod ? 2 : 3;
-        inst.SetArg(pos, arg);
+        const IR::Value value = inst_info.force_level0 ? ir.Imm32(0.f) : arg;
+        inst.SetArg(pos, value);
     }
 }