airspacerenderer.java

world wind java sdk 源码

/*
Copyright (C) 2001, 2008 United States Government as represented by
the Administrator of the National Aeronautics and Space Administration.
All Rights Reserved.
*/
package gov.nasa.worldwind.render.airspaces;

import gov.nasa.worldwind.Locatable;
import gov.nasa.worldwind.geom.*;
import gov.nasa.worldwind.layers.Layer;
import gov.nasa.worldwind.pick.PickSupport;
import gov.nasa.worldwind.render.*;
import gov.nasa.worldwind.util.*;

import javax.media.opengl.GL;
import java.awt.*;
import java.nio.Buffer;
import java.util.Iterator;

/**
 * @author dcollins
 * @version $Id: AirspaceRenderer.java 10903 2009-05-06 07:15:47Z dcollins $
 */
public class AirspaceRenderer
{
    private static final String EXT_BLEND_FUNC_SEPARATE_STRING = "GL_EXT_blend_func_separate";

    private boolean enableAntialiasing;
    private boolean enableBlending;
    private boolean enableDepthOffset;
    private boolean enableLighting;
    private boolean useEXTBlendFuncSeparate;
    private boolean haveEXTBlendFuncSeparate;
    private boolean drawExtents;
    private boolean drawWireframe;
    private Material lightMaterial;
    private Vec4 lightDirection;
    private final PickSupport pickSupport = new PickSupport();
    private double linePickWidth;
    private double depthOffsetFactor;
    private double depthOffsetUnits;

    public AirspaceRenderer()
    {
        this.enableAntialiasing = false;
        this.enableBlending = true;
        this.enableDepthOffset = false;
        this.enableLighting = true;
        this.useEXTBlendFuncSeparate = true;
        this.haveEXTBlendFuncSeparate = false;
        this.drawExtents = false;
        this.drawWireframe = false;
        this.lightMaterial = Material.WHITE;
        this.lightDirection = new Vec4(1.0, 0.5, 1.0);
        this.linePickWidth = 8.0;
        this.depthOffsetFactor = -2;
        this.depthOffsetUnits = -4;
    }

    public boolean isEnableAntialiasing()
    {
        return this.enableAntialiasing;
    }

    public void setEnableAntialiasing(boolean enable)
    {
        this.enableAntialiasing = enable;
    }

    public boolean isEnableBlending()
    {
        return this.enableBlending;
    }

    public void setEnableBlending(boolean enable)
    {
        this.enableBlending = enable;
    }

    public boolean isEnableDepthOffset()
    {
        return this.enableDepthOffset;
    }

    public void setEnableDepthOffset(boolean enable)
    {
        this.enableDepthOffset = enable;
    }

    public boolean isEnableLighting()
    {
        return this.enableLighting;
    }

    public void setEnableLighting(boolean enable)
    {
        this.enableLighting = enable;
    }

    public boolean isUseEXTBlendFuncSeparate()
    {
        return this.useEXTBlendFuncSeparate;
    }

    public void setUseEXTBlendFuncSeparate(boolean useEXTBlendFuncSeparate)
    {
        this.useEXTBlendFuncSeparate = useEXTBlendFuncSeparate;
    }

    protected boolean isHaveEXTBlendFuncSeparate()
    {
        return this.haveEXTBlendFuncSeparate;
    }

    protected void setHaveEXTBlendFuncSeparate(boolean haveEXTBlendFuncSeparate)
    {
        this.haveEXTBlendFuncSeparate = haveEXTBlendFuncSeparate;
    }

    public boolean isDrawExtents()
    {
        return this.drawExtents;
    }

    public void setDrawExtents(boolean draw)
    {
        this.drawExtents = draw;
    }

    public boolean isDrawWireframe()
    {
        return this.drawWireframe;
    }

    public void setDrawWireframe(boolean draw)
    {
        this.drawWireframe = draw;
    }

    public Material getLightMaterial()
    {
        return this.lightMaterial;
    }

    public void setLightMaterial(Material material)
    {
        if (material == null)
        {
            String message = Logging.getMessage("nullValue.MaterialIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.lightMaterial = material;
    }

    public Vec4 getLightDirection()
    {
        return this.lightDirection;
    }

    public void setLightDirection(Vec4 direction)
    {
        if (direction == null)
        {
            String message = Logging.getMessage("nullValue.DirectionIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.lightDirection = direction;
    }

    public double getLinePickWidth()
    {
        return linePickWidth;
    }

    public void setLinePickWidth(double width)
    {
        if (width < 0.0)
        {
            String message = Logging.getMessage("generic.ArgumentOutOfRange", "width < 0");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.linePickWidth = width;
    }

    public double getDepthOffsetFactor()
    {
        return this.depthOffsetFactor;
    }

    public void setDepthOffsetFactor(double factor)
    {
        this.depthOffsetFactor = factor;
    }

    public double getDepthOffsetUnits()
    {
        return depthOffsetUnits;
    }

    public void setDepthOffsetUnits(double units)
    {
        this.depthOffsetUnits = units;
    }

    public PickSupport getPickSupport()
    {
        return this.pickSupport;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public void pickOrdered(DrawContext dc, Iterable<? extends Airspace> airspaces, java.awt.Point pickPoint,
        Layer layer)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        this.drawOrdered(dc, airspaces, layer);
    }

    public void renderOrdered(DrawContext dc, Iterable<? extends Airspace> airspaces)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        this.drawOrdered(dc, airspaces, null);
    }

    public void pickNow(DrawContext dc, Iterable<? extends Airspace> airspaces, java.awt.Point pickPoint, Layer layer)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        PickSupport pickSupport = this.getPickSupport();
        pickSupport.beginPicking(dc);
        try
        {
            // The pick method will bind pickable objects to the renderer's PickSupport.
            this.drawNow(dc, airspaces, pickSupport);
        }
        finally
        {
            pickSupport.endPicking(dc);
        }

        pickSupport.resolvePick(dc, pickPoint, layer);
        pickSupport.clearPickList();
    }

    public void renderNow(DrawContext dc, Iterable<? extends Airspace> airspaces)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        // The render method does not bind any pickable objects.
        this.drawNow(dc, airspaces, null);
    }

    protected void drawOrdered(DrawContext dc, Iterable<? extends Airspace> airspaces, Layer layer)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        for (Airspace airspace : airspaces)
        {
            double eyeDistance = this.computeDistanceFromEye(dc, airspace);
            OrderedAirspace orderedAirspace = new OrderedAirspace(this, airspace, layer, eyeDistance);
            dc.getOrderedRenderables().add(orderedAirspace);
        }
    }

    protected void drawNow(DrawContext dc, Iterable<? extends Airspace> airspaces, PickSupport pickSupport)
    {
        if (dc == null)
        {
            String msg = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        if (airspaces == null)
        {
            String msg = Logging.getMessage("nullValue.AirspaceIterableIsNull");
            Logging.logger().severe(msg);
            throw new IllegalArgumentException(msg);
        }

        this.beginRendering(dc);
        try
        {
            this.drawAirspaces(dc, airspaces, pickSupport);
        }
        finally
        {
            this.endRendering(dc);
        }
    }

    protected double computeDistanceFromEye(DrawContext dc, Airspace airspace)
    {
        Extent extent = airspace.getExtent(dc);
        if (extent == null)
            return 0;

        if (dc.getView() == null || dc.getView().getEyePoint() == null)
            return 0;

        // Compute the distance from the eye point to the extent center.
        double distance = extent.getCenter().distanceTo3(dc.getView().getEyePoint());

        // If the eye point is inside the extent, then just return 0.
        if (distance < extent.getRadius())
        {
            return 0;
        }
        // Otherwise, return the distance from the eye point to the nearest point on the extent.
        else
        {
            return distance - extent.getRadius();
        }
    }

    //**************************************************************//
    //********************  Ordered Airspaces  *********************//
    //**************************************************************//

    protected static class OrderedAirspace implements OrderedRenderable
    {
        protected AirspaceRenderer renderer;
        protected Airspace airspace;
        protected Layer layer;
        protected double eyeDistance;

        public OrderedAirspace(AirspaceRenderer renderer, Airspace airspace, Layer layer, double eyeDistance)
        {
            if (renderer == null)
            {
                String msg = Logging.getMessage("nullValue.RendererIsNull");
                Logging.logger().severe(msg);
                throw new IllegalArgumentException(msg);
            }

            if (airspace == null)
            {
                String msg = Logging.getMessage("nullValue.AirspaceIsNull");