Application: gvSIG desktop » gvSIG 3D

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.gvsig3d.app.extension;

import java.awt.Color;

import java.awt.geom.Rectangle2D;

import java.util.prefs.Preferences;

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.project.ProjectPreferences;

import org.gvsig.app.project.documents.DocumentManager;

import org.gvsig.app.project.documents.view.BaseViewDocument;

import org.gvsig.gvsig3d.Gvsig3DLocator;

import org.gvsig.gvsig3d.Gvsig3DManager;

import org.gvsig.gvsig3d.app.camera.ProjectCamera;

import org.gvsig.gvsig3d.hud.Hud;

import org.gvsig.osgvp.exceptions.node.ChildIndexOutOfBoundsExceptions;

import org.gvsig.osgvp.exceptions.node.NodeException;

import org.gvsig.osgvp.geometry.Envelope3D;

import org.gvsig.osgvp.terrain.JavaDataDriver;

import org.gvsig.osgvp.terrain.LayerManager;

import org.gvsig.osgvp.terrain.Terrain;

import org.gvsig.osgvp.terrain.TerrainViewer;

import org.gvsig.osgvp.terrain.exceptions.TerrainExtentException;

import org.gvsig.osgvp.viewer.Camera;

import org.gvsig.osgvp.viewer.CanvasViewer;

import org.gvsig.osgvp.viewer.DisplaySettings;

import org.gvsig.osgvp.viewer.IViewerContainer;

import org.gvsig.osgvp.viewer.ViewerFactory;

import org.gvsig.osgvp.viewer.ViewerStateListener;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.util.Callable;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * @author AI2

 * @version $Id$

 * 

 */

public class DefaultView3DDocument extends BaseViewDocument {

        private static final long serialVersionUID = 676716312482344764L;

        public static final String PERSISTENCE_DEFINITION_NAME = "DefaultView3DDocument";

        private IViewerContainer _canvas3d = null;

        private TerrainViewer _terrainViewer = null;

        private Terrain _terrain = null;

        // private ProjectCamera _projectCamera = null;

        private JavaDataDriver _terrainDataManager = null;

        private LayerManager _terrainLayerManager = null;

        private int _terrainType = Terrain.CoordinateSystemType.PROJECTED; // spheric

        // or

        // plane

        private Color _backgroundColor;

        private float _verticalExaggeration = 1;

        private DefaultView3DPanel _view = null;

        private static Preferences _prefs = Preferences.userRoot().node(

                        "gvsig.configuration.3D");

        private boolean _perspectiveMode = true;

        private boolean _properties = false;

        private ProjectCamera _projectCamera;

        private static Logger _logger = LoggerFactory

                        .getLogger(DefaultView3DDocument.class.getName());

        public static final Rectangle2D sphericGlobalBounds = new Rectangle2D.Double(

                        -180, -90, 360, 180);

        public static final Rectangle2D planeGlobalBounds = new Rectangle2D.Double(

                        -20000000, -10000000, 40000000, 20000000);

        public static final String BACKGROUNDCOLOR = "backgroundColor";

        public static final String TERRAINTYPE = "terrainType";

        public static final String PROJECTCAMERA = "projectCamera";

        private boolean _isAnimated = false;

        private Gvsig3DManager _manager;

        public DefaultView3DDocument() {

                this(null);

                _backgroundColor = new Color(0, 0, 0, 255);

        }

        public DefaultView3DDocument(DocumentManager factory) {

                super(factory);

                ProjectPreferences preferences = (ProjectPreferences) ApplicationLocator

                                .getManager().getPreferences("project");

                _backgroundColor = new Color(0, 0, 0, 255);

        }

        public int getTerrainType() {

                return _terrainType;

        }

        public void setTerrainType(int type) {

                _terrainType = type;

        }

        public float getVerticalExaggeration() {

                return _verticalExaggeration;

        }

        public void setVerticalExaggeration(float exaggeration) {

                _verticalExaggeration = exaggeration;

        }

        public Color getBackGroundColor() {

                return _backgroundColor;

        }

        public void setBackGroundColor(Color backGroundColor) {

                _backgroundColor = backGroundColor;

                if ((_backgroundColor != null) && (_terrainViewer != null)) {

                        float r, g, b, a;

                        r = ((float) _backgroundColor.getRed()) / 255.0f;

                        g = ((float) _backgroundColor.getGreen()) / 255.0f;

                        b = ((float) _backgroundColor.getBlue()) / 255.0f;

                        a = ((float) _backgroundColor.getAlpha()) / 255.0f;

                        _terrainViewer.setClearColor(r, g, b, a);

                }

        }

        public Terrain getTerrain() {

                return _terrain;

        }

        public void setTerrain(Terrain terrain) {

                _terrain = terrain;

        }

        public IViewerContainer getCanvas3d() {

                return _canvas3d;

        }

        public void setCanvas3d(CanvasViewer canvas3d) {

                _canvas3d = canvas3d;

        }

        // private void setVerticalEx(float exa) {

        //

        // SingleLayerIterator lyrIterator = new SingleLayerIterator(

        // (FLayers3D) getMapContext().getLayers());

        // while (lyrIterator.hasNext()) {

        // FLayer lyr = lyrIterator.next();

        //

        // Layer3DProps props = Layer3DProps.getLayer3DProps(lyr);

        // int type = props.getType();

        // if (exa != props.getVerticalEx()) {

        // if (type == Layer3DProps.layer3DElevation) {

        // props.setVerticalEx(exa);

        // HeightfieldLayer layer = (HeightfieldLayer)props.getTerrainLayer();

        // if(layer == null) return;

        // layer.setVerticalExaggeration(exa);

        // _view.getTerrain().getLayerManager().updateLayers();

        // } else if (type == Layer3DProps.layer3DVector) {

        // props.setVerticalEx(exa);

        // }

        // }

        //

        // }

        // }

        public boolean isPerspectiveModeActive() {

                return _perspectiveMode;

        }

        /**

         * Active the perspective mode. If we disable the perspective mode, the

         * ortho mode will be active

         * 

         * @param perspectiveMode

         *            enable/disable

         */

        public void setActivePerspectiveMode(boolean perspectiveMode) {

                _perspectiveMode = perspectiveMode;

        }

        private void configureProjectionViewMode() {

                if (_perspectiveMode) {

                        System.out.println("Setting up perspective projection");

                        // this.m_canvas3d.getOSGViewer().setProjectionMatrixAsPerspective(

                        // arg0, arg1, arg2, arg3);

                } else {

                        System.out.println("Setting up perspective projection");

                        this._canvas3d.getOSGViewer().setProjectionMatrixAsOrtho(-10, 10,

                                        -10, 10, 1, 1000);

                }

        }

        public DefaultView3DPanel getView() {

                return _view;

        }

        public void setView(DefaultView3DPanel view) {

                _view = view;

        }

        public IViewerContainer getOrCreateCanvas3D() {

                // create libJOSG objects

                if (_canvas3d == null) {

                        try {

                                _terrainViewer = new TerrainViewer() {

                                        // Hack to allow stereo in animation.

                                        @Override

                                        public void frame() {

                                                try {

                                                        setFusionDistance((float) this.getTerrain(0)

                                                                        .getZoom());

                                                } catch (ChildIndexOutOfBoundsExceptions e) {

                                                        ;

                                                }

                                                super.frame();

                                        }

                                };

                        } catch (NodeException e1) {

                                _logger.error("Command: " + "Error creating planer viewer.", e1);

                        }

                        // Getting 3D preferences

                        boolean compatibilitySwing = false;

                        compatibilitySwing = _prefs.getBoolean("compatibilitySwing",

                                        compatibilitySwing);

                        if (compatibilitySwing) {

                                _canvas3d = ViewerFactory.getInstance()

                                                .createViewer(ViewerFactory.VIEWER_TYPE.JPANEL_VIEWER,

                                                                _terrainViewer);

                        } else {

                                _canvas3d = ViewerFactory.getInstance()

                                                .createViewer(ViewerFactory.VIEWER_TYPE.CANVAS_VIEWER,

                                                                _terrainViewer);

                        }

                        ViewerFactory.getInstance().addViewerToAnimator(_canvas3d);

                        ViewerFactory.getInstance().startAnimator();

                        this.configureProjectionViewMode();

                        _canvas3d.getOSGViewer().setDisplaySettings(new DisplaySettings());

                        if (getBackGroundColor() != null) {

                                float r, g, b, a;

                                r = ((float) _backgroundColor.getRed()) / 255.0f;

                                g = ((float) _backgroundColor.getGreen()) / 255.0f;

                                b = ((float) _backgroundColor.getBlue()) / 255.0f;

                                a = ((float) _backgroundColor.getAlpha()) / 255.0f;

                                _terrainViewer.setClearColor(r, g, b, a);

                        }

                        try {

                                if (_terrainType == Terrain.CoordinateSystemType.PROJECTED) {

                                        try {

                                                _terrain = new Terrain("Earth", _terrainType, "WKT",

                                                                "EPSG:23030", planeGlobalBounds.getMinX(),

                                                                planeGlobalBounds.getMinY(),

                                                                planeGlobalBounds.getMaxX(),

                                                                planeGlobalBounds.getMaxY(), 6378137.0,

                                                                6356752.3142);

                                        } catch (TerrainExtentException e) {

                                                // TODO Auto-generated catch block

                                                e.printStackTrace();

                                        }

                                } else {

                                        _terrain = new Terrain();

                                }

                                _terrain.setRasterTerrainTechnique(Terrain.TerrainTechnique.SHADER);

                                /*

                                 * _terrain = new Terrain();

                                 * _terrain.setCoordinateSystemType(_terrainType); if

                                 * (_terrainType == Terrain.CoordinateSystemType.PROJECTED) {

                                 * _terrain.setCoordinateSystemName("EPSG:23030");

                                 * _terrain.setExtent(CacheService.planeGlobalBounds.getMinX(),

                                 * CacheService.planeGlobalBounds.getMinY(),

                                 * CacheService.planeGlobalBounds.getMaxX(),

                                 * CacheService.planeGlobalBounds.getMaxY()); }

                                 */

                                _terrainDataManager = new JavaDataDriver();

                                _canvas3d.getOSGViewer()

                                                .addUpdateOperation(_terrainDataManager);

                                _terrainLayerManager = new LayerManager();

                                _terrain.setLayerManager(_terrainLayerManager);

                                _terrainViewer.addTerrain(_terrain);

                                _manager = Gvsig3DLocator.getManager();

                                Hud hud = _manager

                                                .createDefaultHudInstance(_canvas3d, _terrain);

                                try {

                                        _terrainViewer.addNodeToCameraHUD(hud);

                                } catch (NodeException e) {

                                        _logger.error("Command: " + "Error adding node to hud.", e);

                                }

                                _canvas3d.addKeyListener(new ViewerStateListener(_canvas3d

                                                .getOSGViewer()));

                                if (_canvas3d.getOSGViewer().getCameraManipulator() != null)

                                        _canvas3d.getOSGViewer().getCameraManipulator()

                                                        .computeHomePosition();

                                Camera cam;

                                cam = new Camera();

                                if (_projectCamera == null) {

                                        if (_terrainType == Terrain.CoordinateSystemType.PROJECTED) {

                                                Envelope3D extent = new Envelope3D(_terrain.xMin(),

                                                                _terrain.yMin(), 0, _terrain.xMax(),

                                                                _terrain.yMax(), 0);

                                                double width = extent.xMax() - extent.xMin();

                                                double length = extent.yMax() - extent.yMin();

                                                double height = Math.sqrt(width * width + length

                                                                * length) * 10f;

                                                cam.setViewByLookAt((float) (extent.xMax() / 2.0),

                                                                (float) (extent.yMax() / 2.0), (float) height,

                                                                (float) (extent.xMax() / 2.0),

                                                                (float) (extent.yMax() / 2.0), 0f, 0f, 1f, 0f);

                                                cam.setViewByLookAt(0, 0, 5000000 * 4.6, 0, 0, 0, 0, 1,

                                                                0);

                                                _terrainViewer.getTerrainCameraManipulator()

                                                                .setMinimumDistance(10);

                                                _terrainViewer.getTerrainCameraManipulator()

                                                                .setMaximumDistance(5000000 * 12);

                                        } else {

                                                cam.setViewByLookAt(

                                                                _terrain.getRadiusEquatorial() * 8.0, 0, 0, 0,

                                                                0, 0, 0, 0, 1);

                                                _terrainViewer.getTerrainCameraManipulator()

                                                                .setMinimumDistance(100);

                                                _terrainViewer

                                                                .getTerrainCameraManipulator()

                                                                .setMaximumDistance(

                                                                                (float) (_terrain.getRadiusEquatorial() * 10.0));

                                        }

                                        _projectCamera = new ProjectCamera();

                                        _projectCamera.setCamera(_terrainViewer.getCamera());

                                } else {

                                        cam = _projectCamera.getCamera();

                                }

                                _terrainViewer.setCamera(cam);

                        } catch (NodeException e) {

                        }

                        // _canvas3d.addKeyListener(new Key3DListener(_terrain));

                }

                return _canvas3d;

        }

        public JavaDataDriver getTerrainDataManager() {

                return _terrainDataManager;

        }

        public LayerManager getTerrainLayerManager() {

                return _terrainLayerManager;

        }

        public TerrainViewer getTerrainViewer() {

                return _terrainViewer;

        }

        public void setTerrainViewer(TerrainViewer terrainViewer) {

                _terrainViewer = terrainViewer;

        }

        public void setPropertiesCreated(boolean value) {

                this._properties = value;

        }

        public boolean getPropertiesCreated() {

                return _properties;

        }

        public void setAnimated(boolean isAnimated) {

                this._isAnimated = isAnimated;

        }

        public boolean getAnimated() {

                return _isAnimated;

        }

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                super.loadFromState(state);

                _backgroundColor = (Color) state.get(BACKGROUNDCOLOR);

                _terrainType = state.getInt(TERRAINTYPE);

                _projectCamera = (ProjectCamera) state.get(PROJECTCAMERA);

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                super.saveToState(state);

                state.set(BACKGROUNDCOLOR, _backgroundColor);

                state.set(TERRAINTYPE, _terrainType);

                //Save the camera position

                _projectCamera = new ProjectCamera();

                _projectCamera.setCamera(_terrainViewer.getCamera());

                state.set(PROJECTCAMERA, _projectCamera);

        }

        public static class RegisterPersistence implements Callable {

                public Object call() throws Exception {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

                        DynStruct definition = manager

                                        .getDefinition(PERSISTENCE_DEFINITION_NAME);

                        if (definition == null) {

                                definition = manager

                                                .addDefinition(DefaultView3DDocument.class,

                                                                PERSISTENCE_DEFINITION_NAME,

                                                                PERSISTENCE_DEFINITION_NAME

                                                                                + " Persistence definition", null, null);

                        }

                        // Description

                        definition.addDynFieldObject(BACKGROUNDCOLOR)

                                        .setClassOfValue(Color.class).setMandatory(false);

                        definition.addDynFieldInt(TERRAINTYPE).setMandatory(true);

                        definition.addDynFieldObject(PROJECTCAMERA)

                                        .setClassOfValue(ProjectCamera.class).setMandatory(true);

                        return Boolean.TRUE;

                }

        }

}