Other: Refactor vector math code.

Author: DeanEdisGG

ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs

@@ -191,10 +191,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                             var numberNode = symbolNode.Next;
                             if (numberNode?.Token is FloatToken)
                             {
-                                // Number must not be used in a following math operation of a different category.
-                                if (numberNode.Next?.Token is not SymbolOperatorToken nextMath ||
-                                    nextMath.GetMathSymbolType() == symbol.GetMathSymbolType() ||
-                                    nextMath.GetMathSymbolType() == TokenExtensions.MathSymbolType.AddSubtract)
+                                if (IsSafeToPerformMath(vectorNode, symbol, numberNode))
                                 {
                                     // Perform math on each bracketed value.
                                     var newCsv =
@@ -231,8 +228,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                             var numberNode = symbolNode.Previous;
                             if (numberNode?.Token is FloatToken)
                             {
-                                // Number must not be used in a preceding math operation.
-                                if (numberNode.Previous?.Token is not SymbolOperatorToken nextMath || nextMath.GetMathSymbolType() != TokenExtensions.MathSymbolType.MultiplyDivide)
+                                if (IsSafeToPerformMath(numberNode, symbol, vectorNode))
                                 {
                                     // Perform math on each bracketed value.
                                     var newCsv =
@@ -270,11 +266,7 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                             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)
+                                if (IsSafeToPerformMath(vectorNode, symbol, rhsVectorNode))
                                 {
                                     // Ensure both brackets have the same number of elements.
                                     var lhsCsv = brackets.GetCsv().ToList();
@@ -314,22 +306,10 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                     .ToList())
                 {
                     var symbolNode = numNodeA.Next;
-                    var symbolType = symbolNode.Token.GetMathSymbolType();
-
-                    if (symbolType != TokenExtensions.MathSymbolType.MultiplyDivide &&
-                        numNodeA.Previous != null &&
-                        numNodeA.Previous.Token is not CommaToken &&
-                        numNodeA.Previous.Token?.GetMathSymbolType() != symbolType)
-                    {
-                        continue;
-                    }
-
                     var numNodeB = symbolNode.Next;
-                    if (numNodeB?.Next?.Token is SymbolOperatorToken &&
-                        numNodeB.Next.Token.GetMathSymbolType() != TokenExtensions.MathSymbolType.AddSubtract)
-                    {
+
+                    if (!IsSafeToPerformMath(numNodeA, symbolNode.Token as SymbolOperatorToken, numNodeB))
                         continue;
-                    }
 
                     var c = DoNodeMath(numNodeA, symbolNode, numNodeB);
 
@@ -355,6 +335,32 @@ numNodeA.Previous.Token is not CommaToken &&
             return repeatSimplifications;
         }
 
+        private static bool IsSafeToPerformMath(SyntaxNode lhsNumNode, SymbolOperatorToken symbol, SyntaxNode rhsNumNode)
+        {
+            if (lhsNumNode == null || symbol == null || rhsNumNode == null)
+                return false;
+
+            var symbolType = symbol.GetMathSymbolType();
+            switch (symbolType)
+            {
+                case TokenExtensions.MathSymbolType.Unknown:
+                    return false;
+
+                // If main symbol is * or /, that's fine - Any further symbols in the expression won't affect things.
+                case TokenExtensions.MathSymbolType.MultiplyDivide:
+                    return true;
+
+                // Only ok to perform math on the two nodes if the surrounding symbols are + or - (or don't exist).
+                case TokenExtensions.MathSymbolType.AddSubtract:
+                    var prevSymbol = (lhsNumNode.Previous as GenericSyntaxNode)?.Token as SymbolOperatorToken;
+                    var nextSymbol = (rhsNumNode.Next is RoundBracketSyntaxNode ? rhsNumNode.Next.Next : rhsNumNode.Next)?.Token as SymbolOperatorToken;
+                    return new[] { prevSymbol, nextSymbol }.Where(o => o != null).All(o => o.GetMathSymbolType() == symbolType);
+
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
         private static double DoNodeMath(SyntaxNode numNodeA, SyntaxNode symbolNode, SyntaxNode numNodeB)
         {
             var a = double.Parse(numNodeA.Token.Content);

ShaderShrinker/UnitTests/TestFiles/SimplifiedReference/ED209.glsl

@@ -1,4 +1,4 @@
-// Processed by 'GLSL Shader Shrinker' (Shrunk by 948 characters)
+// Processed by 'GLSL Shader Shrinker' (Shrunk by 950 characters)
 // (https://github.com/deanthecoder/GLSLShaderShrinker)
 
 float stretch, gunsUp, gunsForward, edWalk, edTwist, edDown, edShoot, doorOpen, glow;
@@ -85,7 +85,7 @@ void setBodyMaterial(inout MarchData mat) {
 	mat.specPower = 30.;
 }
 
-float legWalkAngle(float f) { return sin(edWalk * 3.141 * 6. * f) * .2; }
+float legWalkAngle(float f) { return sin(edWalk * 18.846 * f) * .2; }
 
 float edZ() { return mix(5., -2., edWalk); }
 

ShaderShrinker/UnitTests/VectorArithmeticTests.cs

@@ -290,7 +290,9 @@ public void CheckArithmeticWithVectorAndVector(
                     "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,
+                    "vec2 f = vec2(3) + vec2(4, 5);",
+                    "vec2 v = vec2(1, 2), f = v * vec2(1.1, 2.2) + vec2(6, 7);",
+                    "vec2 v = vec2(1, 2), f = vec2(1.1, 2.2) + vec2(6, 7) * v;")] string code,
             [Values("vec2 f = vec2(2.1, 4.2);",
                     "vec2 f = vec2(8.1, 11.2);",
                     "vec2 f = vec2(7.1, 9.2);",
@@ -307,7 +309,9 @@ public void CheckArithmeticWithVectorAndVector(
                     "vec2 f = vec2(2.2, 8.8);",
                     "vec2 f = vec2(7);",
                     "vec2 f = vec2(8, 9);",
-                    "vec2 f = vec2(7, 8);")] string expected)
+                    "vec2 f = vec2(7, 8);",
+                    "vec2 v = vec2(1, 2), f = v * vec2(1.1, 2.2) + vec2(6, 7);",
+                    "vec2 v = vec2(1, 2), f = vec2(1.1, 2.2) + vec2(6, 7) * v;")] string expected)
         {
             var lexer = new Lexer();
             lexer.Load(code);