800 lines
23 KiB
C++
800 lines
23 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/async_texture_manager.h"
|
|
#include "nel/3d/async_file_manager_3d.h"
|
|
#include "nel/3d/mesh_base_instance.h"
|
|
#include "nel/3d/driver.h"
|
|
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
// ***************************************************************************
|
|
#define NL3D_ATM_MIN_DISTANCE 1.0f
|
|
|
|
// ***************************************************************************
|
|
CAsyncTextureManager::CTextureEntry::CTextureEntry()
|
|
{
|
|
IsTextureEntry= true;
|
|
|
|
Loaded= false;
|
|
UpLoaded= false;
|
|
CanHaveLOD= false;
|
|
BuildFromHLSManager= false;
|
|
HLSManagerTextId= -1;
|
|
BaseSize= 0;
|
|
TotalTextureSizeAsked= 0;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::CTextureEntry::createCoarseBitmap()
|
|
{
|
|
// the texture must exist.
|
|
nlassert(Texture);
|
|
nlassert(Texture->getSize()>0);
|
|
|
|
// copy the bitmap.
|
|
CoarseBitmap= *Texture;
|
|
// remove all mipmaps, and convert to DXTC1 (if possible, ie if was DXTC5 or DXTC3 as example)
|
|
CoarseBitmap.releaseMipMaps();
|
|
// TODODO: conversion to DXTC1
|
|
CoarseBitmap.convertToType(CBitmap::DXTC1);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CAsyncTextureManager::CTextureLod::CTextureLod()
|
|
{
|
|
IsTextureEntry= false;
|
|
|
|
TextureEntry= NULL;
|
|
Weight= 0;
|
|
Level= 0;
|
|
Loaded= false;
|
|
UpLoaded= false;
|
|
ExtraSize= 0;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CAsyncTextureManager::~CAsyncTextureManager()
|
|
{
|
|
// 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);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
CAsyncTextureManager::CAsyncTextureManager()
|
|
{
|
|
_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;
|
|
|
|
// For Texture profiling
|
|
_TextureCategory= new ITexture::CTextureCategory("ASYNC ENTITY MANAGER");
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::setupLod(uint baseLevel, uint maxLevel)
|
|
{
|
|
nlassert(baseLevel>=maxLevel);
|
|
_BaseLodLevel= baseLevel;
|
|
_MaxLodLevel= maxLevel;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::setupMaxUploadPerFrame(uint maxup)
|
|
{
|
|
if(maxup>0)
|
|
_MaxUploadPerFrame= maxup;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::setupMaxHLSColoringPerFrame(uint maxCol)
|
|
{
|
|
if(maxCol>0)
|
|
_MaxHLSColoringPerFrame= maxCol;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::setupMaxTotalTextureSize(uint maxText)
|
|
{
|
|
_MaxTotalTextureSize= maxText;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
uint CAsyncTextureManager::addTextureRef(const string &textNameNotLwr, CMeshBaseInstance *instance, const NLMISC::CVector &position)
|
|
{
|
|
uint ret;
|
|
|
|
// lower case name
|
|
string textName = toLower(textNameNotLwr);
|
|
|
|
// find the texture in map
|
|
ItTextureEntryMap it;
|
|
it= _TextureEntryMap.find(textName);
|
|
|
|
// not found, create.
|
|
if(it==_TextureEntryMap.end())
|
|
{
|
|
// search a free id.
|
|
uint i= (uint)_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);
|
|
// For Profiling
|
|
text->Texture->setTextureCategory(_TextureCategory);
|
|
|
|
// 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 CAsyncTextureManager::deleteTexture(uint id)
|
|
{
|
|
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);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::releaseTexture(uint id, CMeshBaseInstance *instance)
|
|
{
|
|
nlassert(id<_TextureEntries.size());
|
|
nlassert(_TextureEntries[id]);
|
|
|
|
// find an instance in this texture an remove it.
|
|
CTextureEntry *text= _TextureEntries[id];
|
|
uint instSize= (uint)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);
|
|
}
|
|
}
|
|
|
|
// ***************************************************************************
|
|
bool CAsyncTextureManager::isTextureUpLoaded(uint id) const
|
|
{
|
|
nlassert(id<_TextureEntries.size());
|
|
nlassert(_TextureEntries[id]);
|
|
return _TextureEntries[id]->UpLoaded;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
const NLMISC::CBitmap *CAsyncTextureManager::getCoarseBitmap(uint id) const
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::update(IDriver *pDriver)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAsyncTextureManager::uploadTexturePart(ITexture *pText, IDriver *pDriver, uint &nTotalUploaded)
|
|
{
|
|
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;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::getNextTextureToUpLoad(uint &nTotalColored, IDriver *pDriver)
|
|
{
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
bool CAsyncTextureManager::validDXTCMipMap(ITexture *pText)
|
|
{
|
|
return pText->getMipMapCount()>1 && (
|
|
pText->getPixelFormat() == CBitmap::DXTC1 ||
|
|
pText->getPixelFormat() == CBitmap::DXTC1Alpha ||
|
|
pText->getPixelFormat() == CBitmap::DXTC3 ||
|
|
pText->getPixelFormat() == CBitmap::DXTC5 );
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CAsyncTextureManager::updateTextureLodSystem(IDriver *pDriver)
|
|
{
|
|
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=(sint)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=(sint)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);
|
|
// For Profiling
|
|
textLod->Lod->Texture->setTextureCategory(_TextureCategory);
|
|
// 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;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // NL3D
|