Implementation of UBOs instead of uniform constant arrays (#186)

* Sort uniform binding to avoid possible failures in drivers fewer bindings

* Throw exception for Cbuf overflow

* Search for free bindings instead of using locked ones

* EnsureAllocated when binding buffers

* Fix uniform bindings

* Remove spaces

* Use 64 KiB UBOs when available

* Remove double colon

* Use IdentationStr and avoid division in Cbuf offset

* Add spaces

Ryujinx.Graphics/Gal/OpenGL/OGLShader.cs

@@ -69,6 +69,8 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             public ShaderStage Fragment;
         }
 
+        const int ConstBuffersPerStage = 18;
+
         private ShaderProgram Current;
 
         private ConcurrentDictionary<long, ShaderStage> Stages;
@@ -77,11 +79,20 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
         public int CurrentProgramHandle { get; private set; }
 
+        private OGLStreamBuffer[][] ConstBuffers;
+
         public OGLShader()
         {
             Stages = new ConcurrentDictionary<long, ShaderStage>();
 
             Programs = new Dictionary<ShaderProgram, int>();
+
+            ConstBuffers = new OGLStreamBuffer[5][];
+
+            for (int i = 0; i < 5; i++)
+            {
+                ConstBuffers[i] = new OGLStreamBuffer[ConstBuffersPerStage];
+            }
         }
 
         public void Create(IGalMemory Memory, long Key, GalShaderType Type)
@@ -119,27 +130,19 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
         public void SetConstBuffer(long Key, int Cbuf, byte[] Data)
         {
-            BindProgram();
-
             if (Stages.TryGetValue(Key, out ShaderStage Stage))
             {
                 foreach (ShaderDeclInfo DeclInfo in Stage.UniformUsage.Where(x => x.Cbuf == Cbuf))
                 {
-                    int Location = GL.GetUniformLocation(CurrentProgramHandle, DeclInfo.Name);
+                    OGLStreamBuffer Buffer = GetConstBuffer(Stage.Type, Cbuf);
 
-                    int Count = Data.Length >> 2;
+                    int Size = Math.Min(Data.Length, Buffer.Size);
 
-                    //The Index is the index of the last element,
-                    //so we can add 1 to get the uniform array size.
-                    Count = Math.Min(Count, DeclInfo.Index + 1);
+                    byte[] Destiny = Buffer.Map(Size);
 
-                    unsafe
-                    {
-                        fixed (byte* Ptr = Data)
-                        {
-                            GL.Uniform1(Location, Count, (float*)Ptr);
-                        }
-                    }
+                    Array.Copy(Data, Destiny, Size);
+
+                    Buffer.Unmap(Size);
                 }
             }
         }
@@ -204,11 +207,15 @@ namespace Ryujinx.Graphics.Gal.OpenGL
 
                 CheckProgramLink(Handle);
 
+                BindUniformBlocks(Handle);
+
                 Programs.Add(Current, Handle);
             }
 
             GL.UseProgram(Handle);
 
+            BindUniformBuffers(Handle);
+
             CurrentProgramHandle = Handle;
         }
 
@@ -222,6 +229,87 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             }
         }
 
+        private void BindUniformBlocks(int ProgramHandle)
+        {
+            int FreeBinding = 0;
+
+            int BindUniformBlocksIfNotNull(ShaderStage Stage)
+            {
+                if (Stage != null)
+                {
+                    foreach (ShaderDeclInfo DeclInfo in Stage.UniformUsage)
+                    {
+                        int BlockIndex = GL.GetUniformBlockIndex(ProgramHandle, DeclInfo.Name);
+
+                        if (BlockIndex < 0)
+                        {
+                            //It is expected that its found, if it's not then driver might be in a malfunction
+                            throw new InvalidOperationException();
+                        }
+
+                        GL.UniformBlockBinding(ProgramHandle, BlockIndex, FreeBinding);
+
+                        FreeBinding++;
+                    }
+                }
+
+                return FreeBinding;
+            }
+
+            BindUniformBlocksIfNotNull(Current.Vertex);
+            BindUniformBlocksIfNotNull(Current.TessControl);
+            BindUniformBlocksIfNotNull(Current.TessEvaluation);
+            BindUniformBlocksIfNotNull(Current.Geometry);
+            BindUniformBlocksIfNotNull(Current.Fragment);
+        }
+
+        private void BindUniformBuffers(int ProgramHandle)
+        {
+            int FreeBinding = 0;
+
+            int BindUniformBuffersIfNotNull(ShaderStage Stage)
+            {
+                if (Stage != null)
+                {
+                    foreach (ShaderDeclInfo DeclInfo in Stage.UniformUsage)
+                    {
+                        OGLStreamBuffer Buffer = GetConstBuffer(Stage.Type, DeclInfo.Cbuf);
+
+                        GL.BindBufferBase(BufferRangeTarget.UniformBuffer, FreeBinding, Buffer.Handle);
+
+                        FreeBinding++;
+                    }
+                }
+
+                return FreeBinding;
+            }
+            
+            BindUniformBuffersIfNotNull(Current.Vertex);
+            BindUniformBuffersIfNotNull(Current.TessControl);
+            BindUniformBuffersIfNotNull(Current.TessEvaluation);
+            BindUniformBuffersIfNotNull(Current.Geometry);
+            BindUniformBuffersIfNotNull(Current.Fragment);
+        }
+
+        private OGLStreamBuffer GetConstBuffer(GalShaderType StageType, int Cbuf)
+        {
+            int StageIndex = (int)StageType;
+
+            OGLStreamBuffer Buffer = ConstBuffers[StageIndex][Cbuf];
+
+            if (Buffer == null)
+            {
+                //Allocate a maximum of 64 KiB
+                int Size = Math.Min(GL.GetInteger(GetPName.MaxUniformBlockSize), 64 * 1024);
+
+                Buffer = OGLStreamBuffer.Create(BufferTarget.UniformBuffer, Size);
+
+                ConstBuffers[StageIndex][Cbuf] = Buffer;
+            }
+
+            return Buffer;
+        }
+
         public static void CompileAndCheck(int Handle, string Code)
         {
             GL.ShaderSource(Handle, Code);

Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs

@@ -0,0 +1,113 @@
+using System;
+using OpenTK.Graphics.OpenGL;
+
+namespace Ryujinx.Graphics.Gal.OpenGL
+{
+    abstract class OGLStreamBuffer : IDisposable
+    {
+        public int Handle { get; protected set; }
+
+        public int Size { get; protected set; }
+
+        protected BufferTarget Target { get; private set; }
+
+        private bool Mapped = false;
+
+        public OGLStreamBuffer(BufferTarget Target, int MaxSize)
+        {
+            Handle = 0;
+            Mapped = false;
+
+            this.Target = Target;
+            this.Size = MaxSize;
+        }
+
+        public static OGLStreamBuffer Create(BufferTarget Target, int MaxSize)
+        {
+            //TODO: Query here for ARB_buffer_storage and use when available
+            return new SubDataBuffer(Target, MaxSize);
+        }
+
+        public byte[] Map(int Size)
+        {
+            if (Handle == 0 || Mapped || Size > this.Size)
+            {
+                throw new InvalidOperationException();
+            }
+
+            byte[] Memory = InternMap(Size);
+
+            Mapped = true;
+
+            return Memory;
+        }
+
+        public void Unmap(int UsedSize)
+        {
+            if (Handle == 0 || !Mapped)
+            {
+                throw new InvalidOperationException();
+            }
+
+            InternUnmap(UsedSize);
+
+            Mapped = false;
+        }
+
+        protected abstract byte[] InternMap(int Size);
+
+        protected abstract void InternUnmap(int UsedSize);
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool Disposing)
+        {
+            if (Disposing && Handle != 0)
+            {
+                GL.DeleteBuffer(Handle);
+
+                Handle = 0;
+            }
+        }
+    }
+
+    class SubDataBuffer : OGLStreamBuffer
+    {
+        private byte[] Memory;
+
+        public SubDataBuffer(BufferTarget Target, int MaxSize)
+            : base(Target, MaxSize)
+        {
+            Memory = new byte[MaxSize];
+
+            GL.CreateBuffers(1, out int Handle);
+
+            GL.BindBuffer(Target, Handle);
+
+            GL.BufferData(Target, Size, IntPtr.Zero, BufferUsageHint.StreamDraw);
+
+            this.Handle = Handle;
+        }
+
+        protected override byte[] InternMap(int Size)
+        {
+            return Memory;
+        }
+
+        protected override void InternUnmap(int UsedSize)
+        {
+            GL.BindBuffer(Target, Handle);
+            
+            unsafe
+            {
+                fixed (byte* MemoryPtr = Memory)
+                {
+                    GL.BufferSubData(Target, IntPtr.Zero, UsedSize, (IntPtr)MemoryPtr);
+                }
+            }
+        }
+    }
+}

Ryujinx.Graphics/Gal/Shader/GlslDecompiler.cs

@@ -145,7 +145,9 @@ namespace Ryujinx.Graphics.Gal.Shader
 
             foreach (ShaderDeclInfo DeclInfo in Decl.Uniforms.Values.OrderBy(DeclKeySelector))
             {
-                SB.AppendLine($"uniform {GetDecl(DeclInfo)}[{DeclInfo.Index + 1}];");
+                SB.AppendLine($"layout (std140) uniform {DeclInfo.Name} {{");
+                SB.AppendLine($"{IdentationStr}vec4 {DeclInfo.Name}_data[{DeclInfo.Index / 4 + 1}];");
+                SB.AppendLine($"}};");
             }
 
             if (Decl.Uniforms.Count > 0)
@@ -530,15 +532,15 @@ namespace Ryujinx.Graphics.Gal.Shader
 
             if (Cbuf.Offs != null)
             {
-                //Note: We assume that the register value is always a multiple of 4.
-                //This may not be aways the case.
-                string Offset = "(floatBitsToInt(" + GetSrcExpr(Cbuf.Offs) + ") >> 2)";
+                string Offset = "floatBitsToInt(" + GetSrcExpr(Cbuf.Offs) + ")";
 
-                return DeclInfo.Name + "[" + Cbuf.Pos + " + " + Offset + "]";
+                string Index = "(" + Cbuf.Pos * 4 + " + " + Offset + ")";
+
+                return $"{DeclInfo.Name}_data[{Index} / 16][({Index} / 4) % 4]";
             }
             else
             {
-                return DeclInfo.Name + "[" + Cbuf.Pos + "]";
+                return $"{DeclInfo.Name}_data[{Cbuf.Pos / 4}][{Cbuf.Pos % 4}]";
             }
         }