Application: gvSIG desktop » gvSIG 3D

/*

 * Copyright (C) 2012 United States Government as represented by the Administrator of the

 * National Aeronautics and Space Administration.

 * All Rights Reserved.

 */

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

import java.io.File;

import java.io.IOException;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import javax.media.opengl.GL;

import javax.media.opengl.GL2;

import javax.media.opengl.glu.GLU;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import com.jogamp.common.nio.Buffers;

import gov.nasa.worldwind.Configuration;

import gov.nasa.worldwind.WorldWind;

import gov.nasa.worldwind.WorldWindow;

import gov.nasa.worldwind.avlist.AVKey;

import gov.nasa.worldwind.cache.ShapeDataCache;

import gov.nasa.worldwind.exception.WWRuntimeException;

import gov.nasa.worldwind.geom.Box;

import gov.nasa.worldwind.geom.Extent;

import gov.nasa.worldwind.geom.Intersection;

import gov.nasa.worldwind.geom.LatLon;

import gov.nasa.worldwind.geom.Line;

import gov.nasa.worldwind.geom.Position;

import gov.nasa.worldwind.geom.Sector;

import gov.nasa.worldwind.geom.Triangle;

import gov.nasa.worldwind.geom.Vec4;

import gov.nasa.worldwind.globes.Globe;

import gov.nasa.worldwind.ogc.kml.impl.KMLExportUtil;

import gov.nasa.worldwind.render.AbstractShape;

import gov.nasa.worldwind.render.BasicShapeAttributes;

import gov.nasa.worldwind.render.DrawContext;

import gov.nasa.worldwind.render.Material;

import gov.nasa.worldwind.render.ShapeAttributes;

import gov.nasa.worldwind.render.SurfacePolygon;

import gov.nasa.worldwind.render.SurfaceShape;

import gov.nasa.worldwind.render.WWTexture;

import gov.nasa.worldwind.terrain.Terrain;

import gov.nasa.worldwind.util.GLUTessellatorSupport;

import gov.nasa.worldwind.util.Logging;

import gov.nasa.worldwind.util.OGLStackHandler;

import gov.nasa.worldwind.util.WWBufferUtil;

import gov.nasa.worldwind.util.WWMath;

/**

 * A multi-sided 3D shell formed by a base polygon in latitude and longitude extruded from the terrain to either a

 * specified height or an independent height per location. The base polygon may be complex with multiple internal but

 * not intersecting contours.

 * <p/>

 * Extruded polygon boundaries may be specified using either {@link LatLon} locations or {@link Position} positions, but

 * all the shape's boundary vertices must be the same type.

 * <p/>

 * Extruded polygons may optionally be textured. Textures may be applied to both the faces of the outer and inner

 * boundaries or just the outer boundaries. Texture can also be applied independently to the cap. Standard lighting is

 * optionally applied. Texture source images are lazily retrieved and loaded. This can cause a brief period in which the

 * texture is not displayed while it is retrieved from disk or network.

 * <p/>

 * <code>ExtrudedPolygon</code> side faces and cap have independent attributes for both normal and highlighted drawing.

 * <p/>

 * When specifying a single height (altitude mode {@link WorldWind#CONSTANT}, the height is relative to a reference

 * location designated by one of the specified polygon locations in the outer boundary. The default reference location

 * is the first one in the polygon's outer boundary. An alternative location may be specified by calling {@link

 * #setReferenceLocation(LatLon)}. The extruded polygon is capped with a plane at the specified height and tangent to

 * the ellipsoid at the reference location. Since locations other than the reference location may resolve to points at

 * elevations other than that at the reference location, the distances from those points to the cap are adjusted so that

 * the adjacent sides precisely meet the cap. When specifying polygons using a single height, only the latitudes and

 * longitudes of polygon boundary positions must be specified.

 * <p/>

 * Independent per-location heights may be specified via the <i>altitude</i> field of {@link Position}s defining the

 * polygon's inner and outer boundaries. Depending on the specified altitude mode, the position altitudes may be

 * interpreted as altitudes relative to mean sea level or altitudes above the ground at the associated latitude and

 * longitude locations.

 * <p/>

 * Boundaries are required to be closed, their first location must be equal to their last location. Boundaries that are

 * not closed are explicitly closed by this shape when they are specified.

 * <p/>

 * Extruded polygons are safe to share among World Windows. They should not be shared among layers in the same World

 * Window.

 * <p/>

 * In order to support simultaneous use of this shape with multiple globes (windows), this shape maintains a cache of

 * data computed relative to each globe. During rendering, the data for the currently active globe, as indicated in the

 * draw context, is made current. Subsequently called methods rely on the existence of this current data cache entry.

 * <p/>

 * When drawn on a 2D globe, this shape uses a {@link SurfacePolygon} to represent itself. Cap texture is not supported

 * in this case.

 *

 * @author tag

 * @version $Id: ExtrudedPolygon.java 2111 2014-06-30 18:09:45Z tgaskins $

 */

public class ExtrudedPolygon extends AbstractShape

{

    /** The default interior color for sides. */

    protected static final Material DEFAULT_SIDES_INTERIOR_MATERIAL = Material.LIGHT_GRAY;

    /** The default altitude mode. */

    protected static final int DEFAULT_ALTITUDE_MODE = WorldWind.CONSTANT;

    /** The attributes used if attributes are not specified. */

    protected static final ShapeAttributes defaultSideAttributes;

    protected double baseDepth;

    static

    {

        defaultSideAttributes = new BasicShapeAttributes();

        defaultSideAttributes.setInteriorMaterial(DEFAULT_SIDES_INTERIOR_MATERIAL);

    }

    /** The <code>ShapeData</code> class holds globe-specific data for this shape. */

    protected static class ShapeData extends AbstractShapeData implements Iterable<ExtrudedBoundaryInfo>

    {

        /** The boundary locations of the associated shape. Copied from that shape during construction. */

        protected List<ExtrudedBoundaryInfo> boundaries = new ArrayList<ExtrudedBoundaryInfo>();

        /** A buffer holding the Cartesian cap vertices of all the shape's boundaries. */

        protected FloatBuffer capVertexBuffer;

        /** A buffer holding the cap normals of all the shape's boundaries. */

        protected FloatBuffer capNormalBuffer;

        /** A buffer holding the Cartesian vertices of all the shape's side vertices. */

        protected FloatBuffer sideVertexBuffer;

        /** A buffer holding the side normals of all the shape's boundaries. */

        protected FloatBuffer sideNormalBuffer;

        /** A buffer holding the texture coordinates of all the shape's faces. Non-null only when texture is applied. */

        protected FloatBuffer sideTextureCoordsBuffer;

        // Tessellation fields

        /** This shape's tessellation. */

        protected GLUTessellatorSupport.CollectIndexListsCallback cb;

        /**

         * The indices identifying the cap vertices in a shape data's vertex buffer. Determined when this shape is

         * tessellated, which occurs only once unless the shape's boundaries are re-specified.

         */

        protected IntBuffer capFillIndices;

        /** Slices of <code>capFillIndices</code>, one per boundary. */

        protected List<IntBuffer> capFillIndexBuffers;

        /** Indicates whether a tessellation error occurred. No more attempts to tessellate will be made if set to true. */

        protected boolean tessellationError = false;

        /**

         * Constructs an instance using the boundaries of a specified extruded polygon.

         *

         * @param dc    the current draw context.

         * @param shape this shape.

         */

        public ShapeData(DrawContext dc, ExtrudedPolygon shape)

        {

            super(dc, shape.minExpiryTime, shape.maxExpiryTime);

            if (shape.boundaries.size() < 1)

            {

                // add a placeholder for the outer boundary

                this.boundaries.add(new ExtrudedBoundaryInfo(new ArrayList<LatLon>()));

                return;

            }

            // Copy the shape's boundaries.

            for (List<? extends LatLon> boundary : shape.boundaries)

            {

                this.boundaries.add(new ExtrudedBoundaryInfo(boundary));

            }

            // Copy the shape's side texture references.

            this.copySideTextureReferences(shape);

        }

        protected void copySideTextureReferences(ExtrudedPolygon shape)

        {

            if (shape.sideTextures != null)

            {

                for (int i = 0; i < this.boundaries.size() && i < shape.sideTextures.size(); i++)

                {

                    ExtrudedBoundaryInfo ebi = this.boundaries.get(i);

                    if (ebi != null)

                        this.boundaries.get(i).sideTextures = shape.sideTextures.get(i);

                }

            }

        }

        /**

         * Returns the outer boundary information for this shape data.

         *

         * @return this shape data's outer boundary information.

         */

        protected ExtrudedBoundaryInfo getOuterBoundaryInfo()

        {

            return this.boundaries.get(0);

        }

        /**

         * Iterates over the boundary information of this shape data.

         *

         * @return an iterator over this shape data's boundary info.

         */

        public Iterator<ExtrudedBoundaryInfo> iterator()

        {

            return this.boundaries.iterator();

        }

    }

    @Override

    protected AbstractShapeData createCacheEntry(DrawContext dc)

    {

        return new ShapeData(dc, this);

    }

    /**

     * Indicates the currently active shape data.

     *

     * @return the currently active shape data.

     */

    protected ShapeData getCurrent()

    {

        return (ShapeData) this.getCurrentData();

    }

    /**

     * Holds globe-specific information for each contour of the polygon. This class is meant only to be used as a way to

     * group per-boundary information in globe-specific <code>ShapeData</code>.

     */

    protected static class ExtrudedBoundaryInfo

    {

        /** The boundary vertices. This is merely a reference to the paren't shape's boundaries. */

        protected List<? extends LatLon> locations;

        /** The number of faces in the boundary. (The number of positions - 1.) */

        protected int faceCount;

        /** The vertices defining the boundary's cap. */

        protected Vec4[] capVertices;

        /** The vertices defining the boundary's base. These are always on the terrain. */

        protected Vec4[] baseVertices;

        /** Indices identifying the cap vertices in the vertex buffer. */

        protected IntBuffer capFillIndices;

        /** Indices identifying the cap edges in the vertex buffer. */

        protected IntBuffer capEdgeIndices;

        /** A buffer holding the vertices defining the boundary's cap. */

        protected FloatBuffer capVertexBuffer;

        /** A buffer holding the boundary cap's vertex normals. Non-null only when lighting is applied. */

        protected FloatBuffer capNormalBuffer;

        /** The indices identifying the boundary's side faces in the side-vertex buffer. */

        protected IntBuffer sideIndices;

        /** The indices identifying the boundary's edge indices in the side-vertex buffer. */

        protected IntBuffer sideEdgeIndices;

        /** A buffer holding the side vertices. These are passed to OpenGL. */

        protected FloatBuffer sideVertexBuffer;

        /** A buffer holding per-vertex normals. Non-null only when lighting is applied. */

        protected FloatBuffer sideNormalBuffer;

        /** The textures to apply to this boundary, one per face. */

        protected List<WWTexture> sideTextures;

        /**

         * The texture coordinates to use when applying side textures, a coordinate pair for each of 4 corners. These

         * are globe-specific because they account for the varying positions of the base on the terrain. (The cap

         * texture coordinates are not globe-specific.)

         */

        protected FloatBuffer sideTextureCoords;

        /**

         * Constructs a boundary info instance for a specified boundary.

         *

         * @param locations the boundary locations. Only this reference is kept; the boundaries are not copied.

         */

        public ExtrudedBoundaryInfo(List<? extends LatLon> locations)

        {

            this.locations = locations;

            this.faceCount = locations.size() - 1;

        }

    }

    // This static hash map holds the vertex indices that define the shape geometry. Their contents depend only on the

    // number of locations in the source polygon, so they can be reused by all shapes with the same location count.

    protected static HashMap<Integer, IntBuffer> capEdgeIndexBuffers = new HashMap<Integer, IntBuffer>();

    protected static HashMap<Integer, IntBuffer> sideFillIndexBuffers = new HashMap<Integer, IntBuffer>();

    protected static HashMap<Integer, IntBuffer> sideEdgeIndexBuffers = new HashMap<Integer, IntBuffer>();

    /** Indicates the number of vertices that must be present in order for VBOs to be used to render this shape. */

    protected static final int VBO_THRESHOLD = Configuration.getIntegerValue(AVKey.VBO_THRESHOLD, 30);

    /**

     * The location of each vertex in this shape's boundaries. There is one list per boundary. There is always an entry

     * for the outer boundary, but its list is empty if an outer boundary has not been specified.

     */

    protected List<List<? extends LatLon>> boundaries;

    /** The total number of locations in all boundaries. */

    protected int totalNumLocations;

    /** The total number of faces in all this shape's boundaries. */

    protected int totalFaceCount;

    /** This shape's height. Default is 1. */

    protected double height = 1;

    /** The attributes to use when drawing this shape's sides. */

    protected ShapeAttributes sideAttributes;

    /** The attributes to use when drawing this shape's sides in highlight mode. */

    protected ShapeAttributes sideHighlightAttributes;

    /** The currently active side attributes, derived from the specified attributes. Current only during rendering. */

    protected ShapeAttributes activeSideAttributes = new BasicShapeAttributes();

    /** This shape's side textures. */

    protected List<List<WWTexture>> sideTextures;

    /** This shape's cap texture. */

    protected WWTexture capTexture;

    /** This shape's cap texture coordinates. */

    protected FloatBuffer capTextureCoords;

    /** Indicates whether the cap should be drawn. */

    protected boolean enableCap = true;

    /** Indicates whether the sides should be drawn. */

    protected boolean enableSides = true;

    // Intersection fields

    /** The terrain used in the most recent intersection calculations. */

    protected Terrain previousIntersectionTerrain;

    /** The globe state key for the globe used in the most recent intersection calculation. */

    protected Object previousIntersectionGlobeStateKey;

    /** The shape data used for the previous intersection calculation. */

    protected ShapeData previousIntersectionShapeData;

    /** Constructs an extruded polygon with an empty outer boundary and a default height of 1 meter. */

    public ExtrudedPolygon()

    {

        this.boundaries = new ArrayList<List<? extends LatLon>>();

        this.boundaries.add(new ArrayList<LatLon>()); // placeholder for outer boundary

    }

    /**

     * Constructs an extruded polygon of a specified height and an empty outer boundary.

     *

     * @param height the shape height, in meters. May be null, in which case a height of 1 is used. The height is used

     *               only when the altitude mode is {@link WorldWind#CONSTANT}, which is the default for this shape.

     */

    public ExtrudedPolygon(Double height)

    {

        this(); // to initialize the instance

        this.setHeight(height);

    }

    /**

     * Constructs an extruded polygon for a specified list of outer boundary locations and a height.

     *

     * @param corners the list of locations defining this extruded polygon's outer boundary.

     * @param height  the shape height, in meters. May be null, in which case a height of 1 is used. The height is used

     *                only when the altitude mode is {@link WorldWind#CONSTANT}, which is the default for this shape.

     *

     * @throws IllegalArgumentException if the location list is null or the height is specified but less than or equal

     *                                  to zero.

     */

    public ExtrudedPolygon(Iterable<? extends LatLon> corners, Double height)

    {

        this(); // to initialize the instance

        if (corners == null)

        {

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

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        if (height != null && height <= 0)

        {

            String message = Logging.getMessage("generic.ArgumentOutOfRange", "height <= 0");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.setOuterBoundary(corners, height);

    }

    /**

     * Constructs an extruded polygon from an outer boundary, a height, and images for its outer faces.

     *

     * @param corners      the list of locations defining this polygon's outer boundary.

     * @param height       the shape height, in meters. May be null, in which case a height of 1 is used. The height is

     *                     used only when the altitude mode is {@link WorldWind#CONSTANT}, which is the default for this

     *                     shape.

     * @param imageSources images to apply to the polygon's outer faces. One image for each face must be included. May

     *                     also be null.

     *

     * @throws IllegalArgumentException if the location list is null or the height is specified but less than or equal

     *                                  to zero.

     */

    public ExtrudedPolygon(Iterable<? extends LatLon> corners, double height, Iterable<?> imageSources)

    {

        this(corners, height);

        if (imageSources != null)

        {

            this.sideTextures = new ArrayList<List<WWTexture>>();

            this.sideTextures.add(this.fillImageList(imageSources));

        }

    }

    /**

     * Constructs an extruded polygon from an outer boundary.

     *

     * @param corners the list of outer boundary positions -- latitude longitude and altitude. The altitude mode

     *                determines whether the positions are considered relative to mean sea level (they are "absolute")

     *                or the ground elevation at the associated latitude and longitude.

     *

     * @throws IllegalArgumentException if the position list is null.

     */

    public ExtrudedPolygon(Iterable<? extends Position> corners)

    {

        this(corners, 1d); // the height field is ignored when positions are specified, so any value will do

    }

    /**

     * Constructs an extruded polygon from an outer boundary specified with position heights.

     *

     * @param corners the list of positions -- latitude longitude and altitude -- defining the polygon's outer boundary.

     *                The altitude mode determines whether the positions are considered relative to mean sea level (they

     *                are "absolute") or the ground elevation at the associated latitude and longitude.

     *

     * @throws IllegalArgumentException if the position list is null.

     */

    public ExtrudedPolygon(Position.PositionList corners)

    {

        this(corners.list, 1d); // the height field is ignored when positions are specified, so any value will do

    }

    /**

     * Constructs an extruded polygon from an outer boundary and apply specified textures to its outer faces.

     *

     * @param corners      the list of positions -- latitude longitude and altitude -- defining the polygon. The

     *                     altitude mode determines whether the positions are considered relative to mean sea level

     *                     (they are "absolute") or the ground elevation at the associated latitude and longitude.

     * @param imageSources textures to apply to the polygon's outer faces. One texture for each face must be included.

     *                     May also be null.

     *

     * @throws IllegalArgumentException if the position list is null.

     */

    public ExtrudedPolygon(Iterable<? extends Position> corners, Iterable<?> imageSources)

    {

        this(corners);

        if (imageSources != null)

        {

            this.sideTextures = new ArrayList<List<WWTexture>>();

            this.sideTextures.add(this.fillImageList(imageSources));

        }

    }

    protected void initialize()

    {

        // Overridden to specify a default altitude mode unique to extruded polygons.

        this.altitudeMode = DEFAULT_ALTITUDE_MODE;

    }

    protected void reset()

    {

        // Assumes that the boundary lists have already been established.

        for (List<? extends LatLon> locations : this.boundaries)

        {

            if (locations == null || locations.size() < 3)

                continue;

            if (!WWMath.computeWindingOrderOfLocations(locations).equals(AVKey.COUNTER_CLOCKWISE))

                Collections.reverse(locations);

        }

        this.totalNumLocations = this.countLocations();

        this.previousIntersectionShapeData = null;

        this.previousIntersectionTerrain = null;

        this.previousIntersectionGlobeStateKey = null;

        super.reset(); // removes all shape-data cache entries

    }

    /**

     * Counts the total number of locations in this polygon's boundaries, not including positions introduced by

     * extrusion.

     *

     * @return the number of locations in the polygon boundaries.

     */

    protected int countLocations()

    {

        int count = 0;

        for (List<? extends LatLon> locations : this.boundaries)

        {

            count += locations.size();

        }

        this.totalFaceCount = count - this.boundaries.size();

        return count;

    }

    /**

     * Returns the list of locations or positions defining this polygon's outer boundary.

     *

     * @return this polygon's positions.

     */

    public Iterable<? extends LatLon> getOuterBoundary()

    {

        return this.outerBoundary();

    }

    /**

     * Returns a reference to the outer boundary of this polygon.

     *

     * @return this polygon's outer boundary.

     */

    protected List<? extends LatLon> outerBoundary()

    {

        return this.boundaries.get(0);

    }

    /**

     * Indicates whether this shape's outer boundary exists and has more than two points.

     *

     * @return true if the outer boundary is valid, otherwise false.s

     */

    protected boolean isOuterBoundaryValid()

    {

        return this.boundaries.size() > 0 && this.boundaries.get(0).size() > 2;

    }

    /**

     * Specifies the latitude and longitude of the locations defining the outer boundary of this polygon. To specify

     * altitudes, pass {@link Position}s rather than {@link LatLon}s. The shape's height is not modified.

     *

     * @param corners the outer boundary locations.

     *

     * @throws IllegalArgumentException if the location list is null or contains fewer than three locations.

     */

    public void setOuterBoundary(Iterable<? extends LatLon> corners)

    {

        this.setOuterBoundary(corners, this.getHeight());

    }

    /**

     * Specifies the latitudes, longitudes and outer-boundary images for the outer boundary of this polygon. To specify

     * altitudes, pass {@link Position}s rather than {@link LatLon}s.

     *

     * @param corners      the polygon locations.

     * @param imageSources images to apply to the outer faces. One image must be specified for each face. May be null.

     *

     * @throws IllegalArgumentException if the location list is null.

     */

    public void setOuterBoundary(Iterable<? extends LatLon> corners, Iterable<?> imageSources)

    {

        this.setOuterBoundary(corners);

        if (imageSources == null && this.sideTextures == null)

            return;

        // Must install or replace the side textures

        if (this.sideTextures == null)

            this.sideTextures = new ArrayList<List<WWTexture>>();

        // Add or replace the first element, the outer boundary's element, in the list of side textures.

        List<WWTexture> textures = this.fillImageList(imageSources);

        this.sideTextures.set(0, textures);

        // Update the shape cache

        for (ShapeDataCache.ShapeDataCacheEntry entry : this.shapeDataCache)

        {

            ShapeData sd = (ShapeData) entry;

            if (sd.boundaries != null)

                sd.copySideTextureReferences(this);

        }

    }

    /**

     * Specifies the latitude and longitude of the outer boundary locations defining this polygon, and optionally the

     * extruded polygon's height. To specify altitudes for each boundary location, pass {@link Position}s rather than

     * {@link LatLon}s, but those altitudes are used only when the shape's altitude mode is {@link WorldWind#ABSOLUTE}.

     *

     * @param corners the outer boundary locations.

     * @param height  the shape height, in meters.

     *

     * @throws IllegalArgumentException if the location list is null or contains fewer than three locations.

     */

    public void setOuterBoundary(Iterable<? extends LatLon> corners, Double height)

    {

        if (corners == null)

        {

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

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.getBoundaries().set(0, this.fillBoundary(corners));

        if (height != null)

            this.height = height;

        this.reset();

    }

    protected List<? extends LatLon> fillBoundary(Iterable<? extends LatLon> corners)

    {

        ArrayList<LatLon> list = new ArrayList<LatLon>();

        for (LatLon corner : corners)

        {

            if (corner != null)

                list.add(corner);

        }

        if (list.size() < 3)

        {

            String message = Logging.getMessage("generic.InsufficientPositions");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        // Close the list if not already closed.

        if (list.size() > 0 && !list.get(0).equals(list.get(list.size() - 1)))

            list.add(list.get(0));

        list.trimToSize();

        return list;

    }

    /**

     * Add an inner boundary to this polygon.

     *

     * @param corners the boundary's locations.

     *

     * @throws IllegalArgumentException if the location list is null or contains fewer than three locations.

     */

    public void addInnerBoundary(Iterable<? extends LatLon> corners)

    {

        if (corners == null)

        {

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

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.getBoundaries().add(this.fillBoundary(corners));

        this.reset();

    }

    /**

     * Add an inner boundary to this polygon and specify images to apply to each of the boundary's faces. Specify {@link

     * LatLon}s to use the polygon's single height, or {@link Position}s, to include individual altitudes.

     *

     * @param corners      the boundary's locations.

     * @param imageSources images to apply to the boundary's faces. One image must be specified for each face. May be

     *                     null.

     *

     * @throws IllegalArgumentException if the location list is null.

     */

    public void addInnerBoundary(Iterable<? extends LatLon> corners, Iterable<?> imageSources)

    {

        if (corners == null)

        {

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

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.getBoundaries().add(this.fillBoundary(corners));

        if (imageSources != null)

        {

            if (this.sideTextures == null)

            {

                this.sideTextures = new ArrayList<List<WWTexture>>();

                this.sideTextures.add(new ArrayList<WWTexture>()); // placeholder for outer boundary

            }

            this.sideTextures.add(this.fillImageList(imageSources));

        }

        this.reset();

    }

    /**

     * Returns this shape's boundaries.

     *

     * @return this shape's boundaries.

     */

    protected List<List<? extends LatLon>> getBoundaries()

    {

        return this.boundaries;

    }

    /**

     * Creates texture object for a boundary's image sources.

     *

     * @param imageSources the images to apply for this boundary.

     *

     * @return the list of texture objects, or null if the <code>imageSources</code> argument is null.

     */

    protected List<WWTexture> fillImageList(Iterable<?> imageSources)

    {

        if (imageSources == null)

            return null;

        ArrayList<WWTexture> textures = new ArrayList<WWTexture>();

        for (Object source : imageSources)

        {

            if (source != null)

                textures.add(this.makeTexture(source));

            else

                textures.add(null);

        }

        textures.trimToSize();

        return textures;

    }

    /**

     * Returns this extruded polygon's cap image.

     *

     * @return the texture image source, or null if no source has been specified.

     */

    public Object getCapImageSource()

    {

        return this.capTexture != null ? this.capTexture.getImageSource() : null;

    }

    /**

     * Specifies the image to apply to this extruded polygon's cap.

     *

     * @param imageSource   the image source. May be a {@link String} identifying a file path or URL, a {@link File}, or

     *                      a {@link java.net.URL}.

     * @param texCoords     the (s, t) texture coordinates aligning the image to the polygon. There must be one texture

     *                      coordinate pair, (s, t), for each location in the polygon's outer boundary.

     * @param texCoordCount the number of texture coordinates, (s, v) pairs, specified.

     *

     * @throws IllegalArgumentException if the image source is not null and either the texture coordinates are null or

     *                                  inconsistent with the specified texture-coordinate count, or there are fewer

     *                                  than three texture coordinate pairs.

     */

    public void setCapImageSource(Object imageSource, float[] texCoords, int texCoordCount)

    {

        if (imageSource == null)

        {

            this.capTexture = null;

            this.capTextureCoords = null;

            return;

        }

        if (texCoords == null)

        {

            String message = Logging.getMessage("generic.ListIsEmpty");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        if (texCoordCount < 3 || texCoords.length < 2 * texCoordCount)

        {

            String message = Logging.getMessage("generic.InsufficientPositions");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.capTexture = this.makeTexture(imageSource);

        // Determine whether the tex-coord list needs to be closed.

        boolean closeIt = texCoords[0] != texCoords[texCoordCount - 2] || texCoords[1] != texCoords[texCoordCount - 1];

        this.capTextureCoords = Buffers.newDirectFloatBuffer(2 * (texCoordCount + (closeIt ? 1 : 0)));

        for (int i = 0; i < 2 * texCoordCount; i++)

        {

            this.capTextureCoords.put(texCoords[i]);

        }

        if (closeIt)

        {

            this.capTextureCoords.put(this.capTextureCoords.get(0));

            this.capTextureCoords.put(this.capTextureCoords.get(1));

        }

    }

    /**

     * Returns the texture coordinates for this polygon's cap.

     *

     * @return the texture coordinates, or null if no cap texture coordinates have been specified.

     */

    public float[] getTextureCoords()

    {

        if (this.capTextureCoords == null)

            return null;

        float[] retCoords = new float[this.capTextureCoords.limit()];

        this.capTextureCoords.get(retCoords, 0, retCoords.length);

        return retCoords;

    }

    /**

     * Get the texture applied to this extruded polygon's cap.

     *

     * @return The texture, or null if there is no texture or the texture is not yet available.

     */

    protected WWTexture getCapTexture()

    {

        return this.capTexture;

    }

    /**

     * Returns the height of this extruded polygon.

     *

     * @return the height originally specified, in meters.

     */

    public double getHeight()

    {

        return height;

    }

    /**

     * Specifies the height of this extruded polygon.

     *

     * @param height the height, in meters.

     *

     * @throws IllegalArgumentException if the height is less than or equal to zero.

     */

    public void setHeight(double height)

    {

        if (this.height == height)

            return;

        if (height <= 0)

        {

            String message = Logging.getMessage("generic.ArgumentOutOfRange", "height <= 0");

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.height = height;

        this.reset();

    }

    /**

     * Indicates whether the cap of this extruded polygon is drawn.

     *

     * @return true to draw the cap, otherwise false.

     */

    public boolean isEnableCap()

    {

        return enableCap;

    }

    /**

     * Specifies whether the cap of this extruded polygon is drawn.

     *

     * @param enableCap true to draw the cap, otherwise false.

     */

    public void setEnableCap(boolean enableCap)

    {

        this.enableCap = enableCap;

    }

    /**

     * Indicates whether the sides of this extruded polygon are drawn.

     *

     * @return true to draw the sides, otherwise false.

     */

    public boolean isEnableSides()

    {

        return enableSides;

    }

    /**

     * Specifies whether to draw the sides of this extruded polygon.

     *

     * @param enableSides true to draw the sides, otherwise false.

     */

    public void setEnableSides(boolean enableSides)

    {

        this.enableSides = enableSides;

    }

    /**

     * Returns the attributes applied to this polygon's side faces.

     *

     * @return this polygon's side attributes.

     */

    public ShapeAttributes getSideAttributes()

    {

        return this.sideAttributes;

    }

    /**

     * Specifies the attributes applied to this polygon's side faces.

     *

     * @param attributes this polygon's side attributes.

     *

     * @throws IllegalArgumentException if <code>attributes</code> is null.

     */

    public void setSideAttributes(ShapeAttributes attributes)

    {

        if (attributes == null)

        {

            String message = "nullValue.AttributesIsNull";

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.sideAttributes = attributes;

    }

    /**

     * Returns the attributes applied to this polygon's cap.

     *

     * @return this polygon's cap attributes.

     */

    public ShapeAttributes getCapAttributes()

    {

        return this.getAttributes();

    }

    /**

     * Specifies the attributes applied to this polygon's cap.

     *

     * @param attributes this polygon's cap attributes.

     *

     * @throws IllegalArgumentException if <code>attributes</code> is null.

     */

    public void setCapAttributes(ShapeAttributes attributes)

    {

        this.setAttributes(attributes);

    }

    /**

     * Returns the highlight attributes applied to this polygon's side faces.

     *

     * @return this polygon's side highlight attributes.

     */

    public ShapeAttributes getSideHighlightAttributes()

    {

        return sideHighlightAttributes;

    }

    /**

     * Specifies the highlight attributes applied to this polygon's side faces.

     *

     * @param attributes this polygon's side highlight attributes.

     *

     * @throws IllegalArgumentException if <code>attributes</code> is null.

     */

    public void setSideHighlightAttributes(ShapeAttributes attributes)

    {

        if (attributes == null)

        {

            String message = "nullValue.AttributesIsNull";

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.sideHighlightAttributes = attributes;

    }

    /**

     * Returns the highlight attributes applied to this polygon's cap.

     *

     * @return this polygon's cap highlight attributes.

     */

    public ShapeAttributes getCapHighlightAttributes()

    {

        return this.getHighlightAttributes();

    }

    /**

     * Specifies the highlight attributes applied to this polygon's cap.

     *

     * @param attributes this polygon's cap highlight attributes.

     *

     * @throws IllegalArgumentException if <code>attributes</code> is null.

     */

    public void setCapHighlightAttributes(ShapeAttributes attributes)

    {

        this.setHighlightAttributes(attributes);

    }

    /**

     * Each time this polygon is rendered the appropriate attributes for the current mode are determined. This method

     * returns the resolved attributes.

     *

     * @return the currently active attributes for this polygon's side faces.

     */

    protected ShapeAttributes getActiveSideAttributes()

    {

        return this.activeSideAttributes;

    }

    /**

     * Each time this polygon is rendered the appropriate attributes for the current mode are determined. This method

     * returns the resolved attributes.

     *

     * @return the currently active attributes for this polygon's cap.

     */

    protected ShapeAttributes getActiveCapAttributes()

    {

        return this.getActiveAttributes();

    }

    public Sector getSector()

    {

        if (this.sector == null && this.outerBoundary().size() > 2)

            this.sector = Sector.boundingSector(this.getOuterBoundary());

        return this.sector;

    }

    /**

     * Indicates the location to use as a reference location for computed geometry.

     *

     * @return the reference location, or null if no reference location has been specified.

     *

     * @see #getReferencePosition()

     */

    public LatLon getReferenceLocation()

    {

        return this.getReferencePosition();

    }

    /**

     * Specifies the location to use as a reference location for computed geometry. This value should typically be left

     * to the default, which is the first location in the extruded polygon's outer boundary.

     *

     * @param referenceLocation the reference location. May be null, in which case the first location of the outer

     *                          boundary is the reference location.

     *

     * @see #setReferencePosition(gov.nasa.worldwind.geom.Position)

     */

    public void setReferenceLocation(LatLon referenceLocation)

    {

        if (referenceLocation == null)

        {

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

            Logging.logger().severe(message);

            throw new IllegalArgumentException(message);

        }

        this.referencePosition = new Position(referenceLocation, 0);

    }

    /**

     * Indicates the position used as a reference position for this extruded polygon's computed geometry.

     *

     * @return the reference position, or null if no reference position has been specified.

     */

    public Position getReferencePosition()

    {

        if (this.referencePosition != null)

            return this.referencePosition;

        if (this.boundaries.size() > 0 && this.outerBoundary().size() > 0)

        {

            if (this.outerBoundary().get(0) instanceof Position)

                this.referencePosition = (Position) this.outerBoundary().get(0);

            else

                this.referencePosition = new Position(this.outerBoundary().get(0), 0);

        }

        return this.referencePosition;

    }

    /**

     * Returns this object's base depth.

     *

     * @return This object's base depth, in meters.

     *

     * @see #setBaseDepth(double)

     */

    public double getBaseDepth()

    {

        return baseDepth;

    }

    /**

     * Specifies a depth below the terrain at which to place this extruded polygon's base vertices. This value does not

     * affect the height of the extruded polygon nor the position of its cap. It positions the base vertices such that

     * they are the specified distance below the terrain. The default value is zero, therefore the base vertices are

     * position on the terrain.

     *

     * @param baseDepth the depth in meters to position the base vertices below the terrain. Specify positive values to

     *                  position the base vertices below the terrain. (Negative values position the base vertices above

     *                  the terrain.)

     */

    public void setBaseDepth(double baseDepth)

    {

        this.baseDepth = baseDepth;

    }

    /**

     * Returns this extruded polygon's side images.

     *

     * @return a collection of lists each identifying the image sources for the associated outer or inner polygon

     *         boundary.

     */

    public List<List<Object>> getImageSources()

    {

        if (this.sideTextures == null)

            return null;

        boolean hasTextures = false;

        for (List<WWTexture> textures : this.sideTextures)

        {

            if (textures != null && textures.size() > 0)

            {

                hasTextures = true;

                break;

            }

        }

        if (!hasTextures)

            return null;

        List<List<Object>> imageSources = new ArrayList<List<Object>>(this.getBoundaries().size());

        for (List<WWTexture> textures : this.sideTextures)

        {

            if (textures == null)

            {

                imageSources.add(null);

            }

            else

            {

                ArrayList<Object> images = new ArrayList<Object>(textures.size());

                imageSources.add(images);

                for (WWTexture image : textures)

                {

                    images.add(image.getImageSource());

                }

            }

        }

        return imageSources;

    }

    /**

     * Indicates whether side images have been specified for this extruded polygon.

     *

     * @return true if side textures have been specified, otherwise false.

     */

    public boolean hasSideTextures()

    {

        if (this.sideTextures == null)

            return false;

        for (List<WWTexture> textures : this.sideTextures)

        {

            if (textures != null && textures.size() > 0)

                return true;

        }

        return false;

    }

    @Override

    protected boolean mustApplyTexture(DrawContext dc)

    {

        if (this.getCapTexture() != null && this.capTextureCoords != null)

            return true;

        return this.mustApplySideTextures();

    }

    @Override

    protected boolean isTerrainDependent()

    {

        return true; // this shape is terrain dependent regardless of the altitude mode

    }

    protected boolean mustApplySideTextures()

    {

        return this.hasSideTextures();

    }

    /**

     * Indicates whether the interior of either the sides or cap must be drawn.

     *

     * @return true if an interior must be drawn, otherwise false.

     */

    protected boolean mustDrawInterior()

    {

        return super.mustDrawInterior() || this.getActiveSideAttributes().isDrawInterior();

    }

    /**

     * Indicates whether the polygon's outline should be drawn.

     *

     * @return true if the outline should be drawn, otherwise false.

     */

    protected boolean mustDrawOutline()

    {

        return super.mustDrawOutline() || this.getActiveSideAttributes().isDrawOutline();

    }

    protected boolean mustRegenerateGeometry(DrawContext dc)

    {

        ShapeData shapeData = this.getCurrent();

        if (shapeData.capVertexBuffer == null || shapeData.sideVertexBuffer == null)

            return true;

        if (dc.getVerticalExaggeration() != shapeData.getVerticalExaggeration())

            return true;

        if ((this.mustApplyLighting(dc, this.getActiveCapAttributes()) && shapeData.capNormalBuffer == null)

            || (this.mustApplyLighting(dc, this.getActiveSideAttributes()) && shapeData.sideNormalBuffer == null))

            return true;

        return super.mustRegenerateGeometry(dc);

    }

    public Extent getExtent(Globe globe, double verticalExaggeration)

    {

        // See if we've cached an extent associated with the globe.

        Extent extent = super.getExtent(globe, verticalExaggeration);

        if (extent != null)

            return extent;

        return super.computeExtentFromPositions(globe, verticalExaggeration, this.getOuterBoundary());

    }

    /**

     * Computes this shapes extent. If a reference point is specified, the extent is translated to that reference

     * point.

     *

     * @param outerBoundary the shape's outer boundary.

     * @param refPoint      a reference point to which the extent is translated. May be null.

     *

     * @return the computed extent, or null if the extent cannot be computed.

     */

    protected Extent computeExtent(ExtrudedBoundaryInfo outerBoundary, Vec4 refPoint)

    {

        if (outerBoundary == null || outerBoundary.capVertices == null || outerBoundary.baseVertices == null)

            return null;

        Vec4[] topVertices = outerBoundary.capVertices;

        Vec4[] botVertices = outerBoundary.baseVertices;

        ArrayList<Vec4> allVertices = new ArrayList<Vec4>(2 * topVertices.length);

        allVertices.addAll(Arrays.asList(topVertices));

        allVertices.addAll(Arrays.asList(botVertices));

        Box boundingBox = Box.computeBoundingBox(allVertices);

        // The bounding box is computed relative to the polygon's reference point, so it needs to be translated to

        // model coordinates in order to indicate its model-coordinate extent.

        return boundingBox != null ? boundingBox.translate(refPoint) : null;

    }

    protected void determineActiveAttributes()

    {

        super.determineActiveAttributes(); // determine active cap attributes in super class

        if (this.isHighlighted())

        {

            if (this.getSideHighlightAttributes() != null)

                this.activeSideAttributes.copy(this.getSideHighlightAttributes());

            else

            {

                // If no highlight attributes have been specified we need to use the normal attributes but adjust them

                // to cause highlighting.

                if (this.getSideAttributes() != null)

                    this.activeSideAttributes.copy(this.getSideAttributes());

                else

                    this.activeSideAttributes.copy(defaultSideAttributes);

                this.activeSideAttributes.setOutlineMaterial(DEFAULT_HIGHLIGHT_MATERIAL);

                this.activeSideAttributes.setInteriorMaterial(DEFAULT_HIGHLIGHT_MATERIAL);

            }

        }

        else

        {

            if (this.getSideAttributes() != null)

                this.activeSideAttributes.copy(this.getSideAttributes());

            else