Feature: Pre-calculate the results of a vector and vector.

E.g. return vec3(4, 5, 6) * vec3(1, 2, 3) => return vec3(4, 10,18)

Author: DeanEdisGG

ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs

@@ -168,10 +168,10 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                     }
                 }
 
-                // vecN(...) + <float>
+                // 'vecN(...) + ...' or '... + vecN(...)'
                 foreach (var vectorNode in rootNode.TheTree
                     .OfType<GenericSyntaxNode>()
-                    .Where(o => o.Token is TypeToken t && t.Content?.StartsWith("vec") == true))
+                    .Where(o => o.Token is TypeToken t && t.IsVector()))
                 {
                     // Find the brackets.
                     if (vectorNode.Next is not RoundBracketSyntaxNode brackets)
@@ -252,11 +252,55 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                                         numberNode.Remove();
 
                                         didChange = true;
+                                        continue;
                                     }
                                 }
                             }
                         }
                     }
+
+                    // vector then vector.
+                    {
+                        // Find the math symbol.
+                        var symbolNode = brackets.Next;
+                        if (symbolNode?.Token is SymbolOperatorToken symbol && symbol.GetMathSymbolType() != TokenExtensions.MathSymbolType.Unknown)
+                        {
+                            // Find the second vector.
+                            var rhsVectorNode = symbolNode.Next;
+                            if (rhsVectorNode?.Token is TypeToken t && t.IsVector())
+                            {
+                                var rhsVectorBrackets = rhsVectorNode.Next as RoundBracketSyntaxNode;
+
+                                // RHS vector must not be used in a following math operation of a different category.
+                                if (rhsVectorBrackets?.Next?.Token is not SymbolOperatorToken nextMath ||
+                                    nextMath.GetMathSymbolType() == symbol.GetMathSymbolType() ||
+                                    nextMath.GetMathSymbolType() == TokenExtensions.MathSymbolType.AddSubtract)
+                                {
+                                    // Ensure both brackets have the same number of elements.
+                                    var lhsCsv = brackets.GetCsv().ToList();
+                                    var rhsCsv = rhsVectorBrackets.GetCsv().ToList();
+                                    while (lhsCsv.Count < rhsCsv.Count)
+                                        lhsCsv.Add(new[] { lhsCsv.First().Single().Clone() });
+                                    while (rhsCsv.Count < lhsCsv.Count)
+                                        rhsCsv.Add(new[] { rhsCsv.First().Single().Clone() });
+
+                                    // Perform math on each bracketed value.
+                                    var newCsv =
+                                        lhsCsv
+                                            .Select((o, i) => DoNodeMath(o.Single(), symbolNode, rhsCsv[i].Single()))
+                                            .Select(o => new GenericSyntaxNode(FloatToken.From(o, MaxDp).AsIntIfPossible()));
+
+                                    // Replace bracket content and sum.
+                                    brackets.ReplaceWith(new RoundBracketSyntaxNode(newCsv.ToCsv()));
+                                    symbolNode.Remove();
+                                    rhsVectorNode.Remove();
+                                    rhsVectorBrackets.Remove();
+
+                                    didChange = true;
+                                }
+                            }
+                        }
+                    }
                 }
 
                 // Perform simple arithmetic calculations.

ShaderShrinker/UnitTests/TestFiles/SimplifiedReference/ED209.glsl

@@ -1,4 +1,4 @@
-// Processed by 'GLSL Shader Shrinker' (Shrunk by 926 characters)
+// Processed by 'GLSL Shader Shrinker' (Shrunk by 948 characters)
 // (https://github.com/deanthecoder/GLSLShaderShrinker)
 
 float stretch, gunsUp, gunsForward, edWalk, edTwist, edDown, edShoot, doorOpen, glow;
@@ -159,14 +159,13 @@ MarchData gunPod(vec3 p) {
 }
 
 MarchData arms(vec3 p) {
-	const vec3 wrist = vec3(1.5, 0, 0) - vec3(0, 0, .3);
 	MarchData r;
 	setBodyMaterial(r);
 	p.x = abs(p.x);
 	p.yz += vec2(.24, 0);
 	p.xy *= rot(.15 * (gunsUp - 1.));
-	r.d = min(sdCapsule(p, vec3(0), vec3(1.5, 0, 0)), sdCapsule(p, vec3(1.5, 0, 0), wrist));
-	p -= wrist;
+	r.d = min(sdCapsule(p, vec3(0), vec3(1.5, 0, 0)), sdCapsule(p, vec3(1.5, 0, 0), vec3(1.5, 0, -.3)));
+	p -= vec3(1.5, 0, -.3);
 	p.z -= gunsForward * .15;
 	return minResult(r, gunPod(p));
 }

ShaderShrinker/UnitTests/TestFiles/SimplifiedReference/Temple.glsl

@@ -1,4 +1,4 @@
-// Processed by 'GLSL Shader Shrinker' (Shrunk by 396 characters)
+// Processed by 'GLSL Shader Shrinker' (Shrunk by 408 characters)
 // (https://github.com/deanthecoder/GLSLShaderShrinker)
 
 #define SKYCOL	vec3(.6, .8, .9)
@@ -145,7 +145,7 @@ void mainImage(out vec4 fragColor, vec2 fragCoord) {
 	vec2 hit = vec2(0),
 	     uv = (fragCoord - .5 * iResolution.xy) / iResolution.y;
 	vec3 p,
-	     forward = normalize(vec3(-13, -4, 0) - vec3(7, 6.5, -25)),
+	     forward = normalize(vec3(-20, -10.5, 25)),
 	     right = normalize(cross(vec3(0, 1, 0), forward)),
 	     rayDir = normalize(forward + uv.x * right + uv.y * cross(forward, right)),
 	     sunPosUnit = normalize(vec3(.5, .8, .7)),

ShaderShrinker/UnitTests/VectorArithmeticTests.cs

@@ -272,6 +272,53 @@ public void CheckArithmeticWithVectorAndScalar(
             Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo(expected));
         }
 
-        // todo - vec and vec
+        [Test, Sequential]
+        public void CheckArithmeticWithVectorAndVector(
+            [Values("vec2 f = vec2(1.1, 2.2) + vec2(1, 2);",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) + vec2(6, 7);",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) + vec2(5);",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) + 2.0;",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) * vec2(6, 7);",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) * vec2(5);",
+                    "vec2 f = vec2(1.1, 2.2) + vec2(1, 2) * 2.0;",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2);",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) + vec2(6, 7);",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) + vec2(5);",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) + 2.0;",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) * vec2(6, 7);",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) * vec2(5);",
+                    "vec2 f = vec2(1.1, 2.2) * vec2(1, 2) * 2.0;",
+                    "vec2 f = vec2(3) + vec2(4);",
+                    "vec2 f = vec2(3, 4) + vec2(5);",
+                    "vec2 f = vec2(3) + vec2(4, 5);")] string code,
+            [Values("vec2 f = vec2(2.1, 4.2);",
+                    "vec2 f = vec2(8.1, 11.2);",
+                    "vec2 f = vec2(7.1, 9.2);",
+                    "vec2 f = vec2(4.1, 6.2);",
+                    "vec2 f = vec2(7.1, 16.2);",
+                    "vec2 f = vec2(6.1, 12.2);",
+                    "vec2 f = vec2(3.1, 6.2);",
+                    "vec2 f = vec2(1.1, 4.4);",
+                    "vec2 f = vec2(7.1, 11.4);",
+                    "vec2 f = vec2(6.1, 9.4);",
+                    "vec2 f = vec2(3.1, 6.4);",
+                    "vec2 f = vec2(6.6, 30.8);",
+                    "vec2 f = vec2(5.5, 22);",
+                    "vec2 f = vec2(2.2, 8.8);",
+                    "vec2 f = vec2(7);",
+                    "vec2 f = vec2(8, 9);",
+                    "vec2 f = vec2(7, 8);")] 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));
+        }
     }
 }