Application: gvSIG desktop » gvSIG 3D

package org.gvsig.animation3d.swing.impl;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.animation.AngleAnimator;

import gov.nasa.worldwind.animation.AnimationSupport;

import gov.nasa.worldwind.animation.Animator;

import gov.nasa.worldwind.animation.CompoundAnimator;

import gov.nasa.worldwind.animation.Interpolator;

import gov.nasa.worldwind.animation.PositionAnimator;

import gov.nasa.worldwind.animation.ScheduledInterpolator;

import gov.nasa.worldwind.geom.Angle;

import gov.nasa.worldwind.geom.LatLon;

import gov.nasa.worldwind.geom.Position;

import gov.nasa.worldwind.globes.Globe;

import gov.nasa.worldwind.util.PropertyAccessor;

import gov.nasa.worldwind.view.ViewElevationAnimator;

import gov.nasa.worldwind.view.ViewPropertyAccessor;

import gov.nasa.worldwind.view.orbit.OrbitView;

import gov.nasa.worldwind.view.orbit.OrbitViewPropertyAccessor;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.animation3d.swing.api.Frame3D;

/**

 * @author <a href="mailto:lmarques@disid.com">Lluis Marques</a>

 *

 */

public class MultipleFlyToOrbitViewAnimator extends CompoundAnimator {

    private List<Frame3D> frames;

    private int index;

    private OrbitView orbitView;

    /**

     * @param orbitView

     * @param frames

     */

    public MultipleFlyToOrbitViewAnimator(OrbitView orbitView, List<Frame3D> frames) {

        super(new ScheduledInterpolator(10000));

        this.orbitView = orbitView;

        this.frames = frames;

        this.index = 0;

        setFrame(frames.get(index));

    }

    @Override

    protected void setImpl(double interpolant) {

        boolean allStopped = true;

        for (Animator a : animators) {

            if (a != null) {

                if (a.hasNext()) {

                    allStopped = false;

                    a.set(interpolant);

                }

            }

        }

        if (allStopped && index >= frames.size()) {

            this.stop();

        } else if (allStopped && index < frames.size() - 1) {

            index++;

            Frame3D frame = frames.get(index);

            setFrame(frame);

        }

    }

    private void setFrame(Frame3D frame) {

        double latitude = frame.getPosition().getY();

        double longitude = frame.getPosition().getX();

        Position newCenterPos =

            new Position(LatLon.fromDegrees(latitude, longitude), orbitView.getGlobe()

                .getElevation(Angle.fromDegreesLatitude(latitude),

                    Angle.fromDegreesLongitude(longitude))

                + frame.getElevation());

        Angle newHeading = Angle.fromDegrees(frame.getHeading());

        Angle newPitch = Angle.fromDegrees(frame.getPitch());

        long timeToMove =

            AnimationSupport.getScaledTimeMillisecs(orbitView.getEyePosition(), newCenterPos, 4000,

                14000);

        interpolator = new ScheduledInterpolator(timeToMove);

        animators =

            createAnimators(orbitView, orbitView.getCenterPosition(), newCenterPos,

                orbitView.getHeading(), newHeading, orbitView.getPitch(), newPitch,

                orbitView.getZoom(), frame.getZoom(), timeToMove,

                WorldWind.ABSOLUTE);

    }

    private Animator[] createAnimators(OrbitView orbitView, Position beginCenterPos,

        Position endCenterPos, Angle beginHeading, Angle endHeading, Angle beginPitch,

        Angle endPitch, double beginZoom, double endZoom, long timeToMove, int altitudeMode) {

        OnSurfacePositionAnimator centerAnimator =

            new OnSurfacePositionAnimator(orbitView.getGlobe(), new ScheduledInterpolator(

                timeToMove), beginCenterPos, endCenterPos,

                OrbitViewPropertyAccessor.createCenterPositionAccessor(orbitView), altitudeMode);

        // Create an elevation animator with ABSOLUTE altitude mode because the

        // OrbitView altitude mode applies to the

        // center position, not the zoom.

        ViewElevationAnimator zoomAnimator =

            new ViewElevationAnimator(orbitView.getGlobe(), beginZoom, endZoom, beginCenterPos,

                endCenterPos, WorldWind.ABSOLUTE,

                OrbitViewPropertyAccessor.createZoomAccessor(orbitView));

        centerAnimator.useMidZoom = zoomAnimator.getUseMidZoom();

        AngleAnimator headingAnimator =

            new AngleAnimator(new ScheduledInterpolator(timeToMove), beginHeading, endHeading,

                ViewPropertyAccessor.createHeadingAccessor(orbitView));

        AngleAnimator pitchAnimator =

            new AngleAnimator(new ScheduledInterpolator(timeToMove), beginPitch, endPitch,

                ViewPropertyAccessor.createPitchAccessor(orbitView));

        List<Animator> animators = new ArrayList<Animator>();

        animators.add(centerAnimator);

        animators.add(zoomAnimator);

        animators.add(headingAnimator);

        animators.add(pitchAnimator);

        return animators.toArray(new Animator[0]);

    }

    protected static class OnSurfacePositionAnimator extends PositionAnimator {

        Globe globe;

        int altitudeMode;

        boolean useMidZoom = true;

        public OnSurfacePositionAnimator(Globe globe, Interpolator interpolator, Position begin,

            Position end, PropertyAccessor.PositionAccessor propertyAccessor, int altitudeMode) {

            super(interpolator, begin, end, propertyAccessor);

            this.globe = globe;

            this.altitudeMode = altitudeMode;

        }

        @Override

        protected Position nextPosition(double interpolant) {

            final int MAX_SMOOTHING = 1;

            final double CENTER_START = this.useMidZoom ? 0.2 : 0.0;

            final double CENTER_STOP = this.useMidZoom ? 0.8 : 0.8;

            double latLonInterpolant =

                AnimationSupport.basicInterpolant(interpolant, CENTER_START, CENTER_STOP,

                    MAX_SMOOTHING);

            // Invoke the standard next position functionality.

            Position pos = super.nextPosition(latLonInterpolant);

            // Check the altitude mode. If the altitude mode depends on the

            // surface elevation we will reevaluate the

            // end position altitude. When the animation starts we may not have

            // accurate elevation data available for

            // the end position, so recalculating the elevation as we go ensures

            // that the animation will end at the

            // correct altitude.

            double endElevation = 0.0;

            boolean overrideEndElevation = false;

            if (this.altitudeMode == WorldWind.CLAMP_TO_GROUND) {

                overrideEndElevation = true;

                endElevation =

                    this.globe.getElevation(getEnd().getLatitude(), getEnd().getLongitude());

            } else if (this.altitudeMode == WorldWind.RELATIVE_TO_GROUND) {

                overrideEndElevation = true;

                endElevation =

                    this.globe.getElevation(getEnd().getLatitude(), getEnd().getLongitude())

                        + getEnd().getAltitude();

            }

            if (overrideEndElevation) {

                LatLon ll = pos; // Use interpolated lat/lon.

                double e1 = getBegin().getElevation();

                pos =

                    new Position(ll, (1 - latLonInterpolant) * e1 + latLonInterpolant

                        * endElevation);

            }

            return pos;

        }

    }

}