Initial implementation of texture wrapping

osu.Framework/Graphics/Lines/Path_DrawNode.cs

···
 
                 pathShader.Bind();
 
-                texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
                 texture.TextureGL.Bind();
 
                 updateVertexBuffer();

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
         /// <returns>true if the provided texture was not already bound (causing a binding change).</returns>
         public static bool BindTexture(TextureGL texture, TextureUnit unit = TextureUnit.Texture0)
         {
-            bool didBind = BindTexture(texture?.TextureId ?? 0, unit);
+            bool didBind = BindTexture(texture?.TextureId ?? 0, texture.WrapModeS, texture.WrapModeT, unit);
             last_bound_texture_is_atlas[GetTextureUnitId(unit)] = texture is TextureGLAtlas;
 
             return didBind;
         }
+
+        private static WrapMode currentWrapModeS;
+        private static WrapMode currentWrapModeT;
 
         /// <summary>
         /// Binds a texture to draw with.
···
         /// <param name="textureId">The texture to bind.</param>
         /// <param name="unit">The texture unit to bind it to.</param>
         /// <returns>true if the provided texture was not already bound (causing a binding change).</returns>
-        public static bool BindTexture(int textureId, TextureUnit unit = TextureUnit.Texture0)
+        public static bool BindTexture(int textureId, WrapMode wrapModeS = WrapMode.None, WrapMode wrapModeT = WrapMode.None, TextureUnit unit = TextureUnit.Texture0)
         {
             var index = GetTextureUnitId(unit);
+
+            if (wrapModeS != currentWrapModeS)
+            {
+                GlobalPropertyManager.Set(GlobalProperty.WrapModeS, (int)wrapModeS);
+                currentWrapModeS = wrapModeS;
+            }
+
+            if (wrapModeT != currentWrapModeT)
+            {
+                GlobalPropertyManager.Set(GlobalProperty.WrapModeT, (int)wrapModeT);
+                currentWrapModeT = wrapModeT;
+            }
 
             if (last_bound_texture[index] == textureId)
                 return false;

osu.Framework/Graphics/OpenGL/Textures/TextureGL.cs

···
     public abstract class TextureGL : IDisposable
     {
         public bool IsTransparent;
-        public TextureWrapMode WrapMode = TextureWrapMode.ClampToEdge;
+
+        public WrapMode WrapModeS;
+
+        public WrapMode WrapModeT;
 
         #region Disposal
 
···
         internal abstract void FlushUploads();
 
         public abstract void SetData(ITextureUpload upload);
+    }
+
+    public enum WrapMode
+    {
+        None = 0,
+        Clamp = 1,
+        Repeat = 2
     }
 }

osu.Framework/Graphics/OpenGL/Textures/TextureGLSingle.cs

···
         private int internalHeight;
 
         private readonly All filteringMode;
-        private TextureWrapMode internalWrapMode;
 
         /// <summary>
         /// The total amount of times this <see cref="TextureGLAtlas"/> was bound.
···
             FrameStatistics.Add(StatisticsCounterType.Pixels, (long)vertexQuad.Area);
         }
 
-        private void updateWrapMode()
-        {
-            if (!Available)
-                throw new ObjectDisposedException(ToString(), "Can not update wrap mode of a disposed texture.");
-
-            internalWrapMode = WrapMode;
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)internalWrapMode);
-            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)internalWrapMode);
-        }
-
         public override void SetData(ITextureUpload upload)
         {
             if (!Available)
···
 
             if (GLWrapper.BindTexture(this, unit))
                 BindCount++;
-
-            if (internalWrapMode != WrapMode)
-                updateWrapMode();
 
             return true;
         }
···
                     // It controls the amount of mipmap levels generated by GL.GenerateMipmap later on.
                     GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)33085, MAX_MIPMAP_LEVELS);
 
-                    updateWrapMode();
+                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Clamp);
+                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Clamp);
                 }
                 else
                     GLWrapper.BindTexture(this);

osu.Framework/Graphics/Shaders/GlobalProperty.cs

···
         DiscardInner,
         InnerCornerRadius,
         GammaCorrection,
+        WrapModeS,
+        WrapModeT,
         BackbufferDraw,
     }
 }

osu.Framework/Graphics/Shaders/GlobalPropertyManager.cs

···
             global_properties[(int)GlobalProperty.DiscardInner] = new UniformMapping<bool>("g_DiscardInner");
             global_properties[(int)GlobalProperty.InnerCornerRadius] = new UniformMapping<float>("g_InnerCornerRadius");
             global_properties[(int)GlobalProperty.GammaCorrection] = new UniformMapping<bool>("g_GammaCorrection");
+            global_properties[(int)GlobalProperty.WrapModeS] = new UniformMapping<int>("g_WrapModeS");
+            global_properties[(int)GlobalProperty.WrapModeT] = new UniformMapping<int>("g_WrapModeT");
 
             // Backbuffer internals
             global_properties[(int)GlobalProperty.BackbufferDraw] = new UniformMapping<bool>("g_BackbufferDraw");

osu.Framework/Graphics/Shapes/Box.cs

···
                 base.DrawOpaqueInterior(vertexAction);
 
                 TextureShader.Bind();
-                Texture.TextureGL.WrapMode = WrapTexture ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge;
 
                 if (GLWrapper.IsMaskingActive)
                     DrawClipped(ref conservativeScreenSpaceDrawQuad, Texture, DrawColourInfo.Colour, vertexAction: vertexAction);

osu.Framework/Graphics/Sprites/SpriteDrawNode.cs

···
             if (Texture?.Available != true)
                 return;
 
-            Texture.TextureGL.WrapMode = WrapTexture ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge;
-
             Shader.Bind();
 
             Blit(vertexAction);

osu.Framework/Graphics/UserInterface/CircularProgressDrawNode.cs

···
 
             Shader.Bind();
 
-            texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
             texture.TextureGL.Bind();
 
             updateVertexBuffer();

osu.Framework/Graphics/Video/VideoTexture.cs

···
                 throw new ObjectDisposedException(ToString(), "Can not bind a disposed texture.");
 
             for (int i = 0; i < textureIds.Length; i++)
-                GLWrapper.BindTexture(textureIds[i], unit + i);
+                GLWrapper.BindTexture(textureIds[i], 0, 0, unit + i);
 
             return true;
         }

osu.Framework/Resources/Shaders/sh_Texture.fs

···
 #include "sh_Utils.h"
+#include "sh_TextureWrapping.h"
 
 varying lowp vec4 v_Colour;
 varying mediump vec2 v_TexCoord;
+varying mediump vec4 v_TexRect;
 
 uniform lowp sampler2D m_Sampler;
 
 void main(void)
 {
-	gl_FragColor = toSRGB(v_Colour * texture2D(m_Sampler, v_TexCoord, -0.9));
+	gl_FragColor = toSRGB(v_Colour * texture2D(m_Sampler, wrap(v_TexCoord, v_TexRect), -0.9));
 }

osu.Framework/Resources/Shaders/sh_TextureRounded.fs

···
 #include "sh_Utils.h"
 #include "sh_Masking.h"
+#include "sh_TextureWrapping.h"
 
 uniform lowp sampler2D m_Sampler;
 
 void main(void) 
 {
-    gl_FragColor = getRoundedColor(toSRGB(texture2D(m_Sampler, v_TexCoord, -0.9)));
+    gl_FragColor = getRoundedColor(toSRGB(texture2D(m_Sampler, wrap(v_TexCoord, v_TexRect), -0.9)));
 }

osu.Framework/Resources/Shaders/sh_TextureWrapping.h

···
+// 0 -> None
+// 1 -> Clamp
+// 2 -> Repeat
+
+uniform int g_WrapModeS;
+uniform int g_WrapModeT;
+
+float wrap(float coord, int mode, float rangeMin, float rangeMax)
+{
+    if (mode == 1)
+    {
+        return clamp(coord, rangeMin, rangeMax);
+    }
+    else if (mode == 2)
+    {
+        return mod(coord - rangeMin, rangeMax - rangeMin) + rangeMin;
+    }
+    
+    return coord;
+}
+
+vec2 wrap(vec2 texCoord, vec4 texRect)
+{
+    return vec2(wrap(texCoord.x, g_WrapModeS, texRect[0], texRect[2]), wrap(texCoord.y, g_WrapModeT, texRect[1], texRect[3]));
+}