macos: Add updater support (#4464)

This is a very basic updater but should be enough for now.

---------

Co-authored-by: TSRBerry <20988865+TSRBerry@users.noreply.github.com>

Directory.Packages.props

@@ -22,14 +22,14 @@
     <PackageVersion Include="LibHac" Version="0.17.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.1.0" />
-    <PackageVersion Include="OpenTK.Core" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.Graphics" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.5" />
-    <PackageVersion Include="OpenTK.Windowing.GraphicsLibraryFramework" Version="4.7.5" />
+    <PackageVersion Include="OpenTK.Core" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.Graphics" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.Windowing.GraphicsLibraryFramework" Version="4.7.7" />
     <PackageVersion Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build13" />
     <PackageVersion Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" />
@@ -49,7 +49,7 @@
     <PackageVersion Include="System.Management" Version="7.0.0" />
     <PackageVersion Include="System.Net.NameResolution" Version="4.3.0" />
     <PackageVersion Include="System.Threading.ThreadPool" Version="4.3.0" />
-    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-9c9356d" />
+    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-a913199" />
     <PackageVersion Include="XamlNameReferenceGenerator" Version="1.5.1" />
   </ItemGroup>
 </Project>

Ryujinx.Ava/Modules/Updater/Updater.cs

@@ -21,6 +21,7 @@ using System.Net.Http;
 using System.Net.NetworkInformation;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -57,7 +58,7 @@ namespace Ryujinx.Modules
             // Detect current platform
             if (OperatingSystem.IsMacOS())
             {
-                _platformExt = "osx_x64.zip";
+                _platformExt = "macos_universal.app.tar.gz";
             }
             else if (OperatingSystem.IsWindows())
             {
@@ -286,22 +287,40 @@ namespace Ryujinx.Modules
 
             if (_updateSuccessful)
             {
-                var shouldRestart = await ContentDialogHelper.CreateChoiceDialog(LocaleManager.Instance[LocaleKeys.RyujinxUpdater],
-                    LocaleManager.Instance[LocaleKeys.DialogUpdaterCompleteMessage],
-                    LocaleManager.Instance[LocaleKeys.DialogUpdaterRestartMessage]);
+                bool shouldRestart = true;
+
+                if (!OperatingSystem.IsMacOS())
+                {
+                    shouldRestart = await ContentDialogHelper.CreateChoiceDialog(LocaleManager.Instance[LocaleKeys.RyujinxUpdater],
+                        LocaleManager.Instance[LocaleKeys.DialogUpdaterCompleteMessage],
+                        LocaleManager.Instance[LocaleKeys.DialogUpdaterRestartMessage]);
+                }
 
                 if (shouldRestart)
                 {
+                    List<string> arguments = CommandLineState.Arguments.ToList();
                     string ryuName = Path.GetFileName(Environment.ProcessPath);
-                    string ryuExe  = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ryuName);
+                    string executableDirectory = AppDomain.CurrentDomain.BaseDirectory;
+                    string executablePath = Path.Combine(executableDirectory, ryuName);
 
-                    if (!Path.Exists(ryuExe))
+                    if (!Path.Exists(executablePath))
                     {
-                        ryuExe = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, OperatingSystem.IsWindows() ? "Ryujinx.exe" : "Ryujinx");
+                        executablePath = Path.Combine(executableDirectory, OperatingSystem.IsWindows() ? "Ryujinx.exe" : "Ryujinx");
                     }
 
-                    Process.Start(ryuExe, CommandLineState.Arguments);
+                    // On macOS we perform the update at relaunch.
+                    if (OperatingSystem.IsMacOS())
+                    {
+                        string baseBundlePath = Path.GetFullPath(Path.Combine(executableDirectory, "..", ".."));
+                        string newBundlePath = Path.Combine(UpdateDir, "Ryujinx.app");
+                        string updaterScriptPath = Path.Combine(newBundlePath, "Contents", "Resources", "updater.sh");
+                        string currentPid = Process.GetCurrentProcess().Id.ToString();
 
+                        executablePath = "/bin/bash";
+                        arguments.InsertRange(0, new List<string> { updaterScriptPath, baseBundlePath, newBundlePath, currentPid });
+                    }
+
+                    Process.Start(executablePath, arguments);
                     Environment.Exit(0);
                 }
             }
@@ -381,6 +400,15 @@ namespace Ryujinx.Modules
 
                         File.WriteAllBytes(updateFile, mergedFileBytes);
 
+                        // On macOS, ensure that we remove the quarantine bit to prevent Gatekeeper from blocking execution.
+                        if (OperatingSystem.IsMacOS())
+                        {
+                            using (Process xattrProcess = Process.Start("xattr", new List<string> { "-d", "com.apple.quarantine", updateFile }))
+                            {
+                                xattrProcess.WaitForExit();
+                            }
+                        }
+
                         try
                         {
                             InstallUpdate(taskDialog, updateFile);
@@ -470,82 +498,98 @@ namespace Ryujinx.Modules
             worker.Start();
         }
 
+        [SupportedOSPlatform("linux")]
+        [SupportedOSPlatform("macos")]
+        private static void ExtractTarGzipFile(TaskDialog taskDialog, string archivePath, string outputDirectoryPath)
+        {
+            using Stream          inStream   = File.OpenRead(archivePath);
+            using GZipInputStream gzipStream = new(inStream);
+            using TarInputStream  tarStream  = new(gzipStream, Encoding.ASCII);
+
+            TarEntry tarEntry;
+
+            while ((tarEntry = tarStream.GetNextEntry()) is not null)
+            {
+                if (tarEntry.IsDirectory)
+                {
+                    continue;
+                }
+
+                string outPath = Path.Combine(outputDirectoryPath, tarEntry.Name);
+
+                Directory.CreateDirectory(Path.GetDirectoryName(outPath));
+
+                using (FileStream outStream = File.OpenWrite(outPath))
+                {
+                    tarStream.CopyEntryContents(outStream);
+                }
+
+                File.SetUnixFileMode(outPath, (UnixFileMode)tarEntry.TarHeader.Mode);
+                File.SetLastWriteTime(outPath, DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc));
+
+                Dispatcher.UIThread.Post(() =>
+                {
+                    if (tarEntry is null)
+                    {
+                        return;
+                    }
+
+                    taskDialog.SetProgressBarState(GetPercentage(tarEntry.Size, inStream.Length), TaskDialogProgressState.Normal);
+                });
+            }
+        }
+
+        private static void ExtractZipFile(TaskDialog taskDialog, string archivePath, string outputDirectoryPath)
+        {
+            using Stream  inStream = File.OpenRead(archivePath);
+            using ZipFile zipFile  = new(inStream);
+
+            double count = 0;
+            foreach (ZipEntry zipEntry in zipFile)
+            {
+                count++;
+                if (zipEntry.IsDirectory) continue;
+
+                string outPath = Path.Combine(outputDirectoryPath, zipEntry.Name);
+
+                Directory.CreateDirectory(Path.GetDirectoryName(outPath));
+
+                using (Stream     zipStream = zipFile.GetInputStream(zipEntry))
+                using (FileStream outStream = File.OpenWrite(outPath))
+                {
+                    zipStream.CopyTo(outStream);
+                }
+
+                File.SetLastWriteTime(outPath, DateTime.SpecifyKind(zipEntry.DateTime, DateTimeKind.Utc));
+
+                Dispatcher.UIThread.Post(() =>
+                {
+                    taskDialog.SetProgressBarState(GetPercentage(count, zipFile.Count), TaskDialogProgressState.Normal);
+                });
+            }
+        }
+
         private static async void InstallUpdate(TaskDialog taskDialog, string updateFile)
         {
             // Extract Update
             taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterExtracting];
             taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
 
-            if (OperatingSystem.IsLinux())
+            await Task.Run(() =>
             {
-                using Stream          inStream   = File.OpenRead(updateFile);
-                using GZipInputStream gzipStream = new(inStream);
-                using TarInputStream  tarStream  = new(gzipStream, Encoding.ASCII);
-
-                await Task.Run(() =>
+                if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
                 {
-                    TarEntry tarEntry;
-
-                    if (!OperatingSystem.IsWindows())
-                    {
-                        while ((tarEntry = tarStream.GetNextEntry()) is not null)
-                        {
-                            if (tarEntry.IsDirectory) continue;
-
-                            string outPath = Path.Combine(UpdateDir, tarEntry.Name);
-
-                            Directory.CreateDirectory(Path.GetDirectoryName(outPath));
-
-                            using (FileStream outStream = File.OpenWrite(outPath))
-                            {
-                                tarStream.CopyEntryContents(outStream);
-                            }
-
-                            File.SetUnixFileMode(outPath, (UnixFileMode)tarEntry.TarHeader.Mode);
-                            File.SetLastWriteTime(outPath, DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc));
-
-                            Dispatcher.UIThread.Post(() =>
-                            {
-                                taskDialog.SetProgressBarState(GetPercentage(tarEntry.Size, inStream.Length), TaskDialogProgressState.Normal);
-                            });
-                        }
-                    }
-                });
-
-                taskDialog.SetProgressBarState(100, TaskDialogProgressState.Normal);
-            }
-            else
-            {
-                using Stream  inStream = File.OpenRead(updateFile);
-                using ZipFile zipFile  = new(inStream);
-
-                await Task.Run(() =>
+                    ExtractTarGzipFile(taskDialog, updateFile, UpdateDir);
+                }
+                else if (OperatingSystem.IsWindows())
                 {
-                    double count = 0;
-                    foreach (ZipEntry zipEntry in zipFile)
-                    {
-                        count++;
-                        if (zipEntry.IsDirectory) continue;
-
-                        string outPath = Path.Combine(UpdateDir, zipEntry.Name);
-
-                        Directory.CreateDirectory(Path.GetDirectoryName(outPath));
-
-                        using (Stream     zipStream = zipFile.GetInputStream(zipEntry))
-                        using (FileStream outStream = File.OpenWrite(outPath))
-                        {
-                            zipStream.CopyTo(outStream);
-                        }
-
-                        File.SetLastWriteTime(outPath, DateTime.SpecifyKind(zipEntry.DateTime, DateTimeKind.Utc));
-
-                        Dispatcher.UIThread.Post(() =>
-                        {
-                            taskDialog.SetProgressBarState(GetPercentage(count, zipFile.Count), TaskDialogProgressState.Normal);
-                        });
-                    }
-                });
-            }
+                    ExtractZipFile(taskDialog, updateFile, UpdateDir);
+                }
+                else
+                {
+                    throw new NotSupportedException();
+                }
+            });
 
             // Delete downloaded zip
             File.Delete(updateFile);
@@ -555,38 +599,42 @@ namespace Ryujinx.Modules
             taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterRenaming];
             taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
 
-            // Replace old files
-            await Task.Run(() =>
+            // NOTE: On macOS, replacement is delayed to the restart phase.
+            if (!OperatingSystem.IsMacOS())
             {
-                double count = 0;
-                foreach (string file in allFiles)
+                // Replace old files
+                await Task.Run(() =>
                 {
-                    count++;
-                    try
+                    double count = 0;
+                    foreach (string file in allFiles)
                     {
-                        File.Move(file, file + ".ryuold");
-
-                        Dispatcher.UIThread.Post(() =>
+                        count++;
+                        try
                         {
-                            taskDialog.SetProgressBarState(GetPercentage(count, allFiles.Count), TaskDialogProgressState.Normal);
-                        });
-                    }
-                    catch
-                    {
-                        Logger.Warning?.Print(LogClass.Application, LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.UpdaterRenameFailed, file));
-                    }
-                }
+                            File.Move(file, file + ".ryuold");
 
-                Dispatcher.UIThread.Post(() =>
-                {
-                    taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterAddingFiles];
-                    taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
+                            Dispatcher.UIThread.Post(() =>
+                            {
+                                taskDialog.SetProgressBarState(GetPercentage(count, allFiles.Count), TaskDialogProgressState.Normal);
+                            });
+                        }
+                        catch
+                        {
+                            Logger.Warning?.Print(LogClass.Application, LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.UpdaterRenameFailed, file));
+                        }
+                    }
+
+                    Dispatcher.UIThread.Post(() =>
+                    {
+                        taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterAddingFiles];
+                        taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
+                    });
+
+                    MoveAllFilesOver(UpdatePublishDir, HomeDir, taskDialog);
                 });
 
-                MoveAllFilesOver(UpdatePublishDir, HomeDir, taskDialog);
-            });
-
-            Directory.Delete(UpdateDir, true);
+                Directory.Delete(UpdateDir, true);
+            }
 
             _updateSuccessful = true;
 
@@ -596,7 +644,7 @@ namespace Ryujinx.Modules
         public static bool CanUpdate(bool showWarnings)
         {
 #if !DISABLE_UPDATER
-            if (RuntimeInformation.OSArchitecture != Architecture.X64)
+            if (RuntimeInformation.OSArchitecture != Architecture.X64 && !OperatingSystem.IsMacOS())
             {
                 if (showWarnings)
                 {
@@ -669,7 +717,7 @@ namespace Ryujinx.Modules
 #endif
         }
 
-        // NOTE: This method should always reflect the latest build layout.s
+        // NOTE: This method should always reflect the latest build layout.
         private static IEnumerable<string> EnumerateFilesToDelete()
         {
             var files = Directory.EnumerateFiles(HomeDir); // All files directly in base dir.

Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs

@@ -105,13 +105,13 @@ public class TitleUpdateViewModel : BaseModel
             AddUpdate(path);
         }
 
-        // NOTE: Save the list again to remove leftovers.
-        Save();
-
         TitleUpdateModel selected = TitleUpdates.FirstOrDefault(x => x.Path == _titleUpdateWindowData.Selected, null);
 
         SelectedUpdate = selected;
 
+        // NOTE: Save the list again to remove leftovers.
+        Save();
+
         SortUpdates();
     }
 

Ryujinx.Graphics.GAL/Capabilities.cs

@@ -26,6 +26,7 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool SupportsBlendEquationAdvanced;
         public readonly bool SupportsFragmentShaderInterlock;
         public readonly bool SupportsFragmentShaderOrderingIntel;
+        public readonly bool SupportsGeometryShader;
         public readonly bool SupportsGeometryShaderPassthrough;
         public readonly bool SupportsImageLoadFormatted;
         public readonly bool SupportsLayerVertexTessellation;
@@ -68,6 +69,7 @@ namespace Ryujinx.Graphics.GAL
             bool supportsBlendEquationAdvanced,
             bool supportsFragmentShaderInterlock,
             bool supportsFragmentShaderOrderingIntel,
+            bool supportsGeometryShader,
             bool supportsGeometryShaderPassthrough,
             bool supportsImageLoadFormatted,
             bool supportsLayerVertexTessellation,
@@ -107,6 +109,7 @@ namespace Ryujinx.Graphics.GAL
             SupportsBlendEquationAdvanced = supportsBlendEquationAdvanced;
             SupportsFragmentShaderInterlock = supportsFragmentShaderInterlock;
             SupportsFragmentShaderOrderingIntel = supportsFragmentShaderOrderingIntel;
+            SupportsGeometryShader = supportsGeometryShader;
             SupportsGeometryShaderPassthrough = supportsGeometryShaderPassthrough;
             SupportsImageLoadFormatted = supportsImageLoadFormatted;
             SupportsLayerVertexTessellation = supportsLayerVertexTessellation;

Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs

@@ -439,7 +439,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             int samplesInY = msaaMode.SamplesInY();
 
             var scissor = _state.State.ScreenScissorState;
-            Size sizeHint = new Size(scissor.X + scissor.Width, scissor.Y + scissor.Height, 1);
+            Size sizeHint = new Size((scissor.X + scissor.Width) * samplesInX, (scissor.Y + scissor.Height) * samplesInY, 1);
 
             int clipRegionWidth = int.MaxValue;
             int clipRegionHeight = int.MaxValue;

Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs

@@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         private const ushort FileFormatVersionMajor = 1;
         private const ushort FileFormatVersionMinor = 2;
         private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
-        private const uint CodeGenVersion = 4369;
+        private const uint CodeGenVersion = 4368;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";
@@ -774,6 +774,8 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 sBuffers,
                 textures,
                 images,
+                ShaderIdentification.None,
+                0,
                 dataInfo.Stage,
                 dataInfo.UsesInstanceId,
                 dataInfo.UsesDrawParameters,

Ryujinx.Graphics.Gpu/Shader/DiskCache/ParallelDiskCacheLoader.cs

@@ -633,6 +633,11 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 }
             }
 
+            if (!_context.Capabilities.SupportsGeometryShader)
+            {
+                ShaderCache.TryRemoveGeometryStage(translatorContexts);
+            }
+
             CachedShaderStage[] shaders = new CachedShaderStage[guestShaders.Length];
             List<ShaderProgram> translatedStages = new List<ShaderProgram>();
 

Ryujinx.Graphics.Gpu/Shader/GpuAccessorBase.cs

@@ -126,6 +126,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
         public bool QueryHostSupportsFragmentShaderOrderingIntel() => _context.Capabilities.SupportsFragmentShaderOrderingIntel;
 
+        public bool QueryHostSupportsGeometryShader() => _context.Capabilities.SupportsGeometryShader;
+
         public bool QueryHostSupportsGeometryShaderPassthrough() => _context.Capabilities.SupportsGeometryShaderPassthrough;
 
         public bool QueryHostSupportsImageLoadFormatted() => _context.Capabilities.SupportsImageLoadFormatted;

Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs

@@ -353,6 +353,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 }
             }
 
+            if (!_context.Capabilities.SupportsGeometryShader)
+            {
+                TryRemoveGeometryStage(translatorContexts);
+            }
+
             CachedShaderStage[] shaders = new CachedShaderStage[Constants.ShaderStages + 1];
             List<ShaderSource> shaderSources = new List<ShaderSource>();
 
@@ -421,6 +426,39 @@ namespace Ryujinx.Graphics.Gpu.Shader
             return gpShaders;
         }
 
+        /// <summary>
+        /// Tries to eliminate the geometry stage from the array of translator contexts.
+        /// </summary>
+        /// <param name="translatorContexts">Array of translator contexts</param>
+        public static void TryRemoveGeometryStage(TranslatorContext[] translatorContexts)
+        {
+            if (translatorContexts[4] != null)
+            {
+                // We have a geometry shader, but geometry shaders are not supported.
+                // Try to eliminate the geometry shader.
+
+                ShaderProgramInfo info = translatorContexts[4].Translate().Info;
+
+                if (info.Identification == ShaderIdentification.GeometryLayerPassthrough)
+                {
+                    // We managed to identify that this geometry shader is only used to set the output Layer value,
+                    // we can set the Layer on the previous stage instead (usually the vertex stage) and eliminate it.
+
+                    for (int i = 3; i >= 1; i--)
+                    {
+                        if (translatorContexts[i] != null)
+                        {
+                            translatorContexts[i].SetGeometryShaderLayerInputAttribute(info.GpLayerInputAttribute);
+                            translatorContexts[i].SetLastInVertexPipeline(translatorContexts[5] != null);
+                            break;
+                        }
+                    }
+
+                    translatorContexts[4] = null;
+                }
+            }
+        }
+
         /// <summary>
         /// Creates a shader source for use with the backend from a translated shader program.
         /// </summary>

Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -124,6 +124,7 @@ namespace Ryujinx.Graphics.OpenGL
                 supportsBlendEquationAdvanced: HwCapabilities.SupportsBlendEquationAdvanced,
                 supportsFragmentShaderInterlock: HwCapabilities.SupportsFragmentShaderInterlock,
                 supportsFragmentShaderOrderingIntel: HwCapabilities.SupportsFragmentShaderOrdering,
+                supportsGeometryShader: true,
                 supportsGeometryShaderPassthrough: HwCapabilities.SupportsGeometryShaderPassthrough,
                 supportsImageLoadFormatted: HwCapabilities.SupportsImageLoadFormatted,
                 supportsLayerVertexTessellation: HwCapabilities.SupportsShaderViewportLayerArray,

Ryujinx.Graphics.Shader/IGpuAccessor.cs

@@ -259,6 +259,15 @@ namespace Ryujinx.Graphics.Shader
             return false;
         }
 
+        /// <summary>
+        /// Queries host GPU geometry shader support.
+        /// </summary>
+        /// <returns>True if the GPU and driver supports geometry shaders, false otherwise</returns>
+        bool QueryHostSupportsGeometryShader()
+        {
+            return true;
+        }
+
         /// <summary>
         /// Queries host GPU geometry shader passthrough support.
         /// </summary>

Ryujinx.Graphics.Shader/ShaderIdentification.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Graphics.Shader
+{
+    public enum ShaderIdentification
+    {
+        None,
+        GeometryLayerPassthrough
+    }
+}

Ryujinx.Graphics.Shader/ShaderProgramInfo.cs

@@ -10,6 +10,8 @@ namespace Ryujinx.Graphics.Shader
         public ReadOnlyCollection<TextureDescriptor> Textures { get; }
         public ReadOnlyCollection<TextureDescriptor> Images { get; }
 
+        public ShaderIdentification Identification { get; }
+        public int GpLayerInputAttribute { get; }
         public ShaderStage Stage { get; }
         public bool UsesInstanceId { get; }
         public bool UsesDrawParameters { get; }
@@ -22,6 +24,8 @@ namespace Ryujinx.Graphics.Shader
             BufferDescriptor[] sBuffers,
             TextureDescriptor[] textures,
             TextureDescriptor[] images,
+            ShaderIdentification identification,
+            int gpLayerInputAttribute,
             ShaderStage stage,
             bool usesInstanceId,
             bool usesDrawParameters,
@@ -34,6 +38,8 @@ namespace Ryujinx.Graphics.Shader
             Textures = Array.AsReadOnly(textures);
             Images = Array.AsReadOnly(images);
 
+            Identification = identification;
+            GpLayerInputAttribute = gpLayerInputAttribute;
             Stage = stage;
             UsesInstanceId = usesInstanceId;
             UsesDrawParameters = usesDrawParameters;

Ryujinx.Graphics.Shader/Translation/EmitterContext.cs

@@ -241,6 +241,13 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                 this.Copy(Attribute(AttributeConsts.PositionZ), this.FPFusedMultiplyAdd(z, ConstF(0.5f), halfW));
             }
+
+            if (Config.Stage != ShaderStage.Geometry && Config.HasLayerInputAttribute)
+            {
+                Config.SetUsedFeature(FeatureFlags.RtLayer);
+
+                this.Copy(Attribute(AttributeConsts.Layer), Attribute(Config.GpLayerInputAttribute | AttributeConsts.LoadOutputMask));
+            }
         }
 
         public void PrepareForVertexReturn(out Operand oldXLocal, out Operand oldYLocal, out Operand oldZLocal)

Ryujinx.Graphics.Shader/Translation/ShaderConfig.cs

@@ -20,6 +20,8 @@ namespace Ryujinx.Graphics.Shader.Translation
         public bool LastInPipeline { get; private set; }
         public bool LastInVertexPipeline { get; private set; }
 
+        public bool HasLayerInputAttribute { get; private set; }
+        public int GpLayerInputAttribute { get; private set; }
         public int ThreadsPerInputPrimitive { get; }
 
         public OutputTopology OutputTopology { get; }
@@ -245,6 +247,22 @@ namespace Ryujinx.Graphics.Shader.Translation
             LayerOutputAttribute = attr;
         }
 
+        public void SetGeometryShaderLayerInputAttribute(int attr)
+        {
+            HasLayerInputAttribute = true;
+            GpLayerInputAttribute = attr;
+        }
+
+        public void SetLastInVertexPipeline(bool hasFragment)
+        {
+            if (!hasFragment)
+            {
+                LastInPipeline = true;
+            }
+
+            LastInVertexPipeline = true;
+        }
+
         public void SetInputUserAttributeFixedFunc(int index)
         {
             UsedInputAttributes |= 1 << index;
@@ -706,13 +724,15 @@ namespace Ryujinx.Graphics.Shader.Translation
             return FindDescriptorIndex(GetImageDescriptors(), texOp);
         }
 
-        public ShaderProgramInfo CreateProgramInfo()
+        public ShaderProgramInfo CreateProgramInfo(ShaderIdentification identification = ShaderIdentification.None)
         {
             return new ShaderProgramInfo(
                 GetConstantBufferDescriptors(),
                 GetStorageBufferDescriptors(),
                 GetTextureDescriptors(),
                 GetImageDescriptors(),
+                identification,
+                GpLayerInputAttribute,
                 Stage,
                 UsedFeatures.HasFlag(FeatureFlags.InstanceId),
                 UsedFeatures.HasFlag(FeatureFlags.DrawParameters),

Ryujinx.Graphics.Shader/Translation/ShaderIdentifier.cs

@@ -0,0 +1,145 @@
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
+
+namespace Ryujinx.Graphics.Shader.Translation
+{
+    static class ShaderIdentifier
+    {
+        public static ShaderIdentification Identify(Function[] functions, ShaderConfig config)
+        {
+            if (config.Stage == ShaderStage.Geometry &&
+                config.GpuAccessor.QueryPrimitiveTopology() == InputTopology.Triangles &&
+                !config.GpuAccessor.QueryHostSupportsGeometryShader() &&
+                IsLayerPassthroughGeometryShader(functions, out int layerInputAttr))
+            {
+                config.SetGeometryShaderLayerInputAttribute(layerInputAttr);
+
+                return ShaderIdentification.GeometryLayerPassthrough;
+            }
+
+            return ShaderIdentification.None;
+        }
+
+        private static bool IsLayerPassthroughGeometryShader(Function[] functions, out int layerInputAttr)
+        {
+            bool writesLayer = false;
+            layerInputAttr = 0;
+
+            if (functions.Length != 1)
+            {
+                return false;
+            }
+
+            int verticesCount = 0;
+            int totalVerticesCount = 0;
+
+            foreach (BasicBlock block in functions[0].Blocks)
+            {
+                // We are not expecting loops or any complex control flow here, so fail in those cases.
+                if (block.Branch != null && block.Branch.Index <= block.Index)
+                {
+                    return false;
+                }
+
+                foreach (INode node in block.Operations)
+                {
+                    if (!(node is Operation operation))
+                    {
+                        continue;
+                    }
+
+                    if (IsResourceWrite(operation.Inst))
+                    {
+                        return false;
+                    }
+
+                    if (operation.Inst == Instruction.StoreAttribute)
+                    {
+                        return false;
+                    }
+
+                    if (operation.Inst == Instruction.Copy && operation.Dest.Type == OperandType.Attribute)
+                    {
+                        Operand src = operation.GetSource(0);
+
+                        if (src.Type == OperandType.LocalVariable && src.AsgOp is Operation asgOp && asgOp.Inst == Instruction.LoadAttribute)
+                        {
+                            src = Attribute(asgOp.GetSource(0).Value);
+                        }
+
+                        if (src.Type == OperandType.Attribute)
+                        {
+                            if (operation.Dest.Value == AttributeConsts.Layer)
+                            {
+                                if ((src.Value & AttributeConsts.LoadOutputMask) != 0)
+                                {
+                                    return false;
+                                }
+
+                                writesLayer = true;
+                                layerInputAttr = src.Value;
+                            }
+                            else if (src.Value != operation.Dest.Value)
+                            {
+                                return false;
+                            }
+                        }
+                        else if (src.Type == OperandType.Constant)
+                        {
+                            int dstComponent = (operation.Dest.Value >> 2) & 3;
+                            float expectedValue = dstComponent == 3 ? 1f : 0f;
+
+                            if (src.AsFloat() != expectedValue)
+                            {
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                    else if (operation.Inst == Instruction.EmitVertex)
+                    {
+                        verticesCount++;
+                    }
+                    else if (operation.Inst == Instruction.EndPrimitive)
+                    {
+                        totalVerticesCount += verticesCount;
+                        verticesCount = 0;
+                    }
+                }
+            }
+
+            return totalVerticesCount + verticesCount == 3 && writesLayer;
+        }
+
+        private static bool IsResourceWrite(Instruction inst)
+        {
+            switch (inst)
+            {
+                case Instruction.AtomicAdd:
+                case Instruction.AtomicAnd:
+                case Instruction.AtomicCompareAndSwap:
+                case Instruction.AtomicMaxS32:
+                case Instruction.AtomicMaxU32:
+                case Instruction.AtomicMinS32:
+                case Instruction.AtomicMinU32:
+                case Instruction.AtomicOr:
+                case Instruction.AtomicSwap:
+                case Instruction.AtomicXor:
+                case Instruction.ImageAtomic:
+                case Instruction.ImageStore:
+                case Instruction.StoreGlobal:
+                case Instruction.StoreGlobal16:
+                case Instruction.StoreGlobal8:
+                case Instruction.StoreStorage:
+                case Instruction.StoreStorage16:
+                case Instruction.StoreStorage8:
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

Ryujinx.Graphics.Shader/Translation/Translator.cs

@@ -77,9 +77,11 @@ namespace Ryujinx.Graphics.Shader.Translation
                 funcs[i] = new Function(cfg.Blocks, $"fun{i}", false, inArgumentsCount, outArgumentsCount);
             }
 
+            var identification = ShaderIdentifier.Identify(funcs, config);
+
             var sInfo = StructuredProgram.MakeStructuredProgram(funcs, config);
 
-            var info = config.CreateProgramInfo();
+            var info = config.CreateProgramInfo(identification);
 
             return config.Options.TargetLanguage switch
             {

Ryujinx.Graphics.Shader/Translation/TranslatorContext.cs

@@ -138,6 +138,16 @@ namespace Ryujinx.Graphics.Shader.Translation
             _config.MergeFromtNextStage(nextStage._config);
         }
 
+        public void SetGeometryShaderLayerInputAttribute(int attr)
+        {
+            _config.SetGeometryShaderLayerInputAttribute(attr);
+        }
+
+        public void SetLastInVertexPipeline(bool hasFragment)
+        {
+            _config.SetLastInVertexPipeline(hasFragment);
+        }
+
         public ShaderProgram Translate(TranslatorContext other = null)
         {
             FunctionCode[] code = EmitShader(_program, _config, initializeOutputs: other == null, out _);

Ryujinx.Graphics.Vulkan/IdList.cs

@@ -80,8 +80,16 @@ namespace Ryujinx.Graphics.Vulkan
 
             try
             {
-                value = _list[id];
-                return value != null;
+                if ((uint)id < (uint)_list.Count)
+                {
+                    value = _list[id];
+                    return value != null;
+                }
+                else
+                {
+                    value = null;
+                    return false;
+                }
             }
             catch (ArgumentOutOfRangeException)
             {

Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -546,6 +546,7 @@ namespace Ryujinx.Graphics.Vulkan
                 supportsBlendEquationAdvanced: Capabilities.SupportsBlendEquationAdvanced,
                 supportsFragmentShaderInterlock: Capabilities.SupportsFragmentShaderInterlock,
                 supportsFragmentShaderOrderingIntel: false,
+                supportsGeometryShader: Capabilities.SupportsGeometryShader,
                 supportsGeometryShaderPassthrough: Capabilities.SupportsGeometryShaderPassthrough,
                 supportsImageLoadFormatted: features2.Features.ShaderStorageImageReadWithoutFormat,
                 supportsLayerVertexTessellation: featuresVk12.ShaderOutputLayer,

distribution/macos/create_app_bundle.sh

@@ -24,6 +24,7 @@ cp $PUBLISH_DIRECTORY/*.dylib $APP_BUNDLE_DIRECTORY/Contents/Frameworks
 # Then resources
 cp Info.plist $APP_BUNDLE_DIRECTORY/Contents
 cp Ryujinx.icns $APP_BUNDLE_DIRECTORY/Contents/Resources/Ryujinx.icns
+cp updater.sh $APP_BUNDLE_DIRECTORY/Contents/Resources/updater.sh
 cp -r $PUBLISH_DIRECTORY/THIRDPARTY.md $APP_BUNDLE_DIRECTORY/Contents/Resources
 
 echo -n "APPL????" > $APP_BUNDLE_DIRECTORY/Contents/PkgInfo

distribution/macos/create_macos_release.sh

@@ -27,7 +27,7 @@ EXECUTABLE_SUB_PATH=Contents/MacOS/Ryujinx
 rm -rf $TEMP_DIRECTORY
 mkdir -p $TEMP_DIRECTORY
 
-DOTNET_COMMON_ARGS="-p:DebugType=embedded -p:Version=$VERSION -p:SourceRevisionId=$SOURCE_REVISION_ID -p:ExtraDefineConstants=DISABLE_UPDATER --self-contained true"
+DOTNET_COMMON_ARGS="-p:DebugType=embedded -p:Version=$VERSION -p:SourceRevisionId=$SOURCE_REVISION_ID --self-contained true"
 
 dotnet restore
 dotnet build -c Release Ryujinx.Ava

distribution/macos/updater.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+set -e
+
+INSTALL_DIRECTORY=$1
+NEW_APP_DIRECTORY=$2
+APP_PID=$3
+APP_ARGUMENTS="${@:4}"
+
+error_handler() {
+    local lineno="$1"
+
+    script="""
+    set alertTitle to \"Ryujinx - Updater error\"
+    set alertMessage to \"An error occurred during Ryujinx update (updater.sh:$lineno)\n\nPlease download the update manually from our website if the problem persists.\"
+    display dialog alertMessage with icon caution with title alertTitle buttons {\"Open Download Page\", \"Exit\"}
+    set the button_pressed to the button returned of the result
+
+    if the button_pressed is \"Open Download Page\" then
+        open location \"https://ryujinx.org/download\"
+    end if
+    """
+
+    osascript -e "$script"
+    exit 1
+}
+
+trap 'error_handler ${LINENO}' ERR
+
+# Wait for Ryujinx to exit
+# NOTE: in case no fds are open, lsof could be returning with a process still living.
+# We wait 1s and assume the process stopped after that
+lsof -p $APP_PID +r 1 &>/dev/null
+sleep 1
+
+# Now replace and reopen.
+rm -rf "$INSTALL_DIRECTORY"
+mv "$NEW_APP_DIRECTORY" "$INSTALL_DIRECTORY"
+open -a "$INSTALL_DIRECTORY" --args "$APP_ARGUMENTS"