Added setting to turn off streaming of sparse texture unswizzling

src/android/app/src/main/res/values/arrays.xml

@@ -567,6 +567,7 @@
         <item>@string/gpu_swizzle_normal</item>
         <item>@string/gpu_swizzle_medium</item>
         <item>@string/gpu_swizzle_high</item>
+        <item>@string/gpu_swizzle_off</item>
     </string-array>
 
     <integer-array name="gpuSwizzleValues">
@@ -575,6 +576,7 @@
         <item>2</item>
         <item>3</item>
         <item>4</item>
+        <item>5</item>
     </integer-array>
     
     <string-array name="gpuSwizzleChunkEntries">
@@ -583,6 +585,7 @@
         <item>@string/gpu_swizzlechunk_normal</item>
         <item>@string/gpu_swizzlechunk_medium</item>
         <item>@string/gpu_swizzlechunk_high</item>
+        <item>@string/gpu_swizzlechunk_off</item>
     </string-array>
 
     <integer-array name="gpuSwizzleChunkValues">
@@ -591,6 +594,7 @@
         <item>2</item>
         <item>3</item>
         <item>4</item>
+        <item>5</item>
     </integer-array>
 
     <string-array name="temperatureUnitEntries">

src/android/app/src/main/res/values/strings.xml

@@ -986,6 +986,7 @@
     <string name="gpu_swizzle_normal">Normal (16 MB)</string>
     <string name="gpu_swizzle_medium">Medium (32 MB)</string>
     <string name="gpu_swizzle_high">High (64 MB)</string>
+    <string name="gpu_swizzle_off">Off</string>
 
     <!-- GPU swizzle chunks -->
     <string name="gpu_swizzlechunk_verylow">Very Low (32)</string>
@@ -993,6 +994,7 @@
     <string name="gpu_swizzlechunk_normal">Normal (128)</string>
     <string name="gpu_swizzlechunk_medium">Medium (256)</string>
     <string name="gpu_swizzlechunk_high">High (512)</string>
+    <string name="gpu_swizzlechunk_off">Off</string>
 
     <!-- Temperature Units -->
     <string name="temperature_celsius">Celsius</string>

src/common/settings_enums.h

@@ -153,8 +153,8 @@ ENUM(AppletMode, HLE, LLE);
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
 ENUM(GpuOverclock, Normal, Medium, High)
 ENUM(GpuUnswizzleSize, VerySmall, Small, Normal, Large, VeryLarge)
-ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High)
-ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High)
+ENUM(GpuUnswizzle, VeryLow, Low, Normal, Medium, High, Off)
+ENUM(GpuUnswizzleChunk, VeryLow, Low, Normal, Medium, High, Off)
 ENUM(TemperatureUnits, Celsius, Fahrenheit)
 ENUM(ExtendedDynamicState, Disabled, EDS1, EDS2, EDS3);
 ENUM(GpuLogLevel, Off, Errors, Standard, Verbose, All)

src/qt_common/config/shared_translation.cpp

@@ -665,6 +665,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(GpuUnswizzle, Normal, tr("Normal (16 MB)")),
                               PAIR(GpuUnswizzle, Medium, tr("Medium (32 MB)")),
                               PAIR(GpuUnswizzle, High, tr("High (64 MB)")),
+                              PAIR(GpuUnswizzle, Off, tr("Off")),
                           }});
     translations->insert({Settings::EnumMetadata<Settings::GpuUnswizzleChunk>::Index(),
                           {
@@ -673,6 +674,7 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(GpuUnswizzleChunk, Normal, tr("Normal (128)")),
                               PAIR(GpuUnswizzleChunk, Medium, tr("Medium (256)")),
                               PAIR(GpuUnswizzleChunk, High, tr("High (512)")),
+                              PAIR(GpuUnswizzleChunk, Off, tr("Off")),
                           }});
 
     translations->insert({Settings::EnumMetadata<Settings::ExtendedDynamicState>::Index(),

src/video_core/texture_cache/texture_cache.h

@@ -95,6 +95,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
             case Settings::GpuUnswizzle::Normal:  swizzle_chunk_size = 16_MiB; break;
             case Settings::GpuUnswizzle::Medium:  swizzle_chunk_size = 32_MiB; break;
             case Settings::GpuUnswizzle::High:    swizzle_chunk_size = 64_MiB; break;
+            case Settings::GpuUnswizzle::Off:     swizzle_chunk_size = 0; break;
             default:                              swizzle_chunk_size = 16_MiB;
         }
 
@@ -104,6 +105,7 @@ TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManag
             case Settings::GpuUnswizzleChunk::Normal:  swizzle_slices_per_batch = 128; break;
             case Settings::GpuUnswizzleChunk::Medium:  swizzle_slices_per_batch = 256; break;
             case Settings::GpuUnswizzleChunk::High:    swizzle_slices_per_batch = 512; break;
+            case Settings::GpuUnswizzleChunk::Off:     swizzle_slices_per_batch = 0; break;
             default:                                   swizzle_slices_per_batch = 128;
         }
     } else {
@@ -1401,10 +1403,10 @@ void TextureCache<P>::TickAsyncUnswizzle() {
         return;
     }
 
-    if(current_unswizzle_frame > 0) {
+    /*if(current_unswizzle_frame > 0) {
         current_unswizzle_frame--;
         return;
-    }
+    }*/
 
     PendingUnswizzle& task = unswizzle_queue.front();
     Image& image = slot_images[task.image_id];
@@ -1429,7 +1431,10 @@ void TextureCache<P>::TickAsyncUnswizzle() {
     if (task.current_offset < task.total_size) {
         const size_t remaining = task.total_size - task.current_offset;
 
-        size_t copy_amount = (std::min)(swizzle_chunk_size, remaining);
+        size_t copy_amount = 0;
+        if( swizzle_chunk_size == 0 )
+            copy_amount = remaining;
+        else copy_amount = (std::min)(swizzle_chunk_size, remaining);
 
         if (remaining > swizzle_chunk_size) {
             copy_amount = (copy_amount / task.bytes_per_slice) * task.bytes_per_slice;
@@ -1446,7 +1451,11 @@ void TextureCache<P>::TickAsyncUnswizzle() {
     const size_t bytes_ready = task.current_offset - task.last_submitted_offset;
     const u32 complete_slices = static_cast<u32>(bytes_ready / task.bytes_per_slice);
 
-    if (complete_slices >= swizzle_slices_per_batch || (is_final_batch && complete_slices > 0)) {
+    if( swizzle_slices_per_batch <= 0 ) {
+        runtime.AccelerateImageUpload(image, task.staging_buffer, FixSmallVectorADL(FullUploadSwizzles(task.info)), 0, image.info.size.depth);
+        task.last_submitted_offset += (static_cast<size_t>(image.info.size.depth) * task.bytes_per_slice);
+    }
+    else if (complete_slices >= swizzle_slices_per_batch || (is_final_batch && complete_slices > 0)) {
         const u32 z_start = static_cast<u32>(task.last_submitted_offset / task.bytes_per_slice);
         const u32 slices_to_process = (std::min)(complete_slices, swizzle_slices_per_batch);
         const u32 z_count = (std::min)(slices_to_process, image.info.size.depth - z_start);
@@ -1468,7 +1477,7 @@ void TextureCache<P>::TickAsyncUnswizzle() {
         unswizzle_queue.pop_front();
 
         // Wait 4 frames to process the next entry
-        current_unswizzle_frame = 4u;
+        // current_unswizzle_frame = 4u;
     }
 }