CesiumGS · mramato · Sep 29, 2016 · Sep 8, 2016 · Sep 8, 2016 · Sep 8, 2016
diff --git a/Apps/Sandcastle/gallery/development/Display Conditions.html b/Apps/Sandcastle/gallery/development/Display Conditions.html
@@ -0,0 +1,108 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
+    <meta name="description" content="Display conditions">
+    <meta name="cesium-sandcastle-labels" content="Development">
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script type="text/javascript" src="../../../ThirdParty/requirejs-2.1.20/require.js"></script>
+    <script type="text/javascript">
+    require.config({
+        baseUrl : '../../../Source',
+        waitSeconds : 60
+    });
+    </script>
+</head>
+<body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+<style>
+    @import url(../templates/bucket.css);
+</style>
+<div id="cesiumContainer" class="fullSize"></div>
+<div id="loadingOverlay"><h1>Loading...</h1></div>
+<div id="toolbar"></div>
+<script id="cesium_sandcastle_script">
+function startup(Cesium) {
+    'use strict';
+//Sandcastle_Begin
+    var viewer = new Cesium.Viewer('cesiumContainer');
+    var scene = viewer.scene;
+
+    function addBillboardAndPrimitive() {
+        Sandcastle.declare(addBillboardAndPrimitive);
+
+        var billboards = scene.primitives.add(new Cesium.BillboardCollection());
+        billboards.add({
+            image : '../images/facility.gif',
+            position : Cesium.Cartesian3.fromDegrees(-77, 40.5),
+            distanceDisplayCondition : new Cesium.DistanceDisplayCondition(5.5e6)
+        });
+
+        scene.primitives.add(new Cesium.Primitive({
+            geometryInstances : new Cesium.GeometryInstance({
+                geometry : new Cesium.RectangleGeometry({
+                    rectangle : Cesium.Rectangle.fromDegrees(-80.5, 39.7, -75.1, 42.0),
+                    vertexFormat : Cesium.PerInstanceColorAppearance.VERTEX_FORMAT
+                }),
+                attributes: {
+                    color : Cesium.ColorGeometryInstanceAttribute.fromColor(new Cesium.Color(1.0, 0.0, 0.0, 0.5)),
+                    distanceDisplayCondition : new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(0.0, 5.5e6)
+                }
+            }),
+            appearance : new Cesium.PerInstanceColorAppearance({
+                closed : true
+            })
+        }));
+    }
+
+    function addPointAndModel() {
+        Sandcastle.declare(addPointAndModel);
+
+        var position = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
+
+        var pointPrimitives = scene.primitives.add(new Cesium.PointPrimitiveCollection());
+        pointPrimitives.add({
+            color : Cesium.Color.YELLOW,
+            position : position,
+            distanceDisplayCondition : new Cesium.DistanceDisplayCondition(250.5)
+        });
+
+        scene.primitives.add(Cesium.Model.fromGltf({
+            url : '../../SampleData/models/CesiumGround/Cesium_Ground.glb',
+            modelMatrix : Cesium.Transforms.eastNorthUpToFixedFrame(position),
+            distanceDisplayCondition : new Cesium.DistanceDisplayCondition(0.0, 250.5)
+        }));
+    }
+
+    Sandcastle.addToolbarMenu([{
+        text : 'Billboard and Primitive',
+        onselect : function() {
+            addBillboardAndPrimitive();
+            Sandcastle.highlight(addBillboardAndPrimitive);
+        }
+    }, {
+        text : 'Point and Model',
+        onselect : function() {
+            addPointAndModel();
+            Sandcastle.highlight(addPointAndModel);
+        }
+    }]);
+
+    Sandcastle.reset = function () {
+        viewer.camera.flyHome(0);
+        scene.primitives.removeAll();
+    };
+
+//Sandcastle_End
+    Sandcastle.finishedLoading();
+}
+if (typeof Cesium !== "undefined") {
+    startup(Cesium);
+} else if (typeof require === "function") {
+    require(["Cesium"], startup);
+}
+</script>
+</body>
+</html>
diff --git a/Source/Core/DistanceDisplayCondition.js b/Source/Core/DistanceDisplayCondition.js
@@ -0,0 +1,89 @@
+/*global define*/
+define([
+        './Cartesian3',
+        './defaultValue',
+        './defined',
+        './defineProperties',
+        './Matrix4'
+    ], function(
+        Cartesian3,
+        defaultValue,
+        defined,
+        defineProperties,
+        Matrix4) {
+    'use strict';
+
+    /**
+     * DOC_TBA
+     *
+     * @alias DistanceDisplayCondition
+     * @constructor
+     */
+    function DistanceDisplayCondition(near, far) {
+        near = defaultValue(near, 0.0);
+        this._near = near;
+        this._near2 = near * near;
+
+        far = defaultValue(far, Number.MAX_VALUE);
+        this._far = far;
+        this._far2 = far * far;
+    }
+
+    defineProperties(DistanceDisplayCondition.prototype, {
+        /**
+         * DOC_TBA
+         * @memberof DistanceDisplayCondition.prototype
+         * @type {Number}
+         */
+        near : {
+            get : function() {
+                return this._near;
+            },
+            set : function(value) {
+                this._near = value;
+                this._near2 = value * value;
+            }
+        },
+        /**
+         * DOC_TBA
+         * @memberof DistanceDisplayCondition.prototype
+         * @type {Number}
+         */
+        far : {
+            get : function() {
+                return this._far;
+            },
+            set : function(value) {
+                this._far = value;
+                this._far2 = value * value;
+            }
+        }
+    });
+
+    var scratchPosition = new Cartesian3();
+
+    /**
+     * DOC_TBA
+     */
+    DistanceDisplayCondition.prototype.isVisible = function(primitive, frameState) {
+        // TODO: need to consider positions, e.g., for a polyline
+
+        // Distance to center of primitive's reference frame
+        var position = Matrix4.getTranslation(primitive.modelMatrix, scratchPosition);
+        var distance2 = Cartesian3.distanceSquared(position, frameState.camera.positionWC);
+        return (distance2 >= this._near2) && (distance2 <= this._far2);
+    };
+
+    /**
+     * DOC_TBA
+     */
+    DistanceDisplayCondition.equals = function(left, right) {
+        return left === right ||
+               (defined(left) &&
+                defined(right) &&
+                left.near === right.near &&
+                left.far === right.far);
+    };
+
+    return DistanceDisplayCondition;
+});
diff --git a/Source/Core/DistanceDisplayConditionGeometryInstanceAttribute.js b/Source/Core/DistanceDisplayConditionGeometryInstanceAttribute.js
@@ -0,0 +1,161 @@
+/*global define*/
+define([
+        './ComponentDatatype',
+        './defaultValue',
+        './defined',
+        './defineProperties',
+        './DeveloperError'
+    ], function(
+        ComponentDatatype,
+        defaultValue,
+        defined,
+        defineProperties,
+        DeveloperError) {
+    'use strict';
+
+    /**
+     * Value and type information for per-instance geometry attribute that determines if the geometry instance has a distance display condition.
+     *
+     * @alias DistanceDisplayConditionGeometryInstanceAttribute
+     * @constructor
+     *
+     * @param {Number} [near=0.0] The near distance.
+     * @param {Number} [far=Number.MAX_VALUE] The far distance.
+     *
+     * @example
+     * var instance = new Cesium.GeometryInstance({
+     *   geometry : new Cesium.BoxGeometry({
+     *     vertexFormat : Cesium.VertexFormat.POSITION_AND_NORMAL,
+     *     minimum : new Cesium.Cartesian3(-250000.0, -250000.0, -250000.0),
+     *     maximum : new Cesium.Cartesian3(250000.0, 250000.0, 250000.0)
+     *   }),
+     *   modelMatrix : Cesium.Matrix4.multiplyByTranslation(Cesium.Transforms.eastNorthUpToFixedFrame(
+     *     Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883)), new Cesium.Cartesian3(0.0, 0.0, 1000000.0), new Cesium.Matrix4()),
+     *   id : 'box',
+     *   attributes : {
+     *     show : new Cesium.DistanceDisplayConditionGeometryInstanceAttribute(100.0, 10000.0)
+     *   }
+     * });
+     *
+     * @see GeometryInstance
+     * @see GeometryInstanceAttribute
+     */
+    function DistanceDisplayConditionGeometryInstanceAttribute(near, far) {
+        near = defaultValue(near, 0.0);
+        far = defaultValue(far, Number.MAX_VALUE);
+
+        /**
+         * The values for the attributes stored in a typed array.
+         *
+         * @type Float32Array
+         *
+         * @default [0.0, 0.0, Number.MAX_VALUE]
+         */
+        this.value = new Float32Array([near, far]);
+    }
+
+    defineProperties(DistanceDisplayConditionGeometryInstanceAttribute.prototype, {
+        /**
+         * The datatype of each component in the attribute, e.g., individual elements in
+         * {@link DistanceDisplayConditionGeometryInstanceAttribute#value}.
+         *
+         * @memberof DistanceDisplayConditionGeometryInstanceAttribute.prototype
+         *
+         * @type {ComponentDatatype}
+         * @readonly
+         *
+         * @default {@link ComponentDatatype.FLOAT}
+         */
+        componentDatatype : {
+            get : function() {
+                return ComponentDatatype.FLOAT;
+            }
+        },
+
+        /**
+         * The number of components in the attributes, i.e., {@link DistanceDisplayConditionGeometryInstanceAttribute#value}.
+         *
+         * @memberof DistanceDisplayConditionGeometryInstanceAttribute.prototype
+         *
+         * @type {Number}
+         * @readonly
+         *
+         * @default 3
+         */
+        componentsPerAttribute : {
+            get : function() {
+                return 2;
+            }
+        },
+
+        /**
+         * When <code>true</code> and <code>componentDatatype</code> is an integer format,
+         * indicate that the components should be mapped to the range [0, 1] (unsigned)
+         * or [-1, 1] (signed) when they are accessed as floating-point for rendering.
+         *
+         * @memberof DistanceDisplayConditionGeometryInstanceAttribute.prototype
+         *
+         * @type {Boolean}
+         * @readonly
+         *
+         * @default false
+         */
+        normalize : {
+            get : function() {
+                return false;
+            }
+        }
+    });
+
+    /**
+     * Creates a new {@link DistanceDisplayConditionGeometryInstanceAttribute} instance given the provided an enabled flag and {@link DistanceDisplayCondition}.
+     *
+     * @param {DistanceDisplayCondition} distanceDisplayCondition The distance display condition.
+     * @returns {DistanceDisplayConditionGeometryInstanceAttribute} The new {@link DistanceDisplayConditionGeometryInstanceAttribute} instance.
+     *
+     * @example
+     * var instance = new Cesium.GeometryInstance({
+     *   geometry : geometry,
+     *   attributes : {
+     *     color : Cesium.DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition(distanceDisplayCondition),
+     *   }
+     * });
+     */
+    DistanceDisplayConditionGeometryInstanceAttribute.fromDistanceDisplayCondition = function(distanceDisplayCondition) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(distanceDisplayCondition)) {
+            throw new DeveloperError('distanceDisplayCondition is required.');
+        }
+        //>>includeEnd('debug');
+
+        return new DistanceDisplayConditionGeometryInstanceAttribute(distanceDisplayCondition.near, distanceDisplayCondition.far);
+    };
+
+    /**
+     * Converts a distance display condition to a typed array that can be used to assign a distance display condition attribute.
+     *
+     * @param {DistanceDisplayCondition} distanceDisplayCondition The distance display condition value.
+     * @param {Float32Array} [result] The array to store the result in, if undefined a new instance will be created.
+     * @returns {Float32Array} The modified result parameter or a new instance if result was undefined.
+     *
+     * @example
+     * var attributes = primitive.getGeometryInstanceAttributes('an id');
+     * attributes.distanceDisplayCondition = Cesium.DistanceDisplayConditionGeometryInstanceAttribute.toValue(distanceDisplayCondition, attributes.distanceDisplayCondition);
+     */
+    DistanceDisplayConditionGeometryInstanceAttribute.toValue = function(distanceDisplayCondition, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(distanceDisplayCondition)) {
+            throw new DeveloperError('distanceDisplayCondition is required.');
+        }
+        //>>includeEnd('debug');
+
+        if (!defined(result)) {
+            return new Float32Array([distanceDisplayCondition.near, distanceDisplayCondition.far]);
+        }
+        result[0] = distanceDisplayCondition.near;
+        result[1] = distanceDisplayCondition.far;
+        return result;
+    };
+
+    return DistanceDisplayConditionGeometryInstanceAttribute;
+});
diff --git a/Source/Core/GeometryInstanceAttribute.js b/Source/Core/GeometryInstanceAttribute.js
@@ -44,6 +44,7 @@ define([
      * 
      * @see ColorGeometryInstanceAttribute
      * @see ShowGeometryInstanceAttribute
+     * @see DistanceDisplayConditionGeometryInstanceAttribute
      */
     function GeometryInstanceAttribute(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);