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