gov/nasa/worldwind/render/IconRenderer.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.render;
   8
   9 import com.sun.opengl.util.j2d.TextRenderer;
  10 import com.sun.opengl.util.texture.*;
  11 import gov.nasa.worldwind.Locatable;
  12 import gov.nasa.worldwind.exception.WWRuntimeException;
  13 import gov.nasa.worldwind.geom.*;
  14 import gov.nasa.worldwind.globes.SectorGeometryList;
  15 import gov.nasa.worldwind.layers.Layer;
  16 import gov.nasa.worldwind.pick.PickSupport;
  17 import gov.nasa.worldwind.util.Logging;
  18
  19 import javax.media.opengl.GL;
  20 import java.awt.*;
  21 import java.awt.image.*;
  22 import java.util.*;
  23 import java.util.logging.Level;
  24
  25 /**
  26  * @author tag
  27  * @version $Id: IconRenderer.java 3631 2007-11-28 00:46:57Z tgaskins $
  28  */
  29 public class IconRenderer
  30 {
  31     private Pedestal pedestal;
  32     private PickSupport pickSupport = new PickSupport();
  33     private HashMap<Font, ToolTipRenderer> toolTipRenderers = new HashMap<Font, ToolTipRenderer>();
  34
  35     public IconRenderer()
  36     {
  37     }
  38
  39     public Pedestal getPedestal()
  40     {
  41         return pedestal;
  42     }
  43
  44     public void setPedestal(Pedestal pedestal)
  45     {
  46         this.pedestal = pedestal;
  47     }
  48
  49     private static boolean isIconValid(WWIcon icon, boolean checkPosition)
  50     {
  51         if (icon == null || icon.getImageSource() == null)
  52             return false;
  53
  54         //noinspection RedundantIfStatement
  55         if (checkPosition && icon.getPosition() == null)
  56             return false;
  57
  58         return true;
  59     }
  60
  61     public void pick(DrawContext dc, Iterable<WWIcon> icons, java.awt.Point pickPoint, Layer layer)
  62     {
  63         this.drawMany(dc, icons);
  64     }
  65
  66     public void pick(DrawContext dc, WWIcon icon, Vec4 iconPoint, java.awt.Point pickPoint, Layer layer)
  67     {
  68         if (!isIconValid(icon, false))
  69             return;
  70
  71         this.drawOne(dc, icon, iconPoint);
  72     }
  73
  74     public void render(DrawContext dc, Iterable<WWIcon> icons)
  75     {
  76         this.drawMany(dc, icons);
  77     }
  78
  79     public void render(DrawContext dc, WWIcon icon, Vec4 iconPoint)
  80     {
  81         if (!isIconValid(icon, false))
  82             return;
  83
  84         this.drawOne(dc, icon, iconPoint);
  85     }
  86
  87     private void drawMany(DrawContext dc, Iterable<WWIcon> icons)
  88     {
  89         if (dc == null)
  90         {
  91             String msg = Logging.getMessage("nullValue.DrawContextIsNull");
  92             Logging.logger().severe(msg);
  93             throw new IllegalArgumentException(msg);
  94         }
  95
  96         if (dc.getVisibleSector() == null)
  97             return;
  98
  99         SectorGeometryList geos = dc.getSurfaceGeometry();
 100         //noinspection RedundantIfStatement
 101         if (geos == null)
 102             return;
 103
 104         if (icons == null)
 105         {
 106             String msg = Logging.getMessage("nullValue.IconIterator");
 107             Logging.logger().severe(msg);
 108             throw new IllegalArgumentException(msg);
 109         }
 110
 111         Iterator<WWIcon> iterator = icons.iterator();
 112
 113         if (!iterator.hasNext())
 114             return;
 115
 116         while (iterator.hasNext())
 117         {
 118             WWIcon icon = iterator.next();
 119             if (!isIconValid(icon, true))
 120                 continue;
 121
 122             if (!icon.isVisible())
 123                 continue;
 124
 125             // Determine Cartesian position from the surface geometry if the icon is near the surface,
 126             // otherwise draw it from the globe.
 127             Position pos = icon.getPosition();
 128             Vec4 iconPoint = null;
 129             if (pos.getElevation() < dc.getGlobe().getMaxElevation())
 130                 iconPoint = dc.getSurfaceGeometry().getSurfacePoint(icon.getPosition());
 131             if (iconPoint == null)
 132                 iconPoint = dc.getGlobe().computePointFromPosition(icon.getPosition());
 133
 134             // The icons aren't drawn here, but added to the ordered queue to be drawn back-to-front.
 135             double eyeDistance = icon.isAlwaysOnTop() ? 0 : dc.getView().getEyePoint().distanceTo3(iconPoint);
 136             dc.addOrderedRenderable(new OrderedIcon(icon, iconPoint, eyeDistance));
 137
 138             if (icon.isShowToolTip())
 139                 this.addToolTip(dc, icon, iconPoint);
 140         }
 141     }
 142
 143     private void drawOne(DrawContext dc, WWIcon icon, Vec4 iconPoint)
 144     {
 145         if (dc == null)
 146         {
 147             String msg = Logging.getMessage("nullValue.DrawContextIsNull");
 148             Logging.logger().severe(msg);
 149             throw new IllegalArgumentException(msg);
 150         }
 151
 152         if (dc.getVisibleSector() == null)
 153             return;
 154
 155         SectorGeometryList geos = dc.getSurfaceGeometry();
 156         //noinspection RedundantIfStatement
 157         if (geos == null)
 158             return;
 159
 160         if (!icon.isVisible())
 161             return;
 162
 163         if (iconPoint == null)
 164         {
 165             Angle lat = icon.getPosition().getLatitude();
 166             Angle lon = icon.getPosition().getLongitude();
 167
 168             if (!dc.getVisibleSector().contains(lat, lon))
 169                 return;
 170
 171             iconPoint = dc.getSurfaceGeometry().getSurfacePoint(lat, lon, icon.getPosition().getElevation());
 172             if (iconPoint == null)
 173                 return;
 174         }
 175
 176         if (!dc.getView().getFrustumInModelCoordinates().contains(iconPoint))
 177             return;
 178
 179         double horizon = dc.getView().computeHorizonDistance();
 180         double eyeDistance = icon.isAlwaysOnTop() ? 0 : dc.getView().getEyePoint().distanceTo3(iconPoint);
 181         if (eyeDistance > horizon)
 182             return;
 183
 184         // The icon isn't drawn here, but added to the ordered queue to be drawn back-to-front.
 185         dc.addOrderedRenderable(new OrderedIcon(icon, iconPoint, eyeDistance));
 186
 187         if (icon.isShowToolTip())
 188             this.addToolTip(dc, icon, iconPoint);
 189     }
 190
 191     private void addToolTip(DrawContext dc, WWIcon icon, Vec4 iconPoint)
 192     {
 193         if (icon.getToolTipFont() == null && icon.getToolTipText() == null)
 194             return;
 195
 196         final Vec4 screenPoint = dc.getView().project(iconPoint);
 197         if (screenPoint == null)
 198             return;
 199
 200         OrderedText tip = new OrderedText(icon.getToolTipText(), icon.getToolTipFont(), screenPoint,
 201             icon.getToolTipTextColor(), 0d);
 202         dc.addOrderedRenderable(tip);
 203     }
 204
 205     private class OrderedText implements OrderedRenderable
 206     {
 207         Font font;
 208         String text;
 209         Vec4 point;
 210         double eyeDistance;
 211         java.awt.Point pickPoint;
 212         Layer layer;
 213         java.awt.Color color;
 214
 215         OrderedText(String text, Font font, Vec4 point, java.awt.Color color, double eyeDistance)
 216         {
 217             this.text = text;
 218             this.font = font;
 219             this.point = point;
 220             this.eyeDistance = eyeDistance;
 221             this.color = color;
 222         }
 223
 224         OrderedText(String text, Font font, Vec4 point, java.awt.Point pickPoint, Layer layer, double eyeDistance)
 225         {
 226             this.text = text;
 227             this.font = font;
 228             this.point = point;
 229             this.eyeDistance = eyeDistance;
 230             this.pickPoint = pickPoint;
 231             this.layer = layer;
 232         }
 233
 234         public double getDistanceFromEye()
 235         {
 236             return this.eyeDistance;
 237         }
 238
 239         public void render(DrawContext dc)
 240         {
 241             ToolTipRenderer tr = IconRenderer.this.toolTipRenderers.get(this.font);
 242             if (tr == null)
 243             {
 244                 if (this.font != null)
 245                     tr = new ToolTipRenderer(new TextRenderer(this.font, true, true));
 246                 else
 247                     tr = new ToolTipRenderer();
 248                 IconRenderer.this.toolTipRenderers.put(this.font, tr);
 249             }
 250
 251             Rectangle vp = dc.getView().getViewport();
 252             tr.setForeground(this.color);
 253             tr.setUseSystemLookAndFeel(this.color == null);
 254             tr.beginRendering(vp.width, vp.height, true);
 255             tr.draw(this.text, (int) point.x, (int) point.y);
 256             tr.endRendering();
 257         }
 258
 259         public void pick(DrawContext dc, java.awt.Point pickPoint)
 260         {
 261         }
 262     }
 263
 264     private class OrderedIcon implements OrderedRenderable, Locatable
 265     {
 266         WWIcon icon;
 267         Vec4 point;
 268         double eyeDistance;
 269         java.awt.Point pickPoint;
 270         Layer layer;
 271
 272         OrderedIcon(WWIcon icon, Vec4 point, double eyeDistance)
 273         {
 274             this.icon = icon;
 275             this.point = point;
 276             this.eyeDistance = eyeDistance;
 277         }
 278
 279         OrderedIcon(WWIcon icon, Vec4 point, java.awt.Point pickPoint, Layer layer, double eyeDistance)
 280         {
 281             this.icon = icon;
 282             this.point = point;
 283             this.eyeDistance = eyeDistance;
 284             this.pickPoint = pickPoint;
 285             this.layer = layer;
 286         }
 287
 288         public double getDistanceFromEye()
 289         {
 290             return this.eyeDistance;
 291         }
 292
 293         public Position getPosition()
 294         {
 295             return this.icon.getPosition();
 296         }
 297
 298         public void render(DrawContext dc)
 299         {
 300             IconRenderer.this.beginDrawIcons(dc);
 301
 302             try
 303             {
 304                 IconRenderer.this.drawIcon(dc, this);
 305                 // Draw as many as we can in a batch to save ogl state switching.
 306                 while (dc.getOrderedRenderables().peek() instanceof OrderedIcon)
 307                 {
 308                     OrderedIcon oi = (OrderedIcon) dc.getOrderedRenderables().poll();
 309                     IconRenderer.this.drawIcon(dc, oi);
 310                 }
 311             }
 312             catch (WWRuntimeException e)
 313             {
 314                 Logging.logger().log(Level.SEVERE, "generic.ExceptionWhileRenderingIcon", e);
 315             }
 316             catch (Exception e)
 317             {
 318                 Logging.logger().log(Level.SEVERE, "generic.ExceptionWhileRenderingIcon", e);
 319             }
 320             finally
 321             {
 322                 IconRenderer.this.endDrawIcons(dc);
 323             }
 324         }
 325
 326         public void pick(DrawContext dc, java.awt.Point pickPoint)
 327         {
 328             IconRenderer.this.pickSupport.clearPickList();
 329             IconRenderer.this.beginDrawIcons(dc);
 330             try
 331             {
 332                 IconRenderer.this.drawIcon(dc, this);
 333 //                // Draw as many as we can in a batch to save ogl state switching.
 334 //                while (dc.getOrderedRenderables().peek() instanceof OrderedIcon)
 335 //                {
 336 //                    IconRenderer.this.drawIcon(dc, (OrderedIcon) dc.getOrderedRenderables().poll());
 337 //                }
 338             }
 339             catch (WWRuntimeException e)
 340             {
 341                 Logging.logger().log(Level.SEVERE, "generic.ExceptionWhileRenderingIcon", e);
 342             }
 343             catch (Exception e)
 344             {
 345                 Logging.logger().log(Level.SEVERE, "generic.ExceptionWhilePickingIcon", e);
 346             }
 347             finally
 348             {
 349                 IconRenderer.this.endDrawIcons(dc);
 350                 IconRenderer.this.pickSupport.resolvePick(dc, pickPoint, layer);
 351                 IconRenderer.this.pickSupport.clearPickList(); // to ensure entries can be garbage collected
 352             }
 353         }
 354     }
 355
 356     private void beginDrawIcons(DrawContext dc)
 357     {
 358         GL gl = dc.getGL();
 359
 360         int attributeMask =
 361             GL.GL_DEPTH_BUFFER_BIT // for depth test, depth mask and depth func
 362                 | GL.GL_TRANSFORM_BIT // for modelview and perspective
 363                 | GL.GL_VIEWPORT_BIT // for depth range
 364                 | GL.GL_CURRENT_BIT // for current color
 365                 | GL.GL_COLOR_BUFFER_BIT // for alpha test func and ref, and blend
 366                 | GL.GL_TEXTURE_BIT // for texture env
 367                 | GL.GL_DEPTH_BUFFER_BIT // for depth func
 368                 | GL.GL_ENABLE_BIT; // for enable/disable changes
 369         gl.glPushAttrib(attributeMask);
 370
 371         // Apply the depth buffer but don't change it.
 372         gl.glEnable(GL.GL_DEPTH_TEST);
 373         gl.glDepthMask(false);
 374
 375         // Suppress any fully transparent image pixels
 376         gl.glEnable(GL.GL_ALPHA_TEST);
 377         gl.glAlphaFunc(GL.GL_GREATER, 0.001f);
 378
 379         // Load a parallel projection with dimensions (viewportWidth, viewportHeight)
 380         int[] viewport = new int[4];
 381         gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
 382         gl.glMatrixMode(GL.GL_PROJECTION);
 383         gl.glPushMatrix();
 384         gl.glLoadIdentity();
 385         gl.glOrtho(0d, viewport[2], 0d, viewport[3], -1d, 1d);
 386
 387         gl.glMatrixMode(GL.GL_MODELVIEW);
 388         gl.glPushMatrix();
 389
 390         gl.glMatrixMode(GL.GL_TEXTURE);
 391         gl.glPushMatrix();
 392
 393         if (dc.isPickingMode())
 394         {
 395             this.pickSupport.beginPicking(dc);
 396
 397             // Set up to replace the non-transparent texture colors with the single pick color.
 398             gl.glEnable(GL.GL_TEXTURE_2D);
 399             gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_COMBINE);
 400             gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_SRC0_RGB, GL.GL_PREVIOUS);
 401             gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_COMBINE_RGB, GL.GL_REPLACE);
 402         }
 403         else
 404         {
 405             gl.glEnable(GL.GL_TEXTURE_2D);
 406             gl.glEnable(GL.GL_BLEND);
 407             gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_ALPHA);
 408         }
 409     }
 410
 411     private void endDrawIcons(DrawContext dc)
 412     {
 413         if (dc.isPickingMode())
 414             this.pickSupport.endPicking(dc);
 415
 416         GL gl = dc.getGL();
 417         gl.glMatrixMode(GL.GL_PROJECTION);
 418         gl.glPopMatrix();
 419
 420         gl.glMatrixMode(GL.GL_MODELVIEW);
 421         gl.glPopMatrix();
 422
 423         gl.glMatrixMode(GL.GL_TEXTURE);
 424         gl.glPopMatrix();
 425
 426         gl.glPopAttrib();
 427     }
 428
 429     private Vec4 drawIcon(DrawContext dc, OrderedIcon uIcon)
 430     {
 431         if (uIcon.point == null)
 432         {
 433             String msg = Logging.getMessage("nullValue.PointIsNull");
 434             Logging.logger().severe(msg);
 435             return null;
 436         }
 437
 438         WWIcon icon = uIcon.icon;
 439
 440         final Vec4 screenPoint = dc.getView().project(uIcon.point);
 441         if (screenPoint == null)
 442             return null;
 443
 444         Texture iconTexture = dc.getTextureCache().get(icon.getImageSource());
 445         if (iconTexture == null)
 446             iconTexture = this.initializeTexture(dc, icon);
 447
 448         double pedestalScale;
 449         double pedestalSpacing;
 450         Texture pedestalTexture = null;
 451         if (pedestal != null)
 452         {
 453             pedestalScale = this.pedestal.getScale();
 454             pedestalSpacing = pedestal.getSpacingPixels();
 455
 456             pedestalTexture = dc.getTextureCache().get(pedestal.getPath());
 457             if (pedestalTexture == null)
 458                 pedestalTexture = this.initializeTexture(dc, pedestal);
 459         }
 460         else
 461         {
 462             pedestalScale = 0d;
 463             pedestalSpacing = 0d;
 464         }
 465
 466         javax.media.opengl.GL gl = dc.getGL();
 467
 468         this.setDepthFunc(dc, uIcon, screenPoint);
 469
 470         gl.glMatrixMode(GL.GL_MODELVIEW);
 471         gl.glLoadIdentity();
 472
 473         Dimension size = icon.getSize();
 474         double width = size != null ? size.getWidth() : iconTexture.getWidth();
 475         double height = size != null ? size.getHeight() : iconTexture.getHeight();
 476         gl.glTranslated(screenPoint.x - width / 2, screenPoint.y + (pedestalScale * height) + pedestalSpacing, 0d);
 477
 478         if (icon.isHighlighted())
 479         {
 480             double heightDelta = this.pedestal != null ? 0 : height / 2; // expand only above the pedestal
 481             gl.glTranslated(width / 2, heightDelta, 0);
 482             gl.glScaled(icon.getHighlightScale(), icon.getHighlightScale(), icon.getHighlightScale());
 483             gl.glTranslated(-width / 2, -heightDelta, 0);
 484         }
 485
 486         if (dc.isPickingMode())
 487         {
 488             java.awt.Color color = dc.getUniquePickColor();
 489             int colorCode = color.getRGB();
 490             this.pickSupport.addPickableObject(colorCode, icon, uIcon.getPosition(), false);
 491             gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());
 492         }
 493
 494         iconTexture.bind();
 495         TextureCoords texCoords = iconTexture.getImageTexCoords();
 496         gl.glScaled(width, height, 1d);
 497         dc.drawUnitQuad(texCoords);
 498
 499         if (pedestalTexture != null)
 500         {
 501             gl.glLoadIdentity();
 502             gl.glTranslated(screenPoint.x - (pedestalScale * (width / 2)), screenPoint.y, 0d);
 503             gl.glScaled(width * pedestalScale, height * pedestalScale, 1d);
 504
 505             pedestalTexture.bind();
 506             texCoords = pedestalTexture.getImageTexCoords();
 507             dc.drawUnitQuad(texCoords);
 508         }
 509
 510         return screenPoint;
 511     }
 512
 513     private void setDepthFunc(DrawContext dc, OrderedIcon uIcon, Vec4 screenPoint)
 514     {
 515         GL gl = dc.getGL();
 516
 517         if (uIcon.icon.isAlwaysOnTop())
 518         {
 519             gl.glDepthFunc(GL.GL_ALWAYS);
 520             return;
 521         }
 522
 523         Position eyePos = dc.getView().getEyePosition();
 524         if (eyePos == null)
 525         {
 526             gl.glDepthFunc(GL.GL_ALWAYS);
 527             return;
 528         }
 529
 530         double altitude = eyePos.getElevation();
 531         if (altitude < (dc.getGlobe().getMaxElevation() * dc.getVerticalExaggeration()))
 532         {
 533             double depth = screenPoint.z - (8d * 0.00048875809d);
 534             depth = depth < 0d ? 0d : (depth > 1d ? 1d : depth);
 535             gl.glDepthFunc(GL.GL_LESS);
 536             gl.glDepthRange(depth, depth);
 537         }
 538         else if (screenPoint.z >= 1d)
 539         {
 540             gl.glDepthFunc(GL.GL_EQUAL);
 541             gl.glDepthRange(1d, 1d);
 542         }
 543         else
 544         {
 545             gl.glDepthFunc(GL.GL_ALWAYS);
 546         }
 547     }
 548
 549     private Texture initializeTexture(DrawContext dc, WWIcon icon)
 550     {
 551         try
 552         {
 553             Texture iconTexture = null;
 554
 555             if (icon.getImageSource() instanceof String)
 556             {
 557                 String path = (String) icon.getImageSource();
 558                 java.io.InputStream iconStream = this.getClass().getResourceAsStream("/" + path);
 559                 if (iconStream == null)
 560                 {
 561                     java.io.File iconFile = new java.io.File(path);
 562                     if (iconFile.exists())
 563                     {
 564                         iconStream = new java.io.FileInputStream(iconFile);
 565                     }
 566                 }
 567                 iconTexture = TextureIO.newTexture(iconStream, true, null);
 568             }
 569             else if (icon.getImageSource() instanceof BufferedImage)
 570             {
 571                 iconTexture = TextureIO.newTexture((BufferedImage) icon.getImageSource(), true);
 572             }
 573             else
 574             {
 575                 // TODO: Log case of unknown image-source type.
 576             }
 577
 578             if (iconTexture == null)
 579             {
 580                 // TODO: Log case.
 581                 return null;
 582             }
 583
 584             // Icons with the same path are assumed to be identical textures, so key the texture id off the path.
 585             dc.getTextureCache().put(icon.getImageSource(), iconTexture);
 586             iconTexture.bind();
 587
 588             GL gl = dc.getGL();
 589             gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE);
 590             gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR);
 591             gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
 592             gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
 593             gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
 594
 595             return iconTexture;
 596         }
 597         catch (java.io.IOException e)
 598         {
 599             String msg = Logging.getMessage("generic.IOExceptionDuringTextureInitialization");
 600             Logging.logger().log(Level.SEVERE, msg, e);
 601             throw new WWRuntimeException(msg, e);
 602         }
 603     }
 604
 605     @Override
 606     public String toString()
 607     {
 608         return Logging.getMessage("layers.IconLayer.Name");
 609     }
 610 }