Use Cemu hook to force shader cache re-compile when there is no existing backup

Set a default tolerance of 0.01MB when comparing the size of the GLCache to the backup, to avoid unnecessary copying

Author: MoreOrLessSoftware

Cemu_withGLCacheBackup.ps1

@@ -1,7 +1,7 @@
 <#
 
 This PowerShell script is designed to intelligently backup and 
-restore the NVIDIA GL shader cache for CEMU on a PER-GAME basis.
+restore the NVIDIA GL shader cache for Cemu on a PER-GAME basis.
 
 Please see https://github.com/dkr88/CemuGLCacheBackup/blob/master/README.md
 
@@ -19,14 +19,17 @@ param (
 
     [string]$logFile = "Cemu_withGLCacheBackup.log.txt",
 
+    [decimal]$glCacheSizeTolerance = 0.01,
+
     [switch]$showPrompts = $false,
     [switch]$testMode = $false
 )
 
+#region Helper functions
 function Write-Log {
     param(
         [Parameter(Mandatory=$true,Position=0)][string]$Message,
-        [string]$Level = "info"
+        [string]$Level = "trace"
     )
 
     if ($noConsole) {
@@ -39,6 +42,7 @@ function Write-Log {
     else {
         switch ($Level) {
             "debug" { Write-Host $Message -ForegroundColor DarkGray }
+            "info" { Write-Host $Message -ForegroundColor Cyan }
             "success" { Write-Host $Message -ForegroundColor Green }
             "warn" { Write-Host $Message -ForegroundColor Yellow }
             "error" { Write-Host $Message -ForegroundColor Red }
@@ -48,6 +52,90 @@ function Write-Log {
     }
 }
 
+function Set-CemuHookIgnorePrecompiled {
+    if (Test-Path $cemuHookIniFile) {
+        $ini = Get-IniContent $cemuHookIniFile
+    }
+    else {
+        if (!(Test-Path "$cemuDir\dbghelp.dll")) {
+            Write-Log "Cemu hook not detected - delete files from 'shaderCache/precompiled' to ensure clean backup!" -Level "warn"
+            return $false
+        }
+        $ini = @{}
+    }
+    
+    if (!$ini.ContainsKey("Graphics")) {
+        $ini.Graphics = @{}
+    }
+    elseif ($ini.Graphics.ignorePrecompiledShaderCache -eq "true") {
+        Write-Log "You should change the 'Ignore precompiled shader cache' setting to 'Enabled'" -Level "warn"
+        return $false
+    }
+
+    $ini.Graphics.ignorePrecompiledShaderCache = "true"
+    
+    if (Test-Path $cemuHookIniFile) {
+        Copy-Item $cemuHookIniFile $cemuHookIniBackupFile -Force
+    }
+    
+    Out-IniFile $ini -FilePath $cemuHookIniFile
+    Write-Log "Forced ignorePrecompiledShaderCache = true in cemuhook.ini" -Level "info"
+
+    return $true
+}
+
+function Get-IniContent ($FilePath) {
+    $ini = @{}
+    switch -regex -file $FilePath
+    {
+        "^\[(.+)\]" # Section
+        {
+            $section = $matches[1]
+            $ini[$section] = @{}
+            $CommentCount = 0
+        }
+        "^(;.*)$" # Comment
+        {
+            $value = $matches[1]
+            $CommentCount = $CommentCount + 1
+            $name = "Comment" + $CommentCount
+            $ini[$section][$name] = $value
+        } 
+        "(.+?)\s*=\s*(.*)" # Key
+        {
+            $name,$value = $matches[1..2]
+            $ini[$section][$name] = $value
+        }
+    }
+    return $ini
+}
+
+function Out-IniFile($InputObject, $FilePath) {
+    $outFile = New-Item -ItemType file -Path $FilePath -Force
+    foreach ($i in $InputObject.keys)
+    {
+        if (!($($InputObject[$i].GetType().Name) -eq "Hashtable"))
+        {
+            #No Sections
+            Add-Content -Path $outFile -Value "$i = $($InputObject[$i])"
+        } else {
+            #Sections
+            Add-Content -Path $outFile -Value "[$i]"
+            foreach ($j in ($InputObject[$i].keys | Sort-Object))
+            {
+                if ($j -match "^Comment[\d]+") {
+                    Add-Content -Path $outFile -Value "$($InputObject[$i][$j])"
+                } else {
+                    Add-Content -Path $outFile -Value "$j = $($InputObject[$i][$j])" 
+                }
+
+            }
+            Add-Content -Path $outFile -Value ""
+        }
+    }
+}
+#endregion
+
 # Determine the current script path
 if ($MyInvocation.MyCommand.CommandType -eq "ExternalScript") { 
     $scriptPath = Split-Path -Parent -Path $MyInvocation.MyCommand.Definition 
@@ -56,8 +144,10 @@ else {
     $scriptPath = Split-Path -Parent -Path ([Environment]::GetCommandLineArgs()[0]) 
 }
 
-# Default to current script path for CEMU and backup directories
-if (!$cemuDir) { $cemuDir = "$scriptPath" }
+# Default to current script path for Cemu and backup directories
+if (!$cemuDir) { 
+    $cemuDir = "$scriptPath" 
+}
 if (!$backupDir) { 
     $backupDir = "$scriptPath\GLCacheBackup"
     if (!(Test-Path $backupDir)) {
@@ -66,7 +156,12 @@ if (!$backupDir) {
     }
 }
 
-# CEMU args need to be prefixed with '+' instead of '-' otherwise powershell gets confused
+# In case we need to make changes to cemuhook settings
+$cemuHookIniFile = "$cemuDir\cemuhook.ini"
+$cemuHookIniBackupFile = "$cemuDir\cemuhook.ini.glcachebackup"
+$cemuHookIniModified = $false
+
+# Cemu args need to be prefixed with '+' instead of '-' otherwise powershell gets confused
 $cemuArgs = $cemuArgs.Replace("+", "-")
 
 # This will be modified at build time to reflect the exe version being built
@@ -97,11 +192,12 @@ Write-Log "cemuArgs   = $cemuArgs" -Level "debug"
 Write-Log "backupDir  = $backupDir" -Level "debug"
 Write-Log "glCacheDir = $glCacheDir" -Level "debug"
 Write-Log "glCacheId  = $glCacheId" -Level "debug"
+Write-Log "glCacheSizeTolerance = $glCacheSizeTolerance" -Level "debug"
 
 $errors = @()
 
 if (!(Test-Path "$cemuDir/$cemuExe")) {
-    $errors += "CEMU executable was not found - is this script in the CEMU install directory?"
+    $errors += "Cemu executable was not found - is this script in the CEMU install directory?"
 }
 
 if (!(Test-Path $backupDir)) {
@@ -132,28 +228,36 @@ if ($testMode) {
 }
 
 $copyCache = $true
+$forceRecompile = $false
 
 $backupExists = Test-Path "$backupDir\$gameId.bin"
 $backupSize = 0
 
-if ($backupExists -eq $true) {
+if ($backupExists) {
     $backupSize = ((Get-ChildItem $backupDir -Recurse -Filter "$gameId.*" | Measure-Object -Property Length -Sum -ErrorAction Stop).Sum / 1MB)
     Write-Log ("GLCache backup size for $gameId is {0:N2} MB" -f $backupSize)
 }
 else {
     Write-Log "GLCache backup doesn't exist for $gameId"
     $copyCache = $false
+
+    if (!$showPrompts -or (Read-Host "Force re-compile shader cache? ( [y] / n ) ") -ne "n") {
+        if (!$testMode) {    
+            $forceRecompile = $true
+            $cemuHookIniModified = Set-CemuHookIgnorePrecompiled
+        }
+    }
 }
 
 $glCacheExists = Test-Path "$glCacheDir\$glCacheId.bin"
 $glCacheSize = 0
 
-if ($glCacheExists -eq $true) {
+if ($glCacheExists) {
     $glCacheSize = ((Get-ChildItem $glCacheDir -Recurse -Filter "$glCacheId.*" | Measure-Object -Property Length -Sum -ErrorAction Stop).Sum / 1MB)
     Write-Log ("Existing GLCache size is {0:N2} MB" -f $glCacheSize)
 
-    if ($backupExists -eq $true) {
-        if ($glCacheSize -eq $backupSize) {
+    if ($backupExists -and !$forceRecompile) {
+        if ([Math]::Abs($glCacheSize - $backupSize) -lt $glCacheSizeTolerance) {
             Write-Log "Existing GLCache will be re-used - it is the same size as backup"
             $copyCache = $false
         }
@@ -165,7 +269,14 @@ if ($glCacheExists -eq $true) {
         }
     }
     else {
-        if (!$showPrompts -or (Read-Host "Delete existing GLCache before starting? ( [y] / n ) ") -ne "n") {
+        if ($forceRecompile) {
+            Write-Log "Deleting existing GLCache because shader cache will be re-compiled"
+            if (!$testMode) {
+                Remove-Item "$glCacheDir\$glCacheId.bin" -Force
+                Remove-Item "$glCacheDir\$glCacheId.toc" -Force
+            }
+        }
+        elseif (!$showPrompts -or (Read-Host "Delete existing GLCache before starting? ( [y] / n ) ") -ne "n") {
             Write-Log "Deleting existing GLCache and starting fresh"
             if (!$testMode) {    
                 Remove-Item "$glCacheDir\$glCacheId.bin" -Force
@@ -178,28 +289,42 @@ else {
     Write-Log "GLCache doesn't exist at the specified location yet" -Level "warn"
 }
 
-If ($copyCache -eq $true) {
+If ($copyCache) {
     Write-Log "Backup GLCache will be used" -Level "success"
     if (!$testMode) {
         Copy-Item "$backupDir\$gameId.bin" "$glCacheDir\$glCacheId.bin" -Force
         Copy-Item "$backupDir\$gameId.toc" "$glCacheDir\$glCacheId.toc" -Force
     }
 }
 
-Write-Log "Starting CEMU... "
+Write-Log "Starting Cemu... "
 
 Set-Location -Path $cemuDir
 Start-Process -FilePath "$cemuDir/$cemuExe" -ArgumentList "$cemuArgs -g ""$gamePath""" -Wait
 
-Write-Log "CEMU stopped."
+Write-Log "Cemu stopped."
+
+if ($cemuHookIniModified) {
+    if (Test-Path $cemuHookIniBackupFile) {
+        Copy-Item $cemuHookIniBackupFile $cemuHookIniFile -Force
+        Write-Log "Restored cemuhook.ini" -Level "info"
+    }
+    else {
+        Remove-Item $cemuHookIniFile -Force
+        Write-Log "Removed temporary cemuhook.ini"
+    }
+}
+else {
+    Write-Log "cemuhook.ini wasn't modified"
+}
 
 $glCacheExists = Test-Path "$glCacheDir\$glCacheId.bin"
 
 if ($glCacheExists) {
     $newGlCacheSize = ((Get-ChildItem "$glCacheDir\$glCacheId.*" -Recurse | Measure-Object -Property Length -Sum -ErrorAction Stop).Sum / 1MB)
     Write-Log ("New GLCache size is {0:N2} MB" -f $newGlCacheSize)
 
-    if ($newGlCacheSize -gt $backupSize) {
+    if ([Math]::Abs($newGlCacheSize - $backupSize) -gt $glCacheSizeTolerance) {
         if ($backupSize -gt 0) {
             Write-Log ("New GLCache is {0:N8} MB larger than current backup" -f ($newGlCacheSize - $backupSize))
         }
@@ -225,4 +350,8 @@ if ($noConsole) {
 else {
     Stop-Transcript | Out-Null
     Start-Sleep -Seconds 3
+}
+
+if ($showPrompts) {
+    Read-Host "Press enter to exit"
 }

README.md

@@ -5,6 +5,12 @@ the NVIDIA GL shader cache for CEMU on a PER-GAME basis.
 
 The script has been wrapped as an exe using PS2EXE-GUI.
 
+# Requirements
+
+- Cemu
+- Cemu hook (recommended)
+- Only tested on Windows 10
+
 # What it fixes
 
 Primarily, micro-stutters. NVIDIA caches GL shaders in a file on your PC as they are invoked during the course of gameplay in CEMU. These are based on the recompiled shader caches that CEMU creates when it loads a game, but crucially NVIDIA does not cache these at the time CEMU loads the game, but rather as they are invoked during gameplay. This can result in micro-stutters as new shaders are encountered. The problem is, NVIDIA invalidates / deletes these caches on occasion, which means the next time you play the same game the shader might not be cached and thus the stuttering.
@@ -19,15 +25,19 @@ Quite simply, before launching a specific game in CEMU, this script tries to res
 
 So effectively this script maintains a per-game GL shader cache backup.
 
-> If you were previously setting the `Precompiled shader cache` setting in Cemuhook to `Disabled/ignored` to fix stuttering, you should try setting it back to `Enabled` when using GLCache backups.
+>When running a game for the first time, this script will use the Cemu hook .ini file to force a re-compile of the shader cache. This is necessary to get a good clean GLCache to make a backup from.
+>
+>When you exit Cemu after the first run of the game, the backup will be taken and the setting will be reverted to enable the precompiled shader cache again.
+>
+>WARNING: If you make any changes to Cemu hook config on the first run and this script has forced the re-compile, the settings you changed will be reverted when you exit Cemu.
 
 # Setup
 
 1) Place this script/exe *and* 'Cemu_withGLCacheBackup.xml' in the same directory as Cemu.exe.
 
 2) Edit 'Cemu_withGLCacheBackup.xml' and set the NVIDIA GL cache path and ID appropriately.
 
-3) Create shortcuts for each game you want to run.
+3) For each CEMU game you play create a Windows and/or Steam shortcut
 
 # Cemu_withGLCacheBackup.xml
 
@@ -136,18 +146,11 @@ If you use this option, you'll get prompted before restoring and saving backups.
 This flag will make the script not actually restore or backup the cache files. Useful if you just want to test your config and see the size of the shader caches.
 ```
 
-# How do I know if it's working?
+# Troubleshooting
 
-Once you've configured everything correctly and backups are being taken, you can do this simple test:
+- Check the `GLCacheBackup` directory in your Cemu install dir to verify that backups are being created.
 
-1. Run a game using this script and play a section you can easily replay
-2. Exit CEMU
-3. Find the GLCache backup for your game (by default, in the `GLCacheBackup` folder within the CEMU install directory)
-4. Rename the `GLCacheBackup` folder to `GLCacheBackup_off`
-5. Re-launch the game and play the same section, do you get stutters?
-6. Exit CEMU
-7. Delete the new `GLCacheBackup` folder that got created and rename `GLCacheBackup_off` back to `GLCacheBackup`
-8. Re-launch the game and play the same section - there should be less micro-stuttering
+- Check the `Cemu_withGLCacheBackup.log.txt` file to look for errors or warnings.
 
 # Logging