gov/nasa/worldwind/AbstractView.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government as represented by
   3 the Administrator of the National Aeronautics and Space Administration.
   4 All Rights Reserved.
   5 */
   6 package gov.nasa.worldwind;
   7
   8 import gov.nasa.worldwind.geom.*;
   9
  10 import javax.media.opengl.*;
  11 import javax.media.opengl.glu.*;
  12 import java.util.logging.Level;
  13
  14 /**
  15  * @author Paul Collins
  16  * @version $Id: AbstractView.java 2126 2007-06-21 21:00:42Z dcollins $
  17  */
  18 public abstract class AbstractView extends WWObjectImpl implements View
  19 {
  20     // Shared attributes.
  21     private boolean isInitialized = false;
  22     private final double[] matrixArray = new double[32];
  23     private final double[] vecArray = new double[4];
  24     private final int[] viewportArray = new int[4];
  25
  26     // ============== Viewing State ======================= //
  27     // ============== Viewing State ======================= //
  28     // ============== Viewing State ======================= //
  29
  30     // Current OpenGL viewing state.
  31     private Matrix modelView;
  32     private Matrix projection;
  33     private java.awt.Rectangle viewport;
  34
  35     public void apply(DrawContext dc)
  36     {
  37         if (dc == null)
  38         {
  39             String message = WorldWind.retrieveErrMsg("nullValue.DrawContextIsNull");
  40             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  41             throw new IllegalArgumentException(message);
  42         }
  43
  44         if (dc.getGL() == null)
  45         {
  46             String message = WorldWind.retrieveErrMsg("AbstractView.DrawingContextGLIsNull");
  47             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  48             throw new IllegalStateException(message);
  49         }
  50
  51         if (dc.getGlobe() == null)
  52         {
  53             String message = WorldWind.retrieveErrMsg("layers.AbstractLayer.NoGlobeSpecifiedInDrawingContext");
  54             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  55             throw new IllegalStateException(message);
  56         }
  57
  58         if (this.isViewUpdateable(dc))
  59             this.updateViewingState(dc);
  60
  61         this.doApply(dc);
  62     }
  63
  64     public boolean isViewUpdateable(DrawContext dc)
  65     {
  66         if (dc == null)
  67         {
  68             String message = WorldWind.retrieveErrMsg("nullValue.DrawContextIsNull");
  69             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  70             throw new IllegalArgumentException(message);
  71         }
  72
  73         return !dc.isPickingMode();
  74     }
  75
  76     private void updateViewingState(DrawContext dc)
  77     {
  78         this.clearAttributes();
  79         this.drawContext = dc;
  80
  81         // Get the current OpenGL viewport state.
  82         dc.getGL().glGetIntegerv(GL.GL_VIEWPORT, this.viewportArray, 0);
  83         this.viewport = new java.awt.Rectangle(
  84             this.viewportArray[0],
  85             this.viewportArray[1],
  86             this.viewportArray[2],
  87             this.viewportArray[3]);
  88
  89         if (!this.isInitialized)
  90             this.initialize(dc);
  91         this.isInitialized = true;
  92
  93         this.updateStateIterators(dc);
  94     }
  95
  96     protected void loadModelViewProjection(DrawContext dc, Matrix modelView, Matrix projection)
  97     {
  98         if (dc == null)
  99         {
 100             String message = WorldWind.retrieveErrMsg("nullValue.DrawContextIsNull");
 101             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 102             throw new IllegalArgumentException(message);
 103         }
 104
 105         if (dc.getGL() == null)
 106         {
 107             String message = WorldWind.retrieveErrMsg("AbstractView.DrawingContextGLIsNull");
 108             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 109             throw new IllegalStateException(message);
 110         }
 111
 112         if (modelView == null)
 113         {
 114             String message = WorldWind.retrieveErrMsg("AbstractView.ModelViewIsNull");
 115             WorldWind.logger().log(Level.FINE, message);
 116         }
 117
 118         if (projection == null)
 119         {
 120             String message = WorldWind.retrieveErrMsg("AbstractView.ProjectionIsNull");
 121             WorldWind.logger().log(Level.FINE, message);
 122         }
 123
 124         this.modelView = modelView;
 125         this.projection = projection;
 126
 127         GL gl = dc.getGL();
 128         // Store the current matrix-mode state.
 129         final int matrixMode = this.getMatrixMode(gl);
 130
 131         // Apply the model-view matrix to the current OpenGL context held by 'dc'.
 132         this.modelView.toArray(this.matrixArray, 0, false);
 133         gl.glMatrixMode(GL.GL_MODELVIEW);
 134         gl.glLoadMatrixd(this.matrixArray, 0);
 135
 136         // Apply the projection matrix to the current OpenGL context held by 'dc'.
 137         this.projection.toArray(this.matrixArray, 0, false);
 138         gl.glMatrixMode(GL.GL_PROJECTION);
 139         gl.glLoadMatrixd(this.matrixArray, 0);
 140
 141         // Restore matrix-mode state.
 142         gl.glMatrixMode(matrixMode);
 143     }
 144
 145     protected abstract void doApply(DrawContext dc);
 146
 147     public Matrix pushReferenceCenter(DrawContext dc, Vec4 referenceCenter)
 148     {
 149         if (dc == null)
 150         {
 151             String message = WorldWind.retrieveErrMsg("nullValue.DrawContextIsNull");
 152             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 153             throw new IllegalArgumentException(message);
 154         }
 155
 156         if (dc.getGL() == null)
 157         {
 158             String message = WorldWind.retrieveErrMsg("AbstractView.DrawingContextGLIsNull");
 159             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 160             throw new IllegalStateException(message);
 161         }
 162
 163         if (referenceCenter == null)
 164         {
 165             String message = WorldWind.retrieveErrMsg("nullValue.PointIsNull");
 166             WorldWind.logger().log(Level.FINE, message);
 167             throw new IllegalArgumentException(message);
 168         }
 169
 170         // Compute a new model-view matrix with origin at referenceCenter.
 171         Matrix matrix = null;
 172         if (this.modelView != null)
 173             matrix = this.modelView.multiply(Matrix.fromTranslation(referenceCenter));
 174
 175         GL gl = dc.getGL();
 176         // Store the current matrix-mode state.
 177         final int matrixMode = this.getMatrixMode(gl);
 178
 179         if (matrixMode != GL.GL_MODELVIEW)
 180             gl.glMatrixMode(GL.GL_MODELVIEW);
 181
 182         // Push and load a new model-view matrix to the current OpenGL context held by 'dc'.
 183         gl.glPushMatrix();
 184         if (matrix != null)
 185         {
 186             matrix.toArray(this.matrixArray, 0, false);
 187             gl.glLoadMatrixd(this.matrixArray, 0);
 188         }
 189
 190         // Restore matrix-mode state.
 191         if (matrixMode != GL.GL_MODELVIEW)
 192             gl.glMatrixMode(matrixMode);
 193
 194         return matrix;
 195     }
 196
 197     public void popReferenceCenter(DrawContext dc)
 198     {
 199         if (dc == null)
 200         {
 201             String message = WorldWind.retrieveErrMsg("nullValue.DrawContextIsNull");
 202             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 203             throw new IllegalArgumentException(message);
 204         }
 205
 206         if (dc.getGL() == null)
 207         {
 208             String message = WorldWind.retrieveErrMsg("AbstractView.DrawingContextGLIsNull");
 209             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 210             throw new IllegalStateException(message);
 211         }
 212
 213         GL gl = dc.getGL();
 214         // Store the current matrix-mode state.
 215         final int matrixMode = this.getMatrixMode(gl);
 216
 217         // Pop a model-view matrix off the current OpenGL context held by 'dc'.
 218         if (matrixMode != GL.GL_MODELVIEW)
 219             gl.glMatrixMode(GL.GL_MODELVIEW);
 220
 221         // Pop the top model-view matrix.
 222         gl.glPopMatrix();
 223
 224         // Restore matrix-mode state.
 225         if (matrixMode != GL.GL_MODELVIEW)
 226             gl.glMatrixMode(matrixMode);
 227     }
 228
 229     private final int[] matrixModeArray = new int[1];
 230
 231     private int getMatrixMode(GL gl)
 232     {
 233         gl.glGetIntegerv(GL.GL_MATRIX_MODE, this.matrixModeArray, 0);
 234         return this.matrixModeArray[0];
 235     }
 236
 237     // ============== Runtime Initialization ======================= //
 238     // ============== Runtime Initialization ======================= //
 239     // ============== Runtime Initialization ======================= //
 240
 241     private void initialize(DrawContext dc)
 242     {
 243         this.fieldOfView = getInitialFieldOfView(dc, this.fieldOfView);
 244         this.doInitialize(dc);
 245     }
 246
 247     protected void doInitialize(DrawContext dc)
 248     {
 249     }
 250
 251     protected static Angle getInitialFieldOfView(DrawContext dc, Angle clientValue)
 252     {
 253         // Use value specified by client.
 254         if (clientValue != null)
 255             return clientValue;
 256
 257         // Use value from configuration.
 258         Double configValue = Configuration.getDoubleValue(AVKey.FOV);
 259         if (configValue != null)
 260             return Angle.fromDegrees(configValue);
 261
 262         // Fallback to zero.
 263         return Angle.fromDegrees(45.0);
 264     }
 265
 266     protected static Angle getInitialLatitude(DrawContext dc, Angle clientValue)
 267     {
 268         // Use value specified by client.
 269         if (clientValue != null)
 270             return clientValue;
 271
 272         // Use value from configuration.
 273         Double configValue = Configuration.getDoubleValue(AVKey.INITIAL_LATITUDE);
 274         if (configValue != null)
 275             return Angle.fromDegrees(configValue);
 276
 277         // Fallback to zero.
 278         return Angle.ZERO;
 279     }
 280
 281     protected static Angle getInitialLongitude(DrawContext dc, Angle clientValue)
 282     {
 283         // Use value specified by client.
 284         if (clientValue != null)
 285             return clientValue;
 286
 287         // Use value from configuration.
 288         Double configValue = Configuration.getDoubleValue(AVKey.INITIAL_LONGITUDE);
 289         if (configValue != null)
 290             return Angle.fromDegrees(configValue);
 291
 292         // Use longitude of system time-zone.
 293         java.util.TimeZone tz = java.util.Calendar.getInstance().getTimeZone();
 294         if (tz != null)
 295             return Angle.fromDegrees(180.0 * tz.getOffset(System.currentTimeMillis()) / (12.0 * 3.6e6));
 296
 297         // Fallback to zero.
 298         return Angle.ZERO;
 299     }
 300
 301     protected static Angle getInitialHeading(DrawContext dc, Angle clientValue)
 302     {
 303         // Use value specified by client.
 304         if (clientValue != null)
 305             return clientValue;
 306
 307         // Use value from configuration.
 308         Double configValue = Configuration.getDoubleValue("null");
 309         if (configValue != null)
 310             return Angle.fromDegrees(configValue);
 311
 312         // Fallback to zero.
 313         return Angle.ZERO;
 314     }
 315
 316     protected static Angle getInitialPitch(DrawContext dc, Angle clientValue)
 317     {
 318         // Use value specified by client.
 319         if (clientValue != null)
 320             return clientValue;
 321
 322         // Use value from configuration.
 323         Double configValue = Configuration.getDoubleValue("null");
 324         if (configValue != null)
 325             return Angle.fromDegrees(configValue);
 326
 327         // Fallback to zero.
 328         return Angle.ZERO;
 329     }
 330
 331     protected static double getInitialAltitude(DrawContext dc, double clientValue)
 332     {
 333         // Use value specified by client.
 334         if (clientValue >= 0.0)
 335             return clientValue;
 336
 337         // Use value from configuration.
 338         Double configValue = Configuration.getDoubleValue("null");
 339         if (configValue != null)
 340             return configValue;
 341
 342         // Use globe radius with coefficient.
 343         if (dc != null && dc.getGlobe() != null)
 344             return 3.0 * dc.getGlobe().getRadius();
 345
 346         // Fallback to zero.
 347         return 0.0;
 348     }
 349
 350     // ============== Attribute Accessors ======================= //
 351     // ============== Attribute Accessors ======================= //
 352     // ============== Attribute Accessors ======================= //
 353
 354     // Current DrawContext state.
 355     private DrawContext drawContext = null;
 356     // Cached viewing attribute computations.
 357     private Vec4 eye = null;
 358     private Vec4 up = null;
 359     private Vec4 forward = null;
 360     private Frustum frustumInModelCoords = null;
 361     private Angle fieldOfView = null;
 362     private double pixelSizeScale = -1;
 363     private double horizonDistance = -1;
 364
 365     private void clearAttributes()
 366     {
 367         this.drawContext = null;
 368         this.eye = null;
 369         this.up = null;
 370         this.forward = null;
 371         this.frustumInModelCoords = null;
 372         this.pixelSizeScale = -1;
 373         this.horizonDistance = -1;
 374     }
 375
 376     protected DrawContext getDrawContext()
 377     {
 378         return this.drawContext;
 379     }
 380
 381     public Matrix getModelViewMatrix()
 382     {
 383         return this.modelView;
 384     }
 385
 386     public Matrix getProjectionMatrix()
 387     {
 388         return this.projection;
 389     }
 390
 391     public java.awt.Rectangle getViewport()
 392     {
 393         return new java.awt.Rectangle(this.viewport);
 394     }
 395
 396     public Frustum getFrustumInModelCoordinates()
 397     {
 398         if (this.frustumInModelCoords == null)
 399         {
 400             // Compute the current model-view coordinate frustum.
 401             Frustum frust = this.getFrustum();
 402             if (frust != null && this.modelView != null)
 403                 this.frustumInModelCoords = frust.transformBy(this.modelView.getTranspose());
 404         }
 405         return this.frustumInModelCoords;
 406     }
 407
 408     public Angle getFieldOfView()
 409     {
 410         return this.fieldOfView;
 411     }
 412
 413     public void setFieldOfView(Angle newFov)
 414     {
 415         if (newFov == null)
 416         {
 417             String message = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 418             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 419             throw new IllegalArgumentException(message);
 420         }
 421         this.fieldOfView = newFov;
 422     }
 423
 424     public Vec4 getEyePoint()
 425     {
 426         if (this.eye == null)
 427         {
 428             Matrix modelViewInv;
 429             if (this.modelView != null && (modelViewInv = this.modelView.getInverse()) != null)
 430                 this.eye = Vec4.UNIT_W.transformBy4(modelViewInv);
 431         }
 432         return this.eye;
 433     }
 434
 435     public Vec4 getUpVector()
 436     {
 437         if (this.up == null)
 438         {
 439             Matrix modelViewInv;
 440             if (this.modelView != null && (modelViewInv = this.modelView.getInverse()) != null)
 441                 this.up = Vec4.UNIT_Y.transformBy4(modelViewInv);
 442         }
 443         return this.up;
 444     }
 445
 446     public Vec4 getForwardVector()
 447     {
 448         if (this.forward == null)
 449         {
 450             Matrix modelViewInv;
 451             if (this.modelView != null && (modelViewInv = this.modelView.getInverse()) != null)
 452                 this.forward = Vec4.UNIT_NEGATIVE_Z.transformBy4(modelViewInv);
 453         }
 454         return this.forward;
 455     }
 456
 457     // ============== State Iterators ======================= //
 458     // ============== State Iterators ======================= //
 459     // ============== State Iterators ======================= //
 460
 461     private ViewStateIterator viewStateIterator = null;
 462
 463     public void iterateOver(ViewStateIterator viewStateIterator)
 464     {
 465         if (viewStateIterator == null)
 466         {
 467             this.stopIterating();
 468             return;
 469         }
 470
 471         this.viewStateIterator = viewStateIterator.coalesceWith(this, this.viewStateIterator);
 472         this.firePropertyChange(AVKey.VIEW, null, this);
 473     }
 474
 475     public boolean isIterating()
 476     {
 477         return this.viewStateIterator != null;
 478     }
 479
 480     public void stopIterating()
 481     {
 482         this.viewStateIterator = null;
 483     }
 484
 485     private void updateStateIterators(DrawContext dc)
 486     {
 487         if (!this.isIterating())
 488             return;
 489
 490         if (this.viewStateIterator.hasNextState(this))
 491         {
 492             this.viewStateIterator.nextState(this);
 493             this.firePropertyChange(AVKey.VIEW, null, this);
 494         }
 495         else
 496         {
 497             this.stopIterating();
 498         }
 499     }
 500
 501     // ============== Utilities ======================= //
 502     // ============== Utilities ======================= //
 503     // ============== Utilities ======================= //
 504
 505     // GLU
 506     private final GLU glu = new GLU();
 507
 508     // TODO: this should be expressed in OpenGL screen coordinates, not toolkit (e.g. AWT) coordinates
 509     public Line computeRayFromScreenPoint(double x, double y)
 510     {
 511         if (this.viewport == null)
 512             return null;
 513         double invY = this.viewport.height - y - 1; // TODO: should be computed by caller
 514         Vec4 a = this.unProject(new Vec4(x, invY, 0, 0));
 515         Vec4 b = this.unProject(new Vec4(x, invY, 1, 0));
 516         if (a == null || b == null)
 517             return null;
 518         return new Line(a, b.subtract3(a).normalize3());
 519     }
 520
 521     public Position computePositionFromScreenPoint(double x, double y)
 522     {
 523         Line line = this.computeRayFromScreenPoint(x, y);
 524         if (line == null)
 525             return null;
 526
 527         if (this.drawContext == null)
 528             return null;
 529
 530         Globe globe = this.drawContext.getGlobe();
 531         if (globe == null)
 532             return null;
 533
 534         return globe.getIntersectionPosition(line);
 535     }
 536
 537     public double computePixelSizeAtDistance(double distance)
 538     {
 539         if (this.pixelSizeScale < 0)
 540         {
 541             // Compute the current coefficient for computing the size of a pixel.
 542             if (this.fieldOfView != null && this.viewport.width > 0)
 543                 this.pixelSizeScale = 2 * this.fieldOfView.tanHalfAngle() / (double) this.viewport.width;
 544             else if (this.viewport.width > 0)
 545                 this.pixelSizeScale = 1 / (double) this.viewport.width;
 546         }
 547         if (this.pixelSizeScale < 0)
 548             return -1;
 549         return this.pixelSizeScale * Math.abs(distance);
 550     }
 551
 552     public double computeHorizonDistance()
 553     {
 554         if (this.horizonDistance < 0)
 555         {
 556             if (this.drawContext == null)
 557                 return this.horizonDistance;
 558
 559             Globe globe = this.drawContext.getGlobe();
 560             if (globe == null)
 561                 return this.horizonDistance;
 562
 563             this.horizonDistance = this.computeHorizonDistance(globe, this.drawContext.getVerticalExaggeration(),
 564                 this.getEyePoint());
 565         }
 566         return this.horizonDistance;
 567     }
 568
 569     protected double computeHorizonDistance(Globe globe, double verticalExaggeration, Vec4 eyeVec)
 570     {
 571         if (globe == null || eyeVec == null)
 572             return -1;
 573
 574         // Compute the current (approximate) distance from eye to globe horizon.
 575         Position eyePosition = globe.computePositionFromPoint(eyeVec);
 576         double elevation = verticalExaggeration
 577             * globe.getElevation(eyePosition.getLatitude(), eyePosition.getLongitude());
 578         Vec4 surface = globe.computePointFromPosition(eyePosition.getLatitude(), eyePosition.getLongitude(),
 579             elevation);
 580         double altitude = eyeVec.getLength3() - surface.getLength3();
 581         double radius = globe.getMaximumRadius();
 582         return Math.sqrt(altitude * (2 * radius + altitude));
 583     }
 584
 585     public Vec4 project(Vec4 modelPoint)
 586     {
 587         if (modelPoint == null)
 588         {
 589             String message = WorldWind.retrieveErrMsg("nullValue.PointIsNull");
 590             WorldWind.logger().log(Level.FINE, message);
 591             throw new IllegalArgumentException(message);
 592         }
 593
 594         if (this.modelView == null || this.projection == null || this.viewport == null)
 595             return null;
 596
 597         this.modelView.toArray(this.matrixArray, 0, false);
 598         this.projection.toArray(this.matrixArray, 16, false);
 599
 600         if (!this.glu.gluProject(
 601             modelPoint.x, modelPoint.y, modelPoint.z,
 602             this.matrixArray, 0,
 603             this.matrixArray, 16,
 604             this.viewportArray, 0,
 605             this.vecArray, 0))
 606         {
 607             return null;
 608         }
 609
 610         return Vec4.fromArray3(this.vecArray, 0);
 611     }
 612
 613     public Vec4 unProject(Vec4 windowPoint)
 614     {
 615         if (windowPoint == null)
 616         {
 617             String message = WorldWind.retrieveErrMsg("nullValue.PointIsNull");
 618             WorldWind.logger().log(Level.FINE, message);
 619             throw new IllegalArgumentException(message);
 620         }
 621
 622         if (this.modelView == null || this.projection == null || this.viewport == null)
 623             return null;
 624
 625         this.modelView.toArray(this.matrixArray, 0, false);
 626         this.projection.toArray(this.matrixArray, 16, false);
 627
 628         if (!this.glu.gluUnProject(
 629             windowPoint.x, windowPoint.y, windowPoint.z,
 630             this.matrixArray, 0,
 631             this.matrixArray, 16,
 632             this.viewportArray, 0,
 633             this.vecArray, 0))
 634         {
 635             return null;
 636         }
 637
 638         return Vec4.fromArray3(this.vecArray, 0);
 639     }
 640 }