More unary fns for 3d-tiles

Apps/Sandcastle/gallery/3D Tiles Point Cloud Styling.html

@@ -124,6 +124,26 @@
     pointSize : "5"
 });
 
+addStyle('Sign', {
+    color : "color() * sign(${temperature})",
+    pointSize : "5"
+});
+
+addStyle('Rounding Functions', {
+    color : "rgb(floor(${POSITION}[0]) * 255, ceil(${POSITION}[1]) * 255, round(${POSITION}[2]) * 255)",
+    pointSize : "5"
+});
+
+addStyle('Exp and Log Functions', {
+    color : "rgb(log(${POSITION}[0]) * 255, log2(${POSITION}[1]) * 255 + exp2(${POSITION}[1]) * 255, exp(${POSITION}[2]) * 255)",
+    pointSize : "5"
+});
+
+addStyle('Fractional Part', {
+    color : "color() * fract(${temperature})",
+    pointSize : "5"
+});
+
 addStyle('Pow', {
     color : "color() * pow(${temperature}, 3)",
     pointSize : "5"

Source/Scene/Expression.js

@@ -62,7 +62,15 @@ define([
         asin : Math.asin,
         atan : Math.atan,
         radians : CesiumMath.toRadians,
-        degrees : CesiumMath.toDegrees
+        degrees : CesiumMath.toDegrees,
+        sign : Math.sign,
+        floor : Math.floor,
+        ceil : Math.ceil,
+        exp : Math.exp,
+        exp2 : exp2,
+        log : Math.log,
+        log2 : Math.log2,
+        fract : fract
     };
 
     /**
@@ -362,6 +370,29 @@ define([
             }
             val = createRuntimeAst(expression, args[0]);
             return new Node(ExpressionNodeType.UNARY, call, val);
+        } else if (call === 'round') {
+            //>>includeStart('debug', pragmas.debug);
+            if (args.length < 1 || args.length > 1) {
+                throw new DeveloperError('Error: ' + call + ' requires exactly one argument.');
+            }
+            //>>includeEnd('debug');
+            val = createRuntimeAst(expression, args[0]);
+            return new Node(ExpressionNodeType.UNARY, call, val);
+        } else if (call === 'isExactClass' || call === 'isClass') {
+            //>>includeStart('debug', pragmas.debug);
+            if (argsLength < 1 || argsLength > 1) {
+                throw new DeveloperError('Error: ' + call + ' requires exactly one argument.');
+            }
+            //>>includeEnd('debug');
+            val = createRuntimeAst(expression, args[0]);
+            return new Node(ExpressionNodeType.UNARY, call, val);
+        } else if (call === 'getExactClassName') {
+            //>>includeStart('debug', pragmas.debug);
+            if (argsLength > 0) {
+                throw new DeveloperError('Error: ' + call + ' does not take any argument.');
+            }
+            //>>includeEnd('debug');
+            return new Node(ExpressionNodeType.UNARY, call);
         } else if (defined(unaryFunctions[call])) {
             //>>includeStart('debug', pragmas.debug);
             if (args.length < 1 || args.length > 1) {
@@ -1119,7 +1150,15 @@ define([
         return expressions;
     }
 
-    Node.prototype.getShaderExpression = function(attributePrefix, shaderState) {
+    function fract(number) {
+        return number - Math.floor(number);
+    }
+
+    function exp2(exponent) {
+        return Math.pow(2.0,exponent);
+    }
+
+    Node.prototype.getShaderExpression = function(attributePrefix, shaderState, parent) {
         var color;
         var left;
         var right;
@@ -1184,6 +1223,8 @@ define([
                     return 'bool(' + left + ')';
                 } else if (value === 'Number') {
                     return 'float(' + left + ')';
+                } else if (value === 'round') {
+                	return 'floor(' + left + '0.5)';
                 } else if (defined(unaryFunctions[value])) {
                     return value + '(' + left + ')';
                 } else if (value === 'abs') {

Specs/Scene/ExpressionSpec.js

@@ -988,6 +988,189 @@ defineSuite([
         }).toThrowDeveloperError();
     });
 
+    it('evaluates sign function', function() {
+        var expression = new Expression('sign(5.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+
+        expression = new Expression('sign(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('sign(-5.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(-1.0);
+    });
+
+    it('throws if sign function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('sign()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('sign(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates floor function', function() {
+        var expression = new Expression('floor(5.5)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(5.0);
+
+        expression = new Expression('floor(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('floor(-1.2)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(-2.0);
+    });
+
+    it('throws if floor function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('floor()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('floor(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates ceil function', function() {
+        var expression = new Expression('ceil(5.5)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(6.0);
+
+        expression = new Expression('ceil(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('ceil(-1.2)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(-1.0);
+    });
+
+    it('throws if ceil function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('ceil()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('ceil(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates round function', function() {
+        var expression = new Expression('round(5.5)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(6);
+
+        expression = new Expression('round(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0);
+
+        expression = new Expression('round(1.2)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1);
+    });
+
+    it('throws if round function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('round()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('round(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates exp function', function() {
+        var expression = new Expression('exp(1.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(Math.E);
+
+        expression = new Expression('exp(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+    });
+
+    it('throws if exp function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('exp()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('exp(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates exp2 function', function() {
+        var expression = new Expression('exp2(1.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(2.0);
+
+        expression = new Expression('exp2(0.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+
+        expression = new Expression('exp2(2.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(4.0);
+    });
+
+    it('throws if exp2 function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('exp2()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('exp2(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates log function', function() {
+        var expression = new Expression('log(1.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('log(Math.E)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+    });
+
+    it('throws if log function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('log()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('log(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates log2 function', function() {
+        var expression = new Expression('log2(1.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('log2(2.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+
+        expression = new Expression('log2(4.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(2.0);
+    });
+
+    it('throws if log2 function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('log2()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('log2(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates fract function', function() {
+        var expression = new Expression('fract(1.0)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.0);
+
+        expression = new Expression('fract(2.25)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.25);
+
+        expression = new Expression('fract(-2.25)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(0.75);
+    });
+
+    it('throws if fract function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('log2()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('log2(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
     it('evaluates atan2 function', function() {
         var expression = new Expression('atan2(0,1)');
         expect(expression.evaluate(frameState, undefined)).toEqualEpsilon(0.0, CesiumMath.EPSILON10);
@@ -1879,6 +2062,81 @@ defineSuite([
         expect(shaderExpression).toEqual(expected);
     });
 
+    it('gets shader expression for sign', function() {
+        var expression = new Expression('sign(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'sign(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for floor', function() {
+        var expression = new Expression('floor(1.5)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'floor(1.5)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for ceil', function() {
+        var expression = new Expression('ceil(1.2)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'ceil(1.2)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for round', function() {
+        var expression = new Expression('round(1.2)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'round(1.2)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for exp', function() {
+        var expression = new Expression('exp(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'exp(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for exp2', function() {
+        var expression = new Expression('exp2(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'exp2(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for log', function() {
+        var expression = new Expression('log(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'log(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for log2', function() {
+        var expression = new Expression('log2(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'log2(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for fract', function() {
+        var expression = new Expression('fract(1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'fract(1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for clamp', function() {
+        var expression = new Expression('clamp(50.0, 0.0, 100.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'clamp(50.0, 0.0, 100.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for mix', function() {
+        var expression = new Expression('mix(0.0, 2.0, 0.5)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'mix(0.0, 2.0, 0.5)';
+
     it('gets shader expression for atan2', function() {
         var expression = new Expression('atan2(0.0,1.0)');
         var shaderExpression = expression.getShaderExpression('', {});