3d tiles unary ops

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

@@ -109,8 +109,13 @@
     color : "color() * abs(${temperature} - 0.5)"
 });
 
-addStyle('Cos', {
-    color : "color() * abs(cos(${temperature} + TILES3D_TILESET_TIME))"
+addStyle('Trigonometric Functions', {
+    color : "color() * radians(cos(${temperature})) + color() * sin(${temperature}) + color() * tan(${temperature})"
+
+});
+
+addStyle('Arc Trigonometric Functions', {
+    color : "color() * acos(degrees(${temperature})) + color() * asin(${temperature}) + color() * atan(${temperature})"
 });
 
 addStyle('Sqrt', {

Source/Scene/Expression.js

@@ -5,6 +5,7 @@ define([
         '../Core/defineProperties',
         '../Core/DeveloperError',
         '../Core/isArray',
+        '../Core/Math',
         '../ThirdParty/jsep',
         './ExpressionNodeType'
     ], function(
@@ -13,6 +14,7 @@ define([
         defineProperties,
         DeveloperError,
         isArray,
+        CesiumMath,
         jsep,
         ExpressionNodeType) {
     "use strict";
@@ -43,6 +45,19 @@ define([
         }
     };
 
+    var unaryFunctions = {
+        abs : Math.abs,
+        sqrt : Math.sqrt,
+        cos : Math.cos,
+        sin : Math.sin,
+        tan : Math.tan,
+        acos : Math.acos,
+        asin : Math.asin,
+        atan : Math.atan,
+        radians : CesiumMath.toRadians,
+        degrees : CesiumMath.toDegrees
+    };
+
     /**
      * Evaluates an expression defined using the
      * {@link https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/Styling|3D Tiles Styling language}.
@@ -340,23 +355,7 @@ define([
             }
             val = createRuntimeAst(expression, args[0]);
             return new Node(ExpressionNodeType.UNARY, call, val);
-        } else if (call === 'abs') {
-            //>>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 === 'cos') {
-            //>>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 === 'sqrt') {
+        } else if (defined(unaryFunctions[call])) {
             //>>includeStart('debug', pragmas.debug);
             if (args.length < 1 || args.length > 1) {
                 throw new DeveloperError('Error: ' + call + ' requires exactly one argument.');
@@ -599,12 +598,8 @@ define([
                 node.evaluate = node._evaluateNaN;
             } else if (node._value === 'isFinite') {
                 node.evaluate = node._evaluateIsFinite;
-            } else if (node._value === 'abs') {
-                node.evaluate = node._evaluateAbsoluteValue;
-            } else if (node._value === 'cos') {
-                node.evaluate = node._evaluateCosine;
-            } else if (node._value === 'sqrt') {
-                node.evaluate = node._evaluateSquareRoot;
+            } else if (defined(unaryFunctions[node._value])) {
+                node.evaluate = getEvaluateUnaryFunction(node._value);
             } else if (node._value === 'Boolean') {
                 node.evaluate = node._evaluateBooleanConversion;
             } else if (node._value === 'Number') {
@@ -643,6 +638,13 @@ define([
         return feature._content._tileset.timeSinceLoad;
     }
 
+    function getEvaluateUnaryFunction(call) {
+        var evaluate = unaryFunctions[call];
+        return function(feature) {
+            return evaluate(this._left.evaluate(feature));
+        };
+    }
+
     Node.prototype._evaluateLiteral = function(frameState, feature) {
         return this._value;
     };
@@ -940,18 +942,6 @@ define([
         return isFinite(this._left.evaluate(frameState, feature));
     };
 
-    Node.prototype._evaluateAbsoluteValue = function(frameState, feature) {
-        return Math.abs(this._left.evaluate(frameState, feature));
-    };
-
-    Node.prototype._evaluateCosine = function(frameState, feature) {
-        return Math.cos(this._left.evaluate(frameState, feature));
-    };
-
-    Node.prototype._evaluateSquareRoot = function(frameState, feature) {
-        return Math.sqrt(this._left.evaluate(frameState, feature));
-    };
-
     Node.prototype._evaluateBooleanConversion = function(frameState, feature) {
         return Boolean(this._left.evaluate(frameState, feature));
     };
@@ -1169,6 +1159,8 @@ define([
                     return 'bool(' + left + ')';
                 } else if (value === 'Number') {
                     return 'float(' + left + ')';
+                } else if (defined(unaryFunctions[value])) {
+                    return value + '(' + left + ')';
                 } else if (value === 'abs') {
                     return 'abs(' + left + ')';
                 } else if (value === 'cos') {

Specs/Scene/ExpressionSpec.js

@@ -2,10 +2,12 @@
 defineSuite([
         'Scene/Expression',
         'Core/Color',
+        'Core/Math',
         'Scene/ExpressionNodeType'
     ], function(
         Expression,
         Color,
+        CesiumMath,
         ExpressionNodeType) {
     'use strict';
 
@@ -860,6 +862,111 @@ defineSuite([
         }).toThrowDeveloperError();
     });
 
+    it('evaluates sin function', function() {
+        var expression = new Expression('sin(0)');
+        expect(expression.evaluate(undefined)).toEqual(0);
+    });
+
+    it('throws if sin function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('sin()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('sin(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates tan function', function() {
+        var expression = new Expression('tan(0)');
+        expect(expression.evaluate(undefined)).toEqual(0);
+    });
+
+    it('throws if tan function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('tan()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('tan(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates acos function', function() {
+        var expression = new Expression('acos(1)');
+        expect(expression.evaluate(undefined)).toEqual(0);
+    });
+
+    it('throws if acos function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('acos()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('acos(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates asin function', function() {
+        var expression = new Expression('asin(0)');
+        expect(expression.evaluate(undefined)).toEqual(0);
+    });
+
+    it('throws if asin function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('asin()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('asin(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates atan function', function() {
+        var expression = new Expression('atan(0)');
+        expect(expression.evaluate(undefined)).toEqual(0);
+    });
+
+    it('throws if atan function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('atan()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('atan(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates radians function', function() {
+        var expression = new Expression('radians(180)');
+        expect(expression.evaluate(undefined)).toEqualEpsilon(Math.PI, CesiumMath.EPSILON10);
+    });
+
+    it('throws if radians function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('radians()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('radians(1, 2)');
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates degrees function', function() {
+        var expression = new Expression('degrees(2 * PI)');
+        expect(expression.evaluate(undefined)).toEqualEpsilon(360, CesiumMath.EPSILON10);
+    });
+
+    it('throws if degrees function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('degrees()');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('degrees(1, 2)');
+        });
+    });
+
     it('evaluates sqrt function', function() {
         var expression = new Expression('sqrt(1.0)');
         expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
@@ -1658,6 +1765,41 @@ defineSuite([
         expect(shaderExpression).toEqual(expected);
     });
 
+     it('gets shader expression for sin', function() {
+        var expression = new Expression('sin(0.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'sin(0.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for tan', function() {
+        var expression = new Expression('tan(0.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'tan(0.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for acos', function() {
+        var expression = new Expression('acos(0.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'acos(0.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for asin', function() {
+        var expression = new Expression('asin(0.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'asin(0.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for atan', function() {
+        var expression = new Expression('atan(0.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'atan(0.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
     it('gets shader expression for sqrt', function() {
         var expression = new Expression('sqrt(1.0)');
         var shaderExpression = expression.getShaderExpression('', {});