Refactor shader GPU state and memory access (#1203)

* Refactor shader GPU state and memory access * Fix NVDEC project build * Address PR feedback and add missing XML comments
author: gdkchan <gab.dark.100@gmail.com> 2020-05-05 22:02:28 -0300
committer: GitHub <noreply@github.com> 2020-05-06 11:02:28 +1000
commit: b8eb6abeccbd4a468214a4d2ad3a9b6e5e06973c (patch)
tree: cd3d71ebde0f4f32eb674778adae89c0efcb75df /Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
parent: 7f500e7cae940958289abe1a3461e52684742053 (diff)
1 files changed, 75 insertions, 315 deletions
diff --git a/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs b/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
index d7144063..8a1abe32 100644
--- a/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
+++ b/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
@@ -1,33 +1,25 @@
-using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.GAL;
-using Ryujinx.Graphics.Gpu.Image;
 using Ryujinx.Graphics.Gpu.State;
 using Ryujinx.Graphics.Shader;
 using Ryujinx.Graphics.Shader.Translation;
 using System;
 using System.Collections.Generic;
-using System.Runtime.InteropServices;
 
 namespace Ryujinx.Graphics.Gpu.Shader
 {
-    using TextureDescriptor = Image.TextureDescriptor;
-
     /// <summary>
     /// Memory cache of shader code.
     /// </summary>
     class ShaderCache : IDisposable
     {
-        private const int MaxProgramSize = 0x100000;
-
         private const TranslationFlags DefaultFlags = TranslationFlags.DebugMode;
 
-        private GpuContext _context;
-
-        private ShaderDumper _dumper;
+        private readonly GpuContext _context;
 
-        private Dictionary<ulong, List<ComputeShader>> _cpPrograms;
+        private readonly ShaderDumper _dumper;
 
-        private Dictionary<ShaderAddresses, List<GraphicsShader>> _gpPrograms;
+        private readonly Dictionary<ulong, List<ShaderBundle>> _cpPrograms;
+        private readonly Dictionary<ShaderAddresses, List<ShaderBundle>> _gpPrograms;
 
         /// <summary>
         /// Creates a new instance of the shader cache.
@@ -39,9 +31,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             _dumper = new ShaderDumper();
 
-            _cpPrograms = new Dictionary<ulong, List<ComputeShader>>();
-
-            _gpPrograms = new Dictionary<ShaderAddresses, List<GraphicsShader>>();
+            _cpPrograms = new Dictionary<ulong, List<ShaderBundle>>();
+            _gpPrograms = new Dictionary<ShaderAddresses, List<ShaderBundle>>();
         }
 
         /// <summary>
@@ -58,7 +49,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="localMemorySize">Local memory size of the compute shader</param>
         /// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
         /// <returns>Compiled compute shader code</returns>
-        public ComputeShader GetComputeShader(
+        public ShaderBundle GetComputeShader(
             GpuState state,
             ulong gpuVa,
             int localSizeX,
@@ -67,20 +58,20 @@ namespace Ryujinx.Graphics.Gpu.Shader
             int localMemorySize,
             int sharedMemorySize)
         {
-            bool isCached = _cpPrograms.TryGetValue(gpuVa, out List<ComputeShader> list);
+            bool isCached = _cpPrograms.TryGetValue(gpuVa, out List<ShaderBundle> list);
 
             if (isCached)
             {
-                foreach (ComputeShader cachedCpShader in list)
+                foreach (ShaderBundle cachedCpShader in list)
                 {
-                    if (!IsShaderDifferent(cachedCpShader, gpuVa))
+                    if (IsShaderEqual(cachedCpShader, gpuVa))
                     {
                         return cachedCpShader;
                     }
                 }
             }
 
-            CachedShader shader = TranslateComputeShader(
+            ShaderCodeHolder shader = TranslateComputeShader(
                 state,
                 gpuVa,
                 localSizeX,
@@ -93,11 +84,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
             IProgram hostProgram = _context.Renderer.CreateProgram(new IShader[] { shader.HostShader });
 
-            ComputeShader cpShader = new ComputeShader(hostProgram, shader);
+            ShaderBundle cpShader = new ShaderBundle(hostProgram, shader);
 
             if (!isCached)
             {
-                list = new List<ComputeShader>();
+                list = new List<ShaderBundle>();
 
                 _cpPrograms.Add(gpuVa, list);
             }
@@ -117,42 +108,42 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="state">Current GPU state</param>
         /// <param name="addresses">Addresses of the shaders for each stage</param>
         /// <returns>Compiled graphics shader code</returns>
-        public GraphicsShader GetGraphicsShader(GpuState state, ShaderAddresses addresses)
+        public ShaderBundle GetGraphicsShader(GpuState state, ShaderAddresses addresses)
         {
-            bool isCached = _gpPrograms.TryGetValue(addresses, out List<GraphicsShader> list);
+            bool isCached = _gpPrograms.TryGetValue(addresses, out List<ShaderBundle> list);
 
             if (isCached)
             {
-                foreach (GraphicsShader cachedGpShaders in list)
+                foreach (ShaderBundle cachedGpShaders in list)
                 {
-                    if (!IsShaderDifferent(cachedGpShaders, addresses))
+                    if (IsShaderEqual(cachedGpShaders, addresses))
                     {
                         return cachedGpShaders;
                     }
                 }
             }
 
-            GraphicsShader gpShaders = new GraphicsShader();
+            ShaderCodeHolder[] shaders = new ShaderCodeHolder[Constants.ShaderStages];
 
             if (addresses.VertexA != 0)
             {
-                gpShaders.Shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex, addresses.VertexA);
+                shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex, addresses.VertexA);
             }
             else
             {
-                gpShaders.Shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex);
+                shaders[0] = TranslateGraphicsShader(state, ShaderStage.Vertex, addresses.Vertex);
             }
 
-            gpShaders.Shaders[1] = TranslateGraphicsShader(state, ShaderStage.TessellationControl,    addresses.TessControl);
-            gpShaders.Shaders[2] = TranslateGraphicsShader(state, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
-            gpShaders.Shaders[3] = TranslateGraphicsShader(state, ShaderStage.Geometry,               addresses.Geometry);
-            gpShaders.Shaders[4] = TranslateGraphicsShader(state, ShaderStage.Fragment,               addresses.Fragment);
+            shaders[1] = TranslateGraphicsShader(state, ShaderStage.TessellationControl,    addresses.TessControl);
+            shaders[2] = TranslateGraphicsShader(state, ShaderStage.TessellationEvaluation, addresses.TessEvaluation);
+            shaders[3] = TranslateGraphicsShader(state, ShaderStage.Geometry,               addresses.Geometry);
+            shaders[4] = TranslateGraphicsShader(state, ShaderStage.Fragment,               addresses.Fragment);
 
             List<IShader> hostShaders = new List<IShader>();
 
-            for (int stage = 0; stage < gpShaders.Shaders.Length; stage++)
+            for (int stage = 0; stage < Constants.ShaderStages; stage++)
             {
-                ShaderProgram program = gpShaders.Shaders[stage]?.Program;
+                ShaderProgram program = shaders[stage]?.Program;
 
                 if (program == null)
                 {
@@ -161,16 +152,18 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
                 IShader hostShader = _context.Renderer.CompileShader(program);
 
-                gpShaders.Shaders[stage].HostShader = hostShader;
+                shaders[stage].HostShader = hostShader;
 
                 hostShaders.Add(hostShader);
             }
 
-            gpShaders.HostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray());
+            IProgram hostProgram = _context.Renderer.CreateProgram(hostShaders.ToArray());
+
+            ShaderBundle gpShaders = new ShaderBundle(hostProgram, shaders);
 
             if (!isCached)
             {
-                list = new List<GraphicsShader>();
+                list = new List<ShaderBundle>();
 
                 _gpPrograms.Add(addresses, list);
             }
@@ -181,27 +174,27 @@ namespace Ryujinx.Graphics.Gpu.Shader
         }
 
         /// <summary>
-        /// Checks if compute shader code in memory is different from the cached shader.
+        /// Checks if compute shader code in memory is equal to the cached shader.
         /// </summary>
         /// <param name="cpShader">Cached compute shader</param>
         /// <param name="gpuVa">GPU virtual address of the shader code in memory</param>
         /// <returns>True if the code is different, false otherwise</returns>
-        private bool IsShaderDifferent(ComputeShader cpShader, ulong gpuVa)
+        private bool IsShaderEqual(ShaderBundle cpShader, ulong gpuVa)
         {
-            return IsShaderDifferent(cpShader.Shader, gpuVa);
+            return IsShaderEqual(cpShader.Shaders[0], gpuVa);
         }
 
         /// <summary>
-        /// Checks if graphics shader code from all stages in memory is different from the cached shaders.
+        /// Checks if graphics shader code from all stages in memory are equal to the cached shaders.
         /// </summary>
         /// <param name="gpShaders">Cached graphics shaders</param>
         /// <param name="addresses">GPU virtual addresses of all enabled shader stages</param>
         /// <returns>True if the code is different, false otherwise</returns>
-        private bool IsShaderDifferent(GraphicsShader gpShaders, ShaderAddresses addresses)
+        private bool IsShaderEqual(ShaderBundle gpShaders, ShaderAddresses addresses)
         {
             for (int stage = 0; stage < gpShaders.Shaders.Length; stage++)
             {
-                CachedShader shader = gpShaders.Shaders[stage];
+                ShaderCodeHolder shader = gpShaders.Shaders[stage];
 
                 ulong gpuVa = 0;
 
@@ -214,13 +207,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
                     case 4: gpuVa = addresses.Fragment;       break;
                 }
 
-                if (IsShaderDifferent(shader, gpuVa))
+                if (!IsShaderEqual(shader, gpuVa, addresses.VertexA))
                 {
-                    return true;
+                    return false;
                 }
             }
 
-            return false;
+            return true;
         }
 
         /// <summary>
@@ -228,17 +221,27 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// </summary>
         /// <param name="shader">Cached shader to compare with</param>
         /// <param name="gpuVa">GPU virtual address of the binary shader code</param>
+        /// <param name="gpuVaA">Optional GPU virtual address of the "Vertex A" binary shader code</param>
         /// <returns>True if the code is different, false otherwise</returns>
-        private bool IsShaderDifferent(CachedShader shader, ulong gpuVa)
+        private bool IsShaderEqual(ShaderCodeHolder shader, ulong gpuVa, ulong gpuVaA = 0)
         {
             if (shader == null)
             {
-                return false;
+                return true;
             }
 
-            ReadOnlySpan<byte> memoryCode = _context.MemoryAccessor.GetSpan(gpuVa, (ulong)shader.Code.Length * 4);
+            ReadOnlySpan<byte> memoryCode = _context.MemoryAccessor.GetSpan(gpuVa, shader.Code.Length);
 
-            return !MemoryMarshal.Cast<byte, int>(memoryCode).SequenceEqual(shader.Code);
+            bool equals = memoryCode.SequenceEqual(shader.Code);
+
+            if (equals && shader.Code2 != null)
+            {
+                memoryCode = _context.MemoryAccessor.GetSpan(gpuVaA, shader.Code2.Length);
+
+                equals = memoryCode.SequenceEqual(shader.Code2);
+            }
+
+            return equals;
         }
 
         /// <summary>
@@ -252,7 +255,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="localMemorySize">Local memory size of the compute shader</param>
         /// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
         /// <returns>Compiled compute shader code</returns>
-        private CachedShader TranslateComputeShader(
+        private ShaderCodeHolder TranslateComputeShader(
             GpuState state,
             ulong gpuVa,
             int localSizeX,
@@ -266,40 +269,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 return null;
             }
 
-            int QueryInfo(QueryInfoName info, int index)
-            {
-                return info switch
-                {
-                    QueryInfoName.ComputeLocalSizeX
-                        => localSizeX,
-                    QueryInfoName.ComputeLocalSizeY
-                        => localSizeY,
-                    QueryInfoName.ComputeLocalSizeZ
-                        => localSizeZ,
-                    QueryInfoName.ComputeLocalMemorySize
-                        => localMemorySize,
-                    QueryInfoName.ComputeSharedMemorySize
-                        => sharedMemorySize,
-                    QueryInfoName.IsTextureBuffer
-                        => Convert.ToInt32(QueryIsTextureBuffer(state, 0, index, compute: true)),
-                    QueryInfoName.IsTextureRectangle
-                        => Convert.ToInt32(QueryIsTextureRectangle(state, 0, index, compute: true)),
-                    QueryInfoName.TextureFormat
-                        => (int)QueryTextureFormat(state, 0, index, compute: true),
-                    _
-                        => QueryInfoCommon(info)
-                };
-            }
-
-            TranslatorCallbacks callbacks = new TranslatorCallbacks(QueryInfo, PrintLog);
+            GpuAccessor gpuAccessor = new GpuAccessor(_context, state, localSizeX, localSizeY, localSizeZ, localMemorySize, sharedMemorySize);
 
             ShaderProgram program;
 
-            ReadOnlySpan<byte> code = _context.MemoryAccessor.GetSpan(gpuVa, MaxProgramSize);
+            program = Translator.Translate(gpuVa, gpuAccessor, DefaultFlags | TranslationFlags.Compute);
 
-            program = Translator.Translate(code, callbacks, DefaultFlags | TranslationFlags.Compute);
-
-            int[] codeCached = MemoryMarshal.Cast<byte, int>(code.Slice(0, program.Size)).ToArray();
+            byte[] code = _context.MemoryAccessor.ReadBytes(gpuVa, program.Size);
 
             _dumper.Dump(code, compute: true, out string fullPath, out string codePath);
 
@@ -309,7 +285,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                 program.Prepend("// " + fullPath);
             }
 
-            return new CachedShader(program, codeCached);
+            return new ShaderCodeHolder(program, code);
         }
 
         /// <summary>
@@ -323,45 +299,21 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="gpuVa">GPU virtual address of the shader code</param>
         /// <param name="gpuVaA">Optional GPU virtual address of the "Vertex A" shader code</param>
         /// <returns>Compiled graphics shader code</returns>
-        private CachedShader TranslateGraphicsShader(GpuState state, ShaderStage stage, ulong gpuVa, ulong gpuVaA = 0)
+        private ShaderCodeHolder TranslateGraphicsShader(GpuState state, ShaderStage stage, ulong gpuVa, ulong gpuVaA = 0)
         {
             if (gpuVa == 0)
             {
                 return null;
             }
 
-            int QueryInfo(QueryInfoName info, int index)
-            {
-                return info switch
-                {
-                    QueryInfoName.IsTextureBuffer
-                        => Convert.ToInt32(QueryIsTextureBuffer(state, (int)stage - 1, index, compute: false)),
-                    QueryInfoName.IsTextureRectangle
-                        => Convert.ToInt32(QueryIsTextureRectangle(state, (int)stage - 1, index, compute: false)),
-                    QueryInfoName.PrimitiveTopology
-                        => (int)QueryPrimitiveTopology(),
-                    QueryInfoName.TextureFormat
-                        => (int)QueryTextureFormat(state, (int)stage - 1, index, compute: false),
-                    _
-                        => QueryInfoCommon(info)
-                };
-            }
-
-            TranslatorCallbacks callbacks = new TranslatorCallbacks(QueryInfo, PrintLog);
-
-            ShaderProgram program;
-
-            int[] codeCached = null;
+            GpuAccessor gpuAccessor = new GpuAccessor(_context, state, (int)stage - 1);
 
             if (gpuVaA != 0)
             {
-                ReadOnlySpan<byte> codeA = _context.MemoryAccessor.GetSpan(gpuVaA, MaxProgramSize);
-                ReadOnlySpan<byte> codeB = _context.MemoryAccessor.GetSpan(gpuVa,  MaxProgramSize);
+                ShaderProgram program = Translator.Translate(gpuVaA, gpuVa, gpuAccessor, DefaultFlags);
 
-                program = Translator.Translate(codeA, codeB, callbacks, DefaultFlags);
-
-                // TODO: We should also take "codeA" into account.
-                codeCached = MemoryMarshal.Cast<byte, int>(codeB.Slice(0, program.Size)).ToArray();
+                byte[] codeA = _context.MemoryAccessor.ReadBytes(gpuVaA, program.SizeA);
+                byte[] codeB = _context.MemoryAccessor.ReadBytes(gpuVa,  program.Size);
 
                 _dumper.Dump(codeA, compute: false, out string fullPathA, out string codePathA);
                 _dumper.Dump(codeB, compute: false, out string fullPathB, out string codePathB);
@@ -373,14 +325,14 @@ namespace Ryujinx.Graphics.Gpu.Shader
                     program.Prepend("// " + codePathA);
                     program.Prepend("// " + fullPathA);
                 }
+
+                return new ShaderCodeHolder(program, codeB, codeA);
             }
             else
             {
-                ReadOnlySpan<byte> code = _context.MemoryAccessor.GetSpan(gpuVa, MaxProgramSize);
-
-                program = Translator.Translate(code, callbacks, DefaultFlags);
+                ShaderProgram program = Translator.Translate(gpuVa, gpuAccessor, DefaultFlags);
 
-                codeCached = MemoryMarshal.Cast<byte, int>(code.Slice(0, program.Size)).ToArray();
+                byte[] code = _context.MemoryAccessor.ReadBytes(gpuVa, program.Size);
 
                 _dumper.Dump(code, compute: false, out string fullPath, out string codePath);
 
@@ -389,195 +341,9 @@ namespace Ryujinx.Graphics.Gpu.Shader
                     program.Prepend("// " + codePath);
                     program.Prepend("// " + fullPath);
                 }
-            }
-
-            ulong address = _context.MemoryManager.Translate(gpuVa);
-
-            return new CachedShader(program, codeCached);
-        }
-
-        /// <summary>
-        /// Gets the primitive topology for the current draw.
-        /// This is required by geometry shaders.
-        /// </summary>
-        /// <returns>Primitive topology</returns>
-        private InputTopology QueryPrimitiveTopology()
-        {
-            switch (_context.Methods.PrimitiveType)
-            {
-                case PrimitiveType.Points:
-                    return InputTopology.Points;
-                case PrimitiveType.Lines:
-                case PrimitiveType.LineLoop:
-                case PrimitiveType.LineStrip:
-                    return InputTopology.Lines;
-                case PrimitiveType.LinesAdjacency:
-                case PrimitiveType.LineStripAdjacency:
-                    return InputTopology.LinesAdjacency;
-                case PrimitiveType.Triangles:
-                case PrimitiveType.TriangleStrip:
-                case PrimitiveType.TriangleFan:
-                    return InputTopology.Triangles;
-                case PrimitiveType.TrianglesAdjacency:
-                case PrimitiveType.TriangleStripAdjacency:
-                    return InputTopology.TrianglesAdjacency;
-            }
-
-            return InputTopology.Points;
-        }
-
-        /// <summary>
-        /// Check if the target of a given texture is texture buffer.
-        /// This is required as 1D textures and buffer textures shares the same sampler type on binary shader code,
-        /// but not on GLSL.
-        /// </summary>
-        /// <param name="state">Current GPU state</param>
-        /// <param name="stageIndex">Index of the shader stage</param>
-        /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
-        /// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
-        /// <returns>True if the texture is a buffer texture, false otherwise</returns>
-        private bool QueryIsTextureBuffer(GpuState state, int stageIndex, int handle, bool compute)
-        {
-            return GetTextureDescriptor(state, stageIndex, handle, compute).UnpackTextureTarget() == TextureTarget.TextureBuffer;
-        }
-
-        /// <summary>
-        /// Check if the target of a given texture is texture rectangle.
-        /// This is required as 2D textures and rectangle textures shares the same sampler type on binary shader code,
-        /// but not on GLSL.
-        /// </summary>
-        /// <param name="state">Current GPU state</param>
-        /// <param name="stageIndex">Index of the shader stage</param>
-        /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
-        /// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
-        /// <returns>True if the texture is a rectangle texture, false otherwise</returns>
-        private bool QueryIsTextureRectangle(GpuState state, int stageIndex, int handle, bool compute)
-        {
-            var descriptor = GetTextureDescriptor(state, stageIndex, handle, compute);
-
-            TextureTarget target = descriptor.UnpackTextureTarget();
-
-            bool is2DTexture = target == TextureTarget.Texture2D ||
-                               target == TextureTarget.Texture2DRect;
 
-            return !descriptor.UnpackTextureCoordNormalized() && is2DTexture;
-        }
-
-        /// <summary>
-        /// Queries the format of a given texture.
-        /// </summary>
-        /// <param name="state">Current GPU state</param>
-        /// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
-        /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
-        /// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
-        /// <returns>The texture format</returns>
-        private TextureFormat QueryTextureFormat(GpuState state, int stageIndex, int handle, bool compute)
-        {
-            return QueryTextureFormat(GetTextureDescriptor(state, stageIndex, handle, compute));
-        }
-
-        /// <summary>
-        /// Queries the format of a given texture.
-        /// </summary>
-        /// <param name="descriptor">Descriptor of the texture from the texture pool</param>
-        /// <returns>The texture format</returns>
-        private static TextureFormat QueryTextureFormat(TextureDescriptor descriptor)
-        {
-            if (!FormatTable.TryGetTextureFormat(descriptor.UnpackFormat(), descriptor.UnpackSrgb(), out FormatInfo formatInfo))
-            {
-                return TextureFormat.Unknown;
+                return new ShaderCodeHolder(program, code);
             }
-
-            return formatInfo.Format switch
-            {
-                Format.R8Unorm           => TextureFormat.R8Unorm,
-                Format.R8Snorm           => TextureFormat.R8Snorm,
-                Format.R8Uint            => TextureFormat.R8Uint,
-                Format.R8Sint            => TextureFormat.R8Sint,
-                Format.R16Float          => TextureFormat.R16Float,
-                Format.R16Unorm          => TextureFormat.R16Unorm,
-                Format.R16Snorm          => TextureFormat.R16Snorm,
-                Format.R16Uint           => TextureFormat.R16Uint,
-                Format.R16Sint           => TextureFormat.R16Sint,
-                Format.R32Float          => TextureFormat.R32Float,
-                Format.R32Uint           => TextureFormat.R32Uint,
-                Format.R32Sint           => TextureFormat.R32Sint,
-                Format.R8G8Unorm         => TextureFormat.R8G8Unorm,
-                Format.R8G8Snorm         => TextureFormat.R8G8Snorm,
-                Format.R8G8Uint          => TextureFormat.R8G8Uint,
-                Format.R8G8Sint          => TextureFormat.R8G8Sint,
-                Format.R16G16Float       => TextureFormat.R16G16Float,
-                Format.R16G16Unorm       => TextureFormat.R16G16Unorm,
-                Format.R16G16Snorm       => TextureFormat.R16G16Snorm,
-                Format.R16G16Uint        => TextureFormat.R16G16Uint,
-                Format.R16G16Sint        => TextureFormat.R16G16Sint,
-                Format.R32G32Float       => TextureFormat.R32G32Float,
-                Format.R32G32Uint        => TextureFormat.R32G32Uint,
-                Format.R32G32Sint        => TextureFormat.R32G32Sint,
-                Format.R8G8B8A8Unorm     => TextureFormat.R8G8B8A8Unorm,
-                Format.R8G8B8A8Snorm     => TextureFormat.R8G8B8A8Snorm,
-                Format.R8G8B8A8Uint      => TextureFormat.R8G8B8A8Uint,
-                Format.R8G8B8A8Sint      => TextureFormat.R8G8B8A8Sint,
-                Format.R16G16B16A16Float => TextureFormat.R16G16B16A16Float,
-                Format.R16G16B16A16Unorm => TextureFormat.R16G16B16A16Unorm,
-                Format.R16G16B16A16Snorm => TextureFormat.R16G16B16A16Snorm,
-                Format.R16G16B16A16Uint  => TextureFormat.R16G16B16A16Uint,
-                Format.R16G16B16A16Sint  => TextureFormat.R16G16B16A16Sint,
-                Format.R32G32B32A32Float => TextureFormat.R32G32B32A32Float,
-                Format.R32G32B32A32Uint  => TextureFormat.R32G32B32A32Uint,
-                Format.R32G32B32A32Sint  => TextureFormat.R32G32B32A32Sint,
-                Format.R10G10B10A2Unorm  => TextureFormat.R10G10B10A2Unorm,
-                Format.R10G10B10A2Uint   => TextureFormat.R10G10B10A2Uint,
-                Format.R11G11B10Float    => TextureFormat.R11G11B10Float,
-                _                        => TextureFormat.Unknown
-            };
-        }
-
-        /// <summary>
-        /// Gets the texture descriptor for a given texture on the pool.
-        /// </summary>
-        /// <param name="state">Current GPU state</param>
-        /// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
-        /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
-        /// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
-        /// <returns>Texture descriptor</returns>
-        private TextureDescriptor GetTextureDescriptor(GpuState state, int stageIndex, int handle, bool compute)
-        {
-            if (compute)
-            {
-                return _context.Methods.TextureManager.GetComputeTextureDescriptor(state, handle);
-            }
-            else
-            {
-                return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(state, stageIndex, handle);
-            }
-        }
-
-        /// <summary>
-        /// Returns information required by both compute and graphics shader compilation.
-        /// </summary>
-        /// <param name="info">Information queried</param>
-        /// <returns>Requested information</returns>
-        private int QueryInfoCommon(QueryInfoName info)
-        {
-            return info switch
-            {
-                QueryInfoName.StorageBufferOffsetAlignment
-                    => _context.Capabilities.StorageBufferOffsetAlignment,
-                QueryInfoName.SupportsNonConstantTextureOffset
-                    => Convert.ToInt32(_context.Capabilities.SupportsNonConstantTextureOffset),
-                _
-                    => 0
-            };
-        }
-
-        /// <summary>
-        /// Prints a warning from the shader code translator.
-        /// </summary>
-        /// <param name="message">Warning message</param>
-        private static void PrintLog(string message)
-        {
-            Logger.PrintWarning(LogClass.Gpu, $"Shader translator: {message}");
         }
 
         /// <summary>
@@ -586,25 +352,19 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// </summary>
         public void Dispose()
         {
-            foreach (List<ComputeShader> list in _cpPrograms.Values)
+            foreach (List<ShaderBundle> list in _cpPrograms.Values)
             {
-                foreach (ComputeShader shader in list)
+                foreach (ShaderBundle bundle in list)
                 {
-                    shader.HostProgram.Dispose();
-                    shader.Shader?.HostShader.Dispose();
+                    bundle.Dispose();
                 }
             }
 
-            foreach (List<GraphicsShader> list in _gpPrograms.Values)
+            foreach (List<ShaderBundle> list in _gpPrograms.Values)
             {
-                foreach (GraphicsShader shader in list)
+                foreach (ShaderBundle bundle in list)
                 {
-                    shader.HostProgram.Dispose();
-
-                    foreach (CachedShader cachedShader in shader.Shaders)
-                    {
-                        cachedShader?.HostShader.Dispose();
-                    }
+                    bundle.Dispose();
                 }
             }
         }
author	gdkchan <gab.dark.100@gmail.com>	2020-05-05 22:02:28 -0300
committer	GitHub <noreply@github.com>	2020-05-06 11:02:28 +1000
commit	b8eb6abeccbd4a468214a4d2ad3a9b6e5e06973c (patch)
tree	cd3d71ebde0f4f32eb674778adae89c0efcb75df /Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs
parent	7f500e7cae940958289abe1a3461e52684742053 (diff)