cesiumDemo/Source/Scene/Picking.js

import  ApproximateTerrainHeights from '../Core/ApproximateTerrainHeights.js';
import  BoundingRectangle from '../Core/BoundingRectangle.js';
import  Cartesian2 from '../Core/Cartesian2.js';
import  Cartesian3 from '../Core/Cartesian3.js';
import  Cartographic from '../Core/Cartographic.js';
import  Check from '../Core/Check.js';
import  Color from '../Core/Color.js';
import  defaultValue from '../Core/defaultValue.js';
import  defined from '../Core/defined.js';
import  DeveloperError from '../Core/DeveloperError.js';
import  Matrix4 from '../Core/Matrix4.js';
import  OrthographicFrustum from '../Core/OrthographicFrustum.js';
import  OrthographicOffCenterFrustum from '../Core/OrthographicOffCenterFrustum.js';
import  PerspectiveFrustum from '../Core/PerspectiveFrustum.js';
import  PerspectiveOffCenterFrustum from '../Core/PerspectiveOffCenterFrustum.js';
import  Ray from '../Core/Ray.js';
import  ShowGeometryInstanceAttribute from '../Core/ShowGeometryInstanceAttribute.js';
import  when from '../ThirdParty/when.js';
import  Camera from './Camera.js';
import  Cesium3DTileFeature from './Cesium3DTileFeature.js';
import  Cesium3DTilePass from './Cesium3DTilePass.js';
import  Cesium3DTilePassState from './Cesium3DTilePassState.js';
import  Cesium3DTileset from './Cesium3DTileset.js';
import  PickDepth from './PickDepth.js';
import  PrimitiveCollection from './PrimitiveCollection.js';
import  SceneMode from './SceneMode.js';
import  SceneTransforms from './SceneTransforms.js';
import  View from './View.js';

    var offscreenDefaultWidth = 0.1;

    var mostDetailedPreloadTilesetPassState = new Cesium3DTilePassState({
        pass : Cesium3DTilePass.MOST_DETAILED_PRELOAD
    });

    var mostDetailedPickTilesetPassState = new Cesium3DTilePassState({
        pass : Cesium3DTilePass.MOST_DETAILED_PICK
    });

    var pickTilesetPassState = new Cesium3DTilePassState({
        pass : Cesium3DTilePass.PICK
    });

    /**
     * @private
     */
    function Picking(scene) {
        this._mostDetailedRayPicks = [];
        this.pickRenderStateCache = {};
        this._pickPositionCache = {};
        this._pickPositionCacheDirty = false;

        var pickOffscreenViewport = new BoundingRectangle(0, 0, 1, 1);
        var pickOffscreenCamera = new Camera(scene);
        pickOffscreenCamera.frustum = new OrthographicFrustum({
            width: offscreenDefaultWidth,
            aspectRatio: 1.0,
            near: 0.1
        });

        this._pickOffscreenView = new View(scene, pickOffscreenCamera, pickOffscreenViewport);
    }

    Picking.prototype.update = function() {
        this._pickPositionCacheDirty = true;
    };

    Picking.prototype.getPickDepth = function(scene, index) {
        var pickDepths = scene.view.pickDepths;
        var pickDepth = pickDepths[index];
        if (!defined(pickDepth)) {
            pickDepth = new PickDepth();
            pickDepths[index] = pickDepth;
        }
        return pickDepth;
    };

    var scratchOrthoPickingFrustum = new OrthographicOffCenterFrustum();
    var scratchOrthoOrigin = new Cartesian3();
    var scratchOrthoDirection = new Cartesian3();
    var scratchOrthoPixelSize = new Cartesian2();
    var scratchOrthoPickVolumeMatrix4 = new Matrix4();

    function getPickOrthographicCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
        var camera = scene.camera;
        var frustum = camera.frustum;
        if (defined(frustum._offCenterFrustum)) {
            frustum = frustum._offCenterFrustum;
        }

        var x = 2.0 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1.0;
        x *= (frustum.right - frustum.left) * 0.5;
        var y = 2.0 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1.0;
        y *= (frustum.top - frustum.bottom) * 0.5;

        var transform = Matrix4.clone(camera.transform, scratchOrthoPickVolumeMatrix4);
        camera._setTransform(Matrix4.IDENTITY);

        var origin = Cartesian3.clone(camera.position, scratchOrthoOrigin);
        Cartesian3.multiplyByScalar(camera.right, x, scratchOrthoDirection);
        Cartesian3.add(scratchOrthoDirection, origin, origin);
        Cartesian3.multiplyByScalar(camera.up, y, scratchOrthoDirection);
        Cartesian3.add(scratchOrthoDirection, origin, origin);

        camera._setTransform(transform);

        if (scene.mode === SceneMode.SCENE2D) {
            Cartesian3.fromElements(origin.z, origin.x, origin.y, origin);
        }

        var pixelSize = frustum.getPixelDimensions(viewport.width, viewport.height, 1.0, 1.0, scratchOrthoPixelSize);

        var ortho = scratchOrthoPickingFrustum;
        ortho.right = pixelSize.x * 0.5;
        ortho.left = -ortho.right;
        ortho.top = pixelSize.y * 0.5;
        ortho.bottom = -ortho.top;
        ortho.near = frustum.near;
        ortho.far = frustum.far;

        return ortho.computeCullingVolume(origin, camera.directionWC, camera.upWC);
    }

    var scratchPerspPickingFrustum = new PerspectiveOffCenterFrustum();
    var scratchPerspPixelSize = new Cartesian2();

    function getPickPerspectiveCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
        var camera = scene.camera;
        var frustum = camera.frustum;
        var near = frustum.near;

        var tanPhi = Math.tan(frustum.fovy * 0.5);
        var tanTheta = frustum.aspectRatio * tanPhi;

        var x = 2.0 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1.0;
        var y = 2.0 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1.0;

        var xDir = x * near * tanTheta;
        var yDir = y * near * tanPhi;

        var pixelSize = frustum.getPixelDimensions(viewport.width, viewport.height, 1.0, 1.0, scratchPerspPixelSize);
        var pickWidth = pixelSize.x * width * 0.5;
        var pickHeight = pixelSize.y * height * 0.5;

        var offCenter = scratchPerspPickingFrustum;
        offCenter.top = yDir + pickHeight;
        offCenter.bottom = yDir - pickHeight;
        offCenter.right = xDir + pickWidth;
        offCenter.left = xDir - pickWidth;
        offCenter.near = near;
        offCenter.far = frustum.far;

        return offCenter.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
    }

    function getPickCullingVolume(scene, drawingBufferPosition, width, height, viewport) {
        var frustum = scene.camera.frustum;
        if (frustum instanceof OrthographicFrustum || frustum instanceof OrthographicOffCenterFrustum) {
            return getPickOrthographicCullingVolume(scene, drawingBufferPosition, width, height, viewport);
        }

        return getPickPerspectiveCullingVolume(scene, drawingBufferPosition, width, height, viewport);
    }

    // pick rectangle width and height, assumed odd
    var scratchRectangleWidth = 3.0;
    var scratchRectangleHeight = 3.0;
    var scratchRectangle = new BoundingRectangle(0.0, 0.0, scratchRectangleWidth, scratchRectangleHeight);
    var scratchPosition = new Cartesian2();
    var scratchColorZero = new Color(0.0, 0.0, 0.0, 0.0);

    Picking.prototype.pick = function(scene, windowPosition, width, height) {
        //>>includeStart('debug', pragmas.debug);
        if (!defined(windowPosition)) {
            throw new DeveloperError('windowPosition is undefined.');
        }
        //>>includeEnd('debug');

        scratchRectangleWidth = defaultValue(width, 3.0);
        scratchRectangleHeight = defaultValue(height, scratchRectangleWidth);

        var context = scene.context;
        var us = context.uniformState;
        var frameState = scene.frameState;

        var view = scene.defaultView;
        scene.view = view;

        var viewport = view.viewport;
        viewport.x = 0;
        viewport.y = 0;
        viewport.width = context.drawingBufferWidth;
        viewport.height = context.drawingBufferHeight;

        var passState = view.passState;
        passState.viewport = BoundingRectangle.clone(viewport, passState.viewport);

        var drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(scene, windowPosition, scratchPosition);

        scene.jobScheduler.disableThisFrame();

        scene.updateFrameState();
        frameState.cullingVolume = getPickCullingVolume(scene, drawingBufferPosition, scratchRectangleWidth, scratchRectangleHeight, viewport);
        frameState.invertClassification = false;
        frameState.passes.pick = true;
        frameState.tilesetPassState = pickTilesetPassState;

        us.update(frameState);

        scene.updateEnvironment();

        scratchRectangle.x = drawingBufferPosition.x - ((scratchRectangleWidth - 1.0) * 0.5);
        scratchRectangle.y = (scene.drawingBufferHeight - drawingBufferPosition.y) - ((scratchRectangleHeight - 1.0) * 0.5);
        scratchRectangle.width = scratchRectangleWidth;
        scratchRectangle.height = scratchRectangleHeight;
        passState = view.pickFramebuffer.begin(scratchRectangle, view.viewport);

        scene.updateAndExecuteCommands(passState, scratchColorZero);
        scene.resolveFramebuffers(passState);

        var object = view.pickFramebuffer.end(scratchRectangle);
        context.endFrame();
        return object;
    };

    function renderTranslucentDepthForPick(scene, drawingBufferPosition) {
        // PERFORMANCE_IDEA: render translucent only and merge with the previous frame
        var context = scene.context;
        var frameState = scene.frameState;
        var environmentState = scene.environmentState;

        var view = scene.defaultView;
        scene.view = view;

        var viewport = view.viewport;
        viewport.x = 0;
        viewport.y = 0;
        viewport.width = context.drawingBufferWidth;
        viewport.height = context.drawingBufferHeight;

        var passState = view.passState;
        passState.viewport = BoundingRectangle.clone(viewport, passState.viewport);

        scene.clearPasses(frameState.passes);
        frameState.passes.pick = true;
        frameState.passes.depth = true;
        frameState.cullingVolume = getPickCullingVolume(scene, drawingBufferPosition, 1, 1, viewport);
        frameState.tilesetPassState = pickTilesetPassState;

        scene.updateEnvironment();
        environmentState.renderTranslucentDepthForPick = true;
        passState = view.pickDepthFramebuffer.update(context, drawingBufferPosition, viewport);

        scene.updateAndExecuteCommands(passState, scratchColorZero);
        scene.resolveFramebuffers(passState);

        context.endFrame();
    }

    var scratchPerspectiveFrustum = new PerspectiveFrustum();
    var scratchPerspectiveOffCenterFrustum = new PerspectiveOffCenterFrustum();
    var scratchOrthographicFrustum = new OrthographicFrustum();
    var scratchOrthographicOffCenterFrustum = new OrthographicOffCenterFrustum();

    Picking.prototype.pickPositionWorldCoordinates = function(scene, windowPosition, result) {
        if (!scene.useDepthPicking) {
            return undefined;
        }

        //>>includeStart('debug', pragmas.debug);
        if (!defined(windowPosition)) {
            throw new DeveloperError('windowPosition is undefined.');
        }
        if (!scene.context.depthTexture) {
            throw new DeveloperError('Picking from the depth buffer is not supported. Check pickPositionSupported.');
        }
        //>>includeEnd('debug');

        var cacheKey = windowPosition.toString();

        if (this._pickPositionCacheDirty){
            this._pickPositionCache = {};
            this._pickPositionCacheDirty = false;
        } else if (this._pickPositionCache.hasOwnProperty(cacheKey)){
            return Cartesian3.clone(this._pickPositionCache[cacheKey], result);
        }

        var frameState = scene.frameState;
        var context = scene.context;
        var uniformState = context.uniformState;

        var view = scene.defaultView;
        scene.view = view;

        var drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(scene, windowPosition, scratchPosition);
        if (scene.pickTranslucentDepth) {
            renderTranslucentDepthForPick(scene, drawingBufferPosition);
        } else {
            scene.updateFrameState();
            uniformState.update(frameState);
            scene.updateEnvironment();
        }
        drawingBufferPosition.y = scene.drawingBufferHeight - drawingBufferPosition.y;

        var camera = scene.camera;

        // Create a working frustum from the original camera frustum.
        var frustum;
        if (defined(camera.frustum.fov)) {
            frustum = camera.frustum.clone(scratchPerspectiveFrustum);
        } else if (defined(camera.frustum.infiniteProjectionMatrix)){
            frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum);
        } else if (defined(camera.frustum.width)) {
            frustum = camera.frustum.clone(scratchOrthographicFrustum);
        } else {
            frustum = camera.frustum.clone(scratchOrthographicOffCenterFrustum);
        }

        var frustumCommandsList = view.frustumCommandsList;
        var numFrustums = frustumCommandsList.length;
        for (var i = 0; i < numFrustums; ++i) {
            var pickDepth = this.getPickDepth(scene, i);
            var depth = pickDepth.getDepth(context, drawingBufferPosition.x, drawingBufferPosition.y);
            if (depth > 0.0 && depth < 1.0) {
                var renderedFrustum = frustumCommandsList[i];
                var height2D;
                if (scene.mode === SceneMode.SCENE2D) {
                    height2D = camera.position.z;
                    camera.position.z = height2D - renderedFrustum.near + 1.0;
                    frustum.far = Math.max(1.0, renderedFrustum.far - renderedFrustum.near);
                    frustum.near = 1.0;
                    uniformState.update(frameState);
                    uniformState.updateFrustum(frustum);
                } else {
                    frustum.near = renderedFrustum.near * (i !== 0 ? scene.opaqueFrustumNearOffset : 1.0);
                    frustum.far = renderedFrustum.far;
                    uniformState.updateFrustum(frustum);
                }

                result = SceneTransforms.drawingBufferToWgs84Coordinates(scene, drawingBufferPosition, depth, result);

                if (scene.mode === SceneMode.SCENE2D) {
                    camera.position.z = height2D;
                    uniformState.update(frameState);
                }

                this._pickPositionCache[cacheKey] = Cartesian3.clone(result);
                return result;
            }
        }

        this._pickPositionCache[cacheKey] = undefined;
        return undefined;
    };

    var scratchPickPositionCartographic = new Cartographic();

    Picking.prototype.pickPosition = function(scene, windowPosition, result) {
        result = this.pickPositionWorldCoordinates(scene, windowPosition, result);
        if (defined(result) && scene.mode !== SceneMode.SCENE3D) {
            Cartesian3.fromElements(result.y, result.z, result.x, result);

            var projection = scene.mapProjection;
            var ellipsoid = projection.ellipsoid;

            var cart = projection.unproject(result, scratchPickPositionCartographic);
            ellipsoid.cartographicToCartesian(cart, result);
        }

        return result;
    };

    function drillPick(limit, pickCallback) {
        // PERFORMANCE_IDEA: This function calls each primitive's update for each pass. Instead
        // we could update the primitive once, and then just execute their commands for each pass,
        // and cull commands for picked primitives.  e.g., base on the command's owner.
        var i;
        var attributes;
        var result = [];
        var pickedPrimitives = [];
        var pickedAttributes = [];
        var pickedFeatures = [];
        if (!defined(limit)) {
            limit = Number.MAX_VALUE;
        }

        var pickedResult = pickCallback();
        while (defined(pickedResult)) {
            var object = pickedResult.object;
            var position = pickedResult.position;
            var exclude = pickedResult.exclude;

            if (defined(position) && !defined(object)) {
                result.push(pickedResult);
                break;
            }

            if (!defined(object) || !defined(object.primitive)) {
                break;
            }

            if (!exclude) {
                result.push(pickedResult);
                if (0 >= --limit) {
                    break;
                }
            }

            var primitive = object.primitive;
            var hasShowAttribute = false;

            // If the picked object has a show attribute, use it.
            if (typeof primitive.getGeometryInstanceAttributes === 'function') {
                if (defined(object.id)) {
                    attributes = primitive.getGeometryInstanceAttributes(object.id);
                    if (defined(attributes) && defined(attributes.show)) {
                        hasShowAttribute = true;
                        attributes.show = ShowGeometryInstanceAttribute.toValue(false, attributes.show);
                        pickedAttributes.push(attributes);
                    }
                }
            }

            if (object instanceof Cesium3DTileFeature) {
                hasShowAttribute = true;
                object.show = false;
                pickedFeatures.push(object);
            }

            // Otherwise, hide the entire primitive
            if (!hasShowAttribute) {
                primitive.show = false;
                pickedPrimitives.push(primitive);
            }

            pickedResult = pickCallback();
        }

        // Unhide everything we hid while drill picking
        for (i = 0; i < pickedPrimitives.length; ++i) {
            pickedPrimitives[i].show = true;
        }

        for (i = 0; i < pickedAttributes.length; ++i) {
            attributes = pickedAttributes[i];
            attributes.show = ShowGeometryInstanceAttribute.toValue(true, attributes.show);
        }

        for (i = 0; i < pickedFeatures.length; ++i) {
            pickedFeatures[i].show = true;
        }

        return result;
    }

    Picking.prototype.drillPick = function(scene, windowPosition, limit, width, height) {
        var that = this;
        var pickCallback = function() {
            var object = that.pick(scene, windowPosition, width, height);
            if (defined(object)) {
                return {
                    object : object,
                    position : undefined,
                    exclude : false
                };
            }
        };
        var objects = drillPick(limit, pickCallback);
        return objects.map(function(element) {
            return element.object;
        });
    };

    var scratchRight = new Cartesian3();
    var scratchUp = new Cartesian3();

    function MostDetailedRayPick(ray, width, tilesets) {
        this.ray = ray;
        this.width = width;
        this.tilesets = tilesets;
        this.ready = false;
        this.deferred = when.defer();
        this.promise = this.deferred.promise;
    }

    function updateOffscreenCameraFromRay(picking, ray, width, camera) {
        var direction = ray.direction;
        var orthogonalAxis = Cartesian3.mostOrthogonalAxis(direction, scratchRight);
        var right = Cartesian3.cross(direction, orthogonalAxis, scratchRight);
        var up = Cartesian3.cross(direction, right, scratchUp);

        camera.position = ray.origin;
        camera.direction = direction;
        camera.up = up;
        camera.right = right;

        camera.frustum.width = defaultValue(width, offscreenDefaultWidth);
        return camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
    }

    function updateMostDetailedRayPick(picking, scene, rayPick) {
        var frameState = scene.frameState;

        var ray = rayPick.ray;
        var width = rayPick.width;
        var tilesets = rayPick.tilesets;

        var camera = picking._pickOffscreenView.camera;
        var cullingVolume = updateOffscreenCameraFromRay(picking, ray, width, camera);

        var tilesetPassState = mostDetailedPreloadTilesetPassState;
        tilesetPassState.camera = camera;
        tilesetPassState.cullingVolume = cullingVolume;

        var ready = true;
        var tilesetsLength = tilesets.length;
        for (var i = 0; i < tilesetsLength; ++i) {
            var tileset = tilesets[i];
            if (tileset.show && scene.primitives.contains(tileset)) {
                // Only update tilesets that are still contained in the scene's primitive collection and are still visible
                // Update tilesets continually until all tilesets are ready. This way tiles are never removed from the cache.
                tileset.updateForPass(frameState, tilesetPassState);
                ready = (ready && tilesetPassState.ready);
            }
        }

        if (ready) {
            rayPick.deferred.resolve();
        }

        return ready;
    }

    Picking.prototype.updateMostDetailedRayPicks = function(scene) {
        // Modifies array during iteration
        var rayPicks = this._mostDetailedRayPicks;
        for (var i = 0; i < rayPicks.length; ++i) {
            if (updateMostDetailedRayPick(this, scene, rayPicks[i])) {
                rayPicks.splice(i--, 1);
            }
        }
    };

    function getTilesets(primitives, objectsToExclude, tilesets) {
        var length = primitives.length;
        for (var i = 0; i < length; ++i) {
            var primitive = primitives.get(i);
            if (primitive.show) {
                if ((primitive instanceof Cesium3DTileset)) {
                    if (!defined(objectsToExclude) || objectsToExclude.indexOf(primitive) === -1) {
                        tilesets.push(primitive);
                    }
                } else if (primitive instanceof PrimitiveCollection) {
                    getTilesets(primitive, objectsToExclude, tilesets);
                }
            }
        }
    }

    function launchMostDetailedRayPick(picking, scene, ray, objectsToExclude, width, callback) {
        var tilesets = [];
        getTilesets(scene.primitives, objectsToExclude, tilesets);
        if (tilesets.length === 0) {
            return when.resolve(callback());
        }

        var rayPick = new MostDetailedRayPick(ray, width, tilesets);
        picking._mostDetailedRayPicks.push(rayPick);
        return rayPick.promise.then(function() {
            return callback();
        });
    }

    function isExcluded(object, objectsToExclude) {
        if (!defined(object) || !defined(objectsToExclude) || objectsToExclude.length === 0) {
            return false;
        }
        return (objectsToExclude.indexOf(object) > -1) ||
               (objectsToExclude.indexOf(object.primitive) > -1) ||
               (objectsToExclude.indexOf(object.id) > -1);
    }

    function getRayIntersection(picking, scene, ray, objectsToExclude, width, requirePosition, mostDetailed) {
        var context = scene.context;
        var uniformState = context.uniformState;
        var frameState = scene.frameState;

        var view = picking._pickOffscreenView;
        scene.view = view;

        updateOffscreenCameraFromRay(picking, ray, width, view.camera);

        scratchRectangle = BoundingRectangle.clone(view.viewport, scratchRectangle);

        var passState = view.pickFramebuffer.begin(scratchRectangle, view.viewport);

        scene.jobScheduler.disableThisFrame();

        scene.updateFrameState();
        frameState.invertClassification = false;
        frameState.passes.pick = true;
        frameState.passes.offscreen = true;

        if (mostDetailed) {
            frameState.tilesetPassState = mostDetailedPickTilesetPassState;
        } else {
            frameState.tilesetPassState = pickTilesetPassState;
        }

        uniformState.update(frameState);

        scene.updateEnvironment();
        scene.updateAndExecuteCommands(passState, scratchColorZero);
        scene.resolveFramebuffers(passState);

        var position;
        var object = view.pickFramebuffer.end(context);

        if (scene.context.depthTexture) {
            var numFrustums = view.frustumCommandsList.length;
            for (var i = 0; i < numFrustums; ++i) {
                var pickDepth = picking.getPickDepth(scene, i);
                var depth = pickDepth.getDepth(context, 0, 0);
                if (depth > 0.0 && depth < 1.0) {
                    var renderedFrustum = view.frustumCommandsList[i];
                    var near = renderedFrustum.near * (i !== 0 ? scene.opaqueFrustumNearOffset : 1.0);
                    var far = renderedFrustum.far;
                    var distance = near + depth * (far - near);
                    position = Ray.getPoint(ray, distance);
                    break;
                }
            }
        }

        scene.view = scene.defaultView;
        context.endFrame();

        if (defined(object) || defined(position)) {
            return {
                object : object,
                position : position,
                exclude : (!defined(position) && requirePosition) || isExcluded(object, objectsToExclude)
            };
        }
    }

    function getRayIntersections(picking, scene, ray, limit, objectsToExclude, width, requirePosition, mostDetailed) {
        var pickCallback = function() {
            return getRayIntersection(picking, scene, ray, objectsToExclude, width, requirePosition, mostDetailed);
        };
        return drillPick(limit, pickCallback);
    }

    function pickFromRay(picking, scene, ray, objectsToExclude, width, requirePosition, mostDetailed) {
        var results = getRayIntersections(picking, scene, ray, 1, objectsToExclude, width, requirePosition, mostDetailed);
        if (results.length > 0) {
            return results[0];
        }
    }

    function drillPickFromRay(picking, scene, ray, limit, objectsToExclude, width, requirePosition, mostDetailed) {
        return getRayIntersections(picking, scene, ray, limit, objectsToExclude, width, requirePosition, mostDetailed);
    }

    function deferPromiseUntilPostRender(scene, promise) {
        // Resolve promise after scene's postRender in case entities are created when the promise resolves.
        // Entities can't be created between viewer._onTick and viewer._postRender.
        var deferred = when.defer();
        promise.then(function(result) {
            var removeCallback = scene.postRender.addEventListener(function() {
                deferred.resolve(result);
                removeCallback();
            });
            scene.requestRender();
        }).otherwise(function(error) {
            deferred.reject(error);
        });
        return deferred.promise;
    }

    Picking.prototype.pickFromRay = function(scene, ray, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('ray', ray);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('Ray intersections are only supported in 3D mode.');
        }
        //>>includeEnd('debug');

        return pickFromRay(this, scene, ray, objectsToExclude, width, false, false);
    };

    Picking.prototype.drillPickFromRay = function(scene, ray, limit, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('ray', ray);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('Ray intersections are only supported in 3D mode.');
        }
        //>>includeEnd('debug');

        return drillPickFromRay(this, scene, ray, limit, objectsToExclude, width,false, false);
    };

    Picking.prototype.pickFromRayMostDetailed = function(scene, ray, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('ray', ray);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('Ray intersections are only supported in 3D mode.');
        }
        //>>includeEnd('debug');

        var that = this;
        ray = Ray.clone(ray);
        objectsToExclude = defined(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
        return deferPromiseUntilPostRender(scene, launchMostDetailedRayPick(that, scene, ray, objectsToExclude, width, function() {
            return pickFromRay(that, scene, ray, objectsToExclude, width, false, true);
        }));
    };

    Picking.prototype.drillPickFromRayMostDetailed = function(scene, ray, limit, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('ray', ray);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('Ray intersections are only supported in 3D mode.');
        }
        //>>includeEnd('debug');

        var that = this;
        ray = Ray.clone(ray);
        objectsToExclude = defined(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
        return deferPromiseUntilPostRender(scene, launchMostDetailedRayPick(that, scene, ray, objectsToExclude, width, function() {
            return drillPickFromRay(that, scene, ray, limit, objectsToExclude, width, false, true);
        }));
    };

    var scratchSurfacePosition = new Cartesian3();
    var scratchSurfaceNormal = new Cartesian3();
    var scratchSurfaceRay = new Ray();
    var scratchCartographic = new Cartographic();

    function getRayForSampleHeight(scene, cartographic) {
        var globe = scene.globe;
        var ellipsoid = defined(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
        var height = ApproximateTerrainHeights._defaultMaxTerrainHeight;
        var surfaceNormal = ellipsoid.geodeticSurfaceNormalCartographic(cartographic, scratchSurfaceNormal);
        var surfacePosition = Cartographic.toCartesian(cartographic, ellipsoid, scratchSurfacePosition);
        var surfaceRay = scratchSurfaceRay;
        surfaceRay.origin = surfacePosition;
        surfaceRay.direction =  surfaceNormal;
        var ray = new Ray();
        Ray.getPoint(surfaceRay, height, ray.origin);
        Cartesian3.negate(surfaceNormal, ray.direction);
        return ray;
    }

    function getRayForClampToHeight(scene, cartesian) {
        var globe = scene.globe;
        var ellipsoid = defined(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
        var cartographic = Cartographic.fromCartesian(cartesian, ellipsoid, scratchCartographic);
        return getRayForSampleHeight(scene, cartographic);
    }

    function getHeightFromCartesian(scene, cartesian) {
        var globe = scene.globe;
        var ellipsoid = defined(globe) ? globe.ellipsoid : scene.mapProjection.ellipsoid;
        var cartographic = Cartographic.fromCartesian(cartesian, ellipsoid, scratchCartographic);
        return cartographic.height;
    }

    function sampleHeightMostDetailed(picking, scene, cartographic, objectsToExclude, width) {
        var ray = getRayForSampleHeight(scene, cartographic);
        return launchMostDetailedRayPick(picking, scene, ray, objectsToExclude, width, function() {
            var pickResult = pickFromRay(picking, scene, ray, objectsToExclude, width, true, true);
            if (defined(pickResult)) {
                return getHeightFromCartesian(scene, pickResult.position);
            }
        });
    }

    function clampToHeightMostDetailed(picking, scene, cartesian, objectsToExclude, width, result) {
        var ray = getRayForClampToHeight(scene, cartesian);
        return launchMostDetailedRayPick(picking, scene, ray, objectsToExclude, width, function() {
            var pickResult = pickFromRay(picking, scene, ray, objectsToExclude, width, true, true);
            if (defined(pickResult)) {
                return Cartesian3.clone(pickResult.position, result);
            }
        });
    }

    Picking.prototype.sampleHeight = function(scene, position, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('position', position);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('sampleHeight is only supported in 3D mode.');
        }
        if (!scene.sampleHeightSupported) {
            throw new DeveloperError('sampleHeight requires depth texture support. Check sampleHeightSupported.');
        }
        //>>includeEnd('debug');

        var ray = getRayForSampleHeight(scene, position);
        var pickResult = pickFromRay(this, scene, ray, objectsToExclude, width, true, false);
        if (defined(pickResult)) {
            return getHeightFromCartesian(scene, pickResult.position);
        }
    };

    Picking.prototype.clampToHeight = function(scene, cartesian, objectsToExclude, width, result) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('cartesian', cartesian);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('clampToHeight is only supported in 3D mode.');
        }
        if (!scene.clampToHeightSupported) {
            throw new DeveloperError('clampToHeight requires depth texture support. Check clampToHeightSupported.');
        }
        //>>includeEnd('debug');

        var ray = getRayForClampToHeight(scene, cartesian);
        var pickResult = pickFromRay(this, scene, ray, objectsToExclude, width, true, false);
        if (defined(pickResult)) {
            return Cartesian3.clone(pickResult.position, result);
        }
    };

    Picking.prototype.sampleHeightMostDetailed = function(scene, positions, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('positions', positions);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('sampleHeightMostDetailed is only supported in 3D mode.');
        }
        if (!scene.sampleHeightSupported) {
            throw new DeveloperError('sampleHeightMostDetailed requires depth texture support. Check sampleHeightSupported.');
        }
        //>>includeEnd('debug');

        objectsToExclude = defined(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
        var length = positions.length;
        var promises = new Array(length);
        for (var i = 0; i < length; ++i) {
            promises[i] = sampleHeightMostDetailed(this, scene, positions[i], objectsToExclude, width);
        }
        return deferPromiseUntilPostRender(scene, when.all(promises).then(function(heights) {
            var length = heights.length;
            for (var i = 0; i < length; ++i) {
                positions[i].height = heights[i];
            }
            return positions;
        }));
    };

    Picking.prototype.clampToHeightMostDetailed = function(scene, cartesians, objectsToExclude, width) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('cartesians', cartesians);
        if (scene.mode !== SceneMode.SCENE3D) {
            throw new DeveloperError('clampToHeightMostDetailed is only supported in 3D mode.');
        }
        if (!scene.clampToHeightSupported) {
            throw new DeveloperError('clampToHeightMostDetailed requires depth texture support. Check clampToHeightSupported.');
        }
        //>>includeEnd('debug');

        objectsToExclude = defined(objectsToExclude) ? objectsToExclude.slice() : objectsToExclude;
        var length = cartesians.length;
        var promises = new Array(length);
        for (var i = 0; i < length; ++i) {
            promises[i] = clampToHeightMostDetailed(this, scene, cartesians[i], objectsToExclude, width, cartesians[i]);
        }
        return deferPromiseUntilPostRender(scene, when.all(promises).then(function(clampedCartesians) {
            var length = clampedCartesians.length;
            for (var i = 0; i < length; ++i) {
                cartesians[i] = clampedCartesians[i];
            }
            return cartesians;
        }));
    };

    Picking.prototype.destroy = function() {
        this._pickOffscreenView = this._pickOffscreenView && this._pickOffscreenView.destroy();
    };
export default Picking;