NL3D::CAsyncTextureManager Class Reference

#include <async_texture_manager.h>

---

Detailed Description

Async Loader of textures and Texture Load Balancer. Additionaly, store in RAM for each texture load a very low, DXTC1 compressed version of the texture. Used for some Lod systems.

Author:

Lionel Berenguier

Nevrax France

Date:

2002

Definition at line 53 of file async_texture_manager.h.

Public Member Functions
uint	addTextureRef (const std::string &textName, CMeshBaseInstance *instance, const NLMISC::CVector &position)
	CAsyncTextureManager ()
	Constructor.
const NLMISC::CBitmap *	getCoarseBitmap (uint id) const
uint	getLastTextureSizeGot () const
	get what the system really allows
uint	getTotalTextureSizeAsked () const
	get the async texture Size asked (ie maybe bigger than MaxTotalTextureSize).
bool	isTextureUpLoaded (uint id) const
	tells if a texture is loaded in the driver (ie ready to use)
void	releaseTexture (uint id, CMeshBaseInstance *instance)
	release a texture-instance tuple. the texture is released if no more instance use it.
void	setupLod (uint baseLevel, uint maxLevel)
void	setupMaxHLSColoringPerFrame (uint maxCol)
	Setup max texture HLS Coloring per update() call (in bytes). Default to 20K.
void	setupMaxTotalTextureSize (uint maxText)
	Setup max total texture size allowed. Default is 10Mo.
void	setupMaxUploadPerFrame (uint maxup)
	Setup max texture upload in driver per update() call (in bytes). Default to 64K.
void	update (IDriver *pDriver)
	~CAsyncTextureManager ()
Data Fields
CHLSTextureManager	HLSManager
	User is free to add bank to this manager. Other methods are used by the async manager.
Private Types
typedef TTextureEntryMap::iterator	ItTextureEntryMap
typedef std::map< std::string, uint >	TTextureEntryMap
Private Member Functions
void	deleteTexture (uint id)
void	getNextTextureToUpLoad (uint &nTotalColored, IDriver *pDriver)
void	updateTextureLodSystem (IDriver *pDriver)
bool	uploadTexturePart (ITexture *pText, IDriver *pDriver, uint &nTotalUpload)
Static Private Member Functions
bool	validDXTCMipMap (ITexture *pText)
Private Attributes
uint	_BaseLodLevel
CTextureLod *	_CurrentTextureLodLoaded
CTextureBase *	_CurrentUploadTexture
uint	_CurrentUploadTextureLine
uint	_CurrentUploadTextureMipMap
std::vector< uint >	_FreeTextureIds
uint	_LastTextureSizeGot
uint	_MaxHLSColoringPerFrame
uint	_MaxLodLevel
uint	_MaxTotalTextureSize
uint	_MaxUploadPerFrame
std::vector< CTextureEntry * >	_TextureEntries
TTextureEntryMap	_TextureEntryMap
uint	_TotalTextureSizeAsked
std::vector< uint >	_WaitingTextures

---

Member Typedef Documentation

typedef TTextureEntryMap::iterator NL3D::CAsyncTextureManager::ItTextureEntryMap [private]

Definition at line 122 of file async_texture_manager.h. Referenced by addTextureRef().

typedef std::map<std::string, uint> NL3D::CAsyncTextureManager::TTextureEntryMap [private]

Definition at line 121 of file async_texture_manager.h.

---

Constructor & Destructor Documentation

NL3D::CAsyncTextureManager::CAsyncTextureManager (   )

Constructor. Definition at line 104 of file async_texture_manager.cpp. References _BaseLodLevel, _CurrentTextureLodLoaded, _CurrentUploadTexture, _LastTextureSizeGot, _MaxHLSColoringPerFrame, _MaxLodLevel, _MaxTotalTextureSize, _MaxUploadPerFrame, and _TotalTextureSizeAsked. { _BaseLodLevel= 3; _MaxLodLevel= 1; _MaxUploadPerFrame= 65536; _MaxHLSColoringPerFrame= 20*1024; _CurrentUploadTexture= NULL; _MaxTotalTextureSize= 10*1024*1024; _TotalTextureSizeAsked= 0; _LastTextureSizeGot= 0; // Do not share this texture, to force uploading of the lods. _CurrentTextureLodLoaded= NULL; }

NL3D::CAsyncTextureManager::~CAsyncTextureManager (   )

Definition at line 89 of file async_texture_manager.cpp. References _CurrentTextureLodLoaded, _CurrentUploadTexture, _TextureEntries, _TextureEntryMap, _WaitingTextures, deleteTexture(), nlassert, and uint. { // For all remaining textures, delete them. for(uint i=0;i<_TextureEntries.size();i++) { if(_TextureEntries[i]) deleteTexture(i); } // there must be no waitting textures, nor map, nor current upload texture nlassert(_WaitingTextures.empty() && _TextureEntryMap.empty() && _CurrentUploadTexture==NULL && _CurrentTextureLodLoaded==NULL); }

---

Member Function Documentation

uint NL3D::CAsyncTextureManager::addTextureRef (  const std::string &  textName, CMeshBaseInstance *  instance, const NLMISC::CVector &  position )

Add a reference to a texture owned by an instance. If the texture still exist, only the refcount is incremented Else If texture is found in the HLSTextureManager, it is builded (async) from it, else Begin Async loading ThereFore, only CTextureFile are possible. Note also that the texture is uploaded with mipmap by default, and UpLoadFormat is also default (say ITexture::Auto) If the texture file is not a DDS with mipmap, this is an error. But the system doens't fail and the file is entirely loaded and uploaded. The problem is that upload is not cut according to maxUpLoadPerFrame, so some freeze may occur. Definition at line 151 of file async_texture_manager.cpp. References NL3D::CMeshBaseInstance::_AsyncTextureToLoadRefCount, _BaseLodLevel, _FreeTextureIds, _TextureEntries, _TextureEntryMap, _WaitingTextures, NL3D::CHLSTextureManager::findTexture(), HLSManager, NL3D::CAsyncTextureManager::CTextureEntry::Instances, ItTextureEntryMap, sint, NLMISC::strlwr(), NL3D::CAsyncTextureManager::CTextureBase::Texture, uint, and NL3D::CAsyncTextureManager::CTextureEntry::UpLoaded. Referenced by NL3D::CMeshBaseInstance::startAsyncTextureLoading(). { uint ret; // strlwr name string textName= textNameNotLwr; strlwr(textName); // find the texture in map ItTextureEntryMap it; it= _TextureEntryMap.find(textName); // not found, create. if(it==_TextureEntryMap.end()) { // search a free id. uint i= _TextureEntries.size(); if(!_FreeTextureIds.empty()) { i= _FreeTextureIds.back(); _FreeTextureIds.pop_back(); } // resize if needed. if(i>=_TextureEntries.size()) { _TextureEntries.push_back(NULL); _FreeTextureIds.reserve(_TextureEntries.capacity()); } // alloc new. CTextureEntry *text= new CTextureEntry(); _TextureEntries[i]= text; text->Texture= new CTextureFile; // Do not allow degradation. text->Texture->setAllowDegradation(false); // add to map. it= _TextureEntryMap.insert(make_pair(textName, i)).first; // bkup the it for deletion text->ItMap= it; // Start Color or Async loading. text->Texture->setFileName(textName); // First try with the HLSManager sint colorTextId= HLSManager.findTexture(textName); // If found if(colorTextId!=-1) { // Mark the texture as Loaded, and ready to colorize (done in update()). text->Loaded= true; text->BuildFromHLSManager= true; text->HLSManagerTextId= colorTextId; } // else must async load it. else { // start to load a small DDS version if possible text->Texture->setMipMapSkipAtLoad(_BaseLodLevel); // load it async. CAsyncFileManager3D::getInstance().loadTexture(text->Texture, &text->Loaded, position); } // Add to a list so we can check each frame if it has ended. _WaitingTextures.push_back(i); } // get the id of the text entry. ret= it->second; // add this instance to the list of ones which use this texture. CTextureEntry *text= _TextureEntries[ret]; text->Instances.push_back(instance); // if the texture is not yet ready, must increment the instance refCount. if(!text->UpLoaded) instance->_AsyncTextureToLoadRefCount++; return ret; }

void NL3D::CAsyncTextureManager::deleteTexture (  uint  id  )  [private]

Definition at line 232 of file async_texture_manager.cpp. References _CurrentTextureLodLoaded, _CurrentUploadTexture, _FreeTextureIds, _TextureEntries, _TextureEntryMap, _TotalTextureSizeAsked, _WaitingTextures, NL3D::CAsyncTextureManager::CTextureEntry::HDLod, NL3D::CAsyncTextureManager::CTextureEntry::Instances, NL3D::CAsyncTextureManager::CTextureEntry::ItMap, NL3D::CAsyncTextureManager::CTextureLod::Loaded, NL3D::CAsyncTextureManager::CTextureEntry::Loaded, NL3D::CAsyncTextureManager::CTextureBase::Texture, NL3D::CAsyncTextureManager::CTextureEntry::TotalTextureSizeAsked, uint, and NL3D::CAsyncTextureManager::CTextureEntry::UpLoaded. Referenced by releaseTexture(), and ~CAsyncTextureManager(). { CTextureEntry *text= _TextureEntries[id]; // **** Stop AsyncLoading/UpLoading of main texture. // stop async loading if not ended if(!text->Loaded) { CAsyncFileManager3D::getInstance().cancelLoadTexture(text->Texture); } // remove map entry _TextureEntryMap.erase(text->ItMap); // remove in list of waiting textures vector<uint>::iterator itWait= find(_WaitingTextures.begin(),_WaitingTextures.end(), id); if(itWait!=_WaitingTextures.end()) _WaitingTextures.erase(itWait); // If it was the currently uploaded one, abort if(_CurrentUploadTexture==text) { _CurrentUploadTexture= NULL; } // If not uploaded. if(!text->UpLoaded) { // For all its remainding instances, dec refcount for(uint i=0;i<text->Instances.size();i++) { text->Instances[i]->_AsyncTextureToLoadRefCount--; } } // remove from bench _TotalTextureSizeAsked-= text->TotalTextureSizeAsked; // **** Stop AsyncLoading/UpLoading of HDLod 's texture. // Check if must stop TextureLod loading/uploading. CTextureLod *textLod= &text->HDLod; if(textLod==_CurrentTextureLodLoaded) { // stop the async loading if not ended. if(!textLod->Loaded) { CAsyncFileManager3D::getInstance().cancelLoadTexture(textLod->Texture); } // stop uploading if was me if(_CurrentUploadTexture==textLod) { _CurrentUploadTexture= NULL; } // stop loading me. _CurrentTextureLodLoaded= NULL; } // At last delete texture entry. delete text; _TextureEntries[id]= NULL; // add a new free id. _FreeTextureIds.push_back(id); }

const NLMISC::CBitmap * NL3D::CAsyncTextureManager::getCoarseBitmap (  uint  id  )  const

get the RAM LowDef version of a texture. Used For CLodCharacters return NULL if bad Id or if the texture is still not loaded. The bitmap returned has no mipmaps and should be in DXTC1 (not guaranteed). Definition at line 343 of file async_texture_manager.cpp. References _TextureEntries, NL3D::CAsyncTextureManager::CTextureEntry::CoarseBitmap, uint, and NL3D::CAsyncTextureManager::CTextureEntry::UpLoaded. Referenced by NL3D::CSkeletonModel::computeLodTexture(). { if(id>=_TextureEntries.size()) return NULL; CTextureEntry *textEntry= _TextureEntries[id]; if(!textEntry) return NULL; // if the textEntry not uploaded, return NULL if(!textEntry->UpLoaded) return NULL; // ok return the CoarseBitmap return &textEntry->CoarseBitmap; }

uint NL3D::CAsyncTextureManager::getLastTextureSizeGot (   )  const [inline]

get what the system really allows Definition at line 115 of file async_texture_manager.h. References _LastTextureSizeGot, and uint. Referenced by NL3D::CDriverUser::getLastAsyncTextureSizeGot(). {return _LastTextureSizeGot;}

void NL3D::CAsyncTextureManager::getNextTextureToUpLoad (  uint &  nTotalColored, IDriver *  pDriver )  [private]

Definition at line 553 of file async_texture_manager.cpp. References _CurrentTextureLodLoaded, _CurrentUploadTexture, _CurrentUploadTextureLine, _CurrentUploadTextureMipMap, _MaxHLSColoringPerFrame, _TextureEntries, _WaitingTextures, NL3D::CAsyncTextureManager::CTextureEntry::BuildFromHLSManager, NL3D::CHLSTextureManager::buildTexture(), HLSManager, NL3D::CAsyncTextureManager::CTextureEntry::HLSManagerTextId, NL3D::CAsyncTextureManager::CTextureLod::Loaded, NL3D::CAsyncTextureManager::CTextureEntry::Loaded, nlverify, size, NL3D::CAsyncTextureManager::CTextureBase::Texture, uint, and updateTextureLodSystem(). Referenced by update(). { // Reset texture uploading _CurrentUploadTexture= NULL; _CurrentUploadTextureMipMap= 0; _CurrentUploadTextureLine= 0; // Search in WaitingTextures if one has ended async loading vector<uint>::iterator it; for(it=_WaitingTextures.begin();it!=_WaitingTextures.end();it++) { CTextureEntry *text= _TextureEntries[*it]; // If Async loading done. if(text->Loaded) { // Is it a "texture to color" with HLSManager? yes=> color it now. if(text->BuildFromHLSManager) { // If not beyond the max coloring texture if(nTotalColored<_MaxHLSColoringPerFrame) { // Build the texture directly in the TextureFile. nlverify(HLSManager.buildTexture(text->HLSManagerTextId, *text->Texture)); // Must validate the textureFile generation. NB: little weird since this is not really a textureFile. // But it is the easier way to do it. text->Texture->validateGenerateFlag(); // compute the texture size (approx). NB: DXTC5 means 1 pixel==1 byte. uint size= (uint)(text->Texture->getSize(0)*1.33); // Add it to the num of colorised texture done in current update(). nTotalColored+= size; } // Else must quit and don't update any more texture this frame (_CurrentUploadTexture==NULL) else return; } // upload this one _CurrentUploadTexture= text; // remove it from list of waiting textures _WaitingTextures.erase(it); // found => end. return; } } // If here, and if no more waiting textures, update the Lod system. if(_WaitingTextures.empty()) { // if end to load the current lod. if(_CurrentTextureLodLoaded && _CurrentTextureLodLoaded->Loaded) { // upload this one _CurrentUploadTexture= _CurrentTextureLodLoaded; return; } // if no Lod texture currently loading, try to load/unload one if(_CurrentTextureLodLoaded == NULL) { updateTextureLodSystem(pDriver); } } }

uint NL3D::CAsyncTextureManager::getTotalTextureSizeAsked (   )  const [inline]

get the async texture Size asked (ie maybe bigger than MaxTotalTextureSize). Definition at line 113 of file async_texture_manager.h. References _TotalTextureSizeAsked, and uint. Referenced by NL3D::CDriverUser::getTotalAsyncTextureSizeAsked(). {return _TotalTextureSizeAsked;}

bool NL3D::CAsyncTextureManager::isTextureUpLoaded (  uint  id  )  const

tells if a texture is loaded in the driver (ie ready to use) Definition at line 334 of file async_texture_manager.cpp. References _TextureEntries, nlassert, and uint. { nlassert(id<_TextureEntries.size()); nlassert(_TextureEntries[id]); return _TextureEntries[id]->UpLoaded; }

void NL3D::CAsyncTextureManager::releaseTexture (  uint  id, CMeshBaseInstance *  instance )

release a texture-instance tuple. the texture is released if no more instance use it. Definition at line 302 of file async_texture_manager.cpp. References _TextureEntries, deleteTexture(), NL3D::CAsyncTextureManager::CTextureEntry::Instances, nlassert, uint, and NL3D::CAsyncTextureManager::CTextureEntry::UpLoaded. Referenced by NL3D::CMeshBaseInstance::releaseCurrentAsyncTextures(). { nlassert(id<_TextureEntries.size()); nlassert(_TextureEntries[id]); // find an instance in this texture an remove it. CTextureEntry *text= _TextureEntries[id]; uint instSize= text->Instances.size(); for(uint i=0;i<instSize;i++) { if(text->Instances[i]== instance) { // Must first release the refCount if the texture is not uploaded if(!text->UpLoaded) text->Instances[i]->_AsyncTextureToLoadRefCount--; // remove it by swapping with last texture text->Instances[i]= text->Instances[instSize-1]; text->Instances.pop_back(); // must stop: remove only the first occurence of instance. break; } } // if no more instance occurence, the texture is no more used => release it. if(text->Instances.empty()) { // do all the good stuff deleteTexture(id); } }

void NL3D::CAsyncTextureManager::setupLod (  uint  baseLevel, uint  maxLevel )

setup the mipMap levels. When the texture is first added, it is loaded skipping the baseLevel first mipmap During time, furhter mipmap are loaded, according to instance position etc... maxLevel tells where to stop. If 0, the texture will finally be entirely uploaded. Default is 3,1. Definition at line 121 of file async_texture_manager.cpp. References _BaseLodLevel, _MaxLodLevel, nlassert, and uint. Referenced by NL3D::CDriverUser::setupAsyncTextureLod(). { nlassert(baseLevel>=maxLevel); _BaseLodLevel= baseLevel; _MaxLodLevel= maxLevel; }

void NL3D::CAsyncTextureManager::setupMaxHLSColoringPerFrame (  uint  maxCol  )

Setup max texture HLS Coloring per update() call (in bytes). Default to 20K. Definition at line 137 of file async_texture_manager.cpp. References _MaxHLSColoringPerFrame, and uint. Referenced by NL3D::CDriverUser::setupMaxHLSColoringPerFrame(). { if(maxCol>0) _MaxHLSColoringPerFrame= maxCol; }

void NL3D::CAsyncTextureManager::setupMaxTotalTextureSize (  uint  maxText  )

Setup max total texture size allowed. Default is 10Mo. Definition at line 144 of file async_texture_manager.cpp. References _MaxTotalTextureSize, and uint. Referenced by NL3D::CDriverUser::setupMaxTotalAsyncTextureSize(). { _MaxTotalTextureSize= maxText; }

void NL3D::CAsyncTextureManager::setupMaxUploadPerFrame (  uint  maxup  )

Setup max texture upload in driver per update() call (in bytes). Default to 64K. Definition at line 130 of file async_texture_manager.cpp. References _MaxUploadPerFrame, and uint. Referenced by NL3D::CDriverUser::setupAsyncTextureMaxUploadPerFrame(). { if(maxup>0) _MaxUploadPerFrame= maxup; }

void NL3D::CAsyncTextureManager::update (  IDriver *  pDriver  )

update the manager. New loaded texture are uploaded. Instances are updated to know if all their pending textures have been uploaded. Definition at line 361 of file async_texture_manager.cpp. References _BaseLodLevel, _CurrentTextureLodLoaded, _CurrentUploadTexture, _MaxLodLevel, _TotalTextureSizeAsked, NL3D::CAsyncTextureManager::CTextureEntry::BaseSize, NL3D::CAsyncTextureManager::CTextureEntry::CanHaveLOD, NL3D::CAsyncTextureManager::CTextureEntry::createCoarseBitmap(), NL3D::CAsyncTextureManager::CTextureLod::ExtraSize, getNextTextureToUpLoad(), NLMISC::CBitmap::getPixelFormat(), NLMISC::CBitmap::getSize(), NL3D::CAsyncTextureManager::CTextureEntry::HDLod, NL3D::CAsyncTextureManager::CTextureEntry::Instances, NL3D::CAsyncTextureManager::CTextureBase::isTextureEntry(), NL3D::CAsyncTextureManager::CTextureLod::Level, NL3D::CAsyncTextureManager::CTextureLod::Loaded, NL3D::ITexture::release(), NL3D::IDriver::swapTextureHandle(), NL3D::CAsyncTextureManager::CTextureBase::Texture, NL3D::CAsyncTextureManager::CTextureLod::TextureEntry, NL3D::CAsyncTextureManager::CTextureEntry::TotalTextureSizeAsked, uint, NL3D::CAsyncTextureManager::CTextureLod::UpLoaded, NL3D::CAsyncTextureManager::CTextureEntry::UpLoaded, uploadTexturePart(), and validDXTCMipMap(). Referenced by NL3D::CDriverUser::updateAsyncTexture(). { uint nTotalUploaded = 0; uint nTotalColored = 0; // if no texture to upload, get the next one if(_CurrentUploadTexture==NULL) getNextTextureToUpLoad(nTotalColored, pDriver); // while some texture to upload while(_CurrentUploadTexture) { ITexture *pText= _CurrentUploadTexture->Texture; if(uploadTexturePart(pText, pDriver, nTotalUploaded)) { // Stuff for TextureEntry if(_CurrentUploadTexture->isTextureEntry()) { uint i; CTextureEntry *textEntry= static_cast<CTextureEntry*>(_CurrentUploadTexture); // If we are here, the texture is finally entirely uploaded. Compile it! textEntry->UpLoaded= true; // Can Have lod if texture is DXTC and have mipMaps! Also disalbe if system disable it textEntry->CanHaveLOD= validDXTCMipMap(pText) && _BaseLodLevel>_MaxLodLevel; // compute the size it takes in VRAM uint baseMipMapSize= pText->getSize(0)*CBitmap::bitPerPixels[pText->getPixelFormat()]/8; // full size with mipmap textEntry->BaseSize= (uint)(baseMipMapSize*1.33f); // UpLoaded !! => signal all instances. for(i=0;i<textEntry->Instances.size();i++) { textEntry->Instances[i]->_AsyncTextureToLoadRefCount--; } // Create the coarse bitmap with the text (NB: still in memory here) textEntry->createCoarseBitmap(); // If CanHaveLOD, create now the lods entries. if(textEntry->CanHaveLOD) { /* Allow only the MaxLod to be loaded async This is supposed to be faster since a fseek is much longer than a texture Read. Then it is more intelligent to read only One texture (the High Def), than to try to read intermediate ones (512, 256, 128) because this made 3 more fseek. */ // create only the MaxLod possible entry CTextureLod &textLod= textEntry->HDLod; // fill textLod textLod.TextureEntry= textEntry; textLod.Level= _MaxLodLevel; // extra size of the lod only (important for LoadBalacing in updateTextureLodSystem()) textLod.ExtraSize= textEntry->BaseSize*(1<<(2*(_BaseLodLevel-_MaxLodLevel))) - textEntry->BaseSize; // not yet loaded/upLoaded textLod.Loaded= false; textLod.UpLoaded= false; } // compute texture size for bench textEntry->TotalTextureSizeAsked= textEntry->BaseSize + textEntry->HDLod.ExtraSize; // Add texture size to global texture size _TotalTextureSizeAsked+= textEntry->TotalTextureSizeAsked; } // else, stuff for textureLod. else { CTextureLod *textLod= static_cast<CTextureLod*>(_CurrentUploadTexture); // Swap the uploaded Driver Handle with the Main texture. pDriver->swapTextureHandle(*textLod->Texture, *textLod->TextureEntry->Texture); // Flag the Lod. textLod->UpLoaded= true; // Ok, ended to completly load this textureLod. _CurrentTextureLodLoaded= NULL; } // finally uploaded in VRAM, can release the RAM texture memory pText->release(); // if not break because can't upload all parts, get next texture to upload _CurrentUploadTexture= NULL; getNextTextureToUpLoad(nTotalColored, pDriver); } else // Fail to upload all, abort. return; } }

void NL3D::CAsyncTextureManager::updateTextureLodSystem (  IDriver *  pDriver  )  [private]

Definition at line 629 of file async_texture_manager.cpp. References _CurrentTextureLodLoaded, _LastTextureSizeGot, _MaxTotalTextureSize, _TextureEntries, NL3D::CAsyncTextureManager::CTextureEntry::BaseSize, NL3D::CAsyncTextureManager::CTextureEntry::CanHaveLOD, NL3D::CAsyncTextureManager::CTextureEntry::HDLod, NL3D::CAsyncTextureManager::CTextureEntry::Instances, NL3D::CAsyncTextureManager::CTextureLod::Level, NL3D::CAsyncTextureManager::CTextureLod::Loaded, NL3D::CAsyncTextureManager::CTextureLodToSort::Lod, NL3D::CAsyncTextureManager::CTextureEntry::MinDistance, NL3D::CAsyncTextureManager::CTextureEntry::MinPosition, NL3D_ATM_MIN_DISTANCE, nlassert, NL3D::CAsyncTextureManager::CTextureLodToSort::Position, sint, NL3D::IDriver::swapTextureHandle(), NL3D::CAsyncTextureManager::CTextureBase::Texture, NL3D::CAsyncTextureManager::CTextureLod::TextureEntry, uint, NL3D::CAsyncTextureManager::CTextureLod::UpLoaded, and NL3D::CAsyncTextureManager::CTextureLod::Weight. Referenced by getNextTextureToUpLoad(). { sint i; // the array to sort static vector<CTextureLodToSort> lodArray; lodArray.clear(); uint reserveSize= 0; // for each texture entry compute min distance of use //============= uint currentBaseSize= 0; for(i=0;i<(sint)_TextureEntries.size();i++) { if(!_TextureEntries[i]) continue; CTextureEntry &text= *_TextureEntries[i]; // do it only for Lodable textures if(text.CanHaveLOD) { text.MinDistance= FLT_MAX; // for all instances. for(uint j=0;j<text.Instances.size();j++) { float instDist= text.Instances[j]->getAsyncTextureDistance(); if (instDist<text.MinDistance) { text.MinPosition = text.Instances[j]->getPos(); text.MinDistance = instDist; } } // avoid /0 text.MinDistance= max(NL3D_ATM_MIN_DISTANCE, text.MinDistance); // how many textLods to add reserveSize++; // the minimum mem size the system take with base lod. currentBaseSize+= text.BaseSize; } } // reserve space lodArray.reserve(reserveSize); // for each texture lod compute weight, and append //============= for(i=0;i<(sint)_TextureEntries.size();i++) { if(!_TextureEntries[i]) continue; CTextureEntry &text= *_TextureEntries[i]; // do it only for Lodable textures if(text.CanHaveLOD) { // This Weight is actually a screen Pixel Ratio! (divide by distance) CTextureLod *textLod= &text.HDLod; textLod->Weight= (1<<textLod->Level) / text.MinDistance; // add to array CTextureLodToSort toSort; toSort.Lod = textLod; toSort.Position = text.MinPosition; lodArray.push_back(toSort); } } // sort //============= sort(lodArray.begin(), lodArray.end()); // Compute lod to load/unload //============= // Compute Pivot, ie what lods have to be loaded, and what lods do not uint pivot= 0; uint currentWantedSize= currentBaseSize; uint currentLoadedSize= currentBaseSize; for(i=lodArray.size()-1;i>=0;i--) { uint lodSize= lodArray[i].Lod->ExtraSize; currentWantedSize+= lodSize; if(lodArray[i].Lod->UpLoaded) currentLoadedSize+= lodSize; // if > max allowed, stop the pivot here. NB: the pivot is included in the "must load them" part. if(currentWantedSize > _MaxTotalTextureSize) { pivot= i; break; } } // continue to count currentLoadedSize for(;i>=0;i--) { if(lodArray[i].Lod->UpLoaded) currentLoadedSize+= lodArray[i].Lod->ExtraSize; } // save bench. _LastTextureSizeGot= currentLoadedSize; // if the loadedSize is inferior to the wanted size, we can load a new LOD CTextureLodToSort *textLod= NULL; bool unload; if(currentLoadedSize<currentWantedSize) { unload= false; // search from end of the list to pivot (included), the first LOD (ie the most important) to load. for(i=lodArray.size()-1;i>=(sint)pivot;i--) { if(!lodArray[i].Lod->UpLoaded) { textLod= &(lodArray[i]); break; } } // One must have been found, since currentLoadedSize<currentWantedSize nlassert(textLod); } else { unload= true; // search from start to pivot (exclued), the first LOD (ie the less important) to unload. for(i=0;i<(sint)pivot;i++) { if(lodArray[i].Lod->UpLoaded) { textLod= &(lodArray[i]); break; } } // it is possible that not found here. It means that All is Ok!! if(textLod==NULL) // no-op. return; } // load/unload //============= if(!unload) { // create a new TextureFile, with no sharing system. nlassert(textLod->Lod->Texture==NULL); textLod->Lod->Texture= new CTextureFile; // Do not allow degradation. textLod->Lod->Texture->setAllowDegradation(false); textLod->Lod->Texture->enableSharing(false); textLod->Lod->Texture->setFileName(textLod->Lod->TextureEntry->Texture->getFileName()); textLod->Lod->Texture->setMipMapSkipAtLoad(textLod->Lod->Level); // setup async loading _CurrentTextureLodLoaded= textLod->Lod; // load it async. CAsyncFileManager3D::getInstance().loadTexture(textLod->Lod->Texture, &textLod->Lod->Loaded, textLod->Position); } else { // Swap now the lod. nlassert(textLod->Lod->Texture!=NULL); // Swap the uploaded Driver Handle with the Main texture (ot get the Ugly one) pDriver->swapTextureHandle(*textLod->Lod->Texture, *textLod->Lod->TextureEntry->Texture); // Flag the Lod. textLod->Lod->UpLoaded= false; textLod->Lod->Loaded= false; // Release completly the texture in driver. (SmartPtr delete) textLod->Lod->Texture= NULL; } }

bool NL3D::CAsyncTextureManager::uploadTexturePart (  ITexture *  pText, IDriver *  pDriver, uint &  nTotalUpload )  [private]

Definition at line 451 of file async_texture_manager.cpp. References _CurrentUploadTextureLine, _CurrentUploadTextureMipMap, _MaxUploadPerFrame, NLMISC::CBitmap::getHeight(), NLMISC::CBitmap::getMipMapCount(), NLMISC::CBitmap::getPixelFormat(), NL3D::ITexture::getReleasable(), NLMISC::CBitmap::getSize(), NLMISC::CBitmap::getWidth(), min, NLMISC::CRect::set(), NL3D::ITexture::setReleasable(), NL3D::IDriver::setupTextureEx(), uint, uint32, uint8, NL3D::IDriver::uploadTexture(), and validDXTCMipMap(). Referenced by update(). { uint nMipMap; nMipMap = pText->getMipMapCount(); // If this is the start of uploading, setup the texture in driver. if(_CurrentUploadTextureMipMap==0 && _CurrentUploadTextureLine==0) { // If the texture is not a valid DXTC with mipmap if(!validDXTCMipMap(pText)) { /* For now, prefer do nothing, because this may be an error (texture not found) and the texture may not be used at all, so don't take VRAM for nothing. => if the texture is used, it will be loaded synchronously by the caller later in the process => frame freeze. */ /* // upload All now. // MipMap generation and compression may be done here => Maybe Big Freeze. // approximate*2 instead of *1.33 for mipmaps. uint nWeight = pText->getSize (0) * 2; nWeight= (nWeight*CBitmap::bitPerPixels[pText->getPixelFormat()])/8; nTotalUploaded+= nWeight; pDriver->setupTexture(*pText); return true;*/ return true; } else { // Create the texture only and do not upload anything bool isRel = pText->getReleasable (); pText->setReleasable (false); bool isAllUploaded = false; /* Even if the shared texture is still referenced and so still exist in driver, we MUST recreate with good size the texture. This is important for Texture Memory Load Balancing (this may means that is used elsewhere than in the CAsyncTextureManager) Hence: bMustRecreateSharedTexture==true */ pDriver->setupTextureEx (*pText, false, isAllUploaded, true); pText->setReleasable (isRel); // if the texture is already uploaded, abort partial uploading. if (isAllUploaded) return true; } } // try to upload all mipmap for(; _CurrentUploadTextureMipMap<nMipMap; _CurrentUploadTextureMipMap++) { CRect zeRect; uint nMM= _CurrentUploadTextureMipMap; // What is left to upload ? uint nWeight = pText->getSize (nMM) - _CurrentUploadTextureLine*pText->getWidth(nMM); nWeight= (nWeight*CBitmap::bitPerPixels[pText->getPixelFormat()])/8; if ((nTotalUploaded + nWeight) > _MaxUploadPerFrame) { // We cannot upload the whole mipmap -> we have to cut it uint nSizeToUpload = _MaxUploadPerFrame - nTotalUploaded ; // DXTC => min block of 4x4 uint nLineWeight = (max(pText->getWidth(nMM), (uint32)4)*CBitmap::bitPerPixels[pText->getPixelFormat()])/8; uint nNbLineToUpload = nSizeToUpload / nLineWeight; // Upload 4 line by 4 line, and upload at leat one 4*line. nNbLineToUpload = nNbLineToUpload / 4; nNbLineToUpload= max(nNbLineToUpload, 1U); nNbLineToUpload *= 4; // comput rect to upload uint32 nNewLine = _CurrentUploadTextureLine + nNbLineToUpload; nNewLine= min(nNewLine, pText->getHeight(nMM)); zeRect.set (0, _CurrentUploadTextureLine, pText->getWidth(nMM), nNewLine); _CurrentUploadTextureLine = nNewLine; // if fill all the mipmap, must go to next if (_CurrentUploadTextureLine == pText->getHeight(nMM)) { _CurrentUploadTextureLine = 0; _CurrentUploadTextureMipMap++; } } else { // We can upload the whole mipmap (or the whole rest of the mipmap) zeRect.set (0, _CurrentUploadTextureLine, pText->getWidth(nMM), pText->getHeight(nMM)); _CurrentUploadTextureLine= 0; } // upload the texture pDriver->uploadTexture (*pText, zeRect, (uint8)nMM); nTotalUploaded += nWeight; // If outpass max allocated upload, abort. if (nTotalUploaded > _MaxUploadPerFrame) return false; } return true; }

bool NL3D::CAsyncTextureManager::validDXTCMipMap (  ITexture *  pText  )  [static, private]

Definition at line 619 of file async_texture_manager.cpp. References NLMISC::CBitmap::getMipMapCount(), and NLMISC::CBitmap::getPixelFormat(). Referenced by update(), and uploadTexturePart(). { return pText->getMipMapCount()>1 && ( pText->getPixelFormat() == CBitmap::DXTC1 || pText->getPixelFormat() == CBitmap::DXTC1Alpha || pText->getPixelFormat() == CBitmap::DXTC3 || pText->getPixelFormat() == CBitmap::DXTC5 ); }

---

Field Documentation

uint NL3D::CAsyncTextureManager::_BaseLodLevel [private]

Definition at line 213 of file async_texture_manager.h. Referenced by addTextureRef(), CAsyncTextureManager(), setupLod(), and update().

CTextureLod* NL3D::CAsyncTextureManager::_CurrentTextureLodLoaded [private]

Definition at line 232 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), deleteTexture(), getNextTextureToUpLoad(), update(), updateTextureLodSystem(), and ~CAsyncTextureManager().

CTextureBase* NL3D::CAsyncTextureManager::_CurrentUploadTexture [private]

Definition at line 227 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), deleteTexture(), getNextTextureToUpLoad(), update(), and ~CAsyncTextureManager().

uint NL3D::CAsyncTextureManager::_CurrentUploadTextureLine [private]

Definition at line 229 of file async_texture_manager.h. Referenced by getNextTextureToUpLoad(), and uploadTexturePart().

uint NL3D::CAsyncTextureManager::_CurrentUploadTextureMipMap [private]

Definition at line 228 of file async_texture_manager.h. Referenced by getNextTextureToUpLoad(), and uploadTexturePart().

std::vector<uint> NL3D::CAsyncTextureManager::_FreeTextureIds [private]

Definition at line 222 of file async_texture_manager.h. Referenced by addTextureRef(), and deleteTexture().

uint NL3D::CAsyncTextureManager::_LastTextureSizeGot [private]

Definition at line 218 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), getLastTextureSizeGot(), and updateTextureLodSystem().

uint NL3D::CAsyncTextureManager::_MaxHLSColoringPerFrame [private]

Definition at line 215 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), getNextTextureToUpLoad(), and setupMaxHLSColoringPerFrame().

uint NL3D::CAsyncTextureManager::_MaxLodLevel [private]

Definition at line 213 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), setupLod(), and update().

uint NL3D::CAsyncTextureManager::_MaxTotalTextureSize [private]

Definition at line 216 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), setupMaxTotalTextureSize(), and updateTextureLodSystem().

uint NL3D::CAsyncTextureManager::_MaxUploadPerFrame [private]

Definition at line 214 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), setupMaxUploadPerFrame(), and uploadTexturePart().

std::vector<CTextureEntry*> NL3D::CAsyncTextureManager::_TextureEntries [private]

Definition at line 221 of file async_texture_manager.h. Referenced by addTextureRef(), deleteTexture(), getCoarseBitmap(), getNextTextureToUpLoad(), isTextureUpLoaded(), releaseTexture(), updateTextureLodSystem(), and ~CAsyncTextureManager().

TTextureEntryMap NL3D::CAsyncTextureManager::_TextureEntryMap [private]

Definition at line 223 of file async_texture_manager.h. Referenced by addTextureRef(), deleteTexture(), and ~CAsyncTextureManager().

uint NL3D::CAsyncTextureManager::_TotalTextureSizeAsked [private]

Definition at line 217 of file async_texture_manager.h. Referenced by CAsyncTextureManager(), deleteTexture(), getTotalTextureSizeAsked(), and update().

std::vector<uint> NL3D::CAsyncTextureManager::_WaitingTextures [private]

Definition at line 224 of file async_texture_manager.h. Referenced by addTextureRef(), deleteTexture(), getNextTextureToUpLoad(), and ~CAsyncTextureManager().

CHLSTextureManager NL3D::CAsyncTextureManager::HLSManager

User is free to add bank to this manager. Other methods are used by the async manager. Definition at line 57 of file async_texture_manager.h. Referenced by addTextureRef(), getNextTextureToUpLoad(), and NL3D::CDriverUser::loadHLSBank().

---

The documentation for this class was generated from the following files:

• async_texture_manager.h
• async_texture_manager.cpp

---