nel/src/3d/async_texture_manager.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program 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 Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/async_texture_manager.h"
  23 #include "nel/3d/async_file_manager_3d.h"
  24 #include "nel/3d/mesh_base_instance.h"
  25 #include "nel/3d/driver.h"
  26
  27
  28 using   namespace std;
  29 using   namespace NLMISC;
  30
  31 #ifdef DEBUG_NEW
  32 #define new DEBUG_NEW
  33 #endif
  34
  35 namespace NL3D
  36 {
  37
  38 // ***************************************************************************
  39 #define NL3D_ATM_MIN_DISTANCE           1.0f
  40
  41 // ***************************************************************************
  42 CAsyncTextureManager::CTextureEntry::CTextureEntry()
  43 {
  44         IsTextureEntry= true;
  45
  46         Loaded= false;
  47         UpLoaded= false;
  48         CanHaveLOD= false;
  49         BuildFromHLSManager= false;
  50         HLSManagerTextId= -1;
  51         BaseSize= 0;
  52         TotalTextureSizeAsked= 0;
  53 }
  54
  55
  56 // ***************************************************************************
  57 void            CAsyncTextureManager::CTextureEntry::createCoarseBitmap()
  58 {
  59         // the texture must exist.
  60         nlassert(Texture);
  61         nlassert(Texture->getSize()>0);
  62
  63         // copy the bitmap.
  64         CoarseBitmap= *Texture;
  65         // remove all mipmaps, and convert to DXTC1 (if possible, ie if was DXTC5 or DXTC3 as example)
  66         CoarseBitmap.releaseMipMaps();
  67         // TODODO: conversion to DXTC1
  68         CoarseBitmap.convertToType(CBitmap::DXTC1);
  69 }
  70
  71
  72 // ***************************************************************************
  73 CAsyncTextureManager::CTextureLod::CTextureLod()
  74 {
  75         IsTextureEntry= false;
  76
  77         TextureEntry= NULL;
  78         Weight= 0;
  79         Level= 0;
  80         Loaded= false;
  81         UpLoaded= false;
  82         ExtraSize= 0;
  83 }
  84
  85
  86 // ***************************************************************************
  87 CAsyncTextureManager::~CAsyncTextureManager()
  88 {
  89         // For all remaining textures, delete them.
  90         for(uint i=0;i<_TextureEntries.size();i++)
  91         {
  92                 if(_TextureEntries[i])
  93                         deleteTexture(i);
  94         }
  95
  96         // there must be no waitting textures, nor map, nor current upload texture
  97         nlassert(_WaitingTextures.empty() && _TextureEntryMap.empty() && _CurrentUploadTexture==NULL
  98                 && _CurrentTextureLodLoaded==NULL);
  99 }
 100
 101 // ***************************************************************************
 102 CAsyncTextureManager::CAsyncTextureManager()
 103 {
 104         _BaseLodLevel= 3;
 105         _MaxLodLevel= 1;
 106         _MaxUploadPerFrame= 65536;
 107         _MaxHLSColoringPerFrame= 20*1024;
 108         _CurrentUploadTexture= NULL;
 109         _MaxTotalTextureSize= 10*1024*1024;
 110         _TotalTextureSizeAsked= 0;
 111         _LastTextureSizeGot= 0;
 112
 113         // Do not share this texture, to force uploading of the lods.
 114         _CurrentTextureLodLoaded= NULL;
 115
 116         // For Texture profiling
 117         _TextureCategory= new ITexture::CTextureCategory("ASYNC ENTITY MANAGER");
 118 }
 119
 120
 121 // ***************************************************************************
 122 void                    CAsyncTextureManager::setupLod(uint baseLevel, uint maxLevel)
 123 {
 124         nlassert(baseLevel>=maxLevel);
 125         _BaseLodLevel= baseLevel;
 126         _MaxLodLevel= maxLevel;
 127 }
 128
 129
 130 // ***************************************************************************
 131 void                    CAsyncTextureManager::setupMaxUploadPerFrame(uint maxup)
 132 {
 133         if(maxup>0)
 134                 _MaxUploadPerFrame= maxup;
 135 }
 136
 137 // ***************************************************************************
 138 void                    CAsyncTextureManager::setupMaxHLSColoringPerFrame(uint maxCol)
 139 {
 140         if(maxCol>0)
 141                 _MaxHLSColoringPerFrame= maxCol;
 142 }
 143
 144 // ***************************************************************************
 145 void                    CAsyncTextureManager::setupMaxTotalTextureSize(uint maxText)
 146 {
 147         _MaxTotalTextureSize= maxText;
 148 }
 149
 150
 151 // ***************************************************************************
 152 uint                    CAsyncTextureManager::addTextureRef(const string &textNameNotLwr, CMeshBaseInstance *instance, const NLMISC::CVector &position)
 153 {
 154         uint    ret;
 155
 156         // lower case name
 157         string  textName = toLowerAscii(textNameNotLwr);
 158
 159         // find the texture in map
 160         ItTextureEntryMap       it;
 161         it= _TextureEntryMap.find(textName);
 162
 163         // not found, create.
 164         if(it==_TextureEntryMap.end())
 165         {
 166                 // search a free id.
 167                 uint    i= (uint)_TextureEntries.size();
 168                 if(!_FreeTextureIds.empty())
 169                 {
 170                         i= _FreeTextureIds.back();
 171                         _FreeTextureIds.pop_back();
 172                 }
 173                 // resize if needed.
 174                 if(i>=_TextureEntries.size())
 175                 {
 176                         _TextureEntries.push_back(NULL);
 177                         _FreeTextureIds.reserve(_TextureEntries.capacity());
 178                 }
 179
 180                 // alloc new.
 181                 CTextureEntry   *text= new CTextureEntry();
 182                 _TextureEntries[i]= text;
 183                 text->Texture= new CTextureFile;
 184                 // Do not allow degradation.
 185                 text->Texture->setAllowDegradation(false);
 186                 // For Profiling
 187                 text->Texture->setTextureCategory(_TextureCategory);
 188
 189                 // add to map.
 190                 it= _TextureEntryMap.insert(make_pair(textName, i)).first;
 191                 // bkup the it for deletion
 192                 text->ItMap= it;
 193
 194                 // Start Color or Async loading.
 195                 text->Texture->setFileName(textName);
 196                 // First try with the HLSManager
 197                 sint    colorTextId= HLSManager.findTexture(textName);
 198                 // If found
 199                 if(colorTextId!=-1)
 200                 {
 201                         // Mark the texture as Loaded, and ready to colorize (done in update()).
 202                         text->Loaded= true;
 203                         text->BuildFromHLSManager= true;
 204                         text->HLSManagerTextId= colorTextId;
 205                 }
 206                 // else must async load it.
 207                 else
 208                 {
 209                         // start to load a small DDS version if possible
 210                         text->Texture->setMipMapSkipAtLoad(_BaseLodLevel);
 211                         // load it async.
 212                         CAsyncFileManager3D::getInstance().loadTexture(text->Texture, &text->Loaded, position);
 213                 }
 214                 // Add to a list so we can check each frame if it has ended.
 215                 _WaitingTextures.push_back(i);
 216         }
 217
 218         // get the id of the text entry.
 219         ret= it->second;
 220
 221         // add this instance to the list of ones which use this texture.
 222         CTextureEntry   *text= _TextureEntries[ret];
 223         text->Instances.push_back(instance);
 224
 225         // if the texture is not yet ready, must increment the instance refCount.
 226         if(!text->UpLoaded)
 227                 instance->_AsyncTextureToLoadRefCount++;
 228
 229         return ret;
 230 }
 231
 232
 233 // ***************************************************************************
 234 void                    CAsyncTextureManager::deleteTexture(uint id)
 235 {
 236         CTextureEntry   *text= _TextureEntries[id];
 237
 238
 239         // **** Stop AsyncLoading/UpLoading of main texture.
 240
 241         // stop async loading if not ended
 242         if(!text->Loaded)
 243         {
 244                 CAsyncFileManager3D::getInstance().cancelLoadTexture(text->Texture);
 245         }
 246
 247         // remove map entry
 248         _TextureEntryMap.erase(text->ItMap);
 249
 250         // remove in list of waiting textures
 251         vector<uint>::iterator  itWait= find(_WaitingTextures.begin(),_WaitingTextures.end(), id);
 252         if(itWait!=_WaitingTextures.end())
 253                 _WaitingTextures.erase(itWait);
 254
 255         // If it was the currently uploaded one, abort
 256         if(_CurrentUploadTexture==text)
 257         {
 258                 _CurrentUploadTexture= NULL;
 259         }
 260
 261         // If not uploaded.
 262         if(!text->UpLoaded)
 263         {
 264                 // For all its remainding instances, dec refcount
 265                 for(uint i=0;i<text->Instances.size();i++)
 266                 {
 267                         text->Instances[i]->_AsyncTextureToLoadRefCount--;
 268                 }
 269         }
 270
 271         // remove from bench
 272         _TotalTextureSizeAsked-= text->TotalTextureSizeAsked;
 273
 274
 275         // **** Stop AsyncLoading/UpLoading of HDLod 's texture.
 276
 277         // Check if must stop TextureLod loading/uploading.
 278         CTextureLod             *textLod= &text->HDLod;
 279         if(textLod==_CurrentTextureLodLoaded)
 280         {
 281                 // stop the async loading if not ended.
 282                 if(!textLod->Loaded)
 283                 {
 284                         CAsyncFileManager3D::getInstance().cancelLoadTexture(textLod->Texture);
 285                 }
 286                 // stop uploading if was me
 287                 if(_CurrentUploadTexture==textLod)
 288                 {
 289                         _CurrentUploadTexture= NULL;
 290                 }
 291                 // stop loading me.
 292                 _CurrentTextureLodLoaded= NULL;
 293         }
 294
 295         // At last delete texture entry.
 296         delete text;
 297         _TextureEntries[id]= NULL;
 298         // add a new free id.
 299         _FreeTextureIds.push_back(id);
 300 }
 301
 302
 303 // ***************************************************************************
 304 void                    CAsyncTextureManager::releaseTexture(uint id, CMeshBaseInstance *instance)
 305 {
 306         nlassert(id<_TextureEntries.size());
 307         nlassert(_TextureEntries[id]);
 308
 309         // find an instance in this texture an remove it.
 310         CTextureEntry   *text= _TextureEntries[id];
 311         uint                    instSize= (uint)text->Instances.size();
 312         for(uint i=0;i<instSize;i++)
 313         {
 314                 if(text->Instances[i]== instance)
 315                 {
 316                         // Must first release the refCount if the texture is not uploaded
 317                         if(!text->UpLoaded)
 318                                 text->Instances[i]->_AsyncTextureToLoadRefCount--;
 319                         // remove it by swapping with last texture
 320                         text->Instances[i]= text->Instances[instSize-1];
 321                         text->Instances.pop_back();
 322                         // must stop: remove only the first occurence of instance.
 323                         break;
 324                 }
 325         }
 326
 327         // if no more instance occurence, the texture is no more used => release it.
 328         if(text->Instances.empty())
 329         {
 330                 // do all the good stuff
 331                 deleteTexture(id);
 332         }
 333 }
 334
 335 // ***************************************************************************
 336 bool                    CAsyncTextureManager::isTextureUpLoaded(uint id) const
 337 {
 338         nlassert(id<_TextureEntries.size());
 339         nlassert(_TextureEntries[id]);
 340         return _TextureEntries[id]->UpLoaded;
 341 }
 342
 343
 344 // ***************************************************************************
 345 const NLMISC::CBitmap   *CAsyncTextureManager::getCoarseBitmap(uint id) const
 346 {
 347         if(id>=_TextureEntries.size())
 348                 return NULL;
 349         CTextureEntry   *textEntry= _TextureEntries[id];
 350         if(!textEntry)
 351                 return NULL;
 352
 353         // if the textEntry not uploaded, return NULL
 354         if(!textEntry->UpLoaded)
 355                 return NULL;
 356
 357         // ok return the CoarseBitmap
 358         return &textEntry->CoarseBitmap;
 359 }
 360
 361
 362 // ***************************************************************************
 363 void                    CAsyncTextureManager::update(IDriver *pDriver)
 364 {
 365         uint    nTotalUploaded = 0;
 366         uint    nTotalColored = 0;
 367
 368         // if no texture to upload, get the next one
 369         if(_CurrentUploadTexture==NULL)
 370                 getNextTextureToUpLoad(nTotalColored, pDriver);
 371
 372         // while some texture to upload
 373         while(_CurrentUploadTexture)
 374         {
 375                 ITexture        *pText= _CurrentUploadTexture->Texture;
 376                 if(uploadTexturePart(pText, pDriver, nTotalUploaded))
 377                 {
 378                         // Stuff for TextureEntry
 379                         if(_CurrentUploadTexture->isTextureEntry())
 380                         {
 381                                 uint    i;
 382                                 CTextureEntry   *textEntry= static_cast<CTextureEntry*>(_CurrentUploadTexture);
 383                                 // If we are here, the texture is finally entirely uploaded. Compile it!
 384                                 textEntry->UpLoaded= true;
 385                                 // Can Have lod if texture is DXTC and have mipMaps! Also disalbe if system disable it
 386                                 textEntry->CanHaveLOD= validDXTCMipMap(pText) && _BaseLodLevel>_MaxLodLevel;
 387                                 // compute the size it takes in VRAM
 388                                 uint    baseMipMapSize= pText->getSize(0)*CBitmap::bitPerPixels[pText->getPixelFormat()]/8;
 389                                 // full size with mipmap
 390                                 textEntry->BaseSize= (uint)(baseMipMapSize*1.33f);
 391                                 // UpLoaded !! => signal all instances.
 392                                 for(i=0;i<textEntry->Instances.size();i++)
 393                                 {
 394                                         textEntry->Instances[i]->_AsyncTextureToLoadRefCount--;
 395                                 }
 396
 397                                 // Create the coarse bitmap with the text (NB: still in memory here)
 398                                 textEntry->createCoarseBitmap();
 399
 400                                 // If CanHaveLOD, create now the lods entries.
 401                                 if(textEntry->CanHaveLOD)
 402                                 {
 403                                         /* Allow only the MaxLod to be loaded async
 404                                                 This is supposed to be faster since a fseek is much longer than a texture Read.
 405                                                 Then it is more intelligent to read only One texture (the High Def), than to try to
 406                                                 read intermediate ones (512, 256, 128) because this made 3 more fseek.
 407                                         */
 408                                         // create only the MaxLod possible entry
 409                                         CTextureLod             &textLod= textEntry->HDLod;
 410                                         // fill textLod
 411                                         textLod.TextureEntry= textEntry;
 412                                         textLod.Level= _MaxLodLevel;
 413                                         // extra size of the lod only (important for LoadBalacing in updateTextureLodSystem())
 414                                         textLod.ExtraSize= textEntry->BaseSize*(1<<(2*(_BaseLodLevel-_MaxLodLevel))) - textEntry->BaseSize;
 415                                         // not yet loaded/upLoaded
 416                                         textLod.Loaded= false;
 417                                         textLod.UpLoaded= false;
 418                                 }
 419
 420                                 // compute texture size for bench
 421                                 textEntry->TotalTextureSizeAsked= textEntry->BaseSize + textEntry->HDLod.ExtraSize;
 422
 423                                 // Add texture size to global texture size
 424                                 _TotalTextureSizeAsked+= textEntry->TotalTextureSizeAsked;
 425                         }
 426                         // else, stuff for textureLod.
 427                         else
 428                         {
 429                                 CTextureLod             *textLod= static_cast<CTextureLod*>(_CurrentUploadTexture);
 430                                 // Swap the uploaded Driver Handle with the Main texture.
 431                                 pDriver->swapTextureHandle(*textLod->Texture, *textLod->TextureEntry->Texture);
 432                                 // Flag the Lod.
 433                                 textLod->UpLoaded= true;
 434                                 // Ok, ended to completly load this textureLod.
 435                                 _CurrentTextureLodLoaded= NULL;
 436                         }
 437
 438                         // finally uploaded in VRAM, can release the RAM texture memory
 439                         pText->release();
 440
 441                         // if not break because can't upload all parts, get next texture to upload
 442                         _CurrentUploadTexture= NULL;
 443                         getNextTextureToUpLoad(nTotalColored, pDriver);
 444                 }
 445                 else
 446                         // Fail to upload all, abort.
 447                         return;
 448         }
 449 }
 450
 451
 452 // ***************************************************************************
 453 bool                    CAsyncTextureManager::uploadTexturePart(ITexture *pText, IDriver *pDriver, uint &nTotalUploaded)
 454 {
 455         uint            nMipMap;
 456         nMipMap = pText->getMipMapCount();
 457
 458
 459         // If this is the start of uploading, setup the texture in driver.
 460         if(_CurrentUploadTextureMipMap==0 && _CurrentUploadTextureLine==0)
 461         {
 462                 // If the texture is not a valid DXTC with mipmap
 463                 if(!validDXTCMipMap(pText))
 464                 {
 465                         /* For now, prefer do nothing, because this may be an error (texture not found)
 466                                 and the texture may not be used at all, so don't take VRAM for nothing.
 467                                 => if the texture is used, it will be loaded synchronously by the caller later in the process
 468                                 => frame freeze.
 469                         */
 470                         /*
 471                         // upload All now.
 472                         // MipMap generation and compression may be done here => Maybe Big Freeze.
 473                         // approximate*2 instead of *1.33 for mipmaps.
 474                         uint    nWeight = pText->getSize (0) * 2;
 475                         nWeight= (nWeight*CBitmap::bitPerPixels[pText->getPixelFormat()])/8;
 476                         nTotalUploaded+= nWeight;
 477                         pDriver->setupTexture(*pText);
 478                         return true;*/
 479                         return true;
 480                 }
 481                 else
 482                 {
 483                         // Create the texture only and do not upload anything
 484                         bool isRel = pText->getReleasable ();
 485                         pText->setReleasable (false);
 486                         bool isAllUploaded = false;
 487                         /* Even if the shared texture is still referenced and so still exist in driver, we MUST recreate with good size
 488                                 the texture. This is important for Texture Memory Load Balancing
 489                                 (this may means that is used elsewhere than in the CAsyncTextureManager)
 490                                 Hence: bMustRecreateSharedTexture==true
 491                         */
 492                         pDriver->setupTextureEx (*pText, false, isAllUploaded, true);
 493                         pText->setReleasable (isRel);
 494                         // if the texture is already uploaded, abort partial uploading.
 495                         if (isAllUploaded)
 496                                 return true;
 497                 }
 498         }
 499
 500
 501         // try to upload all mipmap
 502         for(; _CurrentUploadTextureMipMap<nMipMap; _CurrentUploadTextureMipMap++)
 503         {
 504                 CRect zeRect;
 505                 uint nMM= _CurrentUploadTextureMipMap;
 506
 507                 // What is left to upload ?
 508                 uint    nWeight = pText->getSize (nMM) - _CurrentUploadTextureLine*pText->getWidth(nMM);
 509                 nWeight= (nWeight*CBitmap::bitPerPixels[pText->getPixelFormat()])/8;
 510
 511                 if ((nTotalUploaded  + nWeight) > _MaxUploadPerFrame)
 512                 {
 513                         // We cannot upload the whole mipmap -> we have to cut it
 514                         uint nSizeToUpload = _MaxUploadPerFrame - nTotalUploaded ;
 515                         // DXTC => min block of 4x4
 516                         uint nLineWeight = (max(pText->getWidth(nMM), (uint32)4)*CBitmap::bitPerPixels[pText->getPixelFormat()])/8;
 517                         uint nNbLineToUpload = nSizeToUpload / nLineWeight;
 518                         // Upload 4 line by 4 line, and upload at leat one 4*line.
 519                         nNbLineToUpload = nNbLineToUpload / 4;
 520                         nNbLineToUpload= max(nNbLineToUpload, 1U);
 521                         nNbLineToUpload *= 4;
 522                         // comput rect to upload
 523                         uint32 nNewLine = _CurrentUploadTextureLine + nNbLineToUpload;
 524                         nNewLine= min(nNewLine, pText->getHeight(nMM));
 525                         zeRect.set (0, _CurrentUploadTextureLine, pText->getWidth(nMM), nNewLine);
 526                         _CurrentUploadTextureLine = nNewLine;
 527                         // if fill all the mipmap, must go to next
 528                         if (_CurrentUploadTextureLine == pText->getHeight(nMM))
 529                         {
 530                                 _CurrentUploadTextureLine = 0;
 531                                 _CurrentUploadTextureMipMap++;
 532                         }
 533                 }
 534                 else
 535                 {
 536                         // We can upload the whole mipmap (or the whole rest of the mipmap)
 537                         zeRect.set (0, _CurrentUploadTextureLine, pText->getWidth(nMM), pText->getHeight(nMM));
 538                         _CurrentUploadTextureLine= 0;
 539                 }
 540
 541                 // upload the texture
 542                 pDriver->uploadTexture (*pText, zeRect, (uint8)nMM);
 543
 544                 nTotalUploaded += nWeight;
 545                 // If outpass max allocated upload, abort.
 546                 if (nTotalUploaded > _MaxUploadPerFrame)
 547                         return false;
 548         }
 549
 550         return true;
 551 }
 552
 553
 554 // ***************************************************************************
 555 void                    CAsyncTextureManager::getNextTextureToUpLoad(uint &nTotalColored, IDriver *pDriver)
 556 {
 557         // Reset texture uploading
 558         _CurrentUploadTexture= NULL;
 559         _CurrentUploadTextureMipMap= 0;
 560         _CurrentUploadTextureLine= 0;
 561
 562         // Search in WaitingTextures if one has ended async loading
 563         vector<uint>::iterator  it;
 564         for(it=_WaitingTextures.begin();it!=_WaitingTextures.end();it++)
 565         {
 566                 CTextureEntry   *text= _TextureEntries[*it];
 567                 // If Async loading done.
 568                 if(text->Loaded)
 569                 {
 570                         // Is it a "texture to color" with HLSManager? yes=> color it now.
 571                         if(text->BuildFromHLSManager)
 572                         {
 573                                 // If not beyond the max coloring texture
 574                                 if(nTotalColored<_MaxHLSColoringPerFrame)
 575                                 {
 576                                         // Build the texture directly in the TextureFile.
 577                                         nlverify(HLSManager.buildTexture(text->HLSManagerTextId, *text->Texture));
 578                                         // Must validate the textureFile generation. NB: little weird since this is not really a textureFile.
 579                                         // But it is the easier way to do it.
 580                                         text->Texture->validateGenerateFlag();
 581                                         // compute the texture size (approx). NB: DXTC5 means 1 pixel==1 byte.
 582                                         uint    size= (uint)(text->Texture->getSize(0)*1.33);
 583                                         // Add it to the num of colorised texture done in current update().
 584                                         nTotalColored+= size;
 585                                 }
 586                                 // Else must quit and don't update any more texture this frame (_CurrentUploadTexture==NULL)
 587                                 else
 588                                         return;
 589                         }
 590
 591                         // upload this one
 592                         _CurrentUploadTexture= text;
 593                         // remove it from list of waiting textures
 594                         _WaitingTextures.erase(it);
 595                         // found => end.
 596                         return;
 597                 }
 598         }
 599
 600         // If here, and if no more waiting textures, update the Lod system.
 601         if(_WaitingTextures.empty())
 602         {
 603                 // if end to load the current lod.
 604                 if(_CurrentTextureLodLoaded && _CurrentTextureLodLoaded->Loaded)
 605                 {
 606                         // upload this one
 607                         _CurrentUploadTexture= _CurrentTextureLodLoaded;
 608                         return;
 609                 }
 610
 611                 // if no Lod texture currently loading, try to load/unload one
 612                 if(_CurrentTextureLodLoaded == NULL)
 613                 {
 614                         updateTextureLodSystem(pDriver);
 615                 }
 616         }
 617 }
 618
 619
 620 // ***************************************************************************
 621 bool                    CAsyncTextureManager::validDXTCMipMap(ITexture *pText)
 622 {
 623         return pText->getMipMapCount()>1 && (
 624                 pText->getPixelFormat() == CBitmap::DXTC1 ||
 625                 pText->getPixelFormat() == CBitmap::DXTC1Alpha ||
 626                 pText->getPixelFormat() == CBitmap::DXTC3 ||
 627                 pText->getPixelFormat() == CBitmap::DXTC5 );
 628 }
 629
 630 // ***************************************************************************
 631 void                    CAsyncTextureManager::updateTextureLodSystem(IDriver *pDriver)
 632 {
 633         sint    i;
 634
 635         // the array to sort
 636         static  vector<CTextureLodToSort>       lodArray;
 637         lodArray.clear();
 638         uint    reserveSize= 0;
 639
 640         // for each texture entry compute min distance of use
 641         //=============
 642         uint    currentBaseSize= 0;
 643         for(i=0;i<(sint)_TextureEntries.size();i++)
 644         {
 645                 if(!_TextureEntries[i])
 646                         continue;
 647                 CTextureEntry   &text= *_TextureEntries[i];
 648                 // do it only for Lodable textures
 649                 if(text.CanHaveLOD)
 650                 {
 651                         text.MinDistance= FLT_MAX;
 652                         // for all instances.
 653                         for(uint j=0;j<text.Instances.size();j++)
 654                         {
 655                                 float   instDist= text.Instances[j]->getAsyncTextureDistance();
 656
 657                                 if (instDist<text.MinDistance)
 658                                 {
 659                                         text.MinPosition = text.Instances[j]->getPos();
 660                                         text.MinDistance = instDist;
 661                                 }
 662                         }
 663
 664                         // avoid /0
 665                         text.MinDistance= max(NL3D_ATM_MIN_DISTANCE, text.MinDistance);
 666
 667                         // how many textLods to add
 668                         reserveSize++;
 669
 670                         // the minimum mem size the system take with base lod.
 671                         currentBaseSize+= text.BaseSize;
 672                 }
 673         }
 674         // reserve space
 675         lodArray.reserve(reserveSize);
 676
 677
 678         // for each texture lod compute weight, and append
 679         //=============
 680         for(i=0;i<(sint)_TextureEntries.size();i++)
 681         {
 682                 if(!_TextureEntries[i])
 683                         continue;
 684                 CTextureEntry   &text= *_TextureEntries[i];
 685                 // do it only for Lodable textures
 686                 if(text.CanHaveLOD)
 687                 {
 688                         // This Weight is actually a screen Pixel Ratio! (divide by distance)
 689                         CTextureLod     *textLod= &text.HDLod;
 690                         textLod->Weight= (1<<textLod->Level) / text.MinDistance;
 691                         // add to array
 692                         CTextureLodToSort toSort;
 693                         toSort.Lod = textLod;
 694                         toSort.Position = text.MinPosition;
 695                         lodArray.push_back(toSort);
 696                 }
 697         }
 698
 699
 700         // sort
 701         //=============
 702         sort(lodArray.begin(), lodArray.end());
 703
 704
 705         // Compute lod to load/unload
 706         //=============
 707         // Compute Pivot, ie what lods have to be loaded, and what lods do not
 708         uint    pivot= 0;
 709         uint    currentWantedSize= currentBaseSize;
 710         uint    currentLoadedSize= currentBaseSize;
 711         for(i=(sint)lodArray.size()-1;i>=0;i--)
 712         {
 713                 uint    lodSize= lodArray[i].Lod->ExtraSize;
 714                 currentWantedSize+= lodSize;
 715                 if(lodArray[i].Lod->UpLoaded)
 716                         currentLoadedSize+= lodSize;
 717                 // if > max allowed, stop the pivot here. NB: the pivot is included in the "must load them" part.
 718                 if(currentWantedSize > _MaxTotalTextureSize)
 719                 {
 720                         pivot= i;
 721                         break;
 722                 }
 723         }
 724         // continue to count currentLoadedSize
 725         for(;i>=0;i--)
 726         {
 727                 if(lodArray[i].Lod->UpLoaded)
 728                         currentLoadedSize+= lodArray[i].Lod->ExtraSize;
 729         }
 730         // save bench.
 731         _LastTextureSizeGot= currentLoadedSize;
 732
 733
 734         // if the loadedSize is inferior to the wanted size, we can load a new LOD
 735         CTextureLodToSort       *textLod= NULL;
 736         bool                    unload;
 737         if(currentLoadedSize<currentWantedSize)
 738         {
 739                 unload= false;
 740                 // search from end of the list to pivot (included), the first LOD (ie the most important) to load.
 741                 for(i=(sint)lodArray.size()-1;i>=(sint)pivot;i--)
 742                 {
 743                         if(!lodArray[i].Lod->UpLoaded)
 744                         {
 745                                 textLod= &(lodArray[i]);
 746                                 break;
 747                         }
 748                 }
 749                 // One must have been found, since currentLoadedSize<currentWantedSize
 750                 nlassert(textLod);
 751         }
 752         else
 753         {
 754                 unload= true;
 755                 // search from start to pivot (exclued), the first LOD (ie the less important) to unload.
 756                 for(i=0;i<(sint)pivot;i++)
 757                 {
 758                         if(lodArray[i].Lod->UpLoaded)
 759                         {
 760                                 textLod= &(lodArray[i]);
 761                                 break;
 762                         }
 763                 }
 764                 // it is possible that not found here. It means that All is Ok!!
 765                 if(textLod==NULL)
 766                         // no-op.
 767                         return;
 768         }
 769
 770
 771         // load/unload
 772         //=============
 773         if(!unload)
 774         {
 775                 // create a new TextureFile, with no sharing system.
 776                 nlassert(textLod->Lod->Texture==NULL);
 777                 textLod->Lod->Texture= new CTextureFile;
 778                 // Do not allow degradation.
 779                 textLod->Lod->Texture->setAllowDegradation(false);
 780                 textLod->Lod->Texture->enableSharing(false);
 781                 textLod->Lod->Texture->setFileName(textLod->Lod->TextureEntry->Texture->getFileName());
 782                 textLod->Lod->Texture->setMipMapSkipAtLoad(textLod->Lod->Level);
 783                 // For Profiling
 784                 textLod->Lod->Texture->setTextureCategory(_TextureCategory);
 785                 // setup async loading
 786                 _CurrentTextureLodLoaded= textLod->Lod;
 787                 // load it async.
 788                 CAsyncFileManager3D::getInstance().loadTexture(textLod->Lod->Texture, &textLod->Lod->Loaded, textLod->Position);
 789         }
 790         else
 791         {
 792                 // Swap now the lod.
 793                 nlassert(textLod->Lod->Texture!=NULL);
 794                 // Swap the uploaded Driver Handle with the Main texture (ot get the Ugly one)
 795                 pDriver->swapTextureHandle(*textLod->Lod->Texture, *textLod->Lod->TextureEntry->Texture);
 796                 // Flag the Lod.
 797                 textLod->Lod->UpLoaded= false;
 798                 textLod->Lod->Loaded= false;
 799                 // Release completly the texture in driver. (SmartPtr delete)
 800                 textLod->Lod->Texture= NULL;
 801         }
 802
 803 }
 804
 805
 806
 807 } // NL3D