Merge pull request #5040 from glee2244/3d-tiles

First commit with distance

Author: lilleyse

Source/Scene/Expression.js

@@ -82,7 +82,10 @@ define([
         atan2 : Math.atan2,
         pow : Math.pow,
         min : Math.min,
-        max : Math.max
+        max : Math.max,
+        distance : distance,
+        dot: dot,
+        cross: cross
     };
 
     var unaryFunctions = {
@@ -125,6 +128,48 @@ define([
         return CesiumMath.logBase(number, 2.0);
     }
 
+    function distance(x, y) {
+        if (typeof x === 'number' && typeof y === 'number') {
+            return Math.abs(x - y);
+        } else if (x instanceof Cartesian2 && y instanceof Cartesian2) {
+            return Cartesian2.distance(x, y);
+        } else if (x instanceof Cartesian3 && y instanceof Cartesian3) {
+            return Cartesian3.distance(x, y);
+        } else if (x instanceof Cartesian4 && y instanceof Cartesian4) {
+            return Cartesian4.distance(x, y);
+        } else {
+            //>>includeStart('debug', pragmas.debug);
+            throw new DeveloperError('Function distance requires matching types of inputs. Arguments are ' + x + ' and ' + y + '.');
+            //>>includeEnd('debug');
+        }
+    }
+
+    function dot(x, y) {
+        if (typeof x === 'number' && typeof y === 'number') {
+            return x * y;
+        } else if (x instanceof Cartesian2 && y instanceof Cartesian2) {
+            return Cartesian2.dot(x, y);
+        } else if (x instanceof Cartesian3 && y instanceof Cartesian3) {
+            return Cartesian3.dot(x, y);
+        } else if (x instanceof Cartesian4 && y instanceof Cartesian4) {
+            return Cartesian4.dot(x, y);
+        } else {
+            //>>includeStart('debug', pragmas.debug);
+            throw new DeveloperError('Function dot requires matching types of inputs. Arguments are ' + x + ' and ' + y + '.');
+            //>>includeEnd('debug');
+        }
+    }
+
+    function cross(x, y) {
+        if (x instanceof Cartesian3 && y instanceof Cartesian3) {
+            return Cartesian3.cross(x, y, ScratchStorage.getCartesian3());
+        } else {
+            //>>includeStart('debug', pragmas.debug);
+            throw new DeveloperError('Invalid argument type for cross() function, must be vec3');
+            //>>includeEnd('debug');
+        }
+    }
+
     /**
      * Evaluates an expression defined using the
      * {@link https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/Styling|3D Tiles Styling language}.
@@ -247,9 +292,9 @@ define([
         }
 
         shaderExpression = returnType + ' ' + functionName + '() \n' +
-            '{ \n' +
-            '    return ' + shaderExpression + '; \n' +
-            '} \n';
+                           '{ \n' +
+                           '    return ' + shaderExpression + '; \n' +
+                           '} \n';
 
         return shaderExpression;
     };
@@ -400,7 +445,7 @@ define([
                 createRuntimeAst(expression, args[1]),
                 createRuntimeAst(expression, args[2])
             ];
-           return new Node(ExpressionNodeType.LITERAL_COLOR, call, val);
+            return new Node(ExpressionNodeType.LITERAL_COLOR, call, val);
         } else if (call === 'rgba' || call === 'hsla') {
             //>>includeStart('debug', pragmas.debug);
             if (argsLength < 4) {
@@ -808,6 +853,12 @@ define([
     function getEvaluateBinaryFunction(call) {
         var evaluate = binaryFunctions[call];
         return function(feature) {
+            var left = this._left.evaluate(feature);
+            var right = this._right.evaluate(feature);
+
+            if (call === 'distance' || call === 'dot' || call === 'cross') {
+                return evaluate(left, right);
+            }
             return evaluate(this._left.evaluate(feature), this._right.evaluate(feature));
         };
     }

Specs/Scene/ExpressionSpec.js

@@ -2143,6 +2143,105 @@ defineSuite([
         }).toThrowDeveloperError();
     });
 
+    it('evaluates the distance function', function() {
+        var expression = new Expression('distance(0, 1)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+
+        expression = new Expression('distance(vec2(1.0, 0.0), vec2(0.0, 0.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(1.0);
+
+        expression = new Expression('distance(vec3(3.0, 2.0, 1.0), vec3(1.0, 0.0, 0.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(3.0);
+
+        expression = new Expression('distance(vec4(5.0, 5.0, 5.0, 5.0), vec4(0.0, 0.0, 0.0, 0.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(10.0);
+    });
+
+    it('throws if distance function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('distance(0.0)');
+        }) .toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('distance(1, 3, 0)');
+        }).toThrowDeveloperError();
+    });
+
+    it('throws if distance function takes mismatching types of arguments', function() {
+        expect(function() {
+            return new Expression('distance(1, vec2(3.0, 2.0)').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('distance(vec4(5.0, 2.0, 3.0, 1.0), vec3(4.0, 4.0, 4.0))').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates the dot function', function() {
+        var expression = new Expression('dot(1, 2)');
+        expect(expression.evaluate(frameState, undefined)).toEqual(2.0);
+
+        expression = new Expression('dot(vec2(1.0, 1.0), vec2(2.0, 2.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(4.0);
+
+        expression = new Expression('dot(vec3(1.0, 2.0, 3.0), vec3(2.0, 2.0, 1.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(9.0);
+
+        expression = new Expression('dot(vec4(5.0, 5.0, 2.0, 3.0), vec4(1.0, 2.0, 1.0, 1.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(20.0);
+    });
+
+    it('throws if dot function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('dot(0.0)');
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('dot(1, 3, 0)');
+        }).toThrowDeveloperError();
+    });
+
+    it('throws if dot function takes mismatching types of arguments', function() {
+        expect(function() {
+            return new Expression('dot(1, vec2(3.0, 2.0)').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('dot(vec4(5.0, 2.0, 3.0, 1.0), vec3(4.0, 4.0, 4.0))').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+    });
+
+    it('evaluates the cross function', function() {
+        var expression = new Expression('cross(vec3(1.0, 1.0, 1.0), vec3(2.0, 2.0, 2.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(new Cartesian3(0.0, 0.0, 0.0));
+
+        expression = new Expression('cross(vec3(-1.0, -1.0, -1.0), vec3(0.0, -2.0, -5.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(new Cartesian3(3.0, -5.0, 2.0));
+
+        expression = new Expression('cross(vec3(5.0, -2.0, 1.0), vec3(-2.0, -6.0, -8.0))');
+        expect(expression.evaluate(frameState, undefined)).toEqual(new Cartesian3(22.0, 38.0, -34.0));
+    });
+
+    it('throws if cross function takes an invalid number of arguments', function() {
+        expect(function() {
+            return new Expression('cross(vec3(0.0, 0.0, 0.0))');
+        }) .toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('cross(vec3(0.0, 0.0, 0.0), vec3(1.0, 1.0, 1.0), vec3(2.0, 2.0, 2.0))');
+        }).toThrowDeveloperError();
+    });
+
+    it('throws if cross function does not take vec3 arguments', function() {
+        expect(function() {
+            return new Expression('cross(vec2(1.0, 2.0), vec2(3.0, 2.0)').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+
+        expect(function() {
+            return new Expression('cross(vec4(5.0, 2.0, 3.0, 1.0), vec3(4.0, 4.0, 4.0))').evaluate(frameState, undefined);
+        }).toThrowDeveloperError();
+    });
+
     it('evaluates length function', function() {
         var expression = new Expression('length(-3.0)');
         expect(expression.evaluate(frameState, undefined)).toEqual(3.0);
@@ -2587,7 +2686,7 @@ defineSuite([
         feature.addProperty('complicatedArray', [{
             'subproperty' : Cartesian4.UNIT_X,
             'anotherproperty' : Cartesian4.UNIT_Y
-         }, {
+        }, {
             'subproperty' : Cartesian4.UNIT_Z,
             'anotherproperty' : Cartesian4.UNIT_W
         }]);
@@ -3016,7 +3115,7 @@ defineSuite([
         expect(shaderExpression).toEqual(expected);
     });
 
-     it('gets shader expression for sin', function() {
+    it('gets shader expression for sin', function() {
         var expression = new Expression('sin(0.0)');
         var shaderExpression = expression.getShaderExpression('', {});
         var expected = 'sin(0.0)';
@@ -3163,6 +3262,27 @@ defineSuite([
         expect(shaderExpression).toEqual(expected);
     });
 
+    it('gets shader expression for distance', function() {
+        var expression = new Expression('distance(0.0, 1.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'distance(0.0, 1.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for dot', function() {
+        var expression = new Expression('dot(1.0, 2.0)');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'dot(1.0, 2.0)';
+        expect(shaderExpression).toEqual(expected);
+    });
+
+    it('gets shader expression for cross', function() {
+        var expression = new Expression('cross(vec3(1.0, 1.0, 1.0), vec3(2.0, 2.0, 2.0))');
+        var shaderExpression = expression.getShaderExpression('', {});
+        var expected = 'cross(vec3(1.0, 1.0, 1.0), vec3(2.0, 2.0, 2.0))';
+        expect(shaderExpression).toEqual(expected);
+    });
+
     it('throws when getting shader expression for regex', function() {
         var expression = new Expression('regExp("a").test("abc")');
         expect(function() {