gov/nasa/worldwind/DrawContextImpl.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind;
   8
   9 import com.sun.opengl.util.texture.*;
  10 import gov.nasa.worldwind.geom.*;
  11
  12 import javax.media.opengl.*;
  13 import java.util.*;
  14
  15 /**
  16  * @author Tom Gaskins
  17  * @version $Id: DrawContextImpl.java 1994 2007-06-11 16:33:33Z dcollins $
  18  */
  19 public class DrawContextImpl extends WWObjectImpl implements DrawContext
  20 {
  21     private javax.media.opengl.GLContext glContext;
  22     private javax.media.opengl.glu.GLU glu = new javax.media.opengl.glu.GLU();
  23     private View view;
  24     private Model model;
  25     private Globe globe;
  26     private double verticalExaggeration = 1d;
  27     private gov.nasa.worldwind.geom.Sector visibleSector;
  28     private SectorGeometryList surfaceGeometry;// = new SectorGeometryList();
  29     private gov.nasa.worldwind.PickedObjectList pickedObjects = new gov.nasa.worldwind.PickedObjectList();
  30     private int uniquePickNumber = 0;
  31     private java.awt.Color clearColor = new java.awt.Color(0, 0, 0, 0);
  32     private boolean isPickingMode = false;
  33     private int numTextureUnits = -1;
  34     private SurfaceTileRenderer surfaceTileRenderer = new SurfaceTileRenderer();
  35
  36     PriorityQueue<OrderedRenderable> orderedRenderables = new PriorityQueue<OrderedRenderable>(100,
  37         new Comparator<OrderedRenderable>()
  38         {
  39             public int compare(OrderedRenderable orA, OrderedRenderable orB)
  40             {
  41                 double eA = orA.getDistanceFromEye();
  42                 double eB = orB.getDistanceFromEye();
  43
  44                 return eA > eB ? -1 : eA == eB ? 0 : 1;
  45             }
  46         });
  47
  48     public final javax.media.opengl.GL getGL()
  49     {
  50         return this.getGLContext().getGL();
  51     }
  52
  53     public final javax.media.opengl.glu.GLU getGLU()
  54     {
  55         return this.glu;
  56     }
  57
  58     public final javax.media.opengl.GLContext getGLContext()
  59     {
  60         return this.glContext;
  61     }
  62
  63     public final int getDrawableHeight()
  64     {
  65         return this.getGLDrawable().getHeight();
  66     }
  67
  68     public final int getDrawableWidth()
  69     {
  70         return this.getGLDrawable().getWidth();
  71     }
  72
  73     public final javax.media.opengl.GLDrawable getGLDrawable()
  74     {
  75         return this.getGLContext().getGLDrawable();
  76     }
  77
  78     public final void initialize(javax.media.opengl.GLContext glContext)
  79     {
  80         if (glContext == null)
  81         {
  82             String message = WorldWind.retrieveErrMsg("nullValue.GLContextIsNull");
  83             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
  84             throw new IllegalArgumentException(message);
  85         }
  86
  87         this.glContext = glContext;
  88         this.visibleSector = null;
  89         if (this.surfaceGeometry != null)
  90             this.surfaceGeometry.clear();
  91         this.surfaceGeometry = null;
  92
  93         this.pickedObjects.clear();
  94         this.orderedRenderables.clear();
  95         this.uniquePickNumber = 0;
  96
  97         if (this.numTextureUnits < 1)
  98             this.numTextureUnits = queryMaxTextureUnits(glContext);
  99     }
 100
 101     private static int queryMaxTextureUnits(GLContext glContext)
 102     {
 103         int[] mtu = new int[1];
 104         glContext.getGL().glGetIntegerv(GL.GL_MAX_TEXTURE_UNITS, mtu, 0);
 105         return mtu[0];
 106     }
 107
 108     public final void setModel(gov.nasa.worldwind.Model model)
 109     {
 110         this.model = model;
 111         if (this.model == null)
 112             return;
 113
 114         Globe g = this.model.getGlobe();
 115         if (g != null)
 116             this.globe = g;
 117     }
 118
 119     public final Model getModel()
 120     {
 121         return this.model;
 122     }
 123
 124     public final LayerList getLayers()
 125     {
 126         return this.model.getLayers();
 127     }
 128
 129     public final Sector getVisibleSector()
 130     {
 131         return this.visibleSector;
 132     }
 133
 134     public final void setVisibleSector(Sector s)
 135     {
 136         // don't check for null - it is possible that no globe is active, no view is active, no sectors visible, etc.
 137         this.visibleSector = s;
 138     }
 139
 140     public void setSurfaceGeometry(SectorGeometryList surfaceGeometry)
 141     {
 142         this.surfaceGeometry = surfaceGeometry;
 143     }
 144
 145     public SectorGeometryList getSurfaceGeometry()
 146     {
 147         return surfaceGeometry;
 148     }
 149
 150     public final Globe getGlobe()
 151     {
 152         return this.globe != null ? this.globe : this.model.getGlobe();
 153     }
 154
 155     public final void setView(gov.nasa.worldwind.View view)
 156     {
 157         this.view = view;
 158     }
 159
 160     public final View getView()
 161     {
 162         return this.view;
 163     }
 164
 165     public final void setGLContext(javax.media.opengl.GLContext glContext)
 166     {
 167         if (glContext == null)
 168         {
 169             String message = WorldWind.retrieveErrMsg("nullValue.GLContextIsNull");
 170             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
 171             throw new IllegalArgumentException(message);
 172         }
 173
 174         this.glContext = glContext;
 175     }
 176
 177     public final double getVerticalExaggeration()
 178     {
 179         return verticalExaggeration;
 180     }
 181
 182     public final void setVerticalExaggeration(double verticalExaggeration)
 183     {
 184         this.verticalExaggeration = verticalExaggeration;
 185     }
 186
 187     /**
 188      * Add picked objects to the current list of picked objects.
 189      *
 190      * @param pickedObjects the list of picked objects to add
 191      * @throws IllegalArgumentException if <code>pickedObjects is null</code>
 192      */
 193     public void addPickedObjects(gov.nasa.worldwind.PickedObjectList pickedObjects)
 194     {
 195         if (pickedObjects == null)
 196         {
 197             String msg = WorldWind.retrieveErrMsg("nullValue.PickedObjectList");
 198             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 199             throw new IllegalArgumentException(msg);
 200         }
 201
 202         if (this.pickedObjects == null)
 203         {
 204             this.pickedObjects = pickedObjects;
 205             return;
 206         }
 207
 208         for (gov.nasa.worldwind.PickedObject po : pickedObjects)
 209         {
 210             this.pickedObjects.add(po);
 211         }
 212     }
 213
 214     /**
 215      * Adds a single insatnce of the picked object to the current picked-object list
 216      *
 217      * @param pickedObject the object to add
 218      * @throws IllegalArgumentException if <code>picked Object is null</code>
 219      */
 220     public void addPickedObject(PickedObject pickedObject)
 221     {
 222         if (null == pickedObject)
 223         {
 224             String msg = WorldWind.retrieveErrMsg("nullValue.PickedObject");
 225             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 226             throw new IllegalArgumentException(msg);
 227         }
 228
 229         if (null == this.pickedObjects)
 230             this.pickedObjects = new gov.nasa.worldwind.PickedObjectList();
 231
 232         this.pickedObjects.add(pickedObject);
 233     }
 234
 235     public gov.nasa.worldwind.PickedObjectList getPickedObjects()
 236     {
 237         return this.pickedObjects;
 238     }
 239
 240     public java.awt.Color getUniquePickColor()
 241     {
 242         this.uniquePickNumber++;
 243         int clearColorCode = this.getClearColor().getRGB();
 244
 245         if (clearColorCode == this.uniquePickNumber)
 246             this.uniquePickNumber++;
 247
 248         if (this.uniquePickNumber >= 0x00FFFFFF)
 249         {
 250             this.uniquePickNumber = 1;  // no black, no white
 251             if (clearColorCode == this.uniquePickNumber)
 252                 this.uniquePickNumber++;
 253         }
 254
 255         return new java.awt.Color(this.uniquePickNumber, true); // has alpha
 256     }
 257
 258     public java.awt.Color getClearColor()
 259     {
 260         return this.clearColor;
 261     }
 262
 263     /**
 264      * Returns true if the Picking mode is active, otherwise return false
 265      *
 266      * @return true for Picking mode, otherwise false
 267      */
 268     public boolean isPickingMode()
 269     {
 270         return this.isPickingMode;
 271     }
 272
 273     /**
 274      * Enables color picking mode
 275      */
 276     public void enablePickingMode()
 277     {
 278         this.isPickingMode = true;
 279     }
 280
 281     /**
 282      * Disables color picking mode
 283      */
 284     public void disablePickingMode()
 285     {
 286         this.isPickingMode = false;
 287     }
 288
 289     public void addOrderedRenderable(OrderedRenderable orderedRenderable)
 290     {
 291         if (null == orderedRenderable)
 292         {
 293             String msg = WorldWind.retrieveErrMsg("nullValue.OrderedRenderable");
 294             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 295             return; // benign event
 296         }
 297
 298         this.orderedRenderables.add(orderedRenderable);
 299     }
 300
 301     public java.util.Queue<OrderedRenderable> getOrderedRenderables()
 302     {
 303         return this.orderedRenderables;
 304     }
 305
 306     public void drawUnitQuad()
 307     {
 308         GL gl = this.getGL();
 309
 310         gl.glBegin(GL.GL_QUADS); // TODO: use a vertex array or vertex buffer
 311         gl.glVertex2d(0d, 0d);
 312         gl.glVertex2d(1, 0d);
 313         gl.glVertex2d(1, 1);
 314         gl.glVertex2d(0d, 1);
 315         gl.glEnd();
 316     }
 317
 318     public void drawUnitQuad(TextureCoords texCoords)
 319     {
 320         GL gl = this.getGL();
 321
 322         gl.glBegin(GL.GL_QUADS); // TODO: use a vertex array or vertex buffer
 323         gl.glTexCoord2d(texCoords.left(), texCoords.bottom());
 324         gl.glVertex2d(0d, 0d);
 325         gl.glTexCoord2d(texCoords.right(), texCoords.bottom());
 326         gl.glVertex2d(1, 0d);
 327         gl.glTexCoord2d(texCoords.right(), texCoords.top());
 328         gl.glVertex2d(1, 1);
 329         gl.glTexCoord2d(texCoords.left(), texCoords.top());
 330         gl.glVertex2d(0d, 1);
 331         gl.glEnd();
 332     }
 333
 334     public int getNumTextureUnits()
 335     {
 336         return numTextureUnits;
 337     }
 338
 339     public void setNumTextureUnits(int numTextureUnits)
 340     {
 341         // TODO: validate arg for >= 1
 342         this.numTextureUnits = numTextureUnits;
 343     }
 344
 345     public Vec4 getPointOnGlobe(Angle latitude, Angle longitude)
 346     {
 347         if (latitude == null || longitude == null)
 348         {
 349             String message = WorldWind.retrieveErrMsg("nullValue.LatitudeOrLongitudeIsNull");
 350             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 351             throw new IllegalArgumentException(message);
 352         }
 353
 354         if (!this.getVisibleSector().contains(latitude, longitude))
 355             return null;
 356
 357         SectorGeometryList sectorGeometry = this.getSurfaceGeometry();
 358         if (sectorGeometry != null)
 359         {
 360             Vec4 p = sectorGeometry.getSurfacePoint(latitude, longitude);
 361             if (p != null)
 362                 return p;
 363         }
 364
 365         return null;
 366
 367 //        Globe globe = this.getGlobe();
 368 //        if (globe == null)
 369 //            return null;
 370 //
 371 //        double elevation = this.getVerticalExaggeration() * globe.getElevation(latitude, longitude);
 372 //        return this.getGlobe().computeSurfacePoint(latitude, longitude, elevation);
 373     }
 374
 375     public SurfaceTileRenderer getSurfaceTileRenderer()
 376     {
 377         return this.surfaceTileRenderer;
 378     }
 379 }