radiant/textures.cpp

   1 /*
   2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #include "textures.h"
  23
  24 #include "debugging/debugging.h"
  25 #include "warnings.h"
  26
  27 #include "itextures.h"
  28 #include "igl.h"
  29 #include "preferencesystem.h"
  30 #include "qgl.h"
  31
  32 #include "texturelib.h"
  33 #include "container/hashfunc.h"
  34 #include "container/cache.h"
  35 #include "generic/callback.h"
  36 #include "stringio.h"
  37
  38 #include "image.h"
  39 #include "texmanip.h"
  40 #include "preferences.h"
  41
  42
  43
  44 enum ETexturesMode
  45 {
  46   eTextures_NEAREST = 0,
  47   eTextures_NEAREST_MIPMAP_NEAREST = 1,
  48   eTextures_NEAREST_MIPMAP_LINEAR = 2,
  49   eTextures_LINEAR = 3,
  50   eTextures_LINEAR_MIPMAP_NEAREST = 4,
  51   eTextures_LINEAR_MIPMAP_LINEAR = 5,
  52   eTextures_MAX_ANISOTROPY = 6,
  53 };
  54
  55 enum TextureCompressionFormat
  56 {
  57   TEXTURECOMPRESSION_NONE = 0,
  58   TEXTURECOMPRESSION_RGBA = 1,
  59   TEXTURECOMPRESSION_RGBA_S3TC_DXT1 = 2,
  60   TEXTURECOMPRESSION_RGBA_S3TC_DXT3 = 3,
  61   TEXTURECOMPRESSION_RGBA_S3TC_DXT5 = 4,
  62 };
  63
  64 struct texture_globals_t
  65 {
  66   // RIANT
  67   // texture compression format
  68   TextureCompressionFormat m_nTextureCompressionFormat;
  69
  70   float fGamma;
  71
  72   bool bTextureCompressionSupported; // is texture compression supported by hardware?
  73   GLint texture_components;
  74
  75   // temporary values that should be initialised only once at run-time
  76   bool m_bOpenGLCompressionSupported;
  77   bool m_bS3CompressionSupported;
  78
  79   texture_globals_t(GLint components) :
  80     m_nTextureCompressionFormat(TEXTURECOMPRESSION_NONE),
  81     fGamma(1.0f),
  82     bTextureCompressionSupported(false),
  83     texture_components(components),
  84     m_bOpenGLCompressionSupported(false),
  85     m_bS3CompressionSupported(false)
  86   {
  87   }
  88 };
  89
  90 texture_globals_t g_texture_globals(GL_RGBA);
  91
  92 void SetTexParameters(ETexturesMode mode)
  93 {
  94   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
  95
  96   switch (mode)
  97   {
  98   case eTextures_NEAREST:
  99     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
 100     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 101     break;
 102   case eTextures_NEAREST_MIPMAP_NEAREST:
 103     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST );
 104     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 105     break;
 106   case eTextures_NEAREST_MIPMAP_LINEAR:
 107     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR );
 108     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
 109     break;
 110   case eTextures_LINEAR:
 111     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
 112     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 113     break;
 114   case eTextures_LINEAR_MIPMAP_NEAREST:
 115     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
 116     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 117     break;
 118   case eTextures_LINEAR_MIPMAP_LINEAR:
 119     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
 120     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 121     break;
 122   case eTextures_MAX_ANISOTROPY:
 123     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, QGL_maxTextureAnisotropy());
 124     break;
 125   default:
 126     globalOutputStream() << "invalid texture mode\n";
 127   }
 128 }
 129
 130 ETexturesMode g_texture_mode = eTextures_LINEAR_MIPMAP_LINEAR;
 131
 132
 133
 134
 135 byte g_gammatable[256];
 136 void ResampleGamma(float fGamma)
 137 {
 138   int i,inf;
 139   if (fGamma == 1.0)
 140   {
 141     for (i = 0; i < 256; i++)
 142       g_gammatable[i] = i;
 143   } else
 144   {
 145     for (i = 0; i < 256; i++)
 146     {
 147       inf = (int)(255 * pow ( static_cast<double>((i + 0.5) / 255.5) , static_cast<double>(fGamma) ) + 0.5);
 148       if (inf < 0)
 149         inf = 0;
 150       if (inf > 255)
 151         inf = 255;
 152       g_gammatable[i] = inf;
 153     }
 154   }
 155 }
 156
 157 inline const int& min_int(const int& left, const int& right)
 158 {
 159   return std::min(left, right);
 160 }
 161
 162 int max_tex_size = 0;
 163 const int max_texture_quality = 3;
 164 LatchedInt g_Textures_textureQuality(3, "Texture Quality");
 165
 166 /// \brief This function does the actual processing of raw RGBA data into a GL texture.
 167 /// It will also resample to power-of-two dimensions, generate the mipmaps and adjust gamma.
 168 void LoadTextureRGBA(qtexture_t* q, unsigned char* pPixels, int nWidth, int nHeight)
 169 {
 170   static float fGamma = -1;
 171   float total[3];
 172   byte  *outpixels = 0;
 173   int   nCount = nWidth * nHeight;
 174
 175   if (fGamma != g_texture_globals.fGamma)
 176   {
 177     fGamma = g_texture_globals.fGamma;
 178     ResampleGamma(fGamma);
 179   }
 180
 181   q->width = nWidth;
 182   q->height = nHeight;
 183
 184   total[0] = total[1] = total[2] = 0.0f;
 185
 186   // resample texture gamma according to user settings
 187   for (int i = 0; i < (nCount * 4); i += 4)
 188   {
 189     for (int j = 0; j < 3; j++)
 190     {
 191       total[j] += (pPixels + i)[j];
 192       byte b = (pPixels + i)[j];
 193       (pPixels + i)[j] = g_gammatable[b];
 194     }
 195   }
 196
 197   q->color[0] = total[0] / (nCount * 255);
 198   q->color[1] = total[1] / (nCount * 255);
 199   q->color[2] = total[2] / (nCount * 255);
 200
 201   glGenTextures (1, &q->texture_number);
 202
 203   glBindTexture( GL_TEXTURE_2D, q->texture_number );
 204
 205   SetTexParameters(g_texture_mode);
 206
 207   int gl_width = 1;
 208   while(gl_width < nWidth)
 209     gl_width <<= 1;
 210
 211   int gl_height = 1;
 212   while(gl_height < nHeight)
 213     gl_height <<= 1;
 214
 215   bool resampled = false;
 216   if (!(gl_width == nWidth && gl_height == nHeight))
 217   {
 218     resampled = true;
 219     outpixels = (byte *)malloc(gl_width * gl_height * 4);
 220     R_ResampleTexture(pPixels, nWidth, nHeight, outpixels, gl_width, gl_height, 4);
 221   }
 222   else
 223   {
 224     outpixels = pPixels;
 225   }
 226
 227   int quality_reduction = max_texture_quality - g_Textures_textureQuality.m_value;
 228   int target_width = min_int(gl_width >> quality_reduction, max_tex_size);
 229   int target_height = min_int(gl_height >> quality_reduction, max_tex_size);
 230
 231   while (gl_width > target_width || gl_height > target_height)
 232   {
 233     GL_MipReduce(outpixels, outpixels, gl_width, gl_height, target_width, target_height);
 234
 235     if (gl_width > target_width)
 236       gl_width >>= 1;
 237     if (gl_height > target_height)
 238       gl_height >>= 1;
 239   }
 240
 241   int mip = 0;
 242   glTexImage2D(GL_TEXTURE_2D, mip++, g_texture_globals.texture_components, gl_width, gl_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, outpixels);
 243   while (gl_width > 1 || gl_height > 1)
 244   {
 245     GL_MipReduce(outpixels, outpixels, gl_width, gl_height, 1, 1);
 246
 247     if (gl_width > 1)
 248       gl_width >>= 1;
 249     if (gl_height > 1)
 250       gl_height >>= 1;
 251
 252     glTexImage2D(GL_TEXTURE_2D, mip++, g_texture_globals.texture_components, gl_width, gl_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, outpixels);
 253   }
 254
 255   glBindTexture(GL_TEXTURE_2D, 0);
 256   if (resampled)
 257     free(outpixels);
 258 }
 259
 260 #if 0
 261 /*
 262 ==============
 263 Texture_InitPalette
 264 ==============
 265 */
 266 void Texture_InitPalette (byte *pal)
 267 {
 268   int   r,g,b;
 269   int   i;
 270   int   inf;
 271   byte  gammatable[256];
 272   float gamma;
 273
 274   gamma = g_texture_globals.fGamma;
 275
 276   if (gamma == 1.0)
 277   {
 278     for (i=0 ; i<256 ; i++)
 279       gammatable[i] = i;
 280   } else
 281   {
 282     for (i=0 ; i<256 ; i++)
 283     {
 284       inf = (int)(255 * pow ( (i+0.5)/255.5 , gamma ) + 0.5);
 285       if (inf < 0)
 286         inf = 0;
 287       if (inf > 255)
 288         inf = 255;
 289       gammatable[i] = inf;
 290     }
 291   }
 292
 293   for (i=0 ; i<256 ; i++)
 294   {
 295     r = gammatable[pal[0]];
 296     g = gammatable[pal[1]];
 297     b = gammatable[pal[2]];
 298     pal += 3;
 299
 300     //v = (r<<24) + (g<<16) + (b<<8) + 255;
 301     //v = BigLong (v);
 302
 303     //tex_palette[i] = v;
 304     tex_palette[i*3+0] = r;
 305     tex_palette[i*3+1] = g;
 306     tex_palette[i*3+2] = b;
 307   }
 308 }
 309 #endif
 310
 311 #if 0
 312 class TestHashtable
 313 {
 314 public:
 315   TestHashtable()
 316   {
 317     HashTable<CopiedString, CopiedString, HashStringNoCase, StringEqualNoCase> strings;
 318     strings["Monkey"] = "bleh";
 319     strings["MonkeY"] = "blah";
 320   }
 321 };
 322
 323 const TestHashtable g_testhashtable;
 324
 325 #endif
 326
 327 typedef std::pair<LoadImageCallback, CopiedString> TextureKey;
 328
 329 void qtexture_realise(qtexture_t& texture, const TextureKey& key)
 330 {
 331   texture.texture_number = 0;
 332   if(!string_empty(key.second.c_str()))
 333   {
 334     Image* image = key.first.loadImage(key.second.c_str());
 335     if(image != 0)
 336     {
 337       LoadTextureRGBA(&texture, image->getRGBAPixels(), image->getWidth(), image->getHeight());
 338       texture.surfaceFlags = image->getSurfaceFlags();
 339       texture.contentFlags = image->getContentFlags();
 340       texture.value = image->getValue();
 341       image->release();
 342       globalOutputStream() << "Loaded Texture: \"" << key.second.c_str() << "\"\n";
 343       GlobalOpenGL_debugAssertNoErrors();
 344     }
 345     else
 346     {
 347       globalErrorStream() << "Texture load failed: \"" << key.second.c_str() << "\"\n";
 348     }
 349   }
 350 }
 351
 352 void qtexture_unrealise(qtexture_t& texture)
 353 {
 354   if(GlobalOpenGL().contextValid && texture.texture_number != 0)
 355   {
 356     glDeleteTextures(1, &texture.texture_number);
 357     GlobalOpenGL_debugAssertNoErrors();
 358   }
 359 }
 360
 361 class TextureKeyEqualNoCase
 362 {
 363 public:
 364   bool operator()(const TextureKey& key, const TextureKey& other) const
 365   {
 366     return key.first == other.first && string_equal_nocase(key.second.c_str(), other.second.c_str());
 367   }
 368 };
 369
 370 class TextureKeyHashNoCase
 371 {
 372 public:
 373   typedef hash_t hash_type;
 374   hash_t operator()(const TextureKey& key) const
 375   {
 376     return hash_combine(string_hash_nocase(key.second.c_str()), pod_hash(key.first));
 377   }
 378 };
 379
 380 #define DEBUG_TEXTURES 0
 381
 382 class TexturesMap : public TexturesCache
 383 {
 384   class TextureConstructor
 385   {
 386     TexturesMap* m_cache;
 387   public:
 388     explicit TextureConstructor(TexturesMap* cache)
 389       : m_cache(cache)
 390     {
 391     }
 392     qtexture_t* construct(const TextureKey& key)
 393     {
 394       qtexture_t* texture = new qtexture_t(key.first, key.second.c_str());
 395       if(m_cache->realised())
 396       {
 397         qtexture_realise(*texture, key);
 398       }
 399       return texture;
 400     }
 401     void destroy(qtexture_t* texture)
 402     {
 403       if(m_cache->realised())
 404       {
 405         qtexture_unrealise(*texture);
 406       }
 407       delete texture;
 408     }
 409   };
 410
 411   typedef HashedCache<TextureKey, qtexture_t, TextureKeyHashNoCase, TextureKeyEqualNoCase, TextureConstructor> qtextures_t;
 412   qtextures_t m_qtextures;
 413   TexturesCacheObserver* m_observer;
 414   std::size_t m_unrealised;
 415
 416 public:
 417   TexturesMap() : m_qtextures(TextureConstructor(this)), m_observer(0), m_unrealised(1)
 418   {
 419   }
 420   typedef qtextures_t::iterator iterator;
 421
 422   iterator begin()
 423   {
 424     return m_qtextures.begin();
 425   }
 426   iterator end()
 427   {
 428     return m_qtextures.end();
 429   }
 430
 431   LoadImageCallback defaultLoader() const
 432   {
 433     return LoadImageCallback(0, QERApp_LoadImage);
 434   }
 435   Image* loadImage(const char* name)
 436   {
 437     return defaultLoader().loadImage(name);
 438   }
 439   qtexture_t* capture(const char* name)
 440   {
 441     return capture(defaultLoader(), name);
 442   }
 443   qtexture_t* capture(const LoadImageCallback& loader, const char* name)
 444   {
 445 #if DEBUG_TEXTURES
 446     globalOutputStream() << "textures capture: " << makeQuoted(name) << '\n';
 447 #endif
 448     return m_qtextures.capture(TextureKey(loader, name)).get();
 449   }
 450   void release(qtexture_t* texture)
 451   {
 452 #if DEBUG_TEXTURES
 453     globalOutputStream() << "textures release: " << makeQuoted(texture->name) << '\n';
 454 #endif
 455     m_qtextures.release(TextureKey(texture->load, texture->name));
 456   }
 457   void attach(TexturesCacheObserver& observer)
 458   {
 459     ASSERT_MESSAGE(m_observer == 0, "TexturesMap::attach: cannot attach observer");
 460     m_observer = &observer;
 461   }
 462   void detach(TexturesCacheObserver& observer)
 463   {
 464     ASSERT_MESSAGE(m_observer == &observer, "TexturesMap::detach: cannot detach observer");
 465     m_observer = 0;
 466   }
 467   void realise()
 468   {
 469     if(--m_unrealised == 0)
 470     {
 471       g_texture_globals.bTextureCompressionSupported = false;
 472
 473       if(GlobalOpenGL().ARB_texture_compression())
 474       {
 475         g_texture_globals.bTextureCompressionSupported = true;
 476         g_texture_globals.m_bOpenGLCompressionSupported = true;
 477       }
 478
 479       if(GlobalOpenGL().EXT_texture_compression_s3tc())
 480       {
 481         g_texture_globals.bTextureCompressionSupported = true;
 482         g_texture_globals.m_bS3CompressionSupported = true;
 483       }
 484
 485       glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_tex_size);
 486       if(max_tex_size == 0)
 487       {
 488         max_tex_size = 1024;
 489       }
 490
 491       for(qtextures_t::iterator i = m_qtextures.begin(); i != m_qtextures.end(); ++i)
 492       {
 493         if(!(*i).value.empty())
 494         {
 495           qtexture_realise(*(*i).value, (*i).key);
 496         }
 497       }
 498       if(m_observer != 0)
 499       {
 500         m_observer->realise();
 501       }
 502     }
 503   }
 504   void unrealise()
 505   {
 506     if(++m_unrealised == 1)
 507     {
 508       if(m_observer != 0)
 509       {
 510         m_observer->unrealise();
 511       }
 512       for(qtextures_t::iterator i = m_qtextures.begin(); i != m_qtextures.end(); ++i)
 513       {
 514         if(!(*i).value.empty())
 515         {
 516           qtexture_unrealise(*(*i).value);
 517         }
 518       }
 519     }
 520   }
 521   bool realised()
 522   {
 523     return m_unrealised == 0;
 524   }
 525 };
 526
 527 TexturesMap* g_texturesmap;
 528
 529 TexturesCache& GetTexturesCache()
 530 {
 531   return *g_texturesmap;
 532 }
 533
 534
 535 void Textures_Realise()
 536 {
 537   g_texturesmap->realise();
 538 }
 539
 540 void Textures_Unrealise()
 541 {
 542   g_texturesmap->unrealise();
 543 }
 544
 545
 546 Callback g_texturesModeChangedNotify;
 547
 548 void Textures_setModeChangedNotify(const Callback& notify)
 549 {
 550   g_texturesModeChangedNotify = notify;
 551 }
 552
 553 void Textures_ModeChanged()
 554 {
 555   if(g_texturesmap->realised())
 556   {
 557     SetTexParameters(g_texture_mode);
 558
 559     for(TexturesMap::iterator i = g_texturesmap->begin(); i != g_texturesmap->end(); ++i)
 560     {
 561       glBindTexture (GL_TEXTURE_2D, (*i).value->texture_number);
 562       SetTexParameters(g_texture_mode);
 563     }
 564
 565     glBindTexture( GL_TEXTURE_2D, 0 );
 566   }
 567   g_texturesModeChangedNotify();
 568 }
 569
 570 void Textures_SetMode(ETexturesMode mode)
 571 {
 572   if(g_texture_mode != mode)
 573   {
 574     g_texture_mode = mode;
 575
 576     Textures_ModeChanged();
 577   }
 578 }
 579
 580 void Textures_setTextureComponents(GLint texture_components)
 581 {
 582   if(g_texture_globals.texture_components != texture_components)
 583   {
 584     Textures_Unrealise();
 585     g_texture_globals.texture_components = texture_components;
 586     Textures_Realise();
 587   }
 588 }
 589
 590 void Textures_UpdateTextureCompressionFormat()
 591 {
 592   GLint texture_components = GL_RGBA;
 593
 594         if(!g_texturesmap->realised())
 595         {
 596                 texture_components = g_texture_globals.m_nTextureCompressionFormat;
 597         }
 598         else
 599         {
 600                 if (g_texture_globals.bTextureCompressionSupported)
 601                 {
 602                         if(g_texture_globals.m_nTextureCompressionFormat != TEXTURECOMPRESSION_NONE
 603                                 && g_texture_globals.m_nTextureCompressionFormat != TEXTURECOMPRESSION_RGBA
 604                                 && !g_texture_globals.m_bS3CompressionSupported)
 605                         {
 606                                 globalOutputStream() << "OpenGL extension GL_EXT_texture_compression_s3tc not supported by current graphics drivers\n";
 607                                 g_texture_globals.m_nTextureCompressionFormat = TEXTURECOMPRESSION_RGBA; // if this is not supported either, see below
 608                         }
 609                         if (g_texture_globals.m_nTextureCompressionFormat == TEXTURECOMPRESSION_RGBA && !g_texture_globals.m_bOpenGLCompressionSupported)
 610                         {
 611                                 globalOutputStream() << "OpenGL extension GL_ARB_texture_compression not supported by current graphics drivers\n";
 612                                 g_texture_globals.m_nTextureCompressionFormat = TEXTURECOMPRESSION_NONE;
 613                         }
 614
 615                         switch (g_texture_globals.m_nTextureCompressionFormat)
 616                         {
 617                         case (TEXTURECOMPRESSION_NONE):
 618                                 {
 619                                         texture_components = GL_RGBA;
 620                                         break;
 621                                 }
 622                         case (TEXTURECOMPRESSION_RGBA):
 623                                 {
 624                                         texture_components = GL_COMPRESSED_RGBA_ARB;
 625                                         break;
 626                                 }
 627                         case (TEXTURECOMPRESSION_RGBA_S3TC_DXT1):
 628                                 {
 629                                         texture_components = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
 630                                         break;
 631                                 }
 632                         case (TEXTURECOMPRESSION_RGBA_S3TC_DXT3):
 633                                 {
 634                                         texture_components = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
 635                                         break;
 636                                 }
 637                         case (TEXTURECOMPRESSION_RGBA_S3TC_DXT5):
 638                                 {
 639                                         texture_components = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
 640                                         break;
 641                                 }
 642                         }
 643                 }
 644                 else
 645                 {
 646                         texture_components = GL_RGBA;
 647                         g_texture_globals.m_nTextureCompressionFormat = TEXTURECOMPRESSION_NONE;
 648                 }
 649         }
 650
 651   Textures_setTextureComponents(texture_components);
 652 }
 653
 654 void TextureCompressionImport(TextureCompressionFormat& self, int value)
 655 {
 656   if(!g_texture_globals.m_bOpenGLCompressionSupported
 657     && g_texture_globals.m_bS3CompressionSupported
 658     && value >= 1)
 659   {
 660     ++value;
 661   }
 662   switch(value)
 663   {
 664   case 0:
 665     self = TEXTURECOMPRESSION_NONE;
 666     break;
 667   case 1:
 668     self = TEXTURECOMPRESSION_RGBA;
 669     break;
 670   case 2:
 671     self = TEXTURECOMPRESSION_RGBA_S3TC_DXT1;
 672     break;
 673   case 3:
 674     self = TEXTURECOMPRESSION_RGBA_S3TC_DXT3;
 675     break;
 676   case 4:
 677     self = TEXTURECOMPRESSION_RGBA_S3TC_DXT5;
 678     break;
 679   }
 680   Textures_UpdateTextureCompressionFormat();
 681 }
 682 typedef ReferenceCaller1<TextureCompressionFormat, int, TextureCompressionImport> TextureCompressionImportCaller;
 683
 684 void TextureGammaImport(float& self, float value)
 685 {
 686   if(self != value)
 687   {
 688     Textures_Unrealise();
 689     self = value;
 690     Textures_Realise();
 691   }
 692 }
 693 typedef ReferenceCaller1<float, float, TextureGammaImport> TextureGammaImportCaller;
 694
 695 void TextureModeImport(ETexturesMode& self, int value)
 696 {
 697   switch(value)
 698   {
 699   case 0:
 700     Textures_SetMode(eTextures_NEAREST);
 701     break;
 702   case 1:
 703     Textures_SetMode(eTextures_NEAREST_MIPMAP_NEAREST);
 704     break;
 705   case 2:
 706     Textures_SetMode(eTextures_LINEAR);
 707     break;
 708   case 3:
 709     Textures_SetMode(eTextures_NEAREST_MIPMAP_LINEAR);
 710     break;
 711   case 4:
 712     Textures_SetMode(eTextures_LINEAR_MIPMAP_NEAREST);
 713     break;
 714   case 5:
 715     Textures_SetMode(eTextures_LINEAR_MIPMAP_LINEAR);
 716     break;
 717   case 6:
 718     Textures_SetMode(eTextures_MAX_ANISOTROPY);
 719   }
 720 }
 721 typedef ReferenceCaller1<ETexturesMode, int, TextureModeImport> TextureModeImportCaller;
 722
 723 void TextureModeExport(ETexturesMode& self, const IntImportCallback& importer)
 724 {
 725   switch(self)
 726   {
 727   case eTextures_NEAREST:
 728     importer(0);
 729     break;
 730   case eTextures_NEAREST_MIPMAP_NEAREST:
 731     importer(1);
 732     break;
 733   case eTextures_LINEAR:
 734     importer(2);
 735     break;
 736   case eTextures_NEAREST_MIPMAP_LINEAR:
 737     importer(3);
 738     break;
 739   case eTextures_LINEAR_MIPMAP_NEAREST:
 740     importer(4);
 741     break;
 742   case eTextures_LINEAR_MIPMAP_LINEAR:
 743     importer(5);
 744     break;
 745   case eTextures_MAX_ANISOTROPY:
 746     importer(6);
 747     break;
 748   default:
 749     importer(4);
 750   }
 751 }
 752 typedef ReferenceCaller1<ETexturesMode, const IntImportCallback&, TextureModeExport> TextureModeExportCaller;
 753
 754 void Textures_constructPreferences(PreferencesPage& page)
 755 {
 756   {
 757     const char* percentages[] = { "12.5%", "25%", "50%", "100%", };
 758     page.appendRadio(
 759       "Texture Quality",
 760       STRING_ARRAY_RANGE(percentages),
 761       LatchedIntImportCaller(g_Textures_textureQuality),
 762       IntExportCaller(g_Textures_textureQuality.m_latched)
 763     );
 764   }
 765   page.appendSpinner(
 766     "Texture Gamma",
 767     1.0,
 768     0.0,
 769     1.0,
 770     FloatImportCallback(TextureGammaImportCaller(g_texture_globals.fGamma)),
 771     FloatExportCallback(FloatExportCaller(g_texture_globals.fGamma))
 772   );
 773   {
 774     const char* texture_mode[] = { "Nearest", "Nearest Mipmap", "Linear", "Bilinear", "Bilinear Mipmap", "Trilinear", "Anisotropy" };
 775     page.appendCombo(
 776       "Texture Render Mode",
 777       STRING_ARRAY_RANGE(texture_mode),
 778       IntImportCallback(TextureModeImportCaller(g_texture_mode)),
 779       IntExportCallback(TextureModeExportCaller(g_texture_mode))
 780     );
 781   }
 782   {
 783     const char* compression_none[] = { "None" };
 784     const char* compression_opengl[] = { "None", "OpenGL ARB" };
 785     const char* compression_s3tc[] = { "None", "S3TC DXT1", "S3TC DXT3", "S3TC DXT5" };
 786     const char* compression_opengl_s3tc[] = { "None", "OpenGL ARB", "S3TC DXT1", "S3TC DXT3", "S3TC DXT5" };
 787     StringArrayRange compression(
 788       (g_texture_globals.m_bOpenGLCompressionSupported)
 789         ? (g_texture_globals.m_bS3CompressionSupported)
 790           ? STRING_ARRAY_RANGE(compression_opengl_s3tc)
 791           : STRING_ARRAY_RANGE(compression_opengl)
 792         : (g_texture_globals.m_bS3CompressionSupported)
 793           ? STRING_ARRAY_RANGE(compression_s3tc)
 794           : STRING_ARRAY_RANGE(compression_none)
 795     );
 796     page.appendCombo(
 797       "Hardware Texture Compression",
 798       compression,
 799       TextureCompressionImportCaller(g_texture_globals.m_nTextureCompressionFormat),
 800       IntExportCaller(reinterpret_cast<int&>(g_texture_globals.m_nTextureCompressionFormat))
 801     );
 802   }
 803 }
 804 void Textures_constructPage(PreferenceGroup& group)
 805 {
 806   PreferencesPage page(group.createPage("Textures", "Texture Settings"));
 807   Textures_constructPreferences(page);
 808 }
 809 void Textures_registerPreferencesPage()
 810 {
 811   PreferencesDialog_addDisplayPage(FreeCaller1<PreferenceGroup&, Textures_constructPage>());
 812 }
 813
 814 void TextureCompression_importString(const char* string)
 815 {
 816   g_texture_globals.m_nTextureCompressionFormat = static_cast<TextureCompressionFormat>(atoi(string));
 817   Textures_UpdateTextureCompressionFormat();
 818 }
 819 typedef FreeCaller1<const char*, TextureCompression_importString> TextureCompressionImportStringCaller;
 820
 821
 822 void Textures_Construct()
 823 {
 824   g_texturesmap = new TexturesMap;
 825
 826   GlobalPreferenceSystem().registerPreference("TextureCompressionFormat", TextureCompressionImportStringCaller(), IntExportStringCaller(reinterpret_cast<int&>(g_texture_globals.m_nTextureCompressionFormat)));
 827   GlobalPreferenceSystem().registerPreference("TextureFiltering", IntImportStringCaller(reinterpret_cast<int&>(g_texture_mode)), IntExportStringCaller(reinterpret_cast<int&>(g_texture_mode)));
 828   GlobalPreferenceSystem().registerPreference("TextureQuality", IntImportStringCaller(g_Textures_textureQuality.m_latched), IntExportStringCaller(g_Textures_textureQuality.m_latched));
 829   GlobalPreferenceSystem().registerPreference("SI_Gamma", FloatImportStringCaller(g_texture_globals.fGamma), FloatExportStringCaller(g_texture_globals.fGamma));
 830
 831   g_Textures_textureQuality.useLatched();
 832
 833   Textures_registerPreferencesPage();
 834
 835   Textures_ModeChanged();
 836 }
 837 void Textures_Destroy()
 838 {
 839   delete g_texturesmap;
 840 }
 841
 842
 843 #include "modulesystem/modulesmap.h"
 844 #include "modulesystem/singletonmodule.h"
 845 #include "modulesystem/moduleregistry.h"
 846
 847 class TexturesDependencies :
 848   public GlobalRadiantModuleRef,
 849   public GlobalOpenGLModuleRef,
 850   public GlobalPreferenceSystemModuleRef
 851 {
 852   ImageModulesRef m_image_modules;
 853 public:
 854   TexturesDependencies() :
 855     m_image_modules(GlobalRadiant().getRequiredGameDescriptionKeyValue("texturetypes"))
 856   {
 857   }
 858   ImageModules& getImageModules()
 859   {
 860     return m_image_modules.get();
 861   }
 862 };
 863
 864 class TexturesAPI
 865 {
 866   TexturesCache* m_textures;
 867 public:
 868   typedef TexturesCache Type;
 869   STRING_CONSTANT(Name, "*");
 870
 871   TexturesAPI()
 872   {
 873     Textures_Construct();
 874
 875     m_textures = &GetTexturesCache();
 876   }
 877   ~TexturesAPI()
 878   {
 879     Textures_Destroy();
 880   }
 881   TexturesCache* getTable()
 882   {
 883     return m_textures;
 884   }
 885 };
 886
 887 typedef SingletonModule<TexturesAPI, TexturesDependencies> TexturesModule;
 888 typedef Static<TexturesModule> StaticTexturesModule;
 889 StaticRegisterModule staticRegisterTextures(StaticTexturesModule::instance());
 890
 891 ImageModules& Textures_getImageModules()
 892 {
 893   return StaticTexturesModule::instance().getDependencies().getImageModules();
 894 }
 895
 896
 897