Feature: Golf 'return' statements.

Author: DeanEdisGG

ShaderShrinker/Shrinker.Lexer/StringExtensions.cs

@@ -41,6 +41,8 @@ public static int GetCodeCharCount(this string glsl)
                 var endComment = glsl.IndexOf("*/", startComment, StringComparison.Ordinal);
                 if (endComment > startComment)
                     glsl = glsl.Remove(startComment, endComment - startComment + 2);
+                else
+                    break; // Couldn't find comment end.
             }
 
             return glsl.Split('\r', '\n').Sum(o => o.Count(ch => !char.IsWhiteSpace(ch)));

ShaderShrinker/Shrinker.Parser/GlslOutputFormatter.cs

@@ -249,7 +249,7 @@ public static void AppendCode(StringBuilder sb, SyntaxNode rootNode)
                     o.Children.ToList().ForEach(child => AppendCode(subExpr, child));
                     var s = subExpr.ToString().Trim();
 
-                    sb.Append(string.IsNullOrEmpty(s) ? "return" : $"return {s}");
+                    sb.Append(string.IsNullOrEmpty(s) ? o.Name : $"{o.Name} {s}");
                     break;
                 }
 

ShaderShrinker/Shrinker.Parser/Optimizations/GolfExtensions.cs

@@ -146,7 +146,8 @@ public static void GolfDefineCommonTerms(this SyntaxNode rootNode)
                 // What would the saving be, should we #define it?
                 var toAdd = $"#define {replacement} {keyword} ".Length + nodes.Count * replacement.Length;
                 var toRemove = nodes.Count * keyword.Length;
-                if (toAdd >= toRemove)
+                var delta = toAdd - toRemove;
+                if (delta > 0)
                     continue; // Could replace with #define, but not worth it.
 
                 // We'll get a space saving - Add a #define.

ShaderShrinker/Shrinker.Parser/SyntaxNodes/ReturnSyntaxNode.cs

@@ -13,10 +13,14 @@
 
 namespace Shrinker.Parser.SyntaxNodes
 {
-    public class ReturnSyntaxNode : GroupSyntaxNode
+    public class ReturnSyntaxNode : GroupSyntaxNode, IRenamable
     {
         public override string UiName => Children.Any() ? "return ..." : "return";
 
         protected override SyntaxNode CreateSelf() => new ReturnSyntaxNode();
+
+        public string Name { get; private set; } = "return";
+
+        public void Rename(string oldName, string newName) => Name = newName;
     }
 }

ShaderShrinker/UnitTests/TestFiles/GolfedReference/Alien.glsl

@@ -1,87 +1,88 @@
-// Processed by 'GLSL Shader Shrinker' (Shrunk by 2,150 characters)
+// Processed by 'GLSL Shader Shrinker' (Shrunk by 2,233 characters)
 // (https://github.com/deanthecoder/GLSLShaderShrinker)
 
 #define v3	vec3
 #define v2	vec2
 #define _S	smoothstep
+#define RET	return
 #define NM	normalize
 #define LNG	length
 #define _f	float
 #define iT	iTime
 #define iR	iResolution
 #define F
 
-float G(v2 p) { return fract(sin(dot(p, v2(123.45, 87.43))) * 5432.3); }
+float G(v2 p) { RET fract(sin(dot(p, v2(123.45, 87.43))) * 5432.3); }
 
 float Q(v2 p) {
 #ifdef F
 	p *= .05;
-	return texture(iChannel1, p).r;
+	RET texture(iChannel1, p).r;
 #else
 	v2 i = floor(p);
 	v2 f = fract(p);
 	_f a = G(i);
 	_f b = G(i + v2(1, 0));
-	return mix(a, b, f.x) + (G(i + v2(0, 1)) - a) * f.y * (1. - f.x) + (G(i + v2(1)) - b) * f.x * f.y;
+	RET mix(a, b, f.x) + (G(i + v2(0, 1)) - a) * f.y * (1. - f.x) + (G(i + v2(1)) - b) * f.x * f.y;
 #endif
 }
 
 float y(v2 p) {
 	_f f = .5 * Q(p * 1.1);
 	f += .22 * Q(p * 2.3);
 	f += .0625 * Q(p * 8.4);
-	return f / .7825;
+	RET f / .7825;
 }
 
 float sn(_f a, _f b, _f k) {
 	_f h = clamp(.5 + .5 * (b - a) / k, 0., 1.);
-	return mix(b, a, h) - k * h * (1. - h);
+	RET mix(b, a, h) - k * h * (1. - h);
 }
 
 mat2 X(_f a) {
 	_f c = cos(a),
 	   s = sin(a);
-	return mat2(c, s, -s, c);
+	RET mat2(c, s, -s, c);
 }
 
-vec2 O(v2 a, v2 b) { return a.x < b.x ? a : b; }
+vec2 O(v2 a, v2 b) { RET a.x < b.x ? a : b; }
 
-float SS(v3 p, v2 t) { return LNG(v2(LNG(p.xy) - t.x, p.z)) - t.y; }
+float SS(v3 p, v2 t) { RET LNG(v2(LNG(p.xy) - t.x, p.z)) - t.y; }
 
 float ss(v3 p) {
 	p.z = mod(p.z, .6) - .3;
-	return SS(p, v2(2, .2));
+	RET SS(p, v2(2, .2));
 }
 
 float se(v3 p) {
 	_f L = LNG(p.xy);
-	return max(L - 2., 1.9 - L) - y((p.xy + p.yz) * 4.) * .05;
+	RET max(L - 2., 1.9 - L) - y((p.xy + p.yz) * 4.) * .05;
 }
 
 float sf(v3 p) {
 	p.y -= 2.5;
-	return LNG(p.xy) - 1.2 + .2 * pow(abs(.5 + .5 * sin(p.z * 1.4)), 4.);
+	RET LNG(p.xy) - 1.2 + .2 * pow(abs(.5 + .5 * sin(p.z * 1.4)), 4.);
 }
 
 vec3 g(v3 p) {
 	p.xz *= X(-.01 * p.z);
 	if (iT < 44.) p.z += iT;
 	else p.z += 44. + 2.6 * _S(0., 1., min(1., (iT - 44.) / 2.6));
 
-	return p;
+	RET p;
 }
 
 float Z(v3 p) {
 	p = g(p);
 	p.y += sin(p.x * 1.1 + sin(p.z * .7)) * .15;
-	return min(p.y + 1.5 + sin(p.z) * .05, LNG(p - v3(0, -3.3, 49)) - 2.) - y(p.xz) * .1;
+	RET min(p.y + 1.5 + sin(p.z) * .05, LNG(p - v3(0, -3.3, 49)) - 2.) - y(p.xz) * .1;
 }
 
 float Y(v3 p) {
 	p = g(p);
 	v3 T = p;
 	T.x = abs(T.x) - .8;
-	return sn(sn(ss(T), se(T), .1), sf(p), .3);
+	RET sn(sn(ss(T), se(T), .1), sf(p), .3);
 }
 
 float sg(v3 p) {
@@ -95,29 +96,29 @@ float sg(v3 p) {
 	if (iT >= 55.) S += sin(iT - 55.) * .05;
 	d = sn(sn(d, -(LNG(T.xz) - p.y * .5 - mix(.1, .7, S)), -.1), SS((T - v3(0, mix(.4, .25, S), 0)).xzy, v2(.35, .04) * S), .05 * S);
 	d -= y(T.xz + T.xy) * .05;
-	return d;
+	RET d;
 }
 
 float SE(v3 p) {
 	_f t = min(1., max(0., iT - 62.));
-	if (t <= 0.) return 1e10;
+	if (t <= 0.) RET 1e10;
 	p = g(p);
 	p.z -= 49.;
 	p.y += 1.5 - 1.4 * sin(t * 1.57079);
-	return LNG(p) - mix(.1, 2., clamp(0., 1., max(0., iT - 62.8) * 2.5));
+	RET LNG(p) - mix(.1, 2., clamp(0., 1., max(0., iT - 62.8) * 2.5));
 }
 
 vec3 D(v3 W, v3 K, v2 UV) {
 	v3 A = NM(K - W),
 	   V = NM(cross(v3(0, 1, 0), A));
-	return NM(A + V * UV.x + cross(A, V) * UV.y);
+	RET NM(A + V * UV.x + cross(A, V) * UV.y);
 }
 
-vec2 M(v3 p) { return O(O(O(v2(Y(p), 1.5), v2(Z(p), 2.5)), v2(sg(p), 3.5)), v2(SE(p), 4.5)); }
+vec2 M(v3 p) { RET O(O(O(v2(Y(p), 1.5), v2(Z(p), 2.5)), v2(sg(p), 3.5)), v2(SE(p), 4.5)); }
 
 vec3 m(v3 p) {
 	const v2 e = v2(1, -1) * 29e-5;
-	return NM(e.xyy * M(p + e.xyy).x + e.yyx * M(p + e.yyx).x + e.yxy * M(p + e.yxy).x + e.xxx * M(p + e.xxx).x);
+	RET NM(e.xyy * M(p + e.xyy).x + e.yyx * M(p + e.yyx).x + e.yxy * M(p + e.yxy).x + e.xxx * M(p + e.xxx).x);
 }
 
 float r(v3 p) {
@@ -128,14 +129,14 @@ float r(v3 p) {
 	for (int i = 0; i < 16; i++) {
 		h = M(p + U * d).x;
 		P = abs(h / d);
-		if (P < .01) return 0.;
+		if (P < .01) RET 0.;
 		d += h;
 	}
 
-	return P * 5.;
+	RET P * 5.;
 }
 
-float o(v3 p, v3 n) { return 1. - (.3 - M(p + n * .3).x) * 4.; }
+float o(v3 p, v3 n) { RET 1. - (.3 - M(p + n * .3).x) * 4.; }
 
 float u(v3 p, v3 I) {
 	_f w = .1,
@@ -146,42 +147,42 @@ float u(v3 p, v3 I) {
 	w *= .7;
 	st = max(st, _S(1. - w, (1. - w) * 1.06, l)) * .5;
 	w *= .7;
-	return max(st, _S(1. - w, (1. - w) * 1.07, l));
+	RET max(st, _S(1. - w, (1. - w) * 1.07, l));
 }
 
 vec3 ve(v3 v, v2 C) {
 	v2 q = C.xy / iR.xy;
 	v *= .5 + .5 * pow(16. * q.x * q.y * (1. - q.x) * (1. - q.y), .4);
-	return v;
+	RET v;
 }
 
 vec2 E() {
 	_f tg = iT;
-	if (tg < 2.) return v2(0, 1);
+	if (tg < 2.) RET v2(0, 1);
 	tg -= 2.;
-	if (tg < 4.) return v2(0, mix(1., 0., _S(0., 1., min(1., tg / 2.))));
+	if (tg < 4.) RET v2(0, mix(1., 0., _S(0., 1., min(1., tg / 2.))));
 	tg -= 4.;
-	if (tg < 3.5) return v2(0, mix(0., -.4, _S(0., 1., min(1., tg / 1.5))));
+	if (tg < 3.5) RET v2(0, mix(0., -.4, _S(0., 1., min(1., tg / 1.5))));
 	tg -= 3.5;
 	if (tg < 4.) {
 		_f f = _S(0., 1., min(1., tg / 4.));
-		return v2(sin(f * 3.141) * -.6, -.4 + 1.1 * sin(f * 1.5705));
+		RET v2(sin(f * 3.141) * -.6, -.4 + 1.1 * sin(f * 1.5705));
 	}
 
 	tg -= 4.;
-	if (tg < 12.) return v2(0, mix(.7, -.2, _S(0., 1., min(1., tg))));
+	if (tg < 12.) RET v2(0, mix(.7, -.2, _S(0., 1., min(1., tg))));
 	tg -= 12.;
-	if (tg < 17.) return v2(0, mix(-.2, -.05, _S(0., 1., min(1., tg / 5.))));
+	if (tg < 17.) RET v2(0, mix(-.2, -.05, _S(0., 1., min(1., tg / 5.))));
 	tg -= 17.;
-	return v2(0, mix(-.05, -.35, _S(0., 1., min(1., tg / 5.))));
+	RET v2(0, mix(-.05, -.35, _S(0., 1., min(1., tg / 5.))));
 }
 
 void mainImage(out vec4 B, v2 C) {
 	v2 UV = (C - .5 * iR.xy) / iR.y;
 #ifdef USE_WEBCAM
 	if (iT > 63.5) {
 		B = vec4(mix(v3(0), texture(iChannel0, C / iR.xy).rgb, min(1., (iT - 63.5) * 5.)), 1);
-		return;
+		RET;
 	}
 
 #endif