perf(shader): specialize direct image modes in registration modules

core/libs/prx/libSceAgcDriver/tests/execution/ImagePlaneBiasOnSingleLevelVolume.cpp

@@ -24,6 +24,7 @@ constexpr std::uint32_t Height = 16;
 constexpr std::uint32_t Size = 16;
 constexpr std::uint32_t Mips = 1;
 constexpr std::uint32_t Format8888UNorm = 56;
+constexpr std::uint32_t Type2D = 9;
 constexpr std::uint32_t Type3D = 10;
 constexpr float SecondCoordinateScale = 1.0f / static_cast<float>(Size);
 alignas(256) std::array<std::byte, Width * Height * 4> Pixels{};
@@ -79,7 +80,7 @@ void FillTexture() {
     }
 }
 
-void Draw(AgcDriver::VulkanDevice& device, std::array<std::uint32_t, 8> texture, std::array<std::uint32_t, 4> sampler, float bias, bool mixedSamplers = false) {
+std::uint64_t Draw(AgcDriver::VulkanDevice& device, std::array<std::uint32_t, 8> texture, std::array<std::uint32_t, 4> sampler, float bias, bool mixedSamplers = false) {
     const auto& target = device.Target();
     alignas(256) std::array<std::uint32_t, 13> code{};
     std::copy_n(BiasPixelCode.begin(), 3u, code.begin());
@@ -134,8 +135,8 @@ void Draw(AgcDriver::VulkanDevice& device, std::array<std::uint32_t, 8> texture,
         target,
         PixelPushLayout(vertexPush, target)
     };
-    fragment.useCache = false;
     const auto pixelResult = ShaderRecompiler::Recompile(fragment);
+    Require(!target.registrationModules || pixelResult.registrationModule, "single-level volume bias did not exercise its requested registration module");
     const std::array<AgcDriver::Graphics::CompiledShader, 2> shaders{{
         {ShaderStage::Vertex, &vertexResult, 0},
         {ShaderStage::Fragment, &pixelResult, PixelPushOffset(vertexPush, target)}
@@ -159,6 +160,7 @@ void Draw(AgcDriver::VulkanDevice& device, std::array<std::uint32_t, 8> texture,
     const AgcDriver::Pm4::DrawParameters draw{0, static_cast<std::uint32_t>(Triangle.size()), 0, 1, 0, false};
     device.Draw(state, draw, shaders);
     device.WaitIdle();
+    return pixelResult.variantId;
 }
 
 void Check(bool degamma = false) {
@@ -197,8 +199,9 @@ int main() {
         const auto device = OpenVulkanTestDevice();
         if (!device) return VulkanTestSkipped;
         FillTexture();
+        std::uint64_t ordinaryArtifact = 0u;
         for (const float bias : {-16.0f, -0.5f, 0.0f, 0.5f, 16.0f}) {
-            Draw(*device, VolumeDescriptor(), SamplerDescriptor(), bias);
+            ordinaryArtifact = Draw(*device, VolumeDescriptor(), SamplerDescriptor(), bias);
             Check();
         }
         for (const std::uint32_t reduction : {1u, 2u}) {
@@ -207,14 +210,20 @@ int main() {
             Draw(*device, VolumeDescriptor(), sampler, 8.0f);
             Check();
         }
+        auto plane = VolumeDescriptor();
+        plane[3] = (plane[3] & ~(0xfu << 28u)) | (Type2D << 28u);
+        Require(Draw(*device, plane, SamplerDescriptor(), 0.0f) == ordinaryArtifact, "single-level volume and plane modes did not share their cached artifact");
+        Check();
         auto integerTexture = VolumeDescriptor();
         integerTexture[1] = (integerTexture[1] & ~(0x1ffu << 20u)) | (60u << 20u);
         auto forcedSampler = SamplerDescriptor();
         forcedSampler[0] |= 1u << 20u;
         for (const float bias : {-16.0f, 0.0f, 16.0f}) {
-            Draw(*device, integerTexture, forcedSampler, bias);
+            Require(Draw(*device, integerTexture, forcedSampler, bias) == ordinaryArtifact, "single-level volume numeric modes did not share their cached artifact");
             Check(true);
         }
+        Require(Draw(*device, VolumeDescriptor(), SamplerDescriptor(), 0.0f) == ordinaryArtifact, "single-level volume did not reuse its original artifact after a numeric mode change");
+        Check();
         std::string mixedRefusal;
         try {
             Draw(*device, integerTexture, forcedSampler, 0.0f, true);

core/shader/recompiler/Optimization/src/DescriptorBindingBuilder.cpp

@@ -325,7 +325,10 @@ DescriptorBindingPlan DescriptorBindingBuilder::Prepare(const IrBindingLayout& l
     }
     std::vector<std::uint32_t> imageModes(info.images.size());
     for (std::size_t index = 0; index < info.images.size(); ++index) {
-        if (info.images[index].table == NoTable) imageModes[index] = ResourceMaterializer::RuntimeImageMode(info.images[index], snapshot.images.at(index), info.runtimeImageModes.at(index));
+        if (info.images[index].table != NoTable) continue;
+        const auto& modes = info.runtimeImageModes.at(index);
+        imageModes[index] = ResourceMaterializer::RuntimeImageMode(info.images[index], snapshot.images.at(index), modes);
+        if (registrationModules && modes.size() > 1u) plan.specialization.push_back({PipelineSpecialization::ImageBase + static_cast<std::uint32_t>(index) * PipelineSpecialization::ImageWords, imageModes[index]});
     }
     for (std::uint32_t index = 0; index < info.buffers.size(); ++index) {
         const auto& descriptor = snapshot.buffers.at(index);

core/shader/recompiler/SpirvBackend/src/SpirvImageEmitter.cpp

@@ -40,11 +40,6 @@ struct SampleSetup {
     std::uint32_t coord;
 };
 
-std::uint32_t RuntimeImageMode(SpirvEmitterState& state, std::uint32_t resource) {
-    const auto mode = Binary(state, spv::OpShiftRightLogical, TypeU32(state), RuntimeImageDword(state, resource, offsetof(RuntimeAbi::ResourceMetadata, flags) / sizeof(std::uint32_t)), ConstantU32(state, 1u));
-    return state.registrationModules ? Binary(state, spv::OpBitwiseAnd, TypeU32(state), mode, ConstantU32(state, RuntimeAbi::ImageModeMask)) : mode;
-}
-
 std::uint32_t RuntimeImageSwizzle(SpirvEmitterState& state, std::uint32_t resource, std::uint32_t component) {
     const bool table = state.program.Info().images.at(resource).table != NoTable;
     if (!table && !state.registrationModules) return state.module.SpecializationConstant(TypeU32(state), PipelineSpecialization::ImageBase + resource * PipelineSpecialization::ImageWords + 1u + component, component + 4u);
@@ -2012,7 +2007,7 @@ void EmitImage(SpirvValueEmitContext& ctx, const IrValue& inst) {
         state.runtimeImage = nullptr;
         return;
     }
-    const auto selector = tables ? tableSelector : !state.registrationModules ? state.module.SpecializationConstant(TypeU32(state), PipelineSpecialization::ImageBase + memory.resource * PipelineSpecialization::ImageWords, 0u) : RuntimeImageMode(state, memory.resource);
+    const auto selector = tables ? tableSelector : state.module.SpecializationConstant(TypeU32(state), PipelineSpecialization::ImageBase + memory.resource * PipelineSpecialization::ImageWords, 0u);
     const bool returnsValue = inst.Opcode() != IrOpcode::ImageWrite;
     const auto guardedId = returnsValue ? ctx.Result(inst) : 0u;
     ctx.definitions.erase(&inst);