Various bug fixes

Author: Xiaoji Chen

lib/index.js

@@ -1016,7 +1016,8 @@ GLSL.prototype.transforms = {
 		//simple assign, =
 		return Descriptor(`${target} = ${right}`, {
 			type: right.type,
-			complexity: 1
+			complexity: 1,
+			include: right.include
 		})
 	},
 

lib/stdlib.js

@@ -7,6 +7,18 @@
 
 var operators = require('./operators').operators;
 
+// Returns the type of argument at index
+// If argIndex is not specified, assume the first argument
+function genType(argIndex) {
+	if (Number.isInteger(argIndex)) {
+		return function(node) {
+			return this.process(node.children[argIndex + 1]).type;
+		}
+	}
+	var node = argIndex;
+	// node.children[0] is the function itself
+	return this.process(node.children[1]).type;
+}
 
 /**
  * Types stubs
@@ -105,36 +117,43 @@ function radians (degrees) {
 	if (degrees.length) return degrees.map(radians);
 	return degrees * 0.017453292519943295;
 }
+radians.type = genType;
 
 function degrees (radians) {
 	if (radians.length) return radians.map(degrees);
 	return radians * 57.29577951308232;
 }
+degrees.type = genType;
 
 function sin (angle) {
 	if (angle.length) return angle.map(sin);
 	return Math.sin(angle);
 }
+sin.type = genType;
 
 function cos (angle) {
 	if (angle.length) return angle.map(cos);
 	return Math.cos(angle);
 }
+cos.type = genType;
 
 function tan (angle) {
 	if (angle.length) return angle.map(tan);
 	return Math.tan(angle);
 }
+tan.type = genType;
 
 function asin (x) {
 	if (x.length) return x.map(asin);
 	return Math.asin(x);
 }
+asin.type = genType;
 
 function acos (x) {
 	if (x.length) return x.map(acos);
 	return Math.acos(x);
 }
+acos.type = genType;
 
 function atan (y, x) {
 	if (arguments.length > 1) {
@@ -151,23 +170,27 @@ function atan (y, x) {
 
 	return Math.atan(y);
 }
+atan.type = genType;
 
 function pow (x, y) {
 	if (x.length) return x.map(function (x, i) {
 		return Math.pow(x, y[i]);
 	});
 	return Math.pow(x, y);
 }
+pow.type = genType;
 
 function exp (x) {
 	if (x.length) return x.map(exp);
 	return Math.exp(x);
 }
+exp.type = genType;
 
 function log (x) {
 	if (x.length) return x.map(log);
 	return Math.log(x);
 }
+log.type = genType;
 
 var log2 = Math.log2 ? function log2 (x) {
 		if (x.length) return x.map(log2);
@@ -176,36 +199,43 @@ var log2 = Math.log2 ? function log2 (x) {
 		if (x.length) return x.map(log2);
 		return Math.log(x) / Math.LN2;
 	};
+log2.type = genType;
 
 function exp2 (x) {
 	if (x.length) return x.map(exp2);
 	return Math.pow(2, x);
 }
+exp2.type = genType;
 
 function sqrt (x) {
 	if (x.length) return x.map(sqrt);
 	return Math.sqrt(x);
 }
+sqrt.type = genType;
 
 function inversesqrt (x) {
 	if (x.length) return x.map(inversesqrt);
 	return 1 / Math.sqrt(x);
 }
+inversesqrt.type = genType;
 
 function abs (x) {
 	if (x.length) return x.map(abs);
 	return Math.abs(x);
 }
+abs.type = genType;
 
 function floor (x) {
 	if (x.length) return x.map(floor);
 	return Math.floor(x);
 }
+floor.type = genType;
 
 function ceil (x) {
 	if (x.length) return x.map(ceil);
 	return Math.ceil(x);
 }
+ceil.type = genType;
 
 var sign = Math.sign ? function sign (x) {
 	if (x.length) return x.map(sign);
@@ -221,11 +251,13 @@ var sign = Math.sign ? function sign (x) {
 
 	return x > 0 ? 1 : -1;
 };
+sign.type = genType;
 
 function fract (x) {
 	if (x.length) return x.map(fract);
 	return x - Math.floor(x);
 }
+fract.type = genType;
 
 function mod (x, y) {
 	if (x.length) {
@@ -240,6 +272,7 @@ function mod (x, y) {
 	}
 	return x % y;
 }
+mod.type = genType;
 
 function min (x, y) {
 	if (x.length) {
@@ -252,6 +285,7 @@ function min (x, y) {
 	}
 	return Math.min(x, y);
 }
+min.type = genType;
 
 function max (x, y) {
 	if (x.length) {
@@ -264,6 +298,7 @@ function max (x, y) {
 	}
 	return Math.max(x, y);
 }
+max.type = genType;
 
 function clamp (x, min, max) {
 	if (x.length) {
@@ -277,6 +312,7 @@ function clamp (x, min, max) {
 
 	return Math.min(Math.max(x, min), max);
 }
+clamp.type = genType;
 
 function mix (x, y, a) {
 	if (x.length) {
@@ -290,6 +326,7 @@ function mix (x, y, a) {
 
 	return x * (1.0 - a) + y * a;
 }
+mix.type = genType;
 
 function step (edge, x) {
 	if (!x && !edge) return 0
@@ -304,9 +341,7 @@ function step (edge, x) {
 
 	return x < edge ? 0.0 : 1.0;
 }
-step.type = function (node) {
-	return this.process(node.children[1]).type;
-}
+step.type = genType(1);
 
 function smoothstep (edge0, edge1, x) {
 	if (!x && !edge0 && !edge1) return 0
@@ -321,6 +356,7 @@ function smoothstep (edge0, edge1, x) {
 	var t = Math.min(Math.max((x - edge0) / (edge1 - edge0), 0.0), 1.0);
 	return t * t * (3.0 - 2.0 * t);
 }
+smoothstep.type = genType(2);
 
 function length (x) {
 	var sum = 0;
@@ -375,6 +411,7 @@ function normalize (x) {
 	}
 	return out;
 }
+normalize.type = genType;
 
 function faceforward (N, I, Nref) {
 	if (Nref == null) Nref = N;
@@ -386,6 +423,7 @@ function faceforward (N, I, Nref) {
 
 	return dot > 0 ? N.map(function (x) { return -x;}) : N;
 }
+faceforward.type = genType;
 
 function reflect (I, N) {
 	var dot = 0;
@@ -400,6 +438,7 @@ function reflect (I, N) {
 
 	return out;
 }
+reflect.type = genType;
 
 function refract (I, N, eta) {
 	var dot = 0;
@@ -419,7 +458,7 @@ function refract (I, N, eta) {
 
 	return out;
 }
-
+refract.type = genType;
 
 /**
  * Vector relational functions

test/index.js

@@ -60,6 +60,18 @@ test('float x; vec2 uv, position = fn(x) * vec2(uv.yx.yx.x, -uv.y);', function (
 	);
 	t.end()
 })
+test('vec2 uv = vec2(1.); uv += mix(uv, uv, 0.);', function (t) {
+	t.deepEqual(eval(t.name), [2, 2]);
+	t.end()
+})
+test('vec2 uv = vec2(0., 0.5); uv *= smoothstep(0., 1., uv);', function (t) {
+	t.deepEqual(eval(t.name), [0, 0.25]);
+	t.end()
+})
+test('float x = 0.5; vec2 uv = vec2(0., 0.5); uv *= smoothstep(0., 1., x);', function (t) {
+	t.deepEqual(eval(t.name), [0, 0.25]);
+	t.end()
+})
 test('vec2 position; position *= 1.0 + vec2();', function (t) {
 	t.equal(
 		clean(compile(t.name)),