Application: gvSIG desktop » gvSIG 3D

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright © 2007-2016 gvSIG Association

 *

 * 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.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.view3d.lib.impl.layers.vector.alternativepoints;

import java.awt.Color;

import javax.media.opengl.GL;

import javax.media.opengl.GL2;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.geom.Angle;

import gov.nasa.worldwind.geom.Position;

import gov.nasa.worldwind.geom.Vec4;

import gov.nasa.worldwind.render.DrawContext;

import gov.nasa.worldwind.render.markers.BasicMarker;

import gov.nasa.worldwind.render.markers.Marker;

import gov.nasa.worldwind.render.markers.MarkerAttributes;

import gov.nasa.worldwind.render.markers.MarkerShape;

import gov.nasa.worldwind.util.Logging;

/**

 * Marker that can be extruded. Adapted from {@link BasicMarker}.

 *

 * @author Andrea Antonello    andrea.antonello@gmail.com

 */

public class BasicExtrudableMarker implements Marker {

    protected Position position; // may be null

    protected Angle heading; // may be null

    protected Angle pitch; // may be null

    protected Angle roll; // may be null

    // To avoid the memory overhead of creating an attributes object for every new marker, attributes are

    // required to be specified at construction.

    protected BasicExtrudableMarkerAttributes attributes;

    private int altitudeMode = WorldWind.ABSOLUTE;

    public BasicExtrudableMarker(Position position, BasicExtrudableMarkerAttributes attrs) {

        if (attrs == null) {

            String message = Logging.getMessage("nullValue.AttributesIsNull");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.position = position;

        this.attributes = attrs;

    }

    public BasicExtrudableMarker(Position position, BasicExtrudableMarkerAttributes attrs, Angle heading) {

        if (attrs == null) {

            String message = Logging.getMessage("nullValue.AttributesIsNull");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.position = position;

        this.heading = heading;

        this.attributes = attrs;

    }

    public Position getPosition() {

        return position;

    }

    public void setPosition(Position position) {

        this.position = position;

    }

    /** {@inheritDoc} */

    public Angle getHeading() {

        return this.heading;

    }

    /** {@inheritDoc} */

    public void setHeading(Angle heading) {

        this.heading = heading;

    }

    /** {@inheritDoc} */

    public Angle getRoll() {

        return this.roll;

    }

    /** {@inheritDoc} */

    public void setRoll(Angle roll) {

        this.roll = roll;

    }

    /** {@inheritDoc} */

    public Angle getPitch() {

        return this.pitch;

    }

    /** {@inheritDoc} */

    public void setPitch(Angle pitch) {

        this.pitch = pitch;

    }

    public MarkerAttributes getAttributes() {

        return attributes;

    }

    public void setAttributes(MarkerAttributes attributes) {

        if (attributes instanceof BasicExtrudableMarkerAttributes) {

            BasicExtrudableMarkerAttributes attr = (BasicExtrudableMarkerAttributes) attributes;

            this.attributes = attr;

        }

    }

    public void render(DrawContext dc, Vec4 point, double radius, boolean isRelative) {

        MarkerShape shape = this.attributes.getShape(dc);

        shape.render(dc, this, point, radius, isRelative);

        renderExtrude(dc, point);

    }

    public void render(DrawContext dc, Vec4 point, double radius) {

        this.attributes.getShape(dc).render(dc, this, point, radius, false);

        renderExtrude(dc, point);

    }

    private void renderExtrude(DrawContext dc, Vec4 point) {

        if (attributes.isDoExtrude()) {

            Vec4 placePoint;

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

                placePoint = dc.computeTerrainPoint(position.getLatitude(), position.getLongitude(), 0);

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

                placePoint =

                    dc.computeTerrainPoint(position.getLatitude(), position.getLongitude(), position.getAltitude());

            } else {

                // ABSOLUTE

                double height = position.getElevation();

                placePoint =

                    dc.getGlobe().computePointFromPosition(position.getLatitude(), position.getLongitude(), height);

            }

            Vec4 terrainPoint = dc.computeTerrainPoint(position.getLatitude(), position.getLongitude(), 0);

            GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.

            if ((!dc.isDeepPickingEnabled()))

                gl.glEnable(GL.GL_DEPTH_TEST);

            gl.glDepthFunc(GL.GL_LEQUAL);

            gl.glDepthMask(true);

            try {

                dc.getView().pushReferenceCenter(dc, point); // draw relative to the place point

                // set width

                gl.glLineWidth(2f);

                gl.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_FASTEST);

                gl.glEnable(GL.GL_LINE_SMOOTH);

                // set color

                Color color = attributes.getMaterial().getDiffuse();

                gl.glColor4ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue(),

                    (byte) color.getAlpha());

                // draw line

                gl.glBegin(GL2.GL_LINE_STRIP);

                gl.glVertex3d(Vec4.ZERO.x, Vec4.ZERO.y, Vec4.ZERO.z);

                gl.glVertex3d(terrainPoint.x - placePoint.x, terrainPoint.y - placePoint.y,

                    terrainPoint.z - placePoint.z);

                gl.glEnd();

            } finally {

                dc.getView().popReferenceCenter(dc);

            }

        }

    }

    public void setAltitudeMode(int altitudeMode) {

        this.altitudeMode = altitudeMode;

    }

}