gov/nasa/worldwind/layers/TextureTile.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.layers;
   8
   9 import com.sun.opengl.util.texture.*;
  10 import gov.nasa.worldwind.WorldWind;
  11 import gov.nasa.worldwind.cache.TextureCache;
  12 import gov.nasa.worldwind.geom.*;
  13 import gov.nasa.worldwind.globes.Globe;
  14 import gov.nasa.worldwind.render.*;
  15 import gov.nasa.worldwind.util.*;
  16
  17 import javax.media.opengl.*;
  18
  19 /**
  20  * @author tag
  21  * @version $Id: TextureTile.java 2533 2007-08-13 05:59:08Z tgaskins $
  22  */
  23 public class TextureTile extends Tile implements SurfaceTile
  24 {
  25     private volatile TextureData textureData;
  26     private TextureTile fallbackTile = null; // holds texture to use if own texture not available
  27     private Vec4 centroid; // Cartesian coordinate of lat/lon center
  28     private Vec4[] corners; // Cartesian coordinate of lat/lon corners
  29     private Extent extent = null; // bounding volume
  30     private double extentVerticalExaggertion = Double.MIN_VALUE; // VE used to calculate the extent
  31     private double minDistanceToEye = Double.MAX_VALUE;
  32
  33     public TextureTile(Sector sector, TileKey tileKey)
  34     {
  35         super(sector, tileKey);
  36     }
  37
  38     public TextureTile(Sector sector, Level level, int row, int col)
  39     {
  40         super(sector, level, row, col);
  41     }
  42
  43     @Override
  44     public final long getSizeInBytes()
  45     {
  46         long size = super.getSizeInBytes();
  47
  48         if (this.textureData != null)
  49             size += this.textureData.getEstimatedMemorySize();
  50
  51         return size;
  52     }
  53
  54     public TextureTile getFallbackTile()
  55     {
  56         return this.fallbackTile;
  57     }
  58
  59     public void setFallbackTile(TextureTile fallbackTile)
  60     {
  61         this.fallbackTile = fallbackTile;
  62     }
  63
  64     public TextureData getTextureData()
  65     {
  66         return this.textureData;
  67     }
  68
  69     public void setTextureData(TextureData textureData)
  70     {
  71         this.textureData = textureData;
  72     }
  73
  74     public Texture getTexture(TextureCache tc)
  75     {
  76         if (tc == null)
  77         {
  78             String message = Logging.getMessage("nullValue.TextureCacheIsNull");
  79             Logging.logger().severe(message);
  80             throw new IllegalStateException(message);
  81         }
  82
  83         return tc.get(this.getTileKey());
  84     }
  85
  86     public boolean isTextureInMemory(TextureCache tc)
  87     {
  88         if (tc == null)
  89         {
  90             String message = Logging.getMessage("nullValue.TextureCacheIsNull");
  91             Logging.logger().severe(message);
  92             throw new IllegalStateException(message);
  93         }
  94
  95         return this.getTexture(tc) != null || this.getTextureData() != null;
  96     }
  97
  98     public void setTexture(TextureCache tc, Texture texture)
  99     {
 100         if (tc == null)
 101         {
 102             String message = Logging.getMessage("nullValue.TextureCacheIsNull");
 103             Logging.logger().severe(message);
 104             throw new IllegalStateException(message);
 105         }
 106
 107         tc.put(this.getTileKey(), texture);
 108
 109         // No more need for texture data; allow garbage collector and memory cache to reclaim it.
 110         this.textureData = null;
 111         this.updateMemoryCache();
 112     }
 113
 114     public Vec4 getCentroidPoint(Globe globe)
 115     {
 116         if (globe == null)
 117         {
 118             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 119             Logging.logger().severe(msg);
 120             throw new IllegalArgumentException(msg);
 121         }
 122
 123         if (this.centroid == null)
 124         {
 125             LatLon c = this.getSector().getCentroid();
 126             this.centroid = globe.computePointFromPosition(c.getLatitude(), c.getLongitude(), 0);
 127         }
 128
 129         return this.centroid;
 130     }
 131
 132     public Vec4[] getCornerPoints(Globe globe)
 133     {
 134         if (globe == null)
 135         {
 136             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 137             Logging.logger().severe(msg);
 138             throw new IllegalArgumentException(msg);
 139         }
 140
 141         if (this.corners == null)
 142         {
 143             Sector s = this.getSector();
 144             this.corners = new Vec4[4];
 145             this.corners[0] = globe.computePointFromPosition(s.getMinLatitude(), s.getMinLongitude(), 0); // sw
 146             this.corners[1] = globe.computePointFromPosition(s.getMinLatitude(), s.getMaxLongitude(), 0); // se
 147             this.corners[2] = globe.computePointFromPosition(s.getMaxLatitude(), s.getMaxLongitude(), 0); // nw
 148             this.corners[3] = globe.computePointFromPosition(s.getMaxLatitude(), s.getMinLongitude(), 0); // ne
 149         }
 150
 151         return this.corners;
 152     }
 153
 154     public double getWidth()
 155     {
 156         double sLow = this.corners[0].distanceTo3(this.corners[1]);
 157         double sHigh = this.corners[2].distanceTo3(this.corners[3]);
 158
 159         return sLow > sHigh ? sLow : sHigh;
 160     }
 161
 162     public double getHeight()
 163     {
 164         double tLow = this.corners[0].distanceTo3(this.corners[2]);
 165         double tHigh = this.corners[1].distanceTo3(this.corners[3]);
 166
 167         return tLow > tHigh ? tLow : tHigh;
 168     }
 169
 170     public double getMinDistanceToEye()
 171     {
 172         return this.minDistanceToEye;
 173     }
 174
 175     public void setMinDistanceToEye(double minDistanceToEye)
 176     {
 177         if (minDistanceToEye < 0)
 178         {
 179             String msg = Logging.getMessage("layers.TextureTile.MinDistanceToEyeNegative");
 180             Logging.logger().severe(msg);
 181             throw new IllegalArgumentException(msg);
 182         }
 183         this.minDistanceToEye = minDistanceToEye;
 184     }
 185
 186     public Extent getExtent(DrawContext dc)
 187     {
 188         if (dc == null)
 189         {
 190             String msg = Logging.getMessage("nullValue.DrawContextIsNull");
 191             Logging.logger().severe(msg);
 192             throw new IllegalArgumentException(msg);
 193         }
 194
 195         if (this.extent == null || this.extentVerticalExaggertion != dc.getVerticalExaggeration())
 196         {
 197             this.extent = Sector.computeBoundingCylinder(dc.getGlobe(), dc.getVerticalExaggeration(), this.getSector());
 198             this.extentVerticalExaggertion = dc.getVerticalExaggeration();
 199         }
 200
 201         return this.extent;
 202     }
 203
 204     public TextureTile[] createSubTiles(Level nextLevel)
 205     {
 206         if (nextLevel == null)
 207         {
 208             String msg = Logging.getMessage("nullValue.LevelIsNull");
 209             Logging.logger().severe(msg);
 210             throw new IllegalArgumentException(msg);
 211         }
 212         Angle p0 = this.getSector().getMinLatitude();
 213         Angle p2 = this.getSector().getMaxLatitude();
 214         Angle p1 = Angle.midAngle(p0, p2);
 215
 216         Angle t0 = this.getSector().getMinLongitude();
 217         Angle t2 = this.getSector().getMaxLongitude();
 218         Angle t1 = Angle.midAngle(t0, t2);
 219
 220         String nextLevelCacheName = nextLevel.getCacheName();
 221         int nextLevelNum = nextLevel.getLevelNumber();
 222         int row = this.getRow();
 223         int col = this.getColumn();
 224
 225         TextureTile[] subTiles = new TextureTile[4];
 226
 227         TileKey key = new TileKey(nextLevelNum, 2 * row, 2 * col, nextLevelCacheName);
 228         TextureTile subTile = this.getTileFromMemoryCache(key);
 229         if (subTile != null)
 230             subTiles[0] = subTile;
 231         else
 232             subTiles[0] = new TextureTile(new Sector(p0, p1, t0, t1), nextLevel, 2 * row, 2 * col);
 233
 234         key = new TileKey(nextLevelNum, 2 * row, 2 * col + 1, nextLevelCacheName);
 235         subTile = this.getTileFromMemoryCache(key);
 236         if (subTile != null)
 237             subTiles[1] = subTile;
 238         else
 239             subTiles[1] = new TextureTile(new Sector(p0, p1, t1, t2), nextLevel, 2 * row, 2 * col + 1);
 240
 241         key = new TileKey(nextLevelNum, 2 * row + 1, 2 * col, nextLevelCacheName);
 242         subTile = this.getTileFromMemoryCache(key);
 243         if (subTile != null)
 244             subTiles[2] = subTile;
 245         else
 246             subTiles[2] = new TextureTile(new Sector(p1, p2, t0, t1), nextLevel, 2 * row + 1, 2 * col);
 247
 248         key = new TileKey(nextLevelNum, 2 * row + 1, 2 * col + 1, nextLevelCacheName);
 249         subTile = this.getTileFromMemoryCache(key);
 250         if (subTile != null)
 251             subTiles[3] = subTile;
 252         else
 253             subTiles[3] = new TextureTile(new Sector(p1, p2, t1, t2), nextLevel, 2 * row + 1, 2 * col + 1);
 254
 255         return subTiles;
 256     }
 257
 258     private TextureTile getTileFromMemoryCache(TileKey tileKey)
 259     {
 260         return (TextureTile) WorldWind.getMemoryCache(TextureTile.class.getName()).getObject(tileKey);
 261     }
 262
 263     private void updateMemoryCache()
 264     {
 265         if (this.getTileFromMemoryCache(this.getTileKey()) != null)
 266             WorldWind.getMemoryCache(TextureTile.class.getName()).add(this.getTileKey(), this);
 267     }
 268
 269     public Texture initializeTexture(DrawContext dc)
 270     {
 271         if (dc == null)
 272         {
 273             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 274             Logging.logger().severe(message);
 275             throw new IllegalStateException(message);
 276         }
 277
 278         Texture t = this.getTexture(dc.getTextureCache());
 279         if (t != null)
 280             return t;
 281
 282         if (this.getTextureData() == null)
 283         {
 284             String msg = Logging.getMessage("nullValue.TextureDataIsNull");
 285             Logging.logger().severe(msg);
 286             throw new IllegalStateException(msg);
 287         }
 288
 289         try
 290         {
 291             t = TextureIO.newTexture(this.getTextureData());
 292         }
 293         catch (Exception e)
 294         {
 295             Logging.logger().log(
 296                 java.util.logging.Level.SEVERE, "layers.TextureLayer.ExceptionAttemptingToReadTextureFile", e);
 297             return null;
 298         }
 299
 300         this.setTexture(dc.getTextureCache(), t);
 301         t.bind();
 302
 303         GL gl = dc.getGL();
 304         gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
 305         gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
 306         gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
 307         gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
 308
 309         return t;
 310     }
 311
 312     public boolean bind(DrawContext dc)
 313     {
 314         if (dc == null)
 315         {
 316             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 317             Logging.logger().severe(message);
 318             throw new IllegalStateException(message);
 319         }
 320
 321         Texture t = this.getTexture(dc.getTextureCache());
 322         if (t == null && this.getTextureData() != null)
 323         {
 324             t = this.initializeTexture(dc);
 325             if (t != null)
 326                 return true; // texture was bound during initialization.
 327         }
 328
 329         if (t == null && this.getFallbackTile() != null)
 330         {
 331             TextureTile resourceTile = this.getFallbackTile();
 332             t = resourceTile.getTexture(dc.getTextureCache());
 333             if (t == null)
 334             {
 335                 t = resourceTile.initializeTexture(dc);
 336                 if (t != null)
 337                     return true; // texture was bound during initialization.
 338             }
 339         }
 340
 341         if (t != null)
 342             t.bind();
 343
 344         return t != null;
 345     }
 346
 347     public void applyInternalTransform(DrawContext dc)
 348     {
 349         if (dc == null)
 350         {
 351             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 352             Logging.logger().severe(message);
 353             throw new IllegalStateException(message);
 354         }
 355
 356         // Use the tile's texture if available.
 357         Texture t = this.getTexture(dc.getTextureCache());
 358         if (t == null && this.getTextureData() != null)
 359             t = this.initializeTexture(dc);
 360
 361         if (t != null)
 362         {
 363             if (t.getMustFlipVertically())
 364             {
 365                 GL gl = GLContext.getCurrent().getGL();
 366                 gl.glMatrixMode(GL.GL_TEXTURE);
 367                 gl.glLoadIdentity();
 368                 gl.glScaled(1, -1, 1);
 369                 gl.glTranslated(0, -1, 0);
 370             }
 371             return;
 372         }
 373
 374         // Use the tile's fallback texture if its primary texture is not available.
 375         TextureTile resourceTile = this.getFallbackTile();
 376         if (resourceTile == null) // no fallback specified
 377             return;
 378
 379         t = resourceTile.getTexture(dc.getTextureCache());
 380         if (t == null && resourceTile.getTextureData() != null)
 381             t = resourceTile.initializeTexture(dc);
 382
 383         if (t == null) // was not able to initialize the fallback texture
 384             return;
 385
 386         // Apply necessary transforms to the fallback texture.
 387         GL gl = GLContext.getCurrent().getGL();
 388         gl.glMatrixMode(GL.GL_TEXTURE);
 389         gl.glLoadIdentity();
 390
 391         if (t.getMustFlipVertically())
 392         {
 393             gl.glScaled(1, -1, 1);
 394             gl.glTranslated(0, -1, 0);
 395         }
 396
 397         this.applyResourceTextureTransform(dc);
 398     }
 399
 400     private void applyResourceTextureTransform(DrawContext dc)
 401     {
 402         if (dc == null)
 403         {
 404             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 405             Logging.logger().severe(message);
 406             throw new IllegalStateException(message);
 407         }
 408
 409         if (this.getLevel() == null)
 410             return;
 411
 412         int levelDelta = this.getLevelNumber() - this.getFallbackTile().getLevelNumber();
 413         if (levelDelta <= 0)
 414             return;
 415
 416         double twoToTheN = Math.pow(2, levelDelta);
 417         double oneOverTwoToTheN = 1 / twoToTheN;
 418
 419         double sShift = oneOverTwoToTheN * (this.getColumn() % twoToTheN);
 420         double tShift = oneOverTwoToTheN * (this.getRow() % twoToTheN);
 421
 422         dc.getGL().glTranslated(sShift, tShift, 0);
 423         dc.getGL().glScaled(oneOverTwoToTheN, oneOverTwoToTheN, 1);
 424     }
 425
 426     @Override
 427     public boolean equals(Object o)
 428     {
 429         if (this == o)
 430             return true;
 431         if (o == null || getClass() != o.getClass())
 432             return false;
 433
 434         final TextureTile tile = (TextureTile) o;
 435
 436         return !(this.getTileKey() != null ? !this.getTileKey().equals(tile.getTileKey()) : tile.getTileKey() != null);
 437     }
 438
 439     @Override
 440     public int hashCode()
 441     {
 442         return (this.getTileKey() != null ? this.getTileKey().hashCode() : 0);
 443     }
 444
 445     @Override
 446     public String toString()
 447     {
 448         return this.getSector().toString();
 449     }
 450 }