Feature: Dot products with two constant vectors (or one with a single unit value) are simplified.

e.g.
"f = dot(vec2(1, 2), vec2(3,4))" => "f = 11.0"
"f = dot(vec2(0, 1), v)" => "f = v.y"

Author: DeanEdisGG

README.md

@@ -567,6 +567,7 @@ E.g.
 * Change ```pow(3.0, 2.0)``` to ```9.0```
 * 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);```
+* Change ```float f = dot(v, vec3(0, 1, 0));``` to ```float f = v.y;```
 
 ---
 ## Replace Functions Calls With Result

ShaderShrinker/Shrinker.Parser/Optimizations/PerformArithmeticExtension.cs

@@ -195,6 +195,45 @@ public static bool PerformArithmetic(this SyntaxNode rootNode)
                     didChange = true;
                 }
 
+                // dot(vecN(nums), vecN(nums)) => <the result>
+                foreach (var dotNode in functionCalls
+                    .Where(o => o.Name == "dot" && o.Params.Children.Any(n => (n.Token as TypeToken)?.IsVector() == true))
+                    .ToList())
+                {
+                    var dotParams = dotNode.Params.GetCsv().ToList();
+                    var vectors = dotParams.Select(o => o.First()).Where(o => (o.Token as TypeToken)?.IsVector() == true).ToList();
+                    var nums = vectors.Select(GetVectorNumericCsv).ToList();
+                    if (nums.All(o => o == null))
+                        continue; // Neither arg is a simple numeric vector.
+
+                    if (nums.Count(o => o != null) == 2)
+                    {
+                        // Both args are vectors and simple numeric - We can calculate the result.
+                        var sum = nums[0].Select((t, i) => t * nums[1][i]).Sum();
+                        dotNode.ReplaceWith(new GenericSyntaxNode(FloatToken.From(sum, MaxDp)));
+                        didChange = true;
+                        continue;
+                    }
+
+                    // Do any of the vectors have only a single '1' component?
+                    var vectorWithAOne = vectors.FirstOrDefault(o => IsSingleElementOne(GetVectorNumericCsv(o)));
+                    if (vectorWithAOne == null)
+                        continue; // Nope.
+
+                    // Yes - The 'other' param just needs a .x/.y/.z suffix.
+                    var otherParam = dotParams.Single(o => o[0] != vectorWithAOne);
+
+                    // But first check it a single variable...
+                    if (otherParam.Count != 1 || otherParam.Single() is not GenericSyntaxNode node)
+                        continue;
+                    
+                    // Replace the dot().
+                    var oneIndex = GetVectorNumericCsv(vectorWithAOne).IndexOf(1.0);
+                    var newNode = new GenericSyntaxNode($"{node.Token.Content}.{"xyzw"[oneIndex]}");
+                    dotNode.ReplaceWith(newNode);
+                    didChange = true;
+                }
+
                 // Constant math/trig functions => <the result>
                 var mathOp = new List<Tuple<string, Func<double, double>>>
                 {
@@ -430,6 +469,11 @@ private static List<double> GetVectorNumericCsv(SyntaxNode vectorNode)
             return nums;
         }
 
+        private static bool IsSingleElementOne(IList<double> values) =>
+            values != null &&
+            values.All(o => o is 0.0 or 1.0) &&
+            Math.Abs(values.Count(o => Math.Abs(o - 1.0) < 0.00001) - 1.0) < 0.00001;
+
         private static bool IsSafeToPerformMath(SyntaxNode lhsNumNode, SymbolOperatorToken symbol, SyntaxNode rhsNumNode)
         {
             if (lhsNumNode == null || symbol == null || rhsNumNode == null)

ShaderShrinker/Shrinker.WpfApp/OptionsDialog.xaml

@@ -573,6 +573,7 @@
                     * Change ```pow(3.0, 2.0)``` to ```9.0```
                     * 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);```
+                    * Change ```float f = dot(v, vec3(0, 1, 0));``` to ```float f = v.y;```
                 </MdXaml:MarkdownScrollViewer>
             </CheckBox.ToolTip>
         </CheckBox>

ShaderShrinker/UnitTests/ShrinkerTests.cs

@@ -2131,8 +2131,8 @@ public void CheckInliningFunctionsCalledWithConstNumericParams(
                        "mat2 main() { return mat2(.76031, .64956, -.64956, .76031); }",
                        "mat2 main() { return mat2(.85252, -.52269, .52269, .85252); }",
                        "int main() { return 12; }",
-                       "float main() { return dot(vec2(1, 2), vec2(1, 2)); }",
-                       "float main() { return dot(vec2(1, 2), vec2(1, 2)); }",
+                       "float main() { return 5.; }",
+                       "float main() { return 5.; }",
                        "vec3 f(vec3 p) { float c = cos(.1 * p.x), s = sin(.1 * p.x); return vec3(mat2(c, -s, s, c) * p.xy, p.z); } vec3 p; vec3 main() { return f(p) + vec3(1); }",
                        "float main() { return 0.; }",
                        "float main() { return vec3(0); }",

ShaderShrinker/UnitTests/VectorArithmeticTests.cs

@@ -265,6 +265,32 @@ public void CheckArithmeticWithFractFunction()
             Assert.That(rootNode.ToCode().ToSimple(), Is.EqualTo("float f = .9;"));
         }
 
+        [Test, Sequential]
+        public void CheckArithmeticWithSingleIndexDotFunction(
+            [Values("vec3 v; float f = dot(vec3(0, 0, 1), v);|vec3 v; float f = v.z;",
+                    "vec3 v; float f = dot(vec3(0, 1, 0), v);|vec3 v; float f = v.y;",
+                    "vec3 v; float f = dot(vec3(1, 0, 0), v);|vec3 v; float f = v.x;",
+                    "vec3 v; float f = dot(v, vec3(0, 1, 0));|vec3 v; float f = v.y;",
+                    "vec2 v; float f = dot(v, vec2(1, 0));|vec2 v; float f = v.x;",
+                    "float f = dot(vec2(1, 2), vec2(3, 4));|float f = 11.;",
+                    "float f = dot(vec2(2), vec2(3, 4));|float f = 14.;",
+                    "vec2 v; float f = dot(v + v, vec2(1, 0));|vec2 v; float f = dot(v + v, vec2(1, 0));")] string code)
+        {
+            var input = code.Split('|')[0];
+            var expected = code.Split('|')[1];
+
+            var lexer = new Lexer();
+            lexer.Load(input);
+
+            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 CheckArithmeticWithTrigFunctions(
             [Values("float f = sin(3.141);",