Allow overriding of GL-specific shader logic for testing purposes

osu.Framework/Graphics/Shaders/Shader.cs

···
         private int programID = -1;
 
         internal readonly Dictionary<string, IUniform> Uniforms = new Dictionary<string, IUniform>();
-        private IUniform[] uniformsArray;
         private readonly List<ShaderPart> parts;
 
         internal Shader(string name, List<ShaderPart> parts)
···
         {
             parts.RemoveAll(p => p == null);
             Uniforms.Clear();
-            uniformsArray = null;
 
             if (parts.Count == 0)
                 return;
 
-            programID = GL.CreateProgram();
+            programID = CreateProgram();
+
+            if (!CompileInternal())
+                throw new ProgramLinkingFailedException(name, GetProgramLog());
+
+            IsLoaded = true;
+
+            SetupUniforms();
+
+            GlobalPropertyManager.Register(this);
+        }
+
+        internal void EnsureLoaded()
+        {
+            if (!IsLoaded)
+                Compile();
+        }
+
+        public void Bind()
+        {
+            if (IsBound)
+                return;
+
+            EnsureLoaded();
+
+            GLWrapper.UseProgram(this);
+
+            foreach (var uniform in Uniforms.Values)
+                uniform?.Update();
+
+            IsBound = true;
+        }
+
+        public void Unbind()
+        {
+            if (!IsBound)
+                return;
+
+            GLWrapper.UseProgram(null);
+
+            IsBound = false;
+        }
+
+        /// <summary>
+        /// Returns a uniform from the shader.
+        /// </summary>
+        /// <param name="name">The name of the uniform.</param>
+        /// <returns>Returns a base uniform.</returns>
+        public Uniform<T> GetUniform<T>(string name)
+            where T : struct, IEquatable<T>
+        {
+            EnsureLoaded();
+
+            return (Uniform<T>)Uniforms[name];
+        }
 
+        protected virtual bool CompileInternal()
+        {
             foreach (ShaderPart p in parts)
             {
                 if (!p.Compiled) p.Compile();
···
             foreach (var part in parts)
                 GL.DetachShader(this, part);
 
-            IsLoaded = linkResult == 1;
+            return linkResult == 1;
+        }
 
-            if (!IsLoaded)
-                throw new ProgramLinkingFailedException(name, GL.GetProgramInfoLog(this));
-
-            // Obtain all the shader uniforms
+        protected virtual void SetupUniforms()
+        {
             GL.GetProgram(this, GetProgramParameterName.ActiveUniforms, out int uniformCount);
-            uniformsArray = new IUniform[uniformCount];
 
             for (int i = 0; i < uniformCount; i++)
             {
                 GL.GetActiveUniform(this, i, 100, out _, out _, out ActiveUniformType type, out string uniformName);
 
-                IUniform createUniform<T>(string name)
-                    where T : struct, IEquatable<T>
-                {
-                    int location = GL.GetUniformLocation(this, name);
-
-                    if (GlobalPropertyManager.CheckGlobalExists(name)) return new GlobalUniform<T>(this, name, location);
-
-                    return new Uniform<T>(this, name, location);
-                }
-
-                IUniform uniform;
-
                 switch (type)
                 {
                     case ActiveUniformType.Bool:
-                        uniform = createUniform<bool>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<bool>(uniformName));
                         break;
 
                     case ActiveUniformType.Float:
-                        uniform = createUniform<float>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<float>(uniformName));
                         break;
 
                     case ActiveUniformType.Int:
-                        uniform = createUniform<int>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<int>(uniformName));
                         break;
 
                     case ActiveUniformType.FloatMat3:
-                        uniform = createUniform<Matrix3>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<Matrix3>(uniformName));
                         break;
 
                     case ActiveUniformType.FloatMat4:
-                        uniform = createUniform<Matrix4>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<Matrix4>(uniformName));
                         break;
 
                     case ActiveUniformType.FloatVec2:
-                        uniform = createUniform<Vector2>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<Vector2>(uniformName));
                         break;
 
                     case ActiveUniformType.FloatVec3:
-                        uniform = createUniform<Vector3>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<Vector3>(uniformName));
                         break;
 
                     case ActiveUniformType.FloatVec4:
-                        uniform = createUniform<Vector4>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<Vector4>(uniformName));
                         break;
 
                     case ActiveUniformType.Sampler2D:
-                        uniform = createUniform<int>(uniformName);
+                        Uniforms.Add(uniformName, createUniform<int>(uniformName));
                         break;
-
-                    default:
-                        continue;
                 }
-
-                uniformsArray[i] = uniform;
-                Uniforms.Add(uniformName, uniformsArray[i]);
             }
 
-            GlobalPropertyManager.Register(this);
-        }
-
-        internal void EnsureLoaded()
-        {
-            if (!IsLoaded)
-                Compile();
-        }
-
-        public void Bind()
-        {
-            if (IsBound)
-                return;
-
-            EnsureLoaded();
-
-            GLWrapper.UseProgram(this);
+            IUniform createUniform<T>(string name)
+                where T : struct, IEquatable<T>
+            {
+                int location = GL.GetUniformLocation(this, name);
 
-            foreach (var uniform in uniformsArray)
-                uniform?.Update();
+                if (GlobalPropertyManager.CheckGlobalExists(name)) return new GlobalUniform<T>(this, name, location);
 
-            IsBound = true;
+                return new Uniform<T>(this, name, location);
+            }
         }
 
-        public void Unbind()
-        {
-            if (!IsBound)
-                return;
+        protected virtual string GetProgramLog() => GL.GetProgramInfoLog(this);
 
-            GLWrapper.UseProgram(null);
+        protected virtual int CreateProgram() => GL.CreateProgram();
 
-            IsBound = false;
+        protected virtual void DeleteProgram(int id)
+        {
+            if (id != -1)
+                GL.DeleteProgram(id);
         }
 
         public override string ToString() => $@"{name} Shader (Compiled: {programID != -1})";
 
-        /// <summary>
-        /// Returns a uniform from the shader.
-        /// </summary>
-        /// <param name="name">The name of the uniform.</param>
-        /// <returns>Returns a base uniform.</returns>
-        public Uniform<T> GetUniform<T>(string name)
-            where T : struct, IEquatable<T>
-        {
-            EnsureLoaded();
+        public static implicit operator int(Shader shader) => shader.programID;
 
-            return (Uniform<T>)Uniforms[name];
-        }
-
-        public static implicit operator int(Shader shader) => shader.programID;
+        #region IDisposable Support
 
         protected internal bool IsDisposed { get; private set; }
 
···
 
                 GlobalPropertyManager.Unregister(this);
 
-                if (programID != -1)
-                    GL.DeleteProgram(this);
+                DeleteProgram(this);
             }
         }
+
+        #endregion
 
         public class PartCompilationFailedException : Exception
         {

osu.Framework/Graphics/Shaders/ShaderManager.cs

···
                 createShaderPart(fragment, ShaderType.FragmentShader)
             };
 
-            return shaderCache[tuple] = new Shader($"{vertex}/{fragment}", parts);
+            return shaderCache[tuple] = CreateShader($"{vertex}/{fragment}", parts);
         }
+
+        internal virtual Shader CreateShader(string name, List<ShaderPart> parts) => new Shader(name, parts);
 
         private ShaderPart createShaderPart(string name, ShaderType type, bool bypassCache = false)
         {