segmentplanerenderer.java

world wind java sdk 源码

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

import com.sun.opengl.util.BufferUtil;
import com.sun.opengl.util.j2d.TextRenderer;
import gov.nasa.worldwind.View;
import gov.nasa.worldwind.avlist.*;
import gov.nasa.worldwind.geom.*;
import gov.nasa.worldwind.globes.Globe;
import gov.nasa.worldwind.layers.Layer;
import gov.nasa.worldwind.pick.*;
import gov.nasa.worldwind.render.markers.*;
import gov.nasa.worldwind.terrain.SectorGeometryList;
import gov.nasa.worldwind.util.*;

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

/**
 * @author dcollins
 * @version $Id: SegmentPlaneRenderer.java 10925 2009-05-06 22:22:50Z dcollins $
 */
public class SegmentPlaneRenderer
{
    protected static class RenderInfo
    {
        protected Globe globe;
        protected Object segmentPlaneKey;

        // Plane geometric properties.
        protected Vec4 planeReferenceCenter;
        protected int planeFillIndexCount;
        protected int planeOutlineIndexCount;
        protected int planeGridIndexCount;
        protected IntBuffer planeFillIndices;
        protected IntBuffer planeOutlineIndices;
        protected IntBuffer planeGridIndices;
        protected DoubleBuffer planeVertices;
        protected DoubleBuffer planeNormals;
        // Border geometric properties.
        protected int borderCylinderIndexCount;
        protected int borderCapIndexCount;
        protected IntBuffer borderCylinderIndices;
        protected IntBuffer borderCapIndices;
        protected FloatBuffer borderCylinderVertices;
        protected FloatBuffer borderCapVertices;
        protected FloatBuffer borderCylinderNormals;
        protected FloatBuffer borderCapNormals;
        // Line segment geometric properties.
        protected MarkerShape[] segmentPointShape;
        // Control point geometric properties.
        protected MarkerShape controlPointShape;

        public boolean isExpired(Globe globe, SegmentPlane segmentPlane)
        {
            return this.globe == null
                || this.segmentPlaneKey == null
                || !this.globe.equals(globe)
                || !this.segmentPlaneKey.equals(segmentPlane.getStateKey());
        }

        public void makeCurrent(Globe globe, SegmentPlane segmentPlane)
        {
            this.globe = globe;
            this.segmentPlaneKey = segmentPlane.getStateKey();
        }
    }

    protected static class ControlPointInfo
    {
        protected SegmentPlane.ControlPoint controlPoint;
        protected Position position;
        protected MarkerShape shape;

        public ControlPointInfo(SegmentPlane.ControlPoint controlPoint, Position position, MarkerShape shape)
        {
            this.controlPoint = controlPoint;
            this.position = position;
            this.shape = shape;
        }
    }

    protected Map<SegmentPlane, RenderInfo> renderInfoMap;
    protected double minObjectSize = 0.01;
    protected double maxObjectSizeCoefficient = 0.005;
    protected final PickSupport pickSupport = new PickSupport();

    public SegmentPlaneRenderer()
    {
        this.renderInfoMap = new HashMap<SegmentPlane, RenderInfo>();
    }

    public double getMinObjectSize()
    {
        return minObjectSize;
    }

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

        this.minObjectSize = size;
    }

    public double getMaxObjectSizeCoefficient()
    {
        return this.maxObjectSizeCoefficient;
    }

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

        this.maxObjectSizeCoefficient = coefficient;
    }

    public void render(DrawContext dc, SegmentPlane segmentPlane)
    {
        if (dc == null)
        {
            String message = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (segmentPlane == null)
        {
            String message = Logging.getMessage("nullValue.SegmentPlaneIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.draw(dc, segmentPlane, null, null);
    }

    public void pick(DrawContext dc, SegmentPlane segmentPlane, java.awt.Point pickPoint, Layer layer)
    {
        if (dc == null)
        {
            String message = Logging.getMessage("nullValue.DrawContextIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (segmentPlane == null)
        {
            String message = Logging.getMessage("nullValue.SegmentPlaneIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        this.pickSupport.beginPicking(dc);
        try
        {
            this.draw(dc, segmentPlane, pickPoint, layer);
        }
        finally
        {
            this.pickSupport.endPicking(dc);
            this.pickSupport.clearPickList();
        }
    }

    public Vec4 intersect(Globe globe, Line ray, SegmentPlane segmentPlane)
    {
        if (ray == null)
        {
            String message = Logging.getMessage("nullValue.LineIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (segmentPlane == null)
        {
            String message = Logging.getMessage("nullValue.SegmentPlaneIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        RenderInfo renderInfo = this.getRenderInfoFor(globe, segmentPlane);
        if (renderInfo == null)
        {
            return null;
        }

        return this.intersectRayWithFill(ray, renderInfo);
    }

    public Position computeControlPointPosition(SectorGeometryList sgl, Globe globe, SegmentPlane segmentPlane,
        SegmentPlane.ControlPoint controlPoint)
    {
        if (globe == null)
        {
            String message = Logging.getMessage("nullValue.GlobeIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (segmentPlane == null)
        {
            String message = Logging.getMessage("nullValue.SegmentPlaneIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (controlPoint == null)
        {
            String message = Logging.getMessage("nullValue.ControlPointIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        double[] coords = controlPoint.getCoordinates();
        return this.computePositionOnPlane(sgl, globe, segmentPlane, coords[0], coords[1],
            controlPoint.isRelativeToSurface());
    }

    public double computeObjectSize(View view, Globe globe, SegmentPlane segmentPlane, Object key, Vec4 point)
    {
        if (view == null)
        {
            String message = Logging.getMessage("nullValue.ViewIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (globe == null)
        {
            String message = Logging.getMessage("nullValue.GlobeIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (segmentPlane == null)
        {
            String message = Logging.getMessage("nullValue.SegmentPlaneIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (key == null)
        {
            String message = Logging.getMessage("nullValue.KeyIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }
        if (point == null)
        {
            String message = Logging.getMessage("nullValue.PointIsNull");
            Logging.logger().severe(message);
            throw new IllegalArgumentException(message);
        }

        return this.computeObjectSize(view, globe, segmentPlane, key, point, false);
    }

    protected RenderInfo getRenderInfoFor(Globe globe, SegmentPlane segmentPlane)
    {
        RenderInfo renderInfo = this.renderInfoMap.get(segmentPlane);
        if (renderInfo == null || renderInfo.isExpired(globe, segmentPlane))
        {
            if (renderInfo == null)
                renderInfo = new RenderInfo();
            this.createSegmentPlaneGeometry(globe, segmentPlane, renderInfo);
            this.createBorderGeometry(globe, segmentPlane, renderInfo);
            this.createControlPointGeometry(globe, segmentPlane, renderInfo);

            renderInfo.makeCurrent(globe, segmentPlane);
            this.renderInfoMap.put(segmentPlane, renderInfo);
        }

        return renderInfo;
    }

    protected MultiLineTextRenderer getTextRendererFor(DrawContext dc, Font font)
    {
        TextRenderer tr = dc.getTextRendererCache().getOrCreate(font);
        return new MultiLineTextRenderer(tr);
    }

    protected void draw(DrawContext dc, SegmentPlane segmentPlane, java.awt.Point pickPoint, Layer layer)
    {
        if (!segmentPlane.isVisible())
            return;

        RenderInfo renderInfo = this.getRenderInfoFor(dc.getGlobe(), segmentPlane);

        OGLStackHandler ogsh = new OGLStackHandler();

        this.begin(dc, ogsh);
        try
        {
            this.drawSegmentPlane(dc, segmentPlane, renderInfo, pickPoint, layer);
        }
        finally
        {
            this.end(dc, ogsh);
        }
    }

    protected void drawSegmentPlane(DrawContext dc, SegmentPlane segmentPlane, RenderInfo renderInfo,
        java.awt.Point pickPoint, Layer layer)
    {
        this.drawPlaneGeometry(dc, segmentPlane, renderInfo, pickPoint, layer);
        this.drawPlaneBorder(dc, segmentPlane, renderInfo, pickPoint, layer);
        this.drawSegmentAltimeter(dc, segmentPlane, renderInfo, pickPoint, layer);
        this.drawControlPoints(dc, segmentPlane, renderInfo, pickPoint, layer);
        this.drawAxisLabels(dc, segmentPlane, renderInfo, pickPoint, layer);
    }

    protected void begin(DrawContext dc, OGLStackHandler ogsh)
    {
        GL gl = dc.getGL();

        OGLStateSupport oglSupport = new OGLStateSupport();
        if (!dc.isPickingMode())
        {
            oglSupport.setEnableBlending(true);
            oglSupport.setEnableLighting(true);
            oglSupport.setColorMode(OGLStateSupport.COLOR_NO_PREMULTIPLIED_ALPHA);
            oglSupport.setLightType(OGLStateSupport.LIGHT_DIRECTIONAL_FROM_VIEWER_POSITION);
            oglSupport.setLightPosition(new Vec4(1.0, 0.5, 1.0));
        }

        int attribMask =
            oglSupport.getAttributeBits()
            | GL.GL_CURRENT_BIT  // For current RGBA color.
            | GL.GL_LINE_BIT     // For line width.
            | GL.GL_POLYGON_BIT; // For cull face, polygon offset.
        ogsh.pushAttrib(gl, attribMask);

        int clientAttribMask =
            GL.GL_CLIENT_VERTEX_ARRAY_BIT; // For vertex and element pointers.
        ogsh.pushClientAttrib(gl, clientAttribMask);

        gl.glDisable(GL.GL_CULL_FACE);
        gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL.GL_NORMAL_ARRAY);

        oglSupport.apply(gl);
    }

    protected void end(DrawContext dc, OGLStackHandler ogsh)
    {
        GL gl = dc.getGL();