Holidays 12.10. -> 25.10.2020

~ Moved code around in files.

SM.Base:
+ PostProcessing-system
+ OnInitialization() for Scenes.
+ Shader-Extensions
+ Added option to not react while unfocused to the window.
+ Added Screenshots to the window.
+ Connected the log system to the SM.OGL-action system.

~ Replaced IShader with abstract MaterialShader.
~ When a log compression folder doesn't exist, it will create one.

SM.OGL:
+ Added support for UniformArrays
+ Added ShaderPreProcessing
+ Added Shader Extensions.
+ Added Debug actions.
+ SM.OGL settings

~ Framebuffer Size is automaticly changed, when the window and scale is set.

SM2D:
+ Added easy shader drawing.

SMCode/SM.OGL/Shaders/UniformCollection.cs

@@ -1,56 +1,109 @@
-using System;
+#region usings
+
+using System;
 using System.Collections.Generic;
 using OpenTK.Graphics.OpenGL4;
 
+#endregion
+
 namespace SM.OGL.Shaders
 {
-    /// <summary>
-    /// Contains and manages the uniform of the parent shader.
-    /// </summary>
-    public class UniformCollection : Dictionary<string, Uniform>
+    public class UniformCollection : Dictionary<string, IUniform>
     {
-        /// <summary>
-        /// The next texture id for the uniform.
-        /// </summary>
         internal int NextTexture = 0;
+        internal string KeyString = "";
+        public GenericShader ParentShader { get; internal set; }
 
-        /// <summary>
-        /// The parent shader.
-        /// </summary>
-        internal GenericShader _parentShader;
+        public new Uniform this[string key] => Get(key);
 
-        /// <summary>
-        /// Get you the uniform under the variable name.
-        /// <para>If it don't find the uniform, it tries to recreate it.</para>
-        /// <para>If the variable doesn't exist in the first place, it will after the recreation send everything to -1, what is the void.</para>
-        /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        public new Uniform this[string key]
+        public Uniform Get(string key)
         {
-            get
+            try
             {
-                try
-                {
-                    return base[key];
-                }
-                catch (KeyNotFoundException)
-                {
-                    Console.WriteLine("[Error] Uniform '"+key+"' was not found. Tried to recreate it.");
-                    Uniform u = new Uniform(GL.GetUniformLocation(_parentShader, key), this);
-                    Add(key, u);
-                    return u;
-                }
+                return (Uniform) base[key];
+            }
+            catch (KeyNotFoundException)
+            {
+                GLCustomActions.AtWarning?.Invoke("Uniform '" + KeyString + key + "' was not found. Tried to recreate it.");
+                var u = new Uniform(GL.GetUniformLocation(ParentShader, KeyString + key), this);
+                Add(key, u);
+                return u;
             }
         }
-        /// <summary>
-        /// Adds a uniform with a location.
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="location"></param>
+
+        public UniformArray GetArray(string key)
+        {
+            try
+            {
+                return (UniformArray) base[key];
+            }
+            catch (KeyNotFoundException)
+            {
+                throw new Exception("UniformArray '"+key+"' wasn't found");
+            }
+        }
+
         public void Add(string key, int location)
         {
             base.Add(key, new Uniform(location, this));
         }
+
+        internal void Set(string key, IUniform value)
+        {
+            base[key] = value;
+        }
+
+        internal void Import(GenericShader shader)
+        {
+            GL.GetProgram(shader, GetProgramParameterName.ActiveUniforms, out var uniformCount);
+            if (uniformCount < 1)
+                GLCustomActions.AtError("No uniforms has been found.");
+
+            var lastArrayKey = "";
+            var array = new UniformArray();
+            var arrayFilled = false;
+
+            if (GLSettings.InfoEveryUniform) GLCustomActions.AtInfo?.Invoke("Uniforms for: " + shader.GetType());
+
+            for (var i = 0; i < uniformCount; i++)
+            {
+                var key = GL.GetActiveUniform(shader, i, out _, out _);
+                var loc = GL.GetUniformLocation(shader, key);
+                if (GLSettings.InfoEveryUniform) GLCustomActions.AtInfo?.Invoke($"{key} - {loc}");
+
+                if (key.Contains("["))
+                {
+                    var keySplits = key.Split('[', ']');
+                    if (keySplits[0] != lastArrayKey)
+                    {
+                        if (arrayFilled) Add(lastArrayKey, array);
+
+                        array = new UniformArray
+                        {
+                            Location = loc,
+                            Name = keySplits[0],
+                            Parent = ParentShader,
+                            Struct = keySplits.Length > 2
+                        };
+
+                        arrayFilled = true;
+                        lastArrayKey = keySplits[0];
+                    }
+
+                    var curIndex = int.Parse(keySplits[1]);
+                    if (array.Size < curIndex) array.Size = curIndex;
+
+                    if (array.Struct)
+                        if (!array.Offsets.ContainsKey(keySplits[2].Trim('.')))
+                            array.Offsets.Add(keySplits[2].Trim('.'), loc - array.Location);
+                }
+                else
+                {
+                    Add(key, loc);
+                }
+            }
+
+            if (arrayFilled) Add(lastArrayKey, array);
+        }
     }
 }