fix(agc): preserve CPU writes after resident linear target draws

core/libs/prx/libSceAgcDriver/CMakeLists.txt

@@ -76,6 +76,17 @@ add_custom_command(
         DEPENDS "${agcTextureDetileShaderSource}" glslang-standalone
         VERBATIM
 )
+set(agcTextureDetileChangedShaderSpv ${agcTextureDetileGeneratedDir}/TextureDetileChanged.spv)
+set(agcTextureDetileChangedShaderHeader ${agcTextureDetileGeneratedDir}/TextureDetileChanged_spv.h)
+add_custom_command(
+        OUTPUT "${agcTextureDetileChangedShaderHeader}"
+        COMMAND ${CMAKE_COMMAND} -E make_directory "${agcTextureDetileGeneratedDir}"
+        COMMAND "$<TARGET_FILE:glslang-standalone>" -V --target-env vulkan1.1 -DBYTE_OUTPUT=1 -o "${agcTextureDetileChangedShaderSpv}" "${agcTextureDetileShaderSource}"
+        COMMAND ${CMAKE_COMMAND} -DINPUT=${agcTextureDetileChangedShaderSpv} -DOUTPUT=${agcTextureDetileChangedShaderHeader}
+        -DSYMBOL=TEXTURE_DETILE_CHANGED_SPV -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
+        DEPENDS "${agcTextureDetileShaderSource}" glslang-standalone
+        VERBATIM
+)
 set(agcTextureDetileImageShaderSpv ${agcTextureDetileGeneratedDir}/TextureDetileImage.spv)
 set(agcTextureDetileImageShaderHeader ${agcTextureDetileGeneratedDir}/TextureDetileImage_spv.h)
 add_custom_command(
@@ -466,6 +477,7 @@ set(agcDriverSources
         ${CMAKE_CURRENT_SOURCE_DIR}/Graphics/src/Sampler.cpp
         ${agcSampleOrderShaderHeaders}
         ${agcTextureDetileShaderHeader}
+        ${agcTextureDetileChangedShaderHeader}
         ${agcReadbackHeaders}
         ${agcMultisampleUploadHeader}
         ${agcCmaskClearShaderHeader}

core/libs/prx/libSceAgcDriver/Graphics/include/Texture.hpp

@@ -27,6 +27,7 @@
 namespace AgcDriver::Graphics {
 
 class Buffer;
+class DeviceBuffer;
 class ResidentColor;
 class CommandBatch;
 class StorageTexture;
@@ -290,6 +291,8 @@ class StorageTexture : public std::enable_shared_from_this<StorageTexture> {
     VkImageView AttachmentProxyView();
     void RecordAttachmentProxyLoad(VkCommandBuffer commands, VkImageLayout attachmentLayout) const;
     void RecordAttachmentProxyStore(VkCommandBuffer commands, VkImageLayout attachmentLayout) const;
+    void PrepareLinearDraw();
+    void FinishLinearDraw();
     void WriteBack();
     // Deferred write-back (APS5_EAGER_WRITEBACK=1 stores at once instead).
     void MarkDirty();
@@ -841,6 +844,7 @@ class StorageTexture : public std::enable_shared_from_this<StorageTexture> {
     std::vector<bool> layerOriginal;
     std::map<std::uint64_t, std::uint64_t> keptAtUnwatch;
     std::shared_ptr<Buffer> savedBytes;
+    std::shared_ptr<DeviceBuffer> linearDrawOriginal;
     std::vector<std::uint64_t> savedTicket;
     std::uint64_t lastSaveTicket = 0;
     // The storage cache let the image go (Flush): a lookup makes a new image of the surface, so

core/libs/prx/libSceAgcDriver/Graphics/include/TextureDetiler.hpp

@@ -47,7 +47,7 @@ namespace AgcDriver::Graphics {
         // into tiled `destination`; offsets always refer to the respective buffers, and `window`
         // restricts the move to part of the mip (a partial upload or write-back, StorageTexture),
         // leaving the other elements of both buffers alone.
-        void Dispatch(VkCommandBuffer commands, TextureTileMode tileMode, std::uint32_t elementBytes, VkBuffer source, std::uint64_t sourceOffset, VkBuffer destination, std::uint64_t destinationOffset, const TileMipLayout& layout, bool retile = false, std::uint32_t slice = 0, bool thick = false, const DetileWindow& window = {});
+        void Dispatch(VkCommandBuffer commands, TextureTileMode tileMode, std::uint32_t elementBytes, VkBuffer source, std::uint64_t sourceOffset, VkBuffer destination, std::uint64_t destinationOffset, const TileMipLayout& layout, bool retile = false, std::uint32_t slice = 0, bool thick = false, const DetileWindow& window = {}, std::uint64_t originalOffset = 0);
         void DispatchImage(VkCommandBuffer commands, TextureTileMode tileMode, std::uint32_t elementBytes, VkBuffer tiled, std::uint64_t tiledOffset, VkImageView view, const TileMipLayout& layout, bool retile = false, std::uint32_t slice = 0, const DetileWindow& window = {});
         void DispatchRepack(VkCommandBuffer commands, VkBuffer source, std::uint64_t sourceOffset, VkBuffer destination, std::uint64_t destinationOffset, std::uint64_t bytes);
         static VkFormat ImageElementFormat(std::uint32_t elementBytes);
@@ -61,7 +61,7 @@ namespace AgcDriver::Graphics {
     private:
         VkPipeline multisampleReadbackPipeline(std::uint32_t elementBytes, bool depth);
         VkPipeline multisampleUploadPipeline(std::uint32_t elementBytes);
-        VkPipeline pipeline(TextureTileMode tileMode, std::uint32_t elementBytes, bool retile, bool thick, bool image = false);
+        VkPipeline pipeline(TextureTileMode tileMode, std::uint32_t elementBytes, bool retile, bool thick, bool image = false, bool changedOnly = false);
         void release() noexcept;
         struct DescriptorRing {
             std::vector<VkDescriptorPool> pools;
@@ -78,6 +78,7 @@ namespace AgcDriver::Graphics {
         VkDescriptorSetLayout descriptorLayout = VK_NULL_HANDLE;
         VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
         VkShaderModule module = VK_NULL_HANDLE;
+        VkShaderModule changedModule = VK_NULL_HANDLE;
         std::vector<std::pair<std::uint32_t, VkPipeline>> pipelines;
         std::vector<std::pair<std::uint32_t, GcnTileGeometry>> gcnGeometries;
         std::uint32_t layerBankXor(TextureTileMode tileMode, std::uint32_t elementBytes, const TileMipLayout& layout, std::uint32_t layer);

core/libs/prx/libSceAgcDriver/Graphics/shaders/TextureDetile.comp

@@ -1,4 +1,7 @@
 #version 450
+#ifdef BYTE_OUTPUT
+#extension GL_EXT_shader_8bit_storage : require
+#endif
 #ifdef LINEAR_IMAGE
 #extension GL_EXT_shader_image_load_formatted : require
 #endif
@@ -33,6 +36,7 @@ layout(constant_id = 22) const uint SPLIT0 = 0u;
 layout(constant_id = 23) const uint SPLIT1 = 0u;
 layout(constant_id = 24) const uint SPLIT2 = 0u;
 layout(constant_id = 25) const uint SPLIT3 = 0u;
+layout(constant_id = 26) const uint CHANGED_ONLY = 0u;
 
 layout(local_size_x = 8, local_size_y = 8) in;
 
@@ -41,8 +45,13 @@ layout(set = 0, binding = 0, std430) buffer Tiled { uint data[]; } tiledBuffer;
 layout(set = 0, binding = 1) uniform uimage2D linearImage;
 #else
 layout(set = 0, binding = 0, std430) readonly buffer Input { uint data[]; } inputBuffer;
+#ifdef BYTE_OUTPUT
+layout(set = 0, binding = 1, std430) writeonly buffer Output { uint8_t data[]; } outputBuffer;
+#else
 layout(set = 0, binding = 1, std430) buffer Output { uint data[]; } outputBuffer;
 #endif
+layout(set = 0, binding = 2, std430) readonly buffer Original { uint data[]; } originalBuffer;
+#endif
 
 layout(push_constant) uniform Push {
     uint srcBase;
@@ -69,6 +78,7 @@ layout(push_constant) uniform Push {
     uint rowBegin;
     uint pipeBankXor;
     uint splitStride;
+    uint originalBase;
 } params;
 
 uint equationBit(uint mask, uvec2 p) {
@@ -193,6 +203,16 @@ void loadElement(uvec2 p, uint dst) {
 }
 #else
 void copyElement(uint src, uint dst) {
+#ifdef BYTE_OUTPUT
+    const uint original = params.originalBase + src - params.srcBase;
+    for (uint offset = 0u; offset < ELEMENT_BYTES; ++offset) {
+        const uint currentAddress = src + offset;
+        const uint originalAddress = original + offset;
+        const uint current = (inputBuffer.data[currentAddress >> 2] >> ((currentAddress & 3u) * 8u)) & 0xffu;
+        const uint before = (originalBuffer.data[originalAddress >> 2] >> ((originalAddress & 3u) * 8u)) & 0xffu;
+        if (current != before) outputBuffer.data[dst + offset] = uint8_t(current);
+    }
+#else
     if (ELEMENT_BYTES >= 4u) {
         for (uint i = 0u; i < ELEMENT_BYTES; i += 4u) {
             outputBuffer.data[(dst + i) >> 2] = inputBuffer.data[(src + i) >> 2];
@@ -204,6 +224,7 @@ void copyElement(uint src, uint dst) {
         atomicAnd(outputBuffer.data[dst >> 2], ~(mask << shift));
         atomicOr(outputBuffer.data[dst >> 2], value << shift);
     }
+#endif
 }
 #endif
 

core/libs/prx/libSceAgcDriver/Graphics/src/Draw.cpp

@@ -2403,7 +2403,7 @@ void keepRecordedDraw(Recorder& recorder, const std::shared_ptr<ShaderResources>
         else residents[index]->MarkDirty();
     }
     for (std::size_t index = 0; index < residents.size(); ++index) {
-        if (storeNow[index]) StorageTexture::FlushPending(residents[index]->Descriptor().baseAddress, static_cast<std::size_t>(residents[index]->GuestBytes()), nullptr, "linear target");
+        if (storeNow[index]) residents[index]->FinishLinearDraw();
     }
 }
 
@@ -2706,6 +2706,9 @@ void recordDraw(const Context& context, const State& state, const Pm4::DrawParam
     const bool fenced = state.depth.has_value() || !record.proxies.empty();
     resources.RequireGuestBuffers();
     if (UsesMeshWindow(shaders)) PrepareMeshWindow(context);
+    for (const auto& target : record.targets) {
+        if (target != nullptr) target->PrepareLinearDraw();
+    }
     const auto start = recorder->StartDrawPass(passKey, capture || readsTarget || gpuIndirect || meshIndirect || captured || !record.staged.empty() || PixelFunctionLdsSubgroup(shaders) != 0u, fenced, passAccess);
     if (record.spaceKeep != nullptr) *record.spaceKeep = reserveSpaceKeep(*recorder, resources);
     for (const auto& target : record.multisampleTargets) KeepMultisampleTarget_nid_no_patch(target);
@@ -3687,6 +3690,11 @@ void recordPreparedDraw(const Context& context, const State& state, const Pm4::D
     if (recorded && recorder->HasQueuedKeyStores() && (resources->HoldsLease() || recorder->AnyQueuedKeyStore(touches))) recorder->FlushKeyStores();
     // A queued label store over such memory likewise (Recorder::RecordStore).
     if (recorded && recorder->HasQueuedStores() && (resources->HoldsLease() || recorder->AnyQueuedStore(touches))) recorder->FlushStores();
+    if (recorded) {
+        for (const auto& binding : targets) {
+            if (binding.resident != nullptr) binding.resident->PrepareLinearDraw();
+        }
+    }
     const auto commands = recorded ? recorder->Commands() : batch->Handle();
     if (recorded) prepared.spaceKeep = reserveSpaceKeep(*recorder, *resources);
     if (recorded) recorder->PrepareSampleSlot();