Пример #1
0
        public void focusOnTerrainCenter()
        {
            if (this.dc == null)
            {
                String message = Logging.getMessage("nullValue.DrawContextIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }
            if (this.globe == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextGlobeIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }

            if (this.dc.getSurfaceGeometry() == null)
            {
                return;
            }
            if (isAnimating())
            {
                return;
            }

            Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(this.globe,
                                                                            this.center, this.heading, this.pitch, this.roll, this.zoom);

            if (modelview != null)
            {
                Matrix modelviewInv = modelview.getInverse();
                if (modelviewInv != null)
                {
                    // The change in focus must happen seamlessly; we can't move the eye or the forward vector
                    // (only the center position and zoom should change).

                    Vec4           eyePoint      = Vec4.UNIT_W.transformBy4(modelviewInv);
                    Vec4           forward       = Vec4.UNIT_NEGATIVE_Z.transformBy4(modelviewInv);
                    Intersection[] intersections = this.dc.getSurfaceGeometry().intersect(new Line(eyePoint, forward));
                    if (intersections != null && intersections.Length > 0)
                    {
                        Vec4 viewportCenterPoint = intersections[0].getIntersectionPoint();
                        OrbitViewInputSupport.OrbitViewState modelCoords = OrbitViewInputSupport.computeOrbitViewState(
                            this.globe, modelview, viewportCenterPoint);
                        if (validateModelCoordinates(modelCoords))
                        {
                            setModelCoordinates(modelCoords);
                        }
                    }
                }
            }
        }
Пример #2
0
        private Matrix getModelviewInverse(Globe globe,
                                           Position centerPosition, Angle heading, Angle pitch, Angle roll, double zoom)
        {
            if (globe != null && centerPosition != null && heading != null && pitch != null)
            {
                Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(globe,
                                                                                centerPosition, heading, pitch, roll, zoom);
                if (modelview != null)
                {
                    return(modelview.getInverse());
                }
            }

            return(null);
        }
Пример #3
0
        public Vec4 getCurrentEyePoint()
        {
            if (this.globe != null)
            {
                Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(this.globe, this.center,
                                                                                this.heading, this.pitch, this.roll, this.zoom);
                if (modelview != null)
                {
                    Matrix modelviewInv = modelview.getInverse();
                    if (modelviewInv != null)
                    {
                        return(Vec4.UNIT_W.transformBy4(modelviewInv));
                    }
                }
            }

            return(Vec4.ZERO);
        }
Пример #4
0
        public Position getCurrentEyePosition()
        {
            if (this.globe != null)
            {
                Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(this.globe, this.center,
                                                                                this.heading, this.pitch, this.roll, this.zoom);
                if (modelview != null)
                {
                    Matrix modelviewInv = modelview.getInverse();
                    if (modelviewInv != null)
                    {
                        Vec4 eyePoint = Vec4.UNIT_W.transformBy4(modelviewInv);
                        return(this.globe.computePositionFromPoint(eyePoint));
                    }
                }
            }

            return(Position.ZERO);
        }
Пример #5
0
        protected void doApply(DrawContext dc)
        {
            if (dc == null)
            {
                String message = Logging.getMessage("nullValue.DrawContextIsNull");
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }
            if (dc.getGL() == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextGLIsNull");
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }
            if (dc.getGlobe() == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextGlobeIsNull");
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }

            // Update the draw context and the globe, then re-apply the current view property limits. Apply view property
            // limits after updating the globe so that globe-specific property limits are applied correctly.
            this.dc      = dc;
            this.globe   = this.dc.getGlobe();
            this.center  = this.getOrbitViewLimits().limitCenterPosition(this, this.center);
            this.heading = this.getOrbitViewLimits().limitHeading(this, this.heading);
            this.pitch   = this.getOrbitViewLimits().limitPitch(this, this.pitch);
            this.roll    = this.getOrbitViewLimits().limitRoll(this, this.roll);
            this.zoom    = this.getOrbitViewLimits().limitZoom(this, this.zoom);

            //========== modelview matrix state ==========//
            // Compute the current modelview matrix.
            this.modelview = OrbitViewInputSupport.computeTransformMatrix(this.globe, this.center,
                                                                          this.heading, this.pitch, this.roll, this.zoom);
            if (this.modelview == null)
            {
                this.modelview = Matrix.IDENTITY;
            }
            // Compute the current inverse-modelview matrix.
            this.modelviewInv = this.modelview.getInverse();
            if (this.modelviewInv == null)
            {
                this.modelviewInv = Matrix.IDENTITY;
            }

            //========== projection matrix state ==========//
            // Get the current OpenGL viewport state.
            int[] viewportArray = new int[4];
            this.dc.getGL().gl2.GetInteger(OpenGL.GL_VIEWPORT, 0, viewportArray);
//      this.dc.getGL().glGetIntegerv(OpenGL.GL_VIEWPORT, viewportArray, 0);
            this.viewport = new Rectangle(viewportArray[0], viewportArray[1], viewportArray[2], viewportArray[3]);
            // Compute the current clip plane distances. The near distance depends on the far distance, so we must compute
            // the far distance first.
            this.farClipDistance  = computeFarClipDistance();
            this.nearClipDistance = computeNearClipDistance();
            // Compute the current viewport dimensions.
            double viewportWidth  = this.viewport.getWidth() <= 0.0 ? 1.0 : this.viewport.getWidth();
            double viewportHeight = this.viewport.getHeight() <= 0.0 ? 1.0 : this.viewport.getHeight();

            // Compute the current projection matrix.
            this.projection = Matrix.fromPerspective(this.fieldOfView,
                                                     viewportWidth, viewportHeight,
                                                     this.nearClipDistance, this.farClipDistance);
            // Compute the current frustum.
            this.frustum = Frustum.fromPerspective(this.fieldOfView,
                                                   (int)viewportWidth, (int)viewportHeight,
                                                   this.nearClipDistance, this.farClipDistance);

            //========== load GL matrix state ==========//
            loadGLViewState(dc, this.modelview, this.projection);

            //========== after apply (GL matrix state) ==========//
            afterDoApply();
        }
Пример #6
0
        public void setOrientation(Position eyePosition, Position centerPosition)
        {
            if (eyePosition == null || centerPosition == null)
            {
                String message = Logging.getMessage("nullValue.PositionIsNull");
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }
            if (this.globe == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextGlobeIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }

            Vec4 newEyePoint    = this.globe.computePointFromPosition(eyePosition);
            Vec4 newCenterPoint = this.globe.computePointFromPosition(centerPosition);

            if (newEyePoint == null || newCenterPoint == null)
            {
                String message = Logging.getMessage("View.ErrorSettingOrientation", eyePosition, centerPosition);
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }

            // If eye lat/lon != center lat/lon, then the surface normal at the center point will be a good value
            // for the up direction.
            Vec4 up = this.globe.computeSurfaceNormalAtPoint(newCenterPoint);
            // Otherwise, estimate the up direction by using the *current* heading with the new center position.
            Vec4 forward = newCenterPoint.subtract3(newEyePoint).normalize3();

            if (forward.cross3(up).getLength3() < 0.001)
            {
                Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(
                    this.globe, centerPosition, this.heading, Angle.ZERO, Angle.ZERO, 1);
                if (modelview != null)
                {
                    Matrix modelviewInv = modelview.getInverse();
                    if (modelviewInv != null)
                    {
                        up = Vec4.UNIT_Y.transformBy4(modelviewInv);
                    }
                }
            }

            if (up == null)
            {
                String message = Logging.getMessage("View.ErrorSettingOrientation", eyePosition, centerPosition);
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }

            OrbitViewInputSupport.OrbitViewState modelCoords = OrbitViewInputSupport.computeOrbitViewState(
                this.globe, newEyePoint, newCenterPoint, up);
            if (!validateModelCoordinates(modelCoords))
            {
                String message = Logging.getMessage("View.ErrorSettingOrientation", eyePosition, centerPosition);
                Logging.logger().severe(message);
                throw new ArgumentException(message);
            }

            setModelCoordinates(modelCoords);
        }
Пример #7
0
        /** Sets the point of rotation for heading and pitch changes to the surface position at the viewport center. */
        public void focusOnViewportCenter()
        {
            if (this.isAnimating())
            {
                return;
            }
            if (this.dc == null)
            {
                String message = Logging.getMessage("nullValue.DrawContextIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }
            if (this.globe == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextGlobeIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }

            Position viewportCenterPos = this.dc.getViewportCenterPosition();

            if (viewportCenterPos == null)
            {
                String message = Logging.getMessage("nullValue.DrawingContextViewportCenterIsNull");
                Logging.logger().severe(message);
                throw new IllegalStateException(message);
            }

            // We want the actual "geometric point" here, which must be adjusted for vertical exaggeration.
            Vec4 viewportCenterPoint = this.globe.computePointFromPosition(
                viewportCenterPos.getLatitude(), viewportCenterPos.getLongitude(),
                this.globe.getElevation(viewportCenterPos.getLatitude(), viewportCenterPos.getLongitude())
                * dc.getVerticalExaggeration());

            if (viewportCenterPoint != null)
            {
                Matrix modelview = OrbitViewInputSupport.computeTransformMatrix(this.globe,
                                                                                this.center, this.heading, this.pitch, this.roll, this.zoom);
                if (modelview != null)
                {
                    Matrix modelviewInv = modelview.getInverse();
                    if (modelviewInv != null)
                    {
                        // The change in focus must happen seamlessly; we can't move the eye or the forward vector
                        // (only the center position and zoom should change). Therefore we pick a point along the
                        // forward vector, and *near* the viewportCenterPoint, but not necessarily at the
                        // viewportCenterPoint itself.
                        Vec4   eyePoint       = Vec4.UNIT_W.transformBy4(modelviewInv);
                        Vec4   forward        = Vec4.UNIT_NEGATIVE_Z.transformBy4(modelviewInv);
                        double distance       = eyePoint.distanceTo3(viewportCenterPoint);
                        Vec4   newCenterPoint = Vec4.fromLine3(eyePoint, distance, forward);

                        OrbitViewInputSupport.OrbitViewState modelCoords = OrbitViewInputSupport.computeOrbitViewState(
                            this.globe, modelview, newCenterPoint);
                        if (validateModelCoordinates(modelCoords))
                        {
                            setModelCoordinates(modelCoords);
                        }
                    }
                }
            }
        }