Feature: Extend 'perform arithmetic' to include vectors.

E.g.
vec2 f = vec2(1.1, 2.2) + 3.3 * 4.4;
to
vec2 f = vec2(15.62, 16.72);

Author: DeanEdisGG

README.md

@@ -10,7 +10,7 @@ It is written in C# using WPF and Visual Studio 2019, and has several hundred NU
 
 It is designed to work primarily with code from [Shadertoy](https://www.shadertoy.com/), but has limited support for other styles of GLSL too (E.g. [Bonzomatic](https://github.com/Gargaj/Bonzomatic))
 
-After writing a Shadertoy shader, usually from my boilerplate starting code, there is usually a fixed sequence of operations I perform:
+After writing a Shadertoy shader, usually from my boilerplate starting code, there is a sequence of operations I perform:
 * Delete dead/commented-out code.
 * Remove unused functions.
 * Inline some constants (Max raymarching distance, 'hit test' accuracy, ...)
@@ -529,6 +529,7 @@ E.g.
 * Change ```f + 0.0``` or ```f - 0.0``` to ```f```
 * Remove ```f * 0.0``` (when safe).
 * Change ```pow(3.0, 2.0)``` to ```9.0```
-* Change ```float a = 1.2 / 2.3 * 4.5``` to ```a = 2.3478```
+* Change ```float a = 1.2 / 2.3 * 4.5;``` to ```float a = 2.3478;```
+* Change ```vec2 f = vec2(1.1, 2.2) + 3.3 * 4.4;``` to ```vec2 f = vec2(15.62, 16.72);```
 
 ---

ShaderShrinker/Shrinker.Lexer/FloatToken.cs

@@ -16,6 +16,12 @@ namespace Shrinker.Lexer
 {
     public class FloatToken : Token, INumberToken
     {
+        public static FloatToken From(double c, int maxDp)
+        {
+            var floatToken = Math.Abs(c) < 0.0001 && Math.Abs(c) > 0.0 ? new FloatToken(c.ToString($".#{new string('#', maxDp - 1)}e0")) : new FloatToken(c.ToString($"F{maxDp}"));
+            return (FloatToken)floatToken.Simplify();
+        }
+
         public FloatToken(string s)
         {
             Content = s;

ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs

@@ -132,7 +132,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                     if (xy.Count == 2 && xy.All(o => o > 0.0))
                     {
                         powNode.Params.Remove();
-                        powNode.ReplaceWith(new GenericSyntaxNode(new FloatToken($"{Math.Pow(xy[0], xy[1]):F}").Simplify()));
+                        powNode.ReplaceWith(new GenericSyntaxNode(FloatToken.From(Math.Pow(xy[0], xy[1]), MaxDp)));
                         didChange = true;
                     }
                 }
@@ -147,7 +147,64 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                     if (x.Count == 1)
                     {
                         absNode.Params.Remove();
-                        absNode.ReplaceWith(new GenericSyntaxNode(new FloatToken($"{Math.Abs(x[0]):F}").Simplify()));
+                        absNode.ReplaceWith(new GenericSyntaxNode(FloatToken.From(Math.Abs(x[0]), MaxDp)));
+                        didChange = true;
+                    }
+                }
+
+                // vecN(...) + <float>
+                foreach (var vectorNode in rootNode.TheTree
+                    .OfType<GenericSyntaxNode>()
+                    .Where(o => o.Token is TypeToken t && t.Content?.StartsWith("vec") == true))
+                {
+                    // Find the brackets.
+                    if (vectorNode.Next is not RoundBracketSyntaxNode brackets)
+                        continue;
+
+                    // Brackets must be filled with floats.
+                    if (!brackets.IsSimpleCsv())
+                        continue;
+
+                    // Find the math symbol.
+                    var symbolNode = brackets.Next;
+                    if (symbolNode?.Token is not SymbolOperatorToken symbol)
+                        continue;
+                    switch (symbol.GetMathSymbolType())
+                    {
+                        case TokenExtensions.MathSymbolType.AddSubtract:
+                        case TokenExtensions.MathSymbolType.MultiplyDivide:
+                            break; // Supported.
+
+                        default:
+                            continue; // Not supported - Continue search.
+                    }
+
+                    // Find the float number.
+                    var numberNode = symbolNode.Next;
+                    if (numberNode?.Token is not FloatToken)
+                        continue;
+
+                    // Number must not be used in a following math operation.
+                    if (numberNode.Next?.Token is SymbolOperatorToken nextMath && nextMath.GetMathSymbolType() == TokenExtensions.MathSymbolType.MultiplyDivide)
+                        continue;
+
+                    // Perform math on each bracketed value.
+                    var newCsv =
+                        brackets
+                            .GetCsv()
+                            .Select(o => DoNodeMath(o.Single(), symbolNode, numberNode))
+                            .Select(o => new GenericSyntaxNode(FloatToken.From(o, MaxDp)));
+
+                    // Replace bracket content and sum (if it shrinks the code).
+                    var newBrackets = new RoundBracketSyntaxNode(newCsv.ToCsv());
+                    var oldSize = brackets.ToCode().Length + 1 + numberNode.ToCode().Length;
+                    var newSize = newBrackets.ToCode().Length;
+                    if (newSize <= oldSize)
+                    {
+                        brackets.ReplaceWith(newBrackets);
+                        symbolNode.Remove();
+                        numberNode.Remove();
+
                         didChange = true;
                     }
                 }
@@ -179,66 +236,17 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                         continue;
                     }
 
-                    var a = double.Parse(numNodeA.Token.Content);
-                    var b = double.Parse(numNodeB.Token.Content);
-
-                    var symbol = symbolNode.Token.Content[0];
-
-                    // Invert * or / if preceded by a /.
-                    // E.g. 1.2 / 2.3 * 4.5 = 1.2 / (2.3 / 4.5)
-                    //                      = 1.2 / 0.51111
-                    //                      = 2.3478
-                    if (numNodeA.Previous?.Token?.GetMathSymbolType() == TokenExtensions.MathSymbolType.MultiplyDivide &&
-                        numNodeA.Previous.HasNodeContent("/"))
-                    {
-                        symbol = symbol == '*' ? '/' : '*';
-                    }
-                    
-                    // Invert + or - if preceded by a -.
-                    // E.g. -3.0 + 0.1 = - (3.0 - 0.1)
-                    //                 = - (2.9)
-                    //                 = -2.9
-                    if (numNodeA.Previous.HasNodeContent("-") &&
-                        symbolNode.Token.GetMathSymbolType() == TokenExtensions.MathSymbolType.AddSubtract)
-                    {
-                        symbol = symbol == '+' ? '-' : '+';
-                    }
-
-                    double c;
-                    switch (symbol)
-                    {
-                        case '+':
-                            c = a + b;
-                            break;
-                        case '-':
-                            c = a - b;
-                            break;
-                        case '*':
-                            c = a * b;
-                            break;
-                        case '/':
-                            c = a / b;
-                            if (double.IsInfinity(c))
-                                c = 0.0;
-                            break;
-                        default:
-                            throw new InvalidOperationException($"Unrecognized math operation '{symbol}'.");
-                    }
+                    var c = DoNodeMath(numNodeA, symbolNode, numNodeB);
 
                     var isFloatResult = numNodeA.Token is FloatToken || numNodeB.Token is FloatToken;
                     numNodeB.Remove();
                     symbolNode.Remove();
 
                     SyntaxNode newNode;
                     if (isFloatResult)
-                    {
-                        var numberToken = Math.Abs(c) < 0.0001 && Math.Abs(c) > 0.0 ? new FloatToken(c.ToString($".#{new string('#', MaxDp - 1)}e0")) : new FloatToken(c.ToString($"F{MaxDp}"));
-                        newNode = numNodeA.ReplaceWith(new GenericSyntaxNode(numberToken.Simplify()));
-                    }
+                        newNode = numNodeA.ReplaceWith(new GenericSyntaxNode(FloatToken.From(c, MaxDp)));
                     else
-                    {
                         newNode = numNodeA.ReplaceWith(new GenericSyntaxNode(new IntToken((int)c)));
-                    }
 
                     // If new node is the sole child of a group, promote it.
                     if (newNode.IsOnlyChild() && newNode.Parent.GetType() == typeof(GroupSyntaxNode))
@@ -255,5 +263,50 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
 
             return repeatSimplifications;
         }
+
+        private static double DoNodeMath(SyntaxNode numNodeA, SyntaxNode symbolNode, SyntaxNode numNodeB)
+        {
+            var a = double.Parse(numNodeA.Token.Content);
+            var b = double.Parse(numNodeB.Token.Content);
+
+            var symbol = symbolNode.Token.Content[0];
+
+            // Invert * or / if preceded by a /.
+            // E.g. 1.2 / 2.3 * 4.5 = 1.2 / (2.3 / 4.5)
+            //                      = 1.2 / 0.51111
+            //                      = 2.3478
+            if (numNodeA.Previous?.Token?.GetMathSymbolType() == TokenExtensions.MathSymbolType.MultiplyDivide &&
+                numNodeA.Previous.HasNodeContent("/"))
+            {
+                symbol = symbol == '*' ? '/' : '*';
+            }
+
+            // Invert + or - if preceded by a -.
+            // E.g. -3.0 + 0.1 = - (3.0 - 0.1)
+            //                 = - (2.9)
+            //                 = -2.9
+            if (numNodeA.Previous.HasNodeContent("-") &&
+                symbolNode.Token.GetMathSymbolType() == TokenExtensions.MathSymbolType.AddSubtract)
+            {
+                symbol = symbol == '+' ? '-' : '+';
+            }
+
+            switch (symbol)
+            {
+                case '+':
+                    return a + b;
+                case '-':
+                    return a - b;
+                case '*':
+                    return a * b;
+                case '/':
+                    var c = a / b;
+                    if (double.IsInfinity(c))
+                        c = 0.0;
+                    return c;
+                default:
+                    throw new InvalidOperationException($"Unrecognized math operation '{symbol}'.");
+            }
+        }
     }
 }

ShaderShrinker/Shrinker.Parser/SyntaxNodes/SyntaxNodeExtensions.cs

@@ -76,5 +76,16 @@ public static IEnumerable<VariableAssignmentSyntaxNode> GlobalVariables(this Syn
         public static bool IsComment(this SyntaxNode node) => node is CommentSyntaxNodeBase || node.Token is CommentTokenBase;
 
         public static bool HasNodeContent(this SyntaxNode node, string s) => node?.Token?.Content == s;
+
+        public static IEnumerable<SyntaxNode> ToCsv(this IEnumerable<SyntaxNode> values)
+        {
+            var nodes = values.ToList();
+            foreach (var node in nodes)
+            {
+                yield return node;
+                if (node != nodes.Last())
+                    yield return new GenericSyntaxNode(new CommaToken());
+            }
+        }
     }
 }

ShaderShrinker/Shrinker.WpfApp/OptionsDialog.xaml

@@ -545,7 +545,8 @@
                     * Change ```f + 0.0``` or ```f - 0.0``` to ```f```
                     * Remove ```f * 0.0``` (when safe).
                     * Change ```pow(3.0, 2.0)``` to ```9.0```
-                    * Change ```float a = 1.2 / 2.3 * 4.5``` to ```a = 2.3478```
+                    * Change ```float a = 1.2 / 2.3 * 4.5;``` to ```float a = 2.3478;```
+                    * Change ```vec2 f = vec2(1.1, 2.2) + 3.3 * 4.4;``` to ```vec2 f = vec2(15.62, 16.72);```
                 </MdXaml:MarkdownScrollViewer>
             </CheckBox.ToolTip>
         </CheckBox>

ShaderShrinker/UnitTests/ShrinkerTests.cs

@@ -1510,6 +1510,39 @@ public void CheckArithmeticWithAbsFunction(
             Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo(expected));
         }
 
+        [Test, Sequential]
+        public void CheckArithmeticWithVectorAndScalar(
+            [Values("vec2 f = vec2(1.1, 2.2) + 3.3;",
+                    "vec3 f = vec3(1.1, 2.2, 3.3) - 4.4;",
+                    "vec4 f = vec4(1.1) * 2.2;",
+                    "vec4 f = vec4(10) / 2.0;",
+                    "vec4 f = vec4(22, 23, 24) / 7.0;",
+                    "void f(vec2 v) { } void main() { f(vec2(1.1, 2.2) + 3.3); }",
+                    "vec2 f = vec2(1.1, 2.2) + 3.3 * 4.4;",
+                    "float i = 2.0; vec2 f = vec2(1.1, 2.2) + 3.3 * i;",
+                    "vec4 f = vec4(1.1) * 2.2 + 3.3;")] string code,
+            [Values("vec2 f = vec2(4.4, 5.5);",
+                    "vec3 f = vec3(-3.3, -2.2, -1.1);",
+                    "vec4 f = vec4(2.42);",
+                    "vec4 f = vec4(5.);",
+                    "vec4 f = vec4(22, 23, 24) / 7.0;",
+                    "void f(vec2 v) { } void main() { f(vec2(4.4, 5.5)); }",
+                    "vec2 f = vec2(15.62, 16.72);",
+                    "float i = 2.0; vec2 f = vec2(1.1, 2.2) + 3.3 * i;",
+                    "vec4 f = vec4(5.72);")] string expected)
+        {
+            var lexer = new Lexer();
+            lexer.Load(code);
+
+            var options = CustomOptions.None();
+            options.PerformArithmetic = true;
+            var rootNode = new Parser(lexer)
+                .Parse()
+                .Simplify(options);
+
+            Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo(expected));
+        }
+
         [Test, Sequential]
         public void CheckRemovingUnusedVariables(
             [Values("void main() { int a; }",