summaryrefslogtreecommitdiff
path: root/indra/newview/llviewertexture.cpp
diff options
context:
space:
mode:
authorRichard Linden <none@none>2013-10-08 11:59:24 -0700
committerRichard Linden <none@none>2013-10-08 11:59:24 -0700
commit80dfbbaacd82179e54163ed48b1bc444e3becbd5 (patch)
treeda3858b58b5ec9c34d6eefa60c4fe87fc5743249 /indra/newview/llviewertexture.cpp
parentf7158bc5afcec1da8b9d2d5a4ed86921e62d4959 (diff)
parent2eeee8a9491398697a8f3167bc4f715a3970fc3a (diff)
merge from viewer-release
Diffstat (limited to 'indra/newview/llviewertexture.cpp')
-rwxr-xr-xindra/newview/llviewertexture.cpp1591
1 files changed, 813 insertions, 778 deletions
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 84f66c359f..09bf022008 100755
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -29,7 +29,6 @@
#include "llviewertexture.h"
// Library includes
-#include "imageids.h"
#include "llmath.h"
#include "llerror.h"
#include "llgl.h"
@@ -63,6 +62,11 @@
#include "lltexturecache.h"
///////////////////////////////////////////////////////////////////////////////
+// extern
+const S32Megabytes gMinVideoRam(32);
+const S32Megabytes gMaxVideoRam(512);
+
+
// statics
LLPointer<LLViewerTexture> LLViewerTexture::sNullImagep = NULL;
LLPointer<LLViewerTexture> LLViewerTexture::sBlackImagep = NULL;
@@ -72,8 +76,8 @@ LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sWhiteImagep = NULL;
LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sDefaultImagep = NULL;
LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sSmokeImagep = NULL;
LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sFlatNormalImagep = NULL;
-LLViewerMediaTexture::media_map_t LLViewerMediaTexture::sMediaMap ;
-LLTexturePipelineTester* LLViewerTextureManager::sTesterp = NULL ;
+LLViewerMediaTexture::media_map_t LLViewerMediaTexture::sMediaMap;
+LLTexturePipelineTester* LLViewerTextureManager::sTesterp = NULL;
const std::string sTesterName("TextureTester");
S32 LLViewerTexture::sImageCount = 0;
@@ -82,21 +86,21 @@ S32 LLViewerTexture::sAuxCount = 0;
LLFrameTimer LLViewerTexture::sEvaluationTimer;
F32 LLViewerTexture::sDesiredDiscardBias = 0.f;
F32 LLViewerTexture::sDesiredDiscardScale = 1.1f;
-S32 LLViewerTexture::sBoundTextureMemoryInBytes = 0;
-S32 LLViewerTexture::sTotalTextureMemoryInBytes = 0;
-S32 LLViewerTexture::sMaxBoundTextureMemInMegaBytes = 0;
-S32 LLViewerTexture::sMaxTotalTextureMemInMegaBytes = 0;
-S32 LLViewerTexture::sMaxDesiredTextureMemInBytes = 0 ;
-S8 LLViewerTexture::sCameraMovingDiscardBias = 0 ;
-F32 LLViewerTexture::sCameraMovingBias = 0.0f ;
-S32 LLViewerTexture::sMaxSculptRez = 128 ; //max sculpt image size
-const S32 MAX_CACHED_RAW_IMAGE_AREA = 64 * 64 ;
-const S32 MAX_CACHED_RAW_SCULPT_IMAGE_AREA = LLViewerTexture::sMaxSculptRez * LLViewerTexture::sMaxSculptRez ;
-const S32 MAX_CACHED_RAW_TERRAIN_IMAGE_AREA = 128 * 128 ;
-S32 LLViewerTexture::sMinLargeImageSize = 65536 ; //256 * 256.
-S32 LLViewerTexture::sMaxSmallImageSize = MAX_CACHED_RAW_IMAGE_AREA ;
-BOOL LLViewerTexture::sFreezeImageScalingDown = FALSE ;
-F32 LLViewerTexture::sCurrentTime = 0.0f ;
+S32Bytes LLViewerTexture::sBoundTextureMemory;
+S32Bytes LLViewerTexture::sTotalTextureMemory;
+S32Megabytes LLViewerTexture::sMaxBoundTextureMem;
+S32Megabytes LLViewerTexture::sMaxTotalTextureMem;
+S32Bytes LLViewerTexture::sMaxDesiredTextureMem;
+S8 LLViewerTexture::sCameraMovingDiscardBias = 0;
+F32 LLViewerTexture::sCameraMovingBias = 0.0f;
+S32 LLViewerTexture::sMaxSculptRez = 128; //max sculpt image size
+const S32 MAX_CACHED_RAW_IMAGE_AREA = 64 * 64;
+const S32 MAX_CACHED_RAW_SCULPT_IMAGE_AREA = LLViewerTexture::sMaxSculptRez * LLViewerTexture::sMaxSculptRez;
+const S32 MAX_CACHED_RAW_TERRAIN_IMAGE_AREA = 128 * 128;
+S32 LLViewerTexture::sMinLargeImageSize = 65536; //256 * 256.
+S32 LLViewerTexture::sMaxSmallImageSize = MAX_CACHED_RAW_IMAGE_AREA;
+BOOL LLViewerTexture::sFreezeImageScalingDown = FALSE;
+F32 LLViewerTexture::sCurrentTime = 0.0f;
F32 LLViewerTexture::sTexelPixelRatio = 1.0f;
LLViewerTexture::EDebugTexels LLViewerTexture::sDebugTexelsMode = LLViewerTexture::DEBUG_TEXELS_OFF;
@@ -138,7 +142,7 @@ void LLLoadedCallbackEntry::removeTexture(LLViewerFetchedTexture* tex)
{
if(mSourceCallbackList)
{
- mSourceCallbackList->erase(tex->getID()) ;
+ mSourceCallbackList->erase(tex->getID());
}
}
@@ -151,33 +155,33 @@ void LLLoadedCallbackEntry::cleanUpCallbackList(LLLoadedCallbackEntry::source_ca
for(LLLoadedCallbackEntry::source_callback_list_t::iterator iter = callback_list->begin();
iter != callback_list->end(); ++iter)
{
- LLViewerFetchedTexture* tex = gTextureList.findImage(*iter) ;
+ LLViewerFetchedTexture* tex = gTextureList.findImage(*iter);
if(tex)
{
- tex->deleteCallbackEntry(callback_list) ;
+ tex->deleteCallbackEntry(callback_list);
}
}
- callback_list->clear() ;
+ callback_list->clear();
}
}
LLViewerMediaTexture* LLViewerTextureManager::createMediaTexture(const LLUUID &media_id, BOOL usemipmaps, LLImageGL* gl_image)
{
- return new LLViewerMediaTexture(media_id, usemipmaps, gl_image) ;
+ return new LLViewerMediaTexture(media_id, usemipmaps, gl_image);
}
LLViewerTexture* LLViewerTextureManager::findTexture(const LLUUID& id)
{
- LLViewerTexture* tex ;
+ LLViewerTexture* tex;
//search fetched texture list
- tex = gTextureList.findImage(id) ;
+ tex = gTextureList.findImage(id);
//search media texture list
if(!tex)
{
- tex = LLViewerTextureManager::findMediaTexture(id) ;
+ tex = LLViewerTextureManager::findMediaTexture(id);
}
- return tex ;
+ return tex;
}
LLViewerFetchedTexture* LLViewerTextureManager::findFetchedTexture(const LLUUID& id)
@@ -187,78 +191,78 @@ LLViewerFetchedTexture* LLViewerTextureManager::findFetchedTexture(const LLUUID
LLViewerMediaTexture* LLViewerTextureManager::findMediaTexture(const LLUUID &media_id)
{
- return LLViewerMediaTexture::findMediaTexture(media_id) ;
+ return LLViewerMediaTexture::findMediaTexture(media_id);
}
LLViewerMediaTexture* LLViewerTextureManager::getMediaTexture(const LLUUID& id, BOOL usemipmaps, LLImageGL* gl_image)
{
- LLViewerMediaTexture* tex = LLViewerMediaTexture::findMediaTexture(id) ;
+ LLViewerMediaTexture* tex = LLViewerMediaTexture::findMediaTexture(id);
if(!tex)
{
- tex = LLViewerTextureManager::createMediaTexture(id, usemipmaps, gl_image) ;
+ tex = LLViewerTextureManager::createMediaTexture(id, usemipmaps, gl_image);
}
- tex->initVirtualSize() ;
+ tex->initVirtualSize();
- return tex ;
+ return tex;
}
LLViewerFetchedTexture* LLViewerTextureManager::staticCastToFetchedTexture(LLTexture* tex, BOOL report_error)
{
if(!tex)
{
- return NULL ;
+ return NULL;
}
- S8 type = tex->getType() ;
+ S8 type = tex->getType();
if(type == LLViewerTexture::FETCHED_TEXTURE || type == LLViewerTexture::LOD_TEXTURE)
{
- return static_cast<LLViewerFetchedTexture*>(tex) ;
+ return static_cast<LLViewerFetchedTexture*>(tex);
}
if(report_error)
{
- llerrs << "not a fetched texture type: " << type << llendl ;
+ LL_ERRS() << "not a fetched texture type: " << type << LL_ENDL;
}
- return NULL ;
+ return NULL;
}
LLPointer<LLViewerTexture> LLViewerTextureManager::getLocalTexture(BOOL usemipmaps, BOOL generate_gl_tex)
{
- LLPointer<LLViewerTexture> tex = new LLViewerTexture(usemipmaps) ;
+ LLPointer<LLViewerTexture> tex = new LLViewerTexture(usemipmaps);
if(generate_gl_tex)
{
- tex->generateGLTexture() ;
- tex->setCategory(LLGLTexture::LOCAL) ;
+ tex->generateGLTexture();
+ tex->setCategory(LLGLTexture::LOCAL);
}
- return tex ;
+ return tex;
}
LLPointer<LLViewerTexture> LLViewerTextureManager::getLocalTexture(const LLUUID& id, BOOL usemipmaps, BOOL generate_gl_tex)
{
- LLPointer<LLViewerTexture> tex = new LLViewerTexture(id, usemipmaps) ;
+ LLPointer<LLViewerTexture> tex = new LLViewerTexture(id, usemipmaps);
if(generate_gl_tex)
{
- tex->generateGLTexture() ;
- tex->setCategory(LLGLTexture::LOCAL) ;
+ tex->generateGLTexture();
+ tex->setCategory(LLGLTexture::LOCAL);
}
- return tex ;
+ return tex;
}
LLPointer<LLViewerTexture> LLViewerTextureManager::getLocalTexture(const LLImageRaw* raw, BOOL usemipmaps)
{
- LLPointer<LLViewerTexture> tex = new LLViewerTexture(raw, usemipmaps) ;
- tex->setCategory(LLGLTexture::LOCAL) ;
- return tex ;
+ LLPointer<LLViewerTexture> tex = new LLViewerTexture(raw, usemipmaps);
+ tex->setCategory(LLGLTexture::LOCAL);
+ return tex;
}
LLPointer<LLViewerTexture> LLViewerTextureManager::getLocalTexture(const U32 width, const U32 height, const U8 components, BOOL usemipmaps, BOOL generate_gl_tex)
{
- LLPointer<LLViewerTexture> tex = new LLViewerTexture(width, height, components, usemipmaps) ;
+ LLPointer<LLViewerTexture> tex = new LLViewerTexture(width, height, components, usemipmaps);
if(generate_gl_tex)
{
- tex->generateGLTexture() ;
- tex->setCategory(LLGLTexture::LOCAL) ;
+ tex->generateGLTexture();
+ tex->setCategory(LLGLTexture::LOCAL);
}
- return tex ;
+ return tex;
}
LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTexture(
@@ -271,11 +275,11 @@ LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTexture(
LLGLenum primary_format,
LLHost request_from_host)
{
- return gTextureList.getImage(image_id, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, request_from_host) ;
+ return gTextureList.getImage(image_id, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, request_from_host);
}
LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromFile(
- const std::string& filename,
+ const std::string& filename,
FTType f_type,
BOOL usemipmaps,
LLViewerTexture::EBoostLevel boost_priority,
@@ -284,11 +288,11 @@ LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromFile(
LLGLenum primary_format,
const LLUUID& force_id)
{
- return gTextureList.getImageFromFile(filename, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, force_id) ;
+ return gTextureList.getImageFromFile(filename, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, force_id);
}
//static
-LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromUrl(const std::string& url,
+LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromUrl(const std::string& url,
FTType f_type,
BOOL usemipmaps,
LLViewerTexture::EBoostLevel boost_priority,
@@ -298,12 +302,12 @@ LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromUrl(const s
const LLUUID& force_id
)
{
- return gTextureList.getImageFromUrl(url, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, force_id) ;
+ return gTextureList.getImageFromUrl(url, f_type, usemipmaps, boost_priority, texture_type, internal_format, primary_format, force_id);
}
LLViewerFetchedTexture* LLViewerTextureManager::getFetchedTextureFromHost(const LLUUID& image_id, FTType f_type, LLHost host)
{
- return gTextureList.getImageFromHost(image_id, f_type, host) ;
+ return gTextureList.getImageFromHost(image_id, f_type, host);
}
// Create a bridge to the viewer texture manager.
@@ -331,15 +335,15 @@ void LLViewerTextureManager::init()
{
LLPointer<LLImageRaw> raw = new LLImageRaw(1,1,3);
raw->clear(0x77, 0x77, 0x77, 0xFF);
- LLViewerTexture::sNullImagep = LLViewerTextureManager::getLocalTexture(raw.get(), TRUE) ;
+ LLViewerTexture::sNullImagep = LLViewerTextureManager::getLocalTexture(raw.get(), TRUE);
}
const S32 dim = 128;
LLPointer<LLImageRaw> image_raw = new LLImageRaw(dim,dim,3);
U8* data = image_raw->getData();
- memset(data, 0, dim * dim * 3) ;
- LLViewerTexture::sBlackImagep = LLViewerTextureManager::getLocalTexture(image_raw.get(), TRUE) ;
+ memset(data, 0, dim * dim * 3);
+ LLViewerTexture::sBlackImagep = LLViewerTextureManager::getLocalTexture(image_raw.get(), TRUE);
#if 1
LLPointer<LLViewerFetchedTexture> imagep = LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT);
@@ -368,16 +372,16 @@ void LLViewerTextureManager::init()
}
imagep->createGLTexture(0, image_raw);
//cache the raw image
- imagep->setCachedRawImage(0, image_raw) ;
+ imagep->setCachedRawImage(0, image_raw);
image_raw = NULL;
#else
LLViewerFetchedTexture::sDefaultImagep = LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT, TRUE, LLGLTexture::BOOST_UI);
#endif
LLViewerFetchedTexture::sDefaultImagep->dontDiscard();
- LLViewerFetchedTexture::sDefaultImagep->setCategory(LLGLTexture::OTHER) ;
+ LLViewerFetchedTexture::sDefaultImagep->setCategory(LLGLTexture::OTHER);
LLViewerFetchedTexture::sSmokeImagep = LLViewerTextureManager::getFetchedTexture(IMG_SMOKE, FTT_DEFAULT, TRUE, LLGLTexture::BOOST_UI);
- LLViewerFetchedTexture::sSmokeImagep->setNoDelete() ;
+ LLViewerFetchedTexture::sSmokeImagep->setNoDelete();
image_raw = new LLImageRaw(32,32,3);
data = image_raw->getData();
@@ -394,14 +398,14 @@ void LLViewerTextureManager::init()
LLViewerTexture::sCheckerBoardImagep = LLViewerTextureManager::getLocalTexture(image_raw.get(), TRUE);
- LLViewerTexture::initClass() ;
-
+ LLViewerTexture::initClass();
+
// Create a texture manager bridge.
gTextureManagerBridgep = new LLViewerTextureManagerBridge;
if (LLMetricPerformanceTesterBasic::isMetricLogRequested(sTesterName) && !LLMetricPerformanceTesterBasic::getTester(sTesterName))
{
- sTesterp = new LLTexturePipelineTester() ;
+ sTesterp = new LLTexturePipelineTester();
if (!sTesterp->isValid())
{
delete sTesterp;
@@ -415,7 +419,7 @@ void LLViewerTextureManager::cleanup()
stop_glerror();
delete gTextureManagerBridgep;
- LLImageGL::sDefaultGLTexture = NULL ;
+ LLImageGL::sDefaultGLTexture = NULL;
LLViewerTexture::sNullImagep = NULL;
LLViewerTexture::sBlackImagep = NULL;
LLViewerTexture::sCheckerBoardImagep = NULL;
@@ -425,7 +429,7 @@ void LLViewerTextureManager::cleanup()
LLViewerFetchedTexture::sWhiteImagep = NULL;
LLViewerFetchedTexture::sFlatNormalImagep = NULL;
- LLViewerMediaTexture::cleanUpClass() ;
+ LLViewerMediaTexture::cleanUpClass();
}
//----------------------------------------------------------------------------------------------
@@ -435,7 +439,7 @@ void LLViewerTextureManager::cleanup()
// static
void LLViewerTexture::initClass()
{
- LLImageGL::sDefaultGLTexture = LLViewerFetchedTexture::sDefaultImagep->getGLTexture() ;
+ LLImageGL::sDefaultGLTexture = LLViewerFetchedTexture::sDefaultImagep->getGLTexture();
if(gSavedSettings.getBOOL("TextureFetchDebuggerEnabled"))
{
@@ -451,42 +455,42 @@ const S32 min_non_tex_system_mem = (128<<20); // 128 MB
F32 texmem_lower_bound_scale = 0.85f;
F32 texmem_middle_bound_scale = 0.925f;
-static LLFastTimer::DeclareTimer FTM_TEXTURE_MEMORY_CHECK("Memory Check");
+static LLTrace::TimeBlock FTM_TEXTURE_MEMORY_CHECK("Memory Check");
//static
bool LLViewerTexture::isMemoryForTextureLow()
{
- const F32 WAIT_TIME = 1.0f ; //second
- static LLFrameTimer timer ;
+ const F32 WAIT_TIME = 1.0f; //second
+ static LLFrameTimer timer;
if(timer.getElapsedTimeF32() < WAIT_TIME) //call this once per second.
{
return false;
}
- timer.reset() ;
+ timer.reset();
- LLFastTimer t(FTM_TEXTURE_MEMORY_CHECK);
+ LL_RECORD_BLOCK_TIME(FTM_TEXTURE_MEMORY_CHECK);
- const S32 MIN_FREE_TEXTURE_MEMORY = 5 ; //MB
- const S32 MIN_FREE_MAIN_MEMORy = 100 ; //MB
+ const S32Megabytes MIN_FREE_TEXTURE_MEMORY(5); //MB
+ const S32Megabytes MIN_FREE_MAIN_MEMORY(100); //MB
- bool low_mem = false ;
+ bool low_mem = false;
if (gGLManager.mHasATIMemInfo)
{
S32 meminfo[4];
glGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI, meminfo);
- if(meminfo[0] / 1024 < MIN_FREE_TEXTURE_MEMORY)
+ if((S32Megabytes)meminfo[0] < MIN_FREE_TEXTURE_MEMORY)
{
- low_mem = true ;
+ low_mem = true;
}
if(!low_mem) //check main memory, only works for windows.
{
- LLMemory::updateMemoryInfo() ;
- if(LLMemory::getAvailableMemKB() / 1024 < MIN_FREE_MAIN_MEMORy)
+ LLMemory::updateMemoryInfo();
+ if(LLMemory::getAvailableMemKB() < MIN_FREE_TEXTURE_MEMORY)
{
- low_mem = true ;
+ low_mem = true;
}
}
}
@@ -498,45 +502,45 @@ bool LLViewerTexture::isMemoryForTextureLow()
if(free_memory / 1024 < MIN_FREE_TEXTURE_MEMORY)
{
- low_mem = true ;
+ low_mem = true;
}
}
#endif
- return low_mem ;
+ return low_mem;
}
-static LLFastTimer::DeclareTimer FTM_TEXTURE_UPDATE_MEDIA("Media");
-static LLFastTimer::DeclareTimer FTM_TEXTURE_UPDATE_TEST("Test");
+static LLTrace::TimeBlock FTM_TEXTURE_UPDATE_MEDIA("Media");
+static LLTrace::TimeBlock FTM_TEXTURE_UPDATE_TEST("Test");
//static
void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity)
{
- sCurrentTime = gFrameTimeSeconds ;
+ sCurrentTime = gFrameTimeSeconds;
LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
if (tester)
{
- LLFastTimer t(FTM_TEXTURE_UPDATE_TEST);
- tester->update() ;
+ LL_RECORD_BLOCK_TIME(FTM_TEXTURE_UPDATE_TEST);
+ tester->update();
}
{
- LLFastTimer t(FTM_TEXTURE_UPDATE_MEDIA);
- LLViewerMediaTexture::updateClass() ;
+ LL_RECORD_BLOCK_TIME(FTM_TEXTURE_UPDATE_MEDIA);
+ LLViewerMediaTexture::updateClass();
}
- sBoundTextureMemoryInBytes = LLImageGL::sBoundTextureMemoryInBytes;//in bytes
- sTotalTextureMemoryInBytes = LLImageGL::sGlobalTextureMemoryInBytes;//in bytes
- sMaxBoundTextureMemInMegaBytes = gTextureList.getMaxResidentTexMem();//in MB
- sMaxTotalTextureMemInMegaBytes = gTextureList.getMaxTotalTextureMem() ;//in MB
- sMaxDesiredTextureMemInBytes = MEGA_BYTES_TO_BYTES(sMaxTotalTextureMemInMegaBytes) ; //in Bytes, by default and when total used texture memory is small.
+ sBoundTextureMemory = LLImageGL::sBoundTextureMemory;
+ sTotalTextureMemory = LLImageGL::sGlobalTextureMemory;
+ sMaxBoundTextureMem = gTextureList.getMaxResidentTexMem();
+ sMaxTotalTextureMem = gTextureList.getMaxTotalTextureMem();
+ sMaxDesiredTextureMem = sMaxTotalTextureMem; //in Bytes, by default and when total used texture memory is small.
- if (BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) >= sMaxBoundTextureMemInMegaBytes ||
- BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) >= sMaxTotalTextureMemInMegaBytes)
+ if (sBoundTextureMemory >= sMaxBoundTextureMem ||
+ sTotalTextureMemory >= sMaxTotalTextureMem)
{
- //when texture memory overflows, lower down the threashold to release the textures more aggressively.
- sMaxDesiredTextureMemInBytes = llmin((S32)(sMaxDesiredTextureMemInBytes * 0.75f) , MEGA_BYTES_TO_BYTES(MAX_VIDEO_RAM_IN_MEGA_BYTES)) ;//512 MB
+ //when texture memory overflows, lower down the threshold to release the textures more aggressively.
+ sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, F32Bytes(gMaxVideoRam));
// If we are using more texture memory than we should,
// scale up the desired discard level
@@ -552,8 +556,8 @@ void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity
sEvaluationTimer.reset();
}
else if (sDesiredDiscardBias > 0.0f &&
- BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) < sMaxBoundTextureMemInMegaBytes * texmem_lower_bound_scale &&
- BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) < sMaxTotalTextureMemInMegaBytes * texmem_lower_bound_scale)
+ sBoundTextureMemory < sMaxBoundTextureMem * texmem_lower_bound_scale &&
+ sTotalTextureMemory < sMaxTotalTextureMem * texmem_lower_bound_scale)
{
// If we are using less texture memory than we should,
// scale down the desired discard level
@@ -564,14 +568,14 @@ void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity
}
}
sDesiredDiscardBias = llclamp(sDesiredDiscardBias, desired_discard_bias_min, desired_discard_bias_max);
-
- F32 camera_moving_speed = LLViewerCamera::getInstance()->getAverageSpeed() ;
+
+ F32 camera_moving_speed = LLViewerCamera::getInstance()->getAverageSpeed();
F32 camera_angular_speed = LLViewerCamera::getInstance()->getAverageAngularSpeed();
sCameraMovingBias = llmax(0.2f * camera_moving_speed, 2.0f * camera_angular_speed - 1);
sCameraMovingDiscardBias = (S8)(sCameraMovingBias);
- LLViewerTexture::sFreezeImageScalingDown = (BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) < 0.75f * sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale) &&
- (BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) < 0.75f * sMaxTotalTextureMemInMegaBytes * texmem_middle_bound_scale) ;
+ LLViewerTexture::sFreezeImageScalingDown = (sBoundTextureMemory < 0.75f * sMaxBoundTextureMem * texmem_middle_bound_scale) &&
+ (sTotalTextureMemory < 0.75f * sMaxTotalTextureMem * texmem_middle_bound_scale);
}
//end of static functions
@@ -616,7 +620,7 @@ LLViewerTexture::LLViewerTexture(const LLImageRaw* raw, BOOL usemipmaps) :
LLViewerTexture::~LLViewerTexture()
{
- // LL_DEBUGS("Avatar") << mID << llendl;
+ // LL_DEBUGS("Avatar") << mID << LL_ENDL;
cleanup();
sImageCount--;
}
@@ -627,31 +631,31 @@ void LLViewerTexture::init(bool firstinit)
mSelectedTime = 0.f;
mMaxVirtualSize = 0.f;
mMaxVirtualSizeResetInterval = 1;
- mMaxVirtualSizeResetCounter = mMaxVirtualSizeResetInterval ;
- mAdditionalDecodePriority = 0.f ;
- mParcelMedia = NULL ;
+ mMaxVirtualSizeResetCounter = mMaxVirtualSizeResetInterval;
+ mAdditionalDecodePriority = 0.f;
+ mParcelMedia = NULL;
mNumVolumes = 0;
- mFaceList[LLRender::DIFFUSE_MAP].clear() ;
- mFaceList[LLRender::NORMAL_MAP].clear() ;
- mFaceList[LLRender::SPECULAR_MAP].clear() ;
+ mFaceList[LLRender::DIFFUSE_MAP].clear();
+ mFaceList[LLRender::NORMAL_MAP].clear();
+ mFaceList[LLRender::SPECULAR_MAP].clear();
mNumFaces[LLRender::DIFFUSE_MAP] =
mNumFaces[LLRender::NORMAL_MAP] =
- mNumFaces[LLRender::SPECULAR_MAP] = 0 ;
+ mNumFaces[LLRender::SPECULAR_MAP] = 0;
mVolumeList.clear();
}
//virtual
S8 LLViewerTexture::getType() const
{
- return LLViewerTexture::LOCAL_TEXTURE ;
+ return LLViewerTexture::LOCAL_TEXTURE;
}
void LLViewerTexture::cleanup()
{
- mFaceList[LLRender::DIFFUSE_MAP].clear() ;
- mFaceList[LLRender::NORMAL_MAP].clear() ;
- mFaceList[LLRender::SPECULAR_MAP].clear() ;
+ mFaceList[LLRender::DIFFUSE_MAP].clear();
+ mFaceList[LLRender::NORMAL_MAP].clear();
+ mFaceList[LLRender::SPECULAR_MAP].clear();
mVolumeList.clear();
}
@@ -660,20 +664,20 @@ void LLViewerTexture::dump()
{
LLGLTexture::dump();
- llinfos << "LLViewerTexture"
+ LL_INFOS() << "LLViewerTexture"
<< " mID " << mID
- << llendl;
+ << LL_ENDL;
}
void LLViewerTexture::setBoostLevel(S32 level)
{
if(mBoostLevel != level)
{
- mBoostLevel = level ;
+ mBoostLevel = level;
if(mBoostLevel != LLViewerTexture::BOOST_NONE &&
mBoostLevel != LLViewerTexture::BOOST_SELECTED)
{
- setNoDelete() ;
+ setNoDelete();
}
}
@@ -681,6 +685,30 @@ void LLViewerTexture::setBoostLevel(S32 level)
{
mSelectedTime = gFrameTimeSeconds;
}
+
+}
+
+bool LLViewerTexture::isActiveFetching()
+{
+ return false;
+}
+
+bool LLViewerTexture::bindDebugImage(const S32 stage)
+{
+ if (stage < 0) return false;
+
+ bool res = true;
+ if (LLViewerTexture::sCheckerBoardImagep.notNull() && (this != LLViewerTexture::sCheckerBoardImagep.get()))
+ {
+ res = gGL.getTexUnit(stage)->bind(LLViewerTexture::sCheckerBoardImagep);
+ }
+
+ if(!res)
+ {
+ return bindDefaultImage(stage);
+ }
+
+ return res;
}
bool LLViewerTexture::bindDefaultImage(S32 stage)
@@ -699,17 +727,17 @@ bool LLViewerTexture::bindDefaultImage(S32 stage)
}
if (!res)
{
- llwarns << "LLViewerTexture::bindDefaultImage failed." << llendl;
+ LL_WARNS() << "LLViewerTexture::bindDefaultImage failed." << LL_ENDL;
}
stop_glerror();
//check if there is cached raw image and switch to it if possible
- switchToCachedImage() ;
+ switchToCachedImage();
LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
if (tester)
{
- tester->updateGrayTextureBinding() ;
+ tester->updateGrayTextureBinding();
}
return res;
}
@@ -729,17 +757,17 @@ void LLViewerTexture::addTextureStats(F32 virtual_size, BOOL needs_gltexture) co
{
if(needs_gltexture)
{
- mNeedsGLTexture = TRUE ;
+ mNeedsGLTexture = TRUE;
}
virtual_size *= sTexelPixelRatio;
if(!mMaxVirtualSizeResetCounter)
{
//flag to reset the values because the old values are used.
- resetMaxVirtualSizeResetCounter() ;
+ resetMaxVirtualSizeResetCounter();
mMaxVirtualSize = virtual_size;
- mAdditionalDecodePriority = 0.f ;
- mNeedsGLTexture = needs_gltexture ;
+ mAdditionalDecodePriority = 0.f;
+ mNeedsGLTexture = needs_gltexture;
}
else if (virtual_size > mMaxVirtualSize)
{
@@ -749,15 +777,15 @@ void LLViewerTexture::addTextureStats(F32 virtual_size, BOOL needs_gltexture) co
void LLViewerTexture::resetTextureStats()
{
- mMaxVirtualSize = 0.0f ;
- mAdditionalDecodePriority = 0.f ;
- mMaxVirtualSizeResetCounter = 0 ;
+ mMaxVirtualSize = 0.0f;
+ mAdditionalDecodePriority = 0.f;
+ mMaxVirtualSizeResetCounter = 0;
}
//virtual
F32 LLViewerTexture::getMaxVirtualSize()
{
- return mMaxVirtualSize ;
+ return mMaxVirtualSize;
}
//virtual
@@ -773,12 +801,12 @@ void LLViewerTexture::addFace(U32 ch, LLFace* facep)
if(mNumFaces[ch] >= mFaceList[ch].size())
{
- mFaceList[ch].resize(2 * mNumFaces[ch] + 1) ;
+ mFaceList[ch].resize(2 * mNumFaces[ch] + 1);
}
- mFaceList[ch][mNumFaces[ch]] = facep ;
- facep->setIndexInTex(ch, mNumFaces[ch]) ;
- mNumFaces[ch]++ ;
- mLastFaceListUpdateTimer.reset() ;
+ mFaceList[ch][mNumFaces[ch]] = facep;
+ facep->setIndexInTex(ch, mNumFaces[ch]);
+ mNumFaces[ch]++;
+ mLastFaceListUpdateTimer.reset();
}
//virtual
@@ -788,18 +816,18 @@ void LLViewerTexture::removeFace(U32 ch, LLFace* facep)
if(mNumFaces[ch] > 1)
{
- S32 index = facep->getIndexInTex(ch) ;
+ S32 index = facep->getIndexInTex(ch);
llassert(index < mFaceList[ch].size());
llassert(index < mNumFaces[ch]);
- mFaceList[ch][index] = mFaceList[ch][--mNumFaces[ch]] ;
- mFaceList[ch][index]->setIndexInTex(ch, index) ;
+ mFaceList[ch][index] = mFaceList[ch][--mNumFaces[ch]];
+ mFaceList[ch][index]->setIndexInTex(ch, index);
}
else
{
- mFaceList[ch].clear() ;
- mNumFaces[ch] = 0 ;
+ mFaceList[ch].clear();
+ mNumFaces[ch] = 0;
}
- mLastFaceListUpdateTimer.reset() ;
+ mLastFaceListUpdateTimer.reset();
}
S32 LLViewerTexture::getTotalNumFaces() const
@@ -826,12 +854,12 @@ void LLViewerTexture::addVolume(LLVOVolume* volumep)
{
if( mNumVolumes >= mVolumeList.size())
{
- mVolumeList.resize(2 * mNumVolumes + 1) ;
+ mVolumeList.resize(2 * mNumVolumes + 1);
}
- mVolumeList[mNumVolumes] = volumep ;
- volumep->setIndexInTex(mNumVolumes) ;
- mNumVolumes++ ;
- mLastVolumeListUpdateTimer.reset() ;
+ mVolumeList[mNumVolumes] = volumep;
+ volumep->setIndexInTex(mNumVolumes);
+ mNumVolumes++;
+ mLastVolumeListUpdateTimer.reset();
}
//virtual
@@ -839,29 +867,29 @@ void LLViewerTexture::removeVolume(LLVOVolume* volumep)
{
if(mNumVolumes > 1)
{
- S32 index = volumep->getIndexInTex() ;
+ S32 index = volumep->getIndexInTex();
llassert(index < mVolumeList.size());
llassert(index < mNumVolumes);
- mVolumeList[index] = mVolumeList[--mNumVolumes] ;
- mVolumeList[index]->setIndexInTex(index) ;
+ mVolumeList[index] = mVolumeList[--mNumVolumes];
+ mVolumeList[index]->setIndexInTex(index);
}
else
{
- mVolumeList.clear() ;
- mNumVolumes = 0 ;
+ mVolumeList.clear();
+ mNumVolumes = 0;
}
- mLastVolumeListUpdateTimer.reset() ;
+ mLastVolumeListUpdateTimer.reset();
}
S32 LLViewerTexture::getNumVolumes() const
{
- return mNumVolumes ;
+ return mNumVolumes;
}
void LLViewerTexture::reorganizeFaceList()
{
static const F32 MAX_WAIT_TIME = 20.f; // seconds
- static const U32 MAX_EXTRA_BUFFER_SIZE = 4 ;
+ static const U32 MAX_EXTRA_BUFFER_SIZE = 4;
if(mLastFaceListUpdateTimer.getElapsedTimeF32() < MAX_WAIT_TIME)
{
@@ -871,32 +899,32 @@ void LLViewerTexture::reorganizeFaceList()
for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
{
if(mNumFaces[i] + MAX_EXTRA_BUFFER_SIZE > mFaceList[i].size())
- {
- return ;
- }
-
+ {
+ return;
+ }
+
mFaceList[i].erase(mFaceList[i].begin() + mNumFaces[i], mFaceList[i].end());
}
- mLastFaceListUpdateTimer.reset() ;
+ mLastFaceListUpdateTimer.reset();
}
void LLViewerTexture::reorganizeVolumeList()
{
static const F32 MAX_WAIT_TIME = 20.f; // seconds
- static const U32 MAX_EXTRA_BUFFER_SIZE = 4 ;
+ static const U32 MAX_EXTRA_BUFFER_SIZE = 4;
if(mNumVolumes + MAX_EXTRA_BUFFER_SIZE > mVolumeList.size())
{
- return ;
+ return;
}
if(mLastVolumeListUpdateTimer.getElapsedTimeF32() < MAX_WAIT_TIME)
{
- return ;
+ return;
}
- mLastVolumeListUpdateTimer.reset() ;
+ mLastVolumeListUpdateTimer.reset();
mVolumeList.erase(mVolumeList.begin() + mNumVolumes, mVolumeList.end());
}
@@ -914,7 +942,7 @@ void LLViewerTexture::setCachedRawImage(S32 discard_level, LLImageRaw* imageraw)
BOOL LLViewerTexture::isLargeImage()
{
- return (S32)mTexelsPerImage > LLViewerTexture::sMinLargeImageSize ;
+ return (S32)mTexelsPerImage > LLViewerTexture::sMinLargeImageSize;
}
//virtual
@@ -923,7 +951,7 @@ void LLViewerTexture::updateBindStatsForTester()
LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
if (tester)
{
- tester->updateTextureBindingStats(this) ;
+ tester->updateTextureBindingStats(this);
}
}
@@ -939,19 +967,19 @@ LLViewerFetchedTexture::LLViewerFetchedTexture(const LLUUID& id, FTType f_type,
: LLViewerTexture(id, usemipmaps),
mTargetHost(host)
{
- init(TRUE) ;
+ init(TRUE);
mFTType = f_type;
if (mFTType == FTT_HOST_BAKE)
{
mCanUseHTTP = false;
}
- generateGLTexture() ;
+ generateGLTexture();
}
LLViewerFetchedTexture::LLViewerFetchedTexture(const LLImageRaw* raw, FTType f_type, BOOL usemipmaps)
: LLViewerTexture(raw, usemipmaps)
{
- init(TRUE) ;
+ init(TRUE);
mFTType = f_type;
}
@@ -959,9 +987,9 @@ LLViewerFetchedTexture::LLViewerFetchedTexture(const std::string& url, FTType f_
: LLViewerTexture(id, usemipmaps),
mUrl(url)
{
- init(TRUE) ;
+ init(TRUE);
mFTType = f_type;
- generateGLTexture() ;
+ generateGLTexture();
}
void LLViewerFetchedTexture::init(bool firstinit)
@@ -972,7 +1000,7 @@ void LLViewerFetchedTexture::init(bool firstinit)
mRequestedDiscardLevel = -1;
mRequestedDownloadPriority = 0.f;
mFullyLoaded = FALSE;
- mCanUseHTTP = true ;
+ mCanUseHTTP = true;
mDesiredDiscardLevel = MAX_DISCARD_LEVEL + 1;
mMinDesiredDiscardLevel = MAX_DISCARD_LEVEL + 1;
@@ -980,7 +1008,7 @@ void LLViewerFetchedTexture::init(bool firstinit)
mKnownDrawWidth = 0;
mKnownDrawHeight = 0;
- mKnownDrawSizeChanged = FALSE ;
+ mKnownDrawSizeChanged = FALSE;
if (firstinit)
{
@@ -993,7 +1021,7 @@ void LLViewerFetchedTexture::init(bool firstinit)
mIsMissingAsset = FALSE;
mLoadedCallbackDesiredDiscardLevel = S8_MAX;
- mPauseLoadedCallBacks = FALSE ;
+ mPauseLoadedCallBacks = FALSE;
mNeedsCreateTexture = FALSE;
@@ -1008,21 +1036,21 @@ void LLViewerFetchedTexture::init(bool firstinit)
mDownloadProgress = 0.f;
mFetchDeltaTime = 999999.f;
mRequestDeltaTime = 0.f;
- mForSculpt = FALSE ;
- mIsFetched = FALSE ;
+ mForSculpt = FALSE;
+ mIsFetched = FALSE;
mInFastCacheList = FALSE;
- mCachedRawImage = NULL ;
- mCachedRawDiscardLevel = -1 ;
- mCachedRawImageReady = FALSE ;
-
- mSavedRawImage = NULL ;
- mForceToSaveRawImage = FALSE ;
- mSaveRawImage = FALSE ;
- mSavedRawDiscardLevel = -1 ;
- mDesiredSavedRawDiscardLevel = -1 ;
- mLastReferencedSavedRawImageTime = 0.0f ;
- mKeptSavedRawImageTime = 0.f ;
+ mCachedRawImage = NULL;
+ mCachedRawDiscardLevel = -1;
+ mCachedRawImageReady = FALSE;
+
+ mSavedRawImage = NULL;
+ mForceToSaveRawImage = FALSE;
+ mSaveRawImage = FALSE;
+ mSavedRawDiscardLevel = -1;
+ mDesiredSavedRawDiscardLevel = -1;
+ mLastReferencedSavedRawImageTime = 0.0f;
+ mKeptSavedRawImageTime = 0.f;
mLastCallBackActiveTime = 0.f;
mInDebug = FALSE;
@@ -1045,7 +1073,7 @@ LLViewerFetchedTexture::~LLViewerFetchedTexture()
//virtual
S8 LLViewerFetchedTexture::getType() const
{
- return LLViewerTexture::FETCHED_TEXTURE ;
+ return LLViewerTexture::FETCHED_TEXTURE;
}
FTType LLViewerFetchedTexture::getFTType() const
@@ -1062,7 +1090,7 @@ void LLViewerFetchedTexture::cleanup()
// We never finished loading the image. Indicate failure.
// Note: this allows mLoadedCallbackUserData to be cleaned up.
entryp->mCallback( FALSE, this, NULL, NULL, 0, TRUE, entryp->mUserData );
- entryp->removeTexture(this) ;
+ entryp->removeTexture(this);
delete entryp;
}
mLoadedCallbackList.clear();
@@ -1070,10 +1098,10 @@ void LLViewerFetchedTexture::cleanup()
// Clean up image data
destroyRawImage();
- mCachedRawImage = NULL ;
- mCachedRawDiscardLevel = -1 ;
- mCachedRawImageReady = FALSE ;
- mSavedRawImage = NULL ;
+ mCachedRawImage = NULL;
+ mCachedRawDiscardLevel = -1;
+ mCachedRawImageReady = FALSE;
+ mSavedRawImage = NULL;
mSavedRawDiscardLevel = -1;
}
@@ -1086,7 +1114,7 @@ void LLViewerFetchedTexture::loadFromFastCache()
}
mInFastCacheList = FALSE;
- mRawImage = LLAppViewer::getTextureCache()->readFromFastCache(getID(), mRawDiscardLevel) ;
+ mRawImage = LLAppViewer::getTextureCache()->readFromFastCache(getID(), mRawDiscardLevel);
if(mRawImage.notNull())
{
mFullWidth = mRawImage->getWidth() << mRawDiscardLevel;
@@ -1097,58 +1125,58 @@ void LLViewerFetchedTexture::loadFromFastCache()
{
//discard all oversized textures.
destroyRawImage();
- llwarns << "oversized, setting as missing" << llendl;
+ LL_WARNS() << "oversized, setting as missing" << LL_ENDL;
setIsMissingAsset();
- mRawDiscardLevel = INVALID_DISCARD_LEVEL ;
+ mRawDiscardLevel = INVALID_DISCARD_LEVEL;
}
else
{
mRequestedDiscardLevel = mDesiredDiscardLevel + 1;
mIsRawImageValid = TRUE;
- addToCreateTexture() ;
+ addToCreateTexture();
}
}
}
void LLViewerFetchedTexture::setForSculpt()
{
- static const S32 MAX_INTERVAL = 8 ; //frames
+ static const S32 MAX_INTERVAL = 8; //frames
- mForSculpt = TRUE ;
+ mForSculpt = TRUE;
if(isForSculptOnly() && hasGLTexture() && !getBoundRecently())
{
- destroyGLTexture() ; //sculpt image does not need gl texture.
+ destroyGLTexture(); //sculpt image does not need gl texture.
mTextureState = ACTIVE;
}
- checkCachedRawSculptImage() ;
- setMaxVirtualSizeResetInterval(MAX_INTERVAL) ;
+ checkCachedRawSculptImage();
+ setMaxVirtualSizeResetInterval(MAX_INTERVAL);
}
BOOL LLViewerFetchedTexture::isForSculptOnly() const
{
- return mForSculpt && !mNeedsGLTexture ;
+ return mForSculpt && !mNeedsGLTexture;
}
BOOL LLViewerFetchedTexture::isDeleted()
{
- return mTextureState == DELETED ;
+ return mTextureState == DELETED;
}
BOOL LLViewerFetchedTexture::isInactive()
{
- return mTextureState == INACTIVE ;
+ return mTextureState == INACTIVE;
}
BOOL LLViewerFetchedTexture::isDeletionCandidate()
{
- return mTextureState == DELETION_CANDIDATE ;
+ return mTextureState == DELETION_CANDIDATE;
}
void LLViewerFetchedTexture::setDeletionCandidate()
{
if(mGLTexturep.notNull() && mGLTexturep->getTexName() && (mTextureState == INACTIVE))
{
- mTextureState = DELETION_CANDIDATE ;
+ mTextureState = DELETION_CANDIDATE;
}
}
@@ -1157,7 +1185,7 @@ void LLViewerFetchedTexture::setInactive()
{
if(mTextureState == ACTIVE && mGLTexturep.notNull() && mGLTexturep->getTexName() && !mGLTexturep->getBoundRecently())
{
- mTextureState = INACTIVE ;
+ mTextureState = INACTIVE;
}
}
@@ -1174,84 +1202,84 @@ void LLViewerFetchedTexture::dump()
{
LLViewerTexture::dump();
- llinfos << "Dump : " << mID
+ LL_INFOS() << "Dump : " << mID
<< ", mIsMissingAsset = " << (S32)mIsMissingAsset
<< ", mFullWidth = " << (S32)mFullWidth
<< ", mFullHeight = " << (S32)mFullHeight
<< ", mOrigWidth = " << (S32)mOrigWidth
<< ", mOrigHeight = " << (S32)mOrigHeight
- << llendl;
- llinfos << " : "
+ << LL_ENDL;
+ LL_INFOS() << " : "
<< " mFullyLoaded = " << (S32)mFullyLoaded
<< ", mFetchState = " << (S32)mFetchState
<< ", mFetchPriority = " << (S32)mFetchPriority
<< ", mDownloadProgress = " << (F32)mDownloadProgress
- << llendl;
- llinfos << " : "
+ << LL_ENDL;
+ LL_INFOS() << " : "
<< " mHasFetcher = " << (S32)mHasFetcher
<< ", mIsFetching = " << (S32)mIsFetching
<< ", mIsFetched = " << (S32)mIsFetched
<< ", mBoostLevel = " << (S32)mBoostLevel
- << llendl;
+ << LL_ENDL;
}
///////////////////////////////////////////////////////////////////////////////
// ONLY called from LLViewerFetchedTextureList
void LLViewerFetchedTexture::destroyTexture()
{
- if(LLImageGL::sGlobalTextureMemoryInBytes < sMaxDesiredTextureMemInBytes * 0.95f)//not ready to release unused memory.
+ if(LLImageGL::sGlobalTextureMemory < sMaxDesiredTextureMem * 0.95f)//not ready to release unused memory.
{
return ;
}
if (mNeedsCreateTexture)//return if in the process of generating a new texture.
{
- return ;
+ return;
}
-
- //LL_DEBUGS("Avatar") << mID << llendl;
- destroyGLTexture() ;
- mFullyLoaded = FALSE ;
+
+ //LL_DEBUGS("Avatar") << mID << LL_ENDL;
+ destroyGLTexture();
+ mFullyLoaded = FALSE;
}
void LLViewerFetchedTexture::addToCreateTexture()
{
- bool force_update = false ;
+ bool force_update = false;
if (getComponents() != mRawImage->getComponents())
{
// We've changed the number of components, so we need to move any
// objects using this pool to a different pool.
mComponents = mRawImage->getComponents();
- mGLTexturep->setComponents(mComponents) ;
- force_update = true ;
+ mGLTexturep->setComponents(mComponents);
+ force_update = true;
for (U32 j = 0; j < LLRender::NUM_TEXTURE_CHANNELS; ++j)
{
llassert(mNumFaces[j] <= mFaceList[j].size());
- for(U32 i = 0 ; i < mNumFaces[j]; i++)
- {
- mFaceList[j][i]->dirtyTexture() ;
+ for(U32 i = 0; i < mNumFaces[j]; i++)
+ {
+ mFaceList[j][i]->dirtyTexture();
}
}
//discard the cached raw image and the saved raw image
- mCachedRawImageReady = FALSE ;
- mCachedRawDiscardLevel = -1 ;
- mCachedRawImage = NULL ;
- mSavedRawDiscardLevel = -1 ;
- mSavedRawImage = NULL ;
+ mCachedRawImageReady = FALSE;
+ mCachedRawDiscardLevel = -1;
+ mCachedRawImage = NULL;
+ mSavedRawDiscardLevel = -1;
+ mSavedRawImage = NULL;
}
if(isForSculptOnly())
{
//just update some variables, not to create a real GL texture.
- createGLTexture(mRawDiscardLevel, mRawImage, 0, FALSE) ;
- mNeedsCreateTexture = FALSE ;
+ createGLTexture(mRawDiscardLevel, mRawImage, 0, FALSE);
+ mNeedsCreateTexture = FALSE;
destroyRawImage();
}
else if(!force_update && getDiscardLevel() > -1 && getDiscardLevel() <= mRawDiscardLevel)
{
- mNeedsCreateTexture = FALSE ;
+ mNeedsCreateTexture = FALSE;
destroyRawImage();
}
else
@@ -1271,11 +1299,11 @@ void LLViewerFetchedTexture::addToCreateTexture()
//scale it down to size >= LLViewerTexture::sMinLargeImageSize
if(w * h > LLViewerTexture::sMinLargeImageSize)
{
- S32 d_level = llmin(mRequestedDiscardLevel, (S32)mDesiredDiscardLevel) - mRawDiscardLevel ;
+ S32 d_level = llmin(mRequestedDiscardLevel, (S32)mDesiredDiscardLevel) - mRawDiscardLevel;
if(d_level > 0)
{
- S32 i = 0 ;
+ S32 i = 0;
while((d_level > 0) && ((w >> i) * (h >> i) > LLViewerTexture::sMinLargeImageSize))
{
i++;
@@ -1283,12 +1311,12 @@ void LLViewerFetchedTexture::addToCreateTexture()
}
if(i > 0)
{
- mRawDiscardLevel += i ;
+ mRawDiscardLevel += i;
if(mRawDiscardLevel >= getDiscardLevel() && getDiscardLevel() > 0)
{
- mNeedsCreateTexture = FALSE ;
+ mNeedsCreateTexture = FALSE;
destroyRawImage();
- return ;
+ return;
}
{
@@ -1304,7 +1332,7 @@ void LLViewerFetchedTexture::addToCreateTexture()
mNeedsCreateTexture = TRUE;
gTextureList.mCreateTextureList.insert(this);
}
- return ;
+ return;
}
// ONLY called from LLViewerTextureList
@@ -1318,12 +1346,12 @@ BOOL LLViewerFetchedTexture::createTexture(S32 usename/*= 0*/)
mNeedsCreateTexture = FALSE;
if (mRawImage.isNull())
{
- llerrs << "LLViewerTexture trying to create texture with no Raw Image" << llendl;
+ LL_ERRS() << "LLViewerTexture trying to create texture with no Raw Image" << LL_ENDL;
}
-// llinfos << llformat("IMAGE Creating (%d) [%d x %d] Bytes: %d ",
+// LL_INFOS() << llformat("IMAGE Creating (%d) [%d x %d] Bytes: %d ",
// mRawDiscardLevel,
// mRawImage->getWidth(), mRawImage->getHeight(),mRawImage->getDataSize())
-// << mID.getString() << llendl;
+// << mID.getString() << LL_ENDL;
BOOL res = TRUE;
// store original size only for locally-sourced images
@@ -1358,14 +1386,14 @@ BOOL LLViewerFetchedTexture::createTexture(S32 usename/*= 0*/)
U32 raw_height = mRawImage->getHeight() << mRawDiscardLevel;
if( raw_width > MAX_IMAGE_SIZE || raw_height > MAX_IMAGE_SIZE )
{
- llinfos << "Width or height is greater than " << MAX_IMAGE_SIZE << ": (" << raw_width << "," << raw_height << ")" << llendl;
+ LL_INFOS() << "Width or height is greater than " << MAX_IMAGE_SIZE << ": (" << raw_width << "," << raw_height << ")" << LL_ENDL;
size_okay = false;
}
if (!LLImageGL::checkSize(mRawImage->getWidth(), mRawImage->getHeight()))
{
// A non power-of-two image was uploaded (through a non standard client)
- llinfos << "Non power of two width or height: (" << mRawImage->getWidth() << "," << mRawImage->getHeight() << ")" << llendl;
+ LL_INFOS() << "Non power of two width or height: (" << mRawImage->getWidth() << "," << mRawImage->getHeight() << ")" << LL_ENDL;
size_okay = false;
}
@@ -1374,15 +1402,15 @@ BOOL LLViewerFetchedTexture::createTexture(S32 usename/*= 0*/)
// An inappropriately-sized image was uploaded (through a non standard client)
// We treat these images as missing assets which causes them to
// be renderd as 'missing image' and to stop requesting data
- llwarns << "!size_ok, setting as missing" << llendl;
+ LL_WARNS() << "!size_ok, setting as missing" << LL_ENDL;
setIsMissingAsset();
destroyRawImage();
return FALSE;
}
- res = mGLTexturep->createGLTexture(mRawDiscardLevel, mRawImage, usename, TRUE, mBoostLevel);
+ res = mGLTexturep->createGLTexture(mRawDiscardLevel, mRawImage, usename, TRUE, mBoostLevel);
- setActive() ;
+ setActive();
if (!needsToSaveRawImage())
{
@@ -1398,11 +1426,11 @@ void LLViewerFetchedTexture::setKnownDrawSize(S32 width, S32 height)
{
if(mKnownDrawWidth < width || mKnownDrawHeight < height)
{
- mKnownDrawWidth = llmax(mKnownDrawWidth, width) ;
- mKnownDrawHeight = llmax(mKnownDrawHeight, height) ;
+ mKnownDrawWidth = llmax(mKnownDrawWidth, width);
+ mKnownDrawHeight = llmax(mKnownDrawHeight, height);
- mKnownDrawSizeChanged = TRUE ;
- mFullyLoaded = FALSE ;
+ mKnownDrawSizeChanged = TRUE;
+ mFullyLoaded = FALSE;
}
addTextureStats((F32)(mKnownDrawWidth * mKnownDrawHeight));
}
@@ -1414,13 +1442,13 @@ void LLViewerFetchedTexture::processTextureStats()
{
if(mDesiredDiscardLevel > mMinDesiredDiscardLevel)//need to load more
{
- mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, mMinDesiredDiscardLevel) ;
- mFullyLoaded = FALSE ;
+ mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, mMinDesiredDiscardLevel);
+ mFullyLoaded = FALSE;
}
}
else
{
- updateVirtualSize() ;
+ updateVirtualSize();
static LLCachedControl<bool> textures_fullres(gSavedSettings,"TextureLoadFullRes");
@@ -1430,7 +1458,7 @@ void LLViewerFetchedTexture::processTextureStats()
}
else if(!mFullWidth || !mFullHeight)
{
- mDesiredDiscardLevel = llmin(getMaxDiscardLevel(), (S32)mLoadedCallbackDesiredDiscardLevel) ;
+ mDesiredDiscardLevel = llmin(getMaxDiscardLevel(), (S32)mLoadedCallbackDesiredDiscardLevel);
}
else
{
@@ -1448,36 +1476,36 @@ void LLViewerFetchedTexture::processTextureStats()
else if(mKnownDrawSizeChanged)//known draw size is set
{
mDesiredDiscardLevel = (S8)llmin(log((F32)mFullWidth / mKnownDrawWidth) / log_2,
- log((F32)mFullHeight / mKnownDrawHeight) / log_2) ;
- mDesiredDiscardLevel = llclamp(mDesiredDiscardLevel, (S8)0, (S8)getMaxDiscardLevel()) ;
- mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, mMinDesiredDiscardLevel) ;
+ log((F32)mFullHeight / mKnownDrawHeight) / log_2);
+ mDesiredDiscardLevel = llclamp(mDesiredDiscardLevel, (S8)0, (S8)getMaxDiscardLevel());
+ mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, mMinDesiredDiscardLevel);
}
- mKnownDrawSizeChanged = FALSE ;
+ mKnownDrawSizeChanged = FALSE;
if(getDiscardLevel() >= 0 && (getDiscardLevel() <= mDesiredDiscardLevel))
{
- mFullyLoaded = TRUE ;
+ mFullyLoaded = TRUE;
}
}
}
if(mForceToSaveRawImage && mDesiredSavedRawDiscardLevel >= 0) //force to refetch the texture.
{
- mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S8)mDesiredSavedRawDiscardLevel) ;
+ mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S8)mDesiredSavedRawDiscardLevel);
if(getDiscardLevel() < 0 || getDiscardLevel() > mDesiredDiscardLevel)
{
- mFullyLoaded = FALSE ;
+ mFullyLoaded = FALSE;
}
}
}
-const F32 MAX_PRIORITY_PIXEL = 999.f ; //pixel area
-const F32 PRIORITY_BOOST_LEVEL_FACTOR = 1000.f ; //boost level
-const F32 PRIORITY_DELTA_DISCARD_LEVEL_FACTOR = 100000.f ; //delta discard
-const S32 MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY = 4 ;
-const F32 PRIORITY_ADDITIONAL_FACTOR = 1000000.f ; //additional
-const S32 MAX_ADDITIONAL_LEVEL_FOR_PRIORITY = 8 ;
-const F32 PRIORITY_BOOST_HIGH_FACTOR = 10000000.f ;//boost high
+const F32 MAX_PRIORITY_PIXEL = 999.f; //pixel area
+const F32 PRIORITY_BOOST_LEVEL_FACTOR = 1000.f; //boost level
+const F32 PRIORITY_DELTA_DISCARD_LEVEL_FACTOR = 100000.f; //delta discard
+const S32 MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY = 4;
+const F32 PRIORITY_ADDITIONAL_FACTOR = 1000000.f; //additional
+const S32 MAX_ADDITIONAL_LEVEL_FOR_PRIORITY = 8;
+const F32 PRIORITY_BOOST_HIGH_FACTOR = 10000000.f;//boost high
F32 LLViewerFetchedTexture::calcDecodePriority()
{
#ifndef LL_RELEASE_FOR_DOWNLOAD
@@ -1493,7 +1521,7 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
}
if(mFullyLoaded && !mForceToSaveRawImage)//already loaded for static texture
{
- return -1.0f ; //alreay fetched
+ return -1.0f; //alreay fetched
}
S32 cur_discard = getCurrentDiscardLevelForFetching();
@@ -1508,7 +1536,7 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
}
else if(mDesiredDiscardLevel >= cur_discard && cur_discard > -1)
{
- priority = -2.0f ;
+ priority = -2.0f;
}
else if(mCachedRawDiscardLevel > -1 && mDesiredDiscardLevel >= mCachedRawDiscardLevel)
{
@@ -1545,7 +1573,7 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
S32 ddiscard = MAX_DISCARD_LEVEL - (S32)desired;
ddiscard = llclamp(ddiscard, 0, MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY);
priority = (ddiscard + 1) * PRIORITY_DELTA_DISCARD_LEVEL_FACTOR;
- setAdditionalDecodePriority(0.1f) ;//boost the textures without any data so far.
+ setAdditionalDecodePriority(0.1f);//boost the textures without any data so far.
}
else if ((mMinDiscardLevel > 0) && (cur_discard <= mMinDiscardLevel))
{
@@ -1580,13 +1608,13 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
// [10,000,000] + [1,000,000-9,000,000] + [100,000-500,000] + [1-20,000] + [0-999]
if (priority > 0.0f)
{
- bool large_enough = mCachedRawImageReady && ((S32)mTexelsPerImage > sMinLargeImageSize) ;
+ bool large_enough = mCachedRawImageReady && ((S32)mTexelsPerImage > sMinLargeImageSize);
if(large_enough)
{
//Note:
//to give small, low-priority textures some chance to be fetched,
//cut the priority in half if the texture size is larger than 256 * 256 and has a 64*64 ready.
- priority *= 0.5f ;
+ priority *= 0.5f;
}
pixel_priority = llclamp(pixel_priority, 0.0f, MAX_PRIORITY_PIXEL);
@@ -1605,7 +1633,7 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
//Note:
//to give small, low-priority textures some chance to be fetched,
//if high priority texture has a 64*64 ready, lower its fetching priority.
- setAdditionalDecodePriority(0.5f) ;
+ setAdditionalDecodePriority(0.5f);
}
else
{
@@ -1622,7 +1650,7 @@ F32 LLViewerFetchedTexture::calcDecodePriority()
//Note:
//to give small, low-priority textures some chance to be fetched,
//cut the additional priority to a quarter if the texture size is larger than 256 * 256 and has a 64*64 ready.
- additional *= 0.25f ;
+ additional *= 0.25f;
}
priority += additional;
}
@@ -1637,9 +1665,9 @@ F32 LLViewerFetchedTexture::maxDecodePriority()
PRIORITY_ADDITIONAL_FACTOR * (MAX_ADDITIONAL_LEVEL_FOR_PRIORITY + 1) + //additional (view dependent factors)
PRIORITY_DELTA_DISCARD_LEVEL_FACTOR * (MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY + 1) + //delta discard
PRIORITY_BOOST_LEVEL_FACTOR * (BOOST_MAX_LEVEL - 1) + //boost level
- MAX_PRIORITY_PIXEL + 1.0f ; //pixel area.
+ MAX_PRIORITY_PIXEL + 1.0f; //pixel area.
- return max_priority ;
+ return max_priority;
}
//============================================================================
@@ -1650,7 +1678,7 @@ void LLViewerFetchedTexture::setDecodePriority(F32 priority)
if(mDecodePriority < F_ALMOST_ZERO)
{
- mStopFetchingTimer.reset() ;
+ mStopFetchingTimer.reset();
}
}
@@ -1667,35 +1695,35 @@ void LLViewerFetchedTexture::updateVirtualSize()
{
if(!mMaxVirtualSizeResetCounter)
{
- addTextureStats(0.f, FALSE) ;//reset
+ addTextureStats(0.f, FALSE);//reset
}
for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
- {
+ {
llassert(mNumFaces[ch] <= mFaceList[ch].size());
- for(U32 i = 0 ; i < mNumFaces[ch]; i++)
+ for(U32 i = 0; i < mNumFaces[ch]; i++)
{
- LLFace* facep = mFaceList[ch][i] ;
- if( facep )
+ LLFace* facep = mFaceList[ch][i];
+ if( facep )
+ {
+ LLDrawable* drawable = facep->getDrawable();
+ if (drawable)
{
- LLDrawable* drawable = facep->getDrawable();
- if (drawable)
+ if(drawable->isRecentlyVisible())
{
- if(drawable->isRecentlyVisible())
+ if (getBoostLevel() == LLViewerTexture::BOOST_NONE &&
+ drawable->getVObj() && drawable->getVObj()->isSelected())
{
- if (getBoostLevel() == LLViewerTexture::BOOST_NONE &&
- drawable->getVObj() && drawable->getVObj()->isSelected())
- {
- setBoostLevel(LLViewerTexture::BOOST_SELECTED);
- }
- addTextureStats(facep->getVirtualSize()) ;
- setAdditionalDecodePriority(facep->getImportanceToCamera()) ;
+ setBoostLevel(LLViewerTexture::BOOST_SELECTED);
}
+ addTextureStats(facep->getVirtualSize());
+ setAdditionalDecodePriority(facep->getImportanceToCamera());
}
}
}
}
+ }
//reset whether or not a face was selected after 10 seconds
const F32 SELECTION_RESET_TIME = 10.f;
@@ -1709,26 +1737,26 @@ void LLViewerFetchedTexture::updateVirtualSize()
{
mMaxVirtualSizeResetCounter--;
}
- reorganizeFaceList() ;
+ reorganizeFaceList();
reorganizeVolumeList();
}
S32 LLViewerFetchedTexture::getCurrentDiscardLevelForFetching()
{
- S32 current_discard = getDiscardLevel() ;
+ S32 current_discard = getDiscardLevel();
if(mForceToSaveRawImage)
{
if(mSavedRawDiscardLevel < 0 || current_discard < 0)
{
- current_discard = -1 ;
+ current_discard = -1;
}
else
{
- current_discard = llmax(current_discard, mSavedRawDiscardLevel) ;
+ current_discard = llmax(current_discard, mSavedRawDiscardLevel);
}
}
- return current_discard ;
+ return current_discard;
}
bool LLViewerFetchedTexture::setDebugFetching(S32 debug_level)
@@ -1745,6 +1773,13 @@ bool LLViewerFetchedTexture::setDebugFetching(S32 debug_level)
return true;
}
+bool LLViewerFetchedTexture::isActiveFetching()
+{
+ static LLCachedControl<bool> monitor_enabled(gSavedSettings,"DebugShowTextureInfo");
+
+ return mFetchState > 7 && mFetchState < 10 && monitor_enabled; //in state of WAIT_HTTP_REQ or DECODE_IMAGE.
+}
+
bool LLViewerFetchedTexture::updateFetch()
{
static LLCachedControl<bool> textures_decode_disabled(gSavedSettings,"TextureDecodeDisabled");
@@ -1752,7 +1787,7 @@ bool LLViewerFetchedTexture::updateFetch()
static LLCachedControl<S32> sCameraMotionBoost(gSavedSettings,"TextureCameraMotionBoost");
if(textures_decode_disabled)
{
- return false ;
+ return false;
}
mFetchState = 0;
@@ -1787,7 +1822,7 @@ bool LLViewerFetchedTexture::updateFetch()
return false;
}
- S32 current_discard = getCurrentDiscardLevelForFetching() ;
+ S32 current_discard = getCurrentDiscardLevelForFetching();
S32 desired_discard = getDesiredDiscardLevel();
F32 decode_priority = getDecodePriority();
decode_priority = llclamp(decode_priority, 0.0f, maxDecodePriority());
@@ -1805,7 +1840,7 @@ bool LLViewerFetchedTexture::updateFetch()
if (finished)
{
mIsFetching = FALSE;
- mLastPacketTimer.reset() ;
+ mLastPacketTimer.reset();
}
else
{
@@ -1819,8 +1854,8 @@ bool LLViewerFetchedTexture::updateFetch()
LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
if (tester)
{
- mIsFetched = TRUE ;
- tester->updateTextureLoadingStats(this, mRawImage, LLAppViewer::getTextureFetch()->isFromLocalCache(mID)) ;
+ mIsFetched = TRUE;
+ tester->updateTextureLoadingStats(this, mRawImage, LLAppViewer::getTextureFetch()->isFromLocalCache(mID));
}
mRawDiscardLevel = fetch_discard;
if ((mRawImage->getDataSize() > 0 && mRawDiscardLevel >= 0) &&
@@ -1834,19 +1869,19 @@ bool LLViewerFetchedTexture::updateFetch()
{
//discard all oversized textures.
destroyRawImage();
- llwarns << "oversize, setting as missing" << llendl;
+ LL_WARNS() << "oversize, setting as missing" << LL_ENDL;
setIsMissingAsset();
- mRawDiscardLevel = INVALID_DISCARD_LEVEL ;
- mIsFetching = FALSE ;
+ mRawDiscardLevel = INVALID_DISCARD_LEVEL;
+ mIsFetching = FALSE;
mLastPacketTimer.reset();
}
else
{
mIsRawImageValid = TRUE;
- addToCreateTexture() ;
+ addToCreateTexture();
}
- return TRUE ;
+ return TRUE;
}
else
{
@@ -1864,16 +1899,16 @@ bool LLViewerFetchedTexture::updateFetch()
// We finished but received no data
if (current_discard < 0)
{
- llwarns << "!mIsFetching, setting as missing, decode_priority " << decode_priority
+ LL_WARNS() << "!mIsFetching, setting as missing, decode_priority " << decode_priority
<< " mRawDiscardLevel " << mRawDiscardLevel
<< " current_discard " << current_discard
- << llendl;
+ << LL_ENDL;
setIsMissingAsset();
desired_discard = -1;
}
else
{
- //llwarns << mID << ": Setting min discard to " << current_discard << llendl;
+ //LL_WARNS() << mID << ": Setting min discard to " << current_discard << LL_ENDL;
mMinDiscardLevel = current_discard;
desired_discard = current_discard;
}
@@ -1891,13 +1926,13 @@ bool LLViewerFetchedTexture::updateFetch()
// // Useful debugging code for undesired deprioritization of textures.
// if (decode_priority <= 0.0f && desired_discard >= 0 && desired_discard < current_discard)
// {
-// llinfos << "Calling updateRequestPriority() with decode_priority = 0.0f" << llendl;
+// LL_INFOS() << "Calling updateRequestPriority() with decode_priority = 0.0f" << LL_ENDL;
// calcDecodePriority();
// }
- static const F32 MAX_HOLD_TIME = 5.0f ; //seconds to wait before canceling fecthing if decode_priority is 0.f.
+ static const F32 MAX_HOLD_TIME = 5.0f; //seconds to wait before canceling fecthing if decode_priority is 0.f.
if(decode_priority > 0.0f || mStopFetchingTimer.getElapsedTimeF32() > MAX_HOLD_TIME)
{
- mStopFetchingTimer.reset() ;
+ mStopFetchingTimer.reset();
LLAppViewer::getTextureFetch()->updateRequestPriority(mID, decode_priority);
}
}
@@ -1923,7 +1958,7 @@ bool LLViewerFetchedTexture::updateFetch()
else if(mCachedRawImage.notNull() && (current_discard < 0 || current_discard > mCachedRawDiscardLevel))
{
make_request = false;
- switchToCachedImage() ; //use the cached raw data first
+ switchToCachedImage(); //use the cached raw data first
}
//else if (!isJustBound() && mCachedRawImageReady)
//{
@@ -1935,7 +1970,7 @@ bool LLViewerFetchedTexture::updateFetch()
// Load the texture progressively: we try not to rush to the desired discard too fast.
// If the camera is not moving, we do not tweak the discard level notch by notch but go to the desired discard with larger boosted steps
// This mitigates the "textures stay blurry" problem when loading while not killing the texture memory while moving around
- S32 delta_level = (mBoostLevel > LLGLTexture::BOOST_NONE) ? 2 : 1 ;
+ S32 delta_level = (mBoostLevel > LLGLTexture::BOOST_NONE) ? 2 : 1;
if (current_discard < 0)
{
desired_discard = llmax(desired_discard, getMaxDiscardLevel() - delta_level);
@@ -2006,7 +2041,7 @@ bool LLViewerFetchedTexture::updateFetch()
const F32 FETCH_IDLE_TIME = 5.f;
if (mLastPacketTimer.getElapsedTimeF32() > FETCH_IDLE_TIME)
{
- LL_DEBUGS("Texture") << "exceeded idle time " << FETCH_IDLE_TIME << ", deleting request: " << getID() << llendl;
+ LL_DEBUGS("Texture") << "exceeded idle time " << FETCH_IDLE_TIME << ", deleting request: " << getID() << LL_ENDL;
LLAppViewer::getTextureFetch()->deleteRequest(getID(), true);
mHasFetcher = FALSE;
}
@@ -2021,7 +2056,7 @@ void LLViewerFetchedTexture::clearFetchedResults()
{
if(mNeedsCreateTexture || mIsFetching)
{
- return ;
+ return;
}
cleanup();
@@ -2038,7 +2073,7 @@ void LLViewerFetchedTexture::forceToDeleteRequest()
if (mHasFetcher)
{
mHasFetcher = FALSE;
- mIsFetching = FALSE ;
+ mIsFetching = FALSE;
}
resetTextureStats();
@@ -2050,14 +2085,14 @@ void LLViewerFetchedTexture::setIsMissingAsset()
{
if (mUrl.empty())
{
- llwarns << mID << ": Marking image as missing" << llendl;
+ LL_WARNS() << mID << ": Marking image as missing" << LL_ENDL;
}
else
{
// This may or may not be an error - it is normal to have no
// map tile on an empty region, but bad if we're failing on a
// server bake texture.
- llwarns << mUrl << ": Marking image as missing" << llendl;
+ LL_WARNS() << mUrl << ": Marking image as missing" << LL_ENDL;
}
if (mHasFetcher)
{
@@ -2086,19 +2121,19 @@ void LLViewerFetchedTexture::setLoadedCallback( loaded_callback_func loaded_call
}
else
{
- mLoadedCallbackDesiredDiscardLevel = llmin(mLoadedCallbackDesiredDiscardLevel, (S8)discard_level) ;
+ mLoadedCallbackDesiredDiscardLevel = llmin(mLoadedCallbackDesiredDiscardLevel, (S8)discard_level);
}
if(mPauseLoadedCallBacks)
{
if(!pause)
{
- unpauseLoadedCallbacks(src_callback_list) ;
+ unpauseLoadedCallbacks(src_callback_list);
}
}
else if(pause)
{
- pauseLoadedCallbacks(src_callback_list) ;
+ pauseLoadedCallbacks(src_callback_list);
}
LLLoadedCallbackEntry* entryp = new LLLoadedCallbackEntry(loaded_callback, discard_level, keep_imageraw, userdata, src_callback_list, this, pause);
@@ -2107,21 +2142,21 @@ void LLViewerFetchedTexture::setLoadedCallback( loaded_callback_func loaded_call
mNeedsAux |= needs_aux;
if(keep_imageraw)
{
- mSaveRawImage = TRUE ;
+ mSaveRawImage = TRUE;
}
if (mNeedsAux && mAuxRawImage.isNull() && getDiscardLevel() >= 0)
{
// We need aux data, but we've already loaded the image, and it didn't have any
- llwarns << "No aux data available for callback for image:" << getID() << llendl;
+ LL_WARNS() << "No aux data available for callback for image:" << getID() << LL_ENDL;
}
- mLastCallBackActiveTime = sCurrentTime ;
+ mLastCallBackActiveTime = sCurrentTime;
}
void LLViewerFetchedTexture::clearCallbackEntryList()
{
if(mLoadedCallbackList.empty())
{
- return ;
+ return;
}
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
@@ -2132,29 +2167,29 @@ void LLViewerFetchedTexture::clearCallbackEntryList()
// We never finished loading the image. Indicate failure.
// Note: this allows mLoadedCallbackUserData to be cleaned up.
entryp->mCallback(FALSE, this, NULL, NULL, 0, TRUE, entryp->mUserData);
- iter = mLoadedCallbackList.erase(iter) ;
+ iter = mLoadedCallbackList.erase(iter);
delete entryp;
}
gTextureList.mCallbackList.erase(this);
- mLoadedCallbackDesiredDiscardLevel = S8_MAX ;
+ mLoadedCallbackDesiredDiscardLevel = S8_MAX;
if(needsToSaveRawImage())
{
- destroySavedRawImage() ;
+ destroySavedRawImage();
}
- return ;
+ return;
}
void LLViewerFetchedTexture::deleteCallbackEntry(const LLLoadedCallbackEntry::source_callback_list_t* callback_list)
{
if(mLoadedCallbackList.empty() || !callback_list)
{
- return ;
+ return;
}
- S32 desired_discard = S8_MAX ;
- S32 desired_raw_discard = INVALID_DISCARD_LEVEL ;
+ S32 desired_discard = S8_MAX;
+ S32 desired_raw_discard = INVALID_DISCARD_LEVEL;
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
iter != mLoadedCallbackList.end(); )
{
@@ -2164,17 +2199,17 @@ void LLViewerFetchedTexture::deleteCallbackEntry(const LLLoadedCallbackEntry::so
// We never finished loading the image. Indicate failure.
// Note: this allows mLoadedCallbackUserData to be cleaned up.
entryp->mCallback(FALSE, this, NULL, NULL, 0, TRUE, entryp->mUserData);
- iter = mLoadedCallbackList.erase(iter) ;
+ iter = mLoadedCallbackList.erase(iter);
delete entryp;
}
else
{
++iter;
- desired_discard = llmin(desired_discard, entryp->mDesiredDiscard) ;
+ desired_discard = llmin(desired_discard, entryp->mDesiredDiscard);
if(entryp->mNeedsImageRaw)
{
- desired_raw_discard = llmin(desired_raw_discard, entryp->mDesiredDiscard) ;
+ desired_raw_discard = llmin(desired_raw_discard, entryp->mDesiredDiscard);
}
}
}
@@ -2187,18 +2222,18 @@ void LLViewerFetchedTexture::deleteCallbackEntry(const LLLoadedCallbackEntry::so
if(needsToSaveRawImage())
{
- destroySavedRawImage() ;
+ destroySavedRawImage();
}
}
else if(needsToSaveRawImage() && mBoostLevel != LLGLTexture::BOOST_PREVIEW)
{
if(desired_raw_discard != INVALID_DISCARD_LEVEL)
{
- mDesiredSavedRawDiscardLevel = desired_raw_discard ;
+ mDesiredSavedRawDiscardLevel = desired_raw_discard;
}
else
{
- destroySavedRawImage() ;
+ destroySavedRawImage();
}
}
}
@@ -2207,29 +2242,29 @@ void LLViewerFetchedTexture::unpauseLoadedCallbacks(const LLLoadedCallbackEntry:
{
if(!callback_list)
{
- mPauseLoadedCallBacks = FALSE ;
- return ;
+ mPauseLoadedCallBacks = FALSE;
+ return;
}
- BOOL need_raw = FALSE ;
+ BOOL need_raw = FALSE;
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
iter != mLoadedCallbackList.end(); )
{
LLLoadedCallbackEntry *entryp = *iter++;
if(entryp->mSourceCallbackList == callback_list)
{
- entryp->mPaused = FALSE ;
+ entryp->mPaused = FALSE;
if(entryp->mNeedsImageRaw)
{
- need_raw = TRUE ;
+ need_raw = TRUE;
}
}
}
- mPauseLoadedCallBacks = FALSE ;
- mLastCallBackActiveTime = sCurrentTime ;
+ mPauseLoadedCallBacks = FALSE;
+ mLastCallBackActiveTime = sCurrentTime;
if(need_raw)
{
- mSaveRawImage = TRUE ;
+ mSaveRawImage = TRUE;
}
}
@@ -2237,10 +2272,10 @@ void LLViewerFetchedTexture::pauseLoadedCallbacks(const LLLoadedCallbackEntry::s
{
if(!callback_list)
{
- return ;
+ return;
}
- bool paused = true ;
+ bool paused = true;
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
iter != mLoadedCallbackList.end(); )
@@ -2248,25 +2283,25 @@ void LLViewerFetchedTexture::pauseLoadedCallbacks(const LLLoadedCallbackEntry::s
LLLoadedCallbackEntry *entryp = *iter++;
if(entryp->mSourceCallbackList == callback_list)
{
- entryp->mPaused = TRUE ;
+ entryp->mPaused = TRUE;
}
else if(!entryp->mPaused)
{
- paused = false ;
+ paused = false;
}
}
if(paused)
{
- mPauseLoadedCallBacks = TRUE ;//when set, loaded callback is paused.
+ mPauseLoadedCallBacks = TRUE;//when set, loaded callback is paused.
resetTextureStats();
- mSaveRawImage = FALSE ;
+ mSaveRawImage = FALSE;
}
}
bool LLViewerFetchedTexture::doLoadedCallbacks()
{
- static const F32 MAX_INACTIVE_TIME = 900.f ; //seconds
+ static const F32 MAX_INACTIVE_TIME = 900.f; //seconds
if (mNeedsCreateTexture)
{
@@ -2279,8 +2314,8 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
}
if(sCurrentTime - mLastCallBackActiveTime > MAX_INACTIVE_TIME && !mIsFetching)
{
- clearCallbackEntryList() ; //remove all callbacks.
- return false ;
+ clearCallbackEntryList(); //remove all callbacks.
+ return false;
}
bool res = false;
@@ -2300,7 +2335,7 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
// Remove ourself from the global list of textures with callbacks
gTextureList.mCallbackList.erase(this);
- return false ;
+ return false;
}
S32 gl_discard = getDiscardLevel();
@@ -2407,7 +2442,7 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
if (run_raw_callbacks && mIsRawImageValid && (mRawDiscardLevel <= getMaxDiscardLevel()))
{
// Do callbacks which require raw image data.
- //llinfos << "doLoadedCallbacks raw for " << getID() << llendl;
+ //LL_INFOS() << "doLoadedCallbacks raw for " << getID() << LL_ENDL;
// Call each party interested in the raw data.
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
@@ -2421,15 +2456,15 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
// to satisfy the interested party, then this is the last time that
// we're going to call them.
- mLastCallBackActiveTime = sCurrentTime ;
+ mLastCallBackActiveTime = sCurrentTime;
//llassert_always(mRawImage.notNull());
if(mNeedsAux && mAuxRawImage.isNull())
{
- llwarns << "Raw Image with no Aux Data for callback" << llendl;
+ LL_WARNS() << "Raw Image with no Aux Data for callback" << LL_ENDL;
}
BOOL final = mRawDiscardLevel <= entryp->mDesiredDiscard ? TRUE : FALSE;
- //llinfos << "Running callback for " << getID() << llendl;
- //llinfos << mRawImage->getWidth() << "x" << mRawImage->getHeight() << llendl;
+ //LL_INFOS() << "Running callback for " << getID() << LL_ENDL;
+ //LL_INFOS() << mRawImage->getWidth() << "x" << mRawImage->getHeight() << LL_ENDL;
entryp->mLastUsedDiscard = mRawDiscardLevel;
entryp->mCallback(TRUE, this, mRawImage, mAuxRawImage, mRawDiscardLevel, final, entryp->mUserData);
if (final)
@@ -2447,7 +2482,7 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
//
if (run_gl_callbacks && (gl_discard <= getMaxDiscardLevel()))
{
- //llinfos << "doLoadedCallbacks GL for " << getID() << llendl;
+ //LL_INFOS() << "doLoadedCallbacks GL for " << getID() << LL_ENDL;
// Call the callbacks interested in GL data.
for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
@@ -2457,7 +2492,7 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
LLLoadedCallbackEntry *entryp = *curiter;
if (!entryp->mNeedsImageRaw && (entryp->mLastUsedDiscard > gl_discard))
{
- mLastCallBackActiveTime = sCurrentTime ;
+ mLastCallBackActiveTime = sCurrentTime;
BOOL final = gl_discard <= entryp->mDesiredDiscard ? TRUE : FALSE;
entryp->mLastUsedDiscard = gl_discard;
entryp->mCallback(TRUE, this, NULL, NULL, gl_discard, final, entryp->mUserData);
@@ -2491,66 +2526,66 @@ void LLViewerFetchedTexture::forceImmediateUpdate()
//only immediately update a deleted texture which is now being re-used.
if(!isDeleted())
{
- return ;
+ return;
}
//if already called forceImmediateUpdate()
if(mInImageList && mDecodePriority == LLViewerFetchedTexture::maxDecodePriority())
{
- return ;
+ return;
}
- gTextureList.forceImmediateUpdate(this) ;
- return ;
+ gTextureList.forceImmediateUpdate(this);
+ return;
}
LLImageRaw* LLViewerFetchedTexture::reloadRawImage(S8 discard_level)
{
- llassert_always(mGLTexturep.notNull()) ;
+ llassert_always(mGLTexturep.notNull());
llassert_always(discard_level >= 0);
llassert_always(mComponents > 0);
if (mRawImage.notNull())
{
//mRawImage is in use by somebody else, do not delete it.
- return NULL ;
+ return NULL;
}
if(mSavedRawDiscardLevel >= 0 && mSavedRawDiscardLevel <= discard_level)
{
if(mSavedRawDiscardLevel != discard_level)
{
- mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), getComponents()) ;
- mRawImage->copy(getSavedRawImage()) ;
+ mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), getComponents());
+ mRawImage->copy(getSavedRawImage());
}
else
{
- mRawImage = getSavedRawImage() ;
+ mRawImage = getSavedRawImage();
}
- mRawDiscardLevel = discard_level ;
+ mRawDiscardLevel = discard_level;
}
else
{
//force to fetch raw image again if cached raw image is not good enough.
if(mCachedRawDiscardLevel > discard_level)
{
- mRawImage = mCachedRawImage ;
+ mRawImage = mCachedRawImage;
mRawDiscardLevel = mCachedRawDiscardLevel;
}
else //cached raw image is good enough, copy it.
{
if(mCachedRawDiscardLevel != discard_level)
{
- mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), getComponents()) ;
- mRawImage->copy(mCachedRawImage) ;
+ mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), getComponents());
+ mRawImage->copy(mCachedRawImage);
}
else
{
- mRawImage = mCachedRawImage ;
+ mRawImage = mCachedRawImage;
}
- mRawDiscardLevel = discard_level ;
+ mRawDiscardLevel = discard_level;
}
}
- mIsRawImageValid = TRUE ;
+ mIsRawImageValid = TRUE;
sRawCount++;
return mRawImage;
@@ -2558,7 +2593,7 @@ LLImageRaw* LLViewerFetchedTexture::reloadRawImage(S8 discard_level)
bool LLViewerFetchedTexture::needsToSaveRawImage()
{
- return mForceToSaveRawImage || mSaveRawImage ;
+ return mForceToSaveRawImage || mSaveRawImage;
}
void LLViewerFetchedTexture::destroyRawImage()
@@ -2577,9 +2612,9 @@ void LLViewerFetchedTexture::destroyRawImage()
{
if(needsToSaveRawImage())
{
- saveRawImage() ;
+ saveRawImage();
}
- setCachedRawImage() ;
+ setCachedRawImage();
}
mRawImage = NULL;
@@ -2595,19 +2630,19 @@ void LLViewerFetchedTexture::switchToCachedImage()
{
if(mCachedRawImage.notNull())
{
- mRawImage = mCachedRawImage ;
+ mRawImage = mCachedRawImage;
if (getComponents() != mRawImage->getComponents())
{
// We've changed the number of components, so we need to move any
// objects using this pool to a different pool.
mComponents = mRawImage->getComponents();
- mGLTexturep->setComponents(mComponents) ;
+ mGLTexturep->setComponents(mComponents);
gTextureList.dirtyImage(this);
}
mIsRawImageValid = TRUE;
- mRawDiscardLevel = mCachedRawDiscardLevel ;
+ mRawDiscardLevel = mCachedRawDiscardLevel;
gTextureList.mCreateTextureList.insert(this);
mNeedsCreateTexture = TRUE;
}
@@ -2619,9 +2654,9 @@ void LLViewerFetchedTexture::setCachedRawImage(S32 discard_level, LLImageRaw* im
{
if(imageraw != mRawImage.get())
{
- mCachedRawImage = imageraw ;
- mCachedRawDiscardLevel = discard_level ;
- mCachedRawImageReady = TRUE ;
+ mCachedRawImage = imageraw;
+ mCachedRawDiscardLevel = discard_level;
+ mCachedRawImageReady = TRUE;
}
}
@@ -2629,49 +2664,49 @@ void LLViewerFetchedTexture::setCachedRawImage()
{
if(mRawImage == mCachedRawImage)
{
- return ;
+ return;
}
if(!mIsRawImageValid)
{
- return ;
+ return;
}
if(mCachedRawImageReady)
{
- return ;
+ return;
}
if(mCachedRawDiscardLevel < 0 || mCachedRawDiscardLevel > mRawDiscardLevel)
{
- S32 i = 0 ;
- S32 w = mRawImage->getWidth() ;
- S32 h = mRawImage->getHeight() ;
+ S32 i = 0;
+ S32 w = mRawImage->getWidth();
+ S32 h = mRawImage->getHeight();
- S32 max_size = MAX_CACHED_RAW_IMAGE_AREA ;
+ S32 max_size = MAX_CACHED_RAW_IMAGE_AREA;
if(LLGLTexture::BOOST_TERRAIN == mBoostLevel)
{
- max_size = MAX_CACHED_RAW_TERRAIN_IMAGE_AREA ;
+ max_size = MAX_CACHED_RAW_TERRAIN_IMAGE_AREA;
}
if(mForSculpt)
{
- max_size = MAX_CACHED_RAW_SCULPT_IMAGE_AREA ;
- mCachedRawImageReady = !mRawDiscardLevel ;
+ max_size = MAX_CACHED_RAW_SCULPT_IMAGE_AREA;
+ mCachedRawImageReady = !mRawDiscardLevel;
}
else
{
- mCachedRawImageReady = (!mRawDiscardLevel || ((w * h) >= max_size)) ;
+ mCachedRawImageReady = (!mRawDiscardLevel || ((w * h) >= max_size));
}
while(((w >> i) * (h >> i)) > max_size)
{
- ++i ;
+ ++i;
}
if(i)
{
if(!(w >> i) || !(h >> i))
{
- --i ;
+ --i;
}
{
@@ -2680,9 +2715,9 @@ void LLViewerFetchedTexture::setCachedRawImage()
mRawImage->scale(w >> i, h >> i) ;
}
}
- mCachedRawImage = mRawImage ;
- mRawDiscardLevel += i ;
- mCachedRawDiscardLevel = mRawDiscardLevel ;
+ mCachedRawImage = mRawImage;
+ mRawDiscardLevel += i;
+ mCachedRawDiscardLevel = mRawDiscardLevel;
}
}
@@ -2692,11 +2727,11 @@ void LLViewerFetchedTexture::checkCachedRawSculptImage()
{
if(getDiscardLevel() != 0)
{
- mCachedRawImageReady = FALSE ;
+ mCachedRawImageReady = FALSE;
}
else if(isForSculptOnly())
{
- resetTextureStats() ; //do not update this image any more.
+ resetTextureStats(); //do not update this image any more.
}
}
}
@@ -2705,45 +2740,45 @@ void LLViewerFetchedTexture::saveRawImage()
{
if(mRawImage.isNull() || mRawImage == mSavedRawImage || (mSavedRawDiscardLevel >= 0 && mSavedRawDiscardLevel <= mRawDiscardLevel))
{
- return ;
+ return;
}
- mSavedRawDiscardLevel = mRawDiscardLevel ;
- mSavedRawImage = new LLImageRaw(mRawImage->getData(), mRawImage->getWidth(), mRawImage->getHeight(), mRawImage->getComponents()) ;
+ mSavedRawDiscardLevel = mRawDiscardLevel;
+ mSavedRawImage = new LLImageRaw(mRawImage->getData(), mRawImage->getWidth(), mRawImage->getHeight(), mRawImage->getComponents());
if(mForceToSaveRawImage && mSavedRawDiscardLevel <= mDesiredSavedRawDiscardLevel)
{
- mForceToSaveRawImage = FALSE ;
+ mForceToSaveRawImage = FALSE;
}
- mLastReferencedSavedRawImageTime = sCurrentTime ;
+ mLastReferencedSavedRawImageTime = sCurrentTime;
}
void LLViewerFetchedTexture::forceToSaveRawImage(S32 desired_discard, F32 kept_time)
{
- mKeptSavedRawImageTime = kept_time ;
- mLastReferencedSavedRawImageTime = sCurrentTime ;
+ mKeptSavedRawImageTime = kept_time;
+ mLastReferencedSavedRawImageTime = sCurrentTime;
if(mSavedRawDiscardLevel > -1 && mSavedRawDiscardLevel <= desired_discard)
{
- return ; //raw imge is ready.
+ return; //raw imge is ready.
}
if(!mForceToSaveRawImage || mDesiredSavedRawDiscardLevel < 0 || mDesiredSavedRawDiscardLevel > desired_discard)
{
- mForceToSaveRawImage = TRUE ;
- mDesiredSavedRawDiscardLevel = desired_discard ;
+ mForceToSaveRawImage = TRUE;
+ mDesiredSavedRawDiscardLevel = desired_discard;
//copy from the cached raw image if exists.
if(mCachedRawImage.notNull() && mRawImage.isNull() )
{
- mRawImage = mCachedRawImage ;
- mRawDiscardLevel = mCachedRawDiscardLevel ;
+ mRawImage = mCachedRawImage;
+ mRawDiscardLevel = mCachedRawDiscardLevel;
- saveRawImage() ;
+ saveRawImage();
- mRawImage = NULL ;
- mRawDiscardLevel = INVALID_DISCARD_LEVEL ;
+ mRawImage = NULL;
+ mRawDiscardLevel = INVALID_DISCARD_LEVEL;
}
}
}
@@ -2751,38 +2786,38 @@ void LLViewerFetchedTexture::destroySavedRawImage()
{
if(mLastReferencedSavedRawImageTime < mKeptSavedRawImageTime)
{
- return ; //keep the saved raw image.
+ return; //keep the saved raw image.
}
- mForceToSaveRawImage = FALSE ;
- mSaveRawImage = FALSE ;
+ mForceToSaveRawImage = FALSE;
+ mSaveRawImage = FALSE;
- clearCallbackEntryList() ;
+ clearCallbackEntryList();
- mSavedRawImage = NULL ;
- mForceToSaveRawImage = FALSE ;
- mSaveRawImage = FALSE ;
- mSavedRawDiscardLevel = -1 ;
- mDesiredSavedRawDiscardLevel = -1 ;
- mLastReferencedSavedRawImageTime = 0.0f ;
- mKeptSavedRawImageTime = 0.f ;
+ mSavedRawImage = NULL;
+ mForceToSaveRawImage = FALSE;
+ mSaveRawImage = FALSE;
+ mSavedRawDiscardLevel = -1;
+ mDesiredSavedRawDiscardLevel = -1;
+ mLastReferencedSavedRawImageTime = 0.0f;
+ mKeptSavedRawImageTime = 0.f;
}
LLImageRaw* LLViewerFetchedTexture::getSavedRawImage()
{
- mLastReferencedSavedRawImageTime = sCurrentTime ;
+ mLastReferencedSavedRawImageTime = sCurrentTime;
- return mSavedRawImage ;
+ return mSavedRawImage;
}
BOOL LLViewerFetchedTexture::hasSavedRawImage() const
{
- return mSavedRawImage.notNull() ;
+ return mSavedRawImage.notNull();
}
F32 LLViewerFetchedTexture::getElapsedLastReferencedSavedRawImageTime() const
{
- return sCurrentTime - mLastReferencedSavedRawImageTime ;
+ return sCurrentTime - mLastReferencedSavedRawImageTime;
}
//----------------------------------------------------------------------------------------------
@@ -2795,13 +2830,13 @@ F32 LLViewerFetchedTexture::getElapsedLastReferencedSavedRawImageTime() const
LLViewerLODTexture::LLViewerLODTexture(const LLUUID& id, FTType f_type, const LLHost& host, BOOL usemipmaps)
: LLViewerFetchedTexture(id, f_type, host, usemipmaps)
{
- init(TRUE) ;
+ init(TRUE);
}
LLViewerLODTexture::LLViewerLODTexture(const std::string& url, FTType f_type, const LLUUID& id, BOOL usemipmaps)
: LLViewerFetchedTexture(url, f_type, id, usemipmaps)
{
- init(TRUE) ;
+ init(TRUE);
}
void LLViewerLODTexture::init(bool firstinit)
@@ -2814,19 +2849,19 @@ void LLViewerLODTexture::init(bool firstinit)
//virtual
S8 LLViewerLODTexture::getType() const
{
- return LLViewerTexture::LOD_TEXTURE ;
+ return LLViewerTexture::LOD_TEXTURE;
}
BOOL LLViewerLODTexture::isUpdateFrozen()
{
- return LLViewerTexture::sFreezeImageScalingDown && !getDiscardLevel() ;
+ return LLViewerTexture::sFreezeImageScalingDown && !getDiscardLevel();
}
// This is gauranteed to get called periodically for every texture
//virtual
void LLViewerLODTexture::processTextureStats()
{
- updateVirtualSize() ;
+ updateVirtualSize();
static LLCachedControl<bool> textures_fullres(gSavedSettings,"TextureLoadFullRes");
@@ -2848,7 +2883,7 @@ void LLViewerLODTexture::processTextureStats()
}
else if (!mFullWidth || !mFullHeight)
{
- mDesiredDiscardLevel = getMaxDiscardLevel() ;
+ mDesiredDiscardLevel = getMaxDiscardLevel();
}
else
{
@@ -2874,7 +2909,7 @@ void LLViewerLODTexture::processTextureStats()
if(isLargeImage() && !isJustBound() && mAdditionalDecodePriority < 0.3f)
{
//if is a big image and not being used recently, nor close to the view point, do not load hi-res data.
- mMaxVirtualSize = llmin(mMaxVirtualSize, (F32)LLViewerTexture::sMinLargeImageSize) ;
+ mMaxVirtualSize = llmin(mMaxVirtualSize, (F32)LLViewerTexture::sMinLargeImageSize);
}
if ((mCalculatedDiscardLevel >= 0.f) &&
@@ -2895,7 +2930,7 @@ void LLViewerLODTexture::processTextureStats()
{
discard_level += sDesiredDiscardBias;
discard_level *= sDesiredDiscardScale; // scale
- discard_level += sCameraMovingDiscardBias ;
+ discard_level += sCameraMovingDiscardBias;
}
discard_level = floorf(discard_level);
@@ -2922,19 +2957,19 @@ void LLViewerLODTexture::processTextureStats()
if(desired_discard_bias_max <= sDesiredDiscardBias && !mForceToSaveRawImage)
{
//needs to release texture memory urgently
- scaleDown() ;
+ scaleDown();
}
// Limit the amount of GL memory bound each frame
- else if ( BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) > sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale &&
+ else if ( sBoundTextureMemory > sMaxBoundTextureMem * texmem_middle_bound_scale &&
(!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
{
- scaleDown() ;
+ scaleDown();
}
// Only allow GL to have 2x the video card memory
- else if ( BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) > sMaxTotalTextureMemInMegaBytes*texmem_middle_bound_scale &&
+ else if ( sTotalTextureMemory > sMaxTotalTextureMem * texmem_middle_bound_scale &&
(!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
{
- scaleDown() ;
+ scaleDown();
}
}
@@ -2942,13 +2977,13 @@ void LLViewerLODTexture::processTextureStats()
if(mForceToSaveRawImage && mDesiredSavedRawDiscardLevel >= 0)
{
- mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S8)mDesiredSavedRawDiscardLevel) ;
+ mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S8)mDesiredSavedRawDiscardLevel);
}
else if(LLPipeline::sMemAllocationThrottled)//release memory of large textures by decrease their resolutions.
{
if(scaleDown())
{
- mDesiredDiscardLevel = mCachedRawDiscardLevel ;
+ mDesiredDiscardLevel = mCachedRawDiscardLevel;
}
}
}
@@ -2957,17 +2992,17 @@ bool LLViewerLODTexture::scaleDown()
{
if(hasGLTexture() && mCachedRawDiscardLevel > getDiscardLevel())
{
- switchToCachedImage() ;
+ switchToCachedImage();
LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
if (tester)
{
- tester->setStablizingTime() ;
+ tester->setStablizingTime();
}
- return true ;
+ return true;
}
- return false ;
+ return false;
}
//----------------------------------------------------------------------------------------------
//end of LLViewerLODTexture
@@ -2979,14 +3014,14 @@ bool LLViewerLODTexture::scaleDown()
//static
void LLViewerMediaTexture::updateClass()
{
- static const F32 MAX_INACTIVE_TIME = 30.f ;
+ static const F32 MAX_INACTIVE_TIME = 30.f;
#if 0
//force to play media.
- gSavedSettings.setBOOL("AudioStreamingMedia", true) ;
+ gSavedSettings.setBOOL("AudioStreamingMedia", true);
#endif
- for(media_map_t::iterator iter = sMediaMap.begin() ; iter != sMediaMap.end(); )
+ for(media_map_t::iterator iter = sMediaMap.begin(); iter != sMediaMap.end(); )
{
LLViewerMediaTexture* mediap = iter->second;
@@ -2997,29 +3032,29 @@ void LLViewerMediaTexture::updateClass()
//
if(mediap->getLastReferencedTimer()->getElapsedTimeF32() > MAX_INACTIVE_TIME)
{
- media_map_t::iterator cur = iter++ ;
- sMediaMap.erase(cur) ;
- continue ;
+ media_map_t::iterator cur = iter++;
+ sMediaMap.erase(cur);
+ continue;
}
}
- ++iter ;
+ ++iter;
}
}
//static
void LLViewerMediaTexture::removeMediaImplFromTexture(const LLUUID& media_id)
{
- LLViewerMediaTexture* media_tex = findMediaTexture(media_id) ;
+ LLViewerMediaTexture* media_tex = findMediaTexture(media_id);
if(media_tex)
{
- media_tex->invalidateMediaImpl() ;
+ media_tex->invalidateMediaImpl();
}
}
//static
void LLViewerMediaTexture::cleanUpClass()
{
- sMediaMap.clear() ;
+ sMediaMap.clear();
}
//static
@@ -3031,9 +3066,9 @@ LLViewerMediaTexture* LLViewerMediaTexture::findMediaTexture(const LLUUID& media
return NULL;
}
- LLViewerMediaTexture* media_tex = iter->second ;
- media_tex->setMediaImpl() ;
- media_tex->getLastReferencedTimer()->reset() ;
+ LLViewerMediaTexture* media_tex = iter->second;
+ media_tex->setMediaImpl();
+ media_tex->getLastReferencedTimer()->reset();
return media_tex;
}
@@ -3045,48 +3080,48 @@ LLViewerMediaTexture::LLViewerMediaTexture(const LLUUID& id, BOOL usemipmaps, LL
{
sMediaMap.insert(std::make_pair(id, this));
- mGLTexturep = gl_image ;
+ mGLTexturep = gl_image;
if(mGLTexturep.isNull())
{
- generateGLTexture() ;
+ generateGLTexture();
}
mGLTexturep->setAllowCompression(false);
- mGLTexturep->setNeedsAlphaAndPickMask(FALSE) ;
+ mGLTexturep->setNeedsAlphaAndPickMask(FALSE);
- mIsPlaying = FALSE ;
+ mIsPlaying = FALSE;
- setMediaImpl() ;
+ setMediaImpl();
- setCategory(LLGLTexture::MEDIA) ;
+ setCategory(LLGLTexture::MEDIA);
- LLViewerTexture* tex = gTextureList.findImage(mID) ;
+ LLViewerTexture* tex = gTextureList.findImage(mID);
if(tex) //this media is a parcel media for tex.
{
- tex->setParcelMedia(this) ;
+ tex->setParcelMedia(this);
}
}
//virtual
LLViewerMediaTexture::~LLViewerMediaTexture()
{
- LLViewerTexture* tex = gTextureList.findImage(mID) ;
+ LLViewerTexture* tex = gTextureList.findImage(mID);
if(tex) //this media is a parcel media for tex.
{
- tex->setParcelMedia(NULL) ;
+ tex->setParcelMedia(NULL);
}
}
void LLViewerMediaTexture::reinit(BOOL usemipmaps /* = TRUE */)
{
- llassert(mGLTexturep.notNull()) ;
+ llassert(mGLTexturep.notNull());
- mUseMipMaps = usemipmaps ;
- getLastReferencedTimer()->reset() ;
- mGLTexturep->setUseMipMaps(mUseMipMaps) ;
- mGLTexturep->setNeedsAlphaAndPickMask(FALSE) ;
+ mUseMipMaps = usemipmaps;
+ getLastReferencedTimer()->reset();
+ mGLTexturep->setUseMipMaps(mUseMipMaps);
+ mGLTexturep->setNeedsAlphaAndPickMask(FALSE);
}
void LLViewerMediaTexture::setUseMipMaps(BOOL mipmap)
@@ -3095,26 +3130,26 @@ void LLViewerMediaTexture::setUseMipMaps(BOOL mipmap)
if(mGLTexturep.notNull())
{
- mGLTexturep->setUseMipMaps(mipmap) ;
+ mGLTexturep->setUseMipMaps(mipmap);
}
}
//virtual
S8 LLViewerMediaTexture::getType() const
{
- return LLViewerTexture::MEDIA_TEXTURE ;
+ return LLViewerTexture::MEDIA_TEXTURE;
}
void LLViewerMediaTexture::invalidateMediaImpl()
{
- mMediaImplp = NULL ;
+ mMediaImplp = NULL;
}
void LLViewerMediaTexture::setMediaImpl()
{
if(!mMediaImplp)
{
- mMediaImplp = LLViewerMedia::getMediaImplFromTextureID(mID) ;
+ mMediaImplp = LLViewerMedia::getMediaImplFromTextureID(mID);
}
}
@@ -3123,71 +3158,71 @@ void LLViewerMediaTexture::setMediaImpl()
// because it does not check the face validity after the current frame.
BOOL LLViewerMediaTexture::findFaces()
{
- mMediaFaceList.clear() ;
+ mMediaFaceList.clear();
- BOOL ret = TRUE ;
+ BOOL ret = TRUE;
- LLViewerTexture* tex = gTextureList.findImage(mID) ;
+ LLViewerTexture* tex = gTextureList.findImage(mID);
if(tex) //this media is a parcel media for tex.
{
for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
{
- const ll_face_list_t* face_list = tex->getFaceList(ch) ;
- U32 end = tex->getNumFaces(ch) ;
- for(U32 i = 0 ; i < end ; i++)
- {
- mMediaFaceList.push_back((*face_list)[i]) ;
- }
+ const ll_face_list_t* face_list = tex->getFaceList(ch);
+ U32 end = tex->getNumFaces(ch);
+ for(U32 i = 0; i < end; i++)
+ {
+ mMediaFaceList.push_back((*face_list)[i]);
}
}
+ }
if(!mMediaImplp)
{
- return TRUE ;
+ return TRUE;
}
//for media on a face.
- const std::list< LLVOVolume* >* obj_list = mMediaImplp->getObjectList() ;
- std::list< LLVOVolume* >::const_iterator iter = obj_list->begin() ;
+ const std::list< LLVOVolume* >* obj_list = mMediaImplp->getObjectList();
+ std::list< LLVOVolume* >::const_iterator iter = obj_list->begin();
for(; iter != obj_list->end(); ++iter)
{
- LLVOVolume* obj = *iter ;
+ LLVOVolume* obj = *iter;
if(obj->mDrawable.isNull())
{
- ret = FALSE ;
- continue ;
+ ret = FALSE;
+ continue;
}
- S32 face_id = -1 ;
- S32 num_faces = obj->mDrawable->getNumFaces() ;
+ S32 face_id = -1;
+ S32 num_faces = obj->mDrawable->getNumFaces();
while((face_id = obj->getFaceIndexWithMediaImpl(mMediaImplp, face_id)) > -1 && face_id < num_faces)
{
- LLFace* facep = obj->mDrawable->getFace(face_id) ;
+ LLFace* facep = obj->mDrawable->getFace(face_id);
if(facep)
{
- mMediaFaceList.push_back(facep) ;
+ mMediaFaceList.push_back(facep);
}
else
{
- ret = FALSE ;
+ ret = FALSE;
}
}
}
- return ret ;
+ return ret;
}
void LLViewerMediaTexture::initVirtualSize()
{
if(mIsPlaying)
{
- return ;
+ return;
}
- findFaces() ;
+ findFaces();
for(std::list< LLFace* >::iterator iter = mMediaFaceList.begin(); iter!= mMediaFaceList.end(); ++iter)
{
- addTextureStats((*iter)->getVirtualSize()) ;
+ addTextureStats((*iter)->getVirtualSize());
}
}
@@ -3195,77 +3230,77 @@ void LLViewerMediaTexture::addMediaToFace(LLFace* facep)
{
if(facep)
{
- facep->setHasMedia(true) ;
+ facep->setHasMedia(true);
}
if(!mIsPlaying)
{
- return ; //no need to add the face because the media is not in playing.
+ return; //no need to add the face because the media is not in playing.
}
- switchTexture(LLRender::DIFFUSE_MAP, facep) ;
+ switchTexture(LLRender::DIFFUSE_MAP, facep);
}
void LLViewerMediaTexture::removeMediaFromFace(LLFace* facep)
{
if(!facep)
{
- return ;
+ return;
}
- facep->setHasMedia(false) ;
+ facep->setHasMedia(false);
if(!mIsPlaying)
{
- return ; //no need to remove the face because the media is not in playing.
+ return; //no need to remove the face because the media is not in playing.
}
- mIsPlaying = FALSE ; //set to remove the media from the face.
- switchTexture(LLRender::DIFFUSE_MAP, facep) ;
- mIsPlaying = TRUE ; //set the flag back.
+ mIsPlaying = FALSE; //set to remove the media from the face.
+ switchTexture(LLRender::DIFFUSE_MAP, facep);
+ mIsPlaying = TRUE; //set the flag back.
if(getTotalNumFaces() < 1) //no face referencing to this media
{
- stopPlaying() ;
+ stopPlaying();
}
}
//virtual
void LLViewerMediaTexture::addFace(U32 ch, LLFace* facep)
{
- LLViewerTexture::addFace(ch, facep) ;
+ LLViewerTexture::addFace(ch, facep);
- const LLTextureEntry* te = facep->getTextureEntry() ;
+ const LLTextureEntry* te = facep->getTextureEntry();
if(te && te->getID().notNull())
{
- LLViewerTexture* tex = gTextureList.findImage(te->getID()) ;
+ LLViewerTexture* tex = gTextureList.findImage(te->getID());
if(tex)
{
- mTextureList.push_back(tex) ;//increase the reference number by one for tex to avoid deleting it.
- return ;
+ mTextureList.push_back(tex);//increase the reference number by one for tex to avoid deleting it.
+ return;
}
}
//check if it is a parcel media
if(facep->getTexture() && facep->getTexture() != this && facep->getTexture()->getID() == mID)
{
- mTextureList.push_back(facep->getTexture()) ; //a parcel media.
- return ;
+ mTextureList.push_back(facep->getTexture()); //a parcel media.
+ return;
}
if(te && te->getID().notNull()) //should have a texture
{
- llerrs << "The face does not have a valid texture before media texture." << llendl ;
+ LL_ERRS() << "The face does not have a valid texture before media texture." << LL_ENDL;
}
}
//virtual
void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
{
- LLViewerTexture::removeFace(ch, facep) ;
+ LLViewerTexture::removeFace(ch, facep);
- const LLTextureEntry* te = facep->getTextureEntry() ;
+ const LLTextureEntry* te = facep->getTextureEntry();
if(te && te->getID().notNull())
{
- LLViewerTexture* tex = gTextureList.findImage(te->getID()) ;
+ LLViewerTexture* tex = gTextureList.findImage(te->getID());
if(tex)
{
for(std::list< LLPointer<LLViewerTexture> >::iterator iter = mTextureList.begin();
@@ -3273,8 +3308,8 @@ void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
{
if(*iter == tex)
{
- mTextureList.erase(iter) ; //decrease the reference number for tex by one.
- return ;
+ mTextureList.erase(iter); //decrease the reference number for tex by one.
+ return;
}
}
@@ -3282,13 +3317,13 @@ void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
for (U32 ch = 0; ch < 3; ++ch)
{
- //
- //we have some trouble here: the texture of the face is changed.
- //we need to find the former texture, and remove it from the list to avoid memory leaking.
+ //
+ //we have some trouble here: the texture of the face is changed.
+ //we need to find the former texture, and remove it from the list to avoid memory leaking.
llassert(mNumFaces[ch] <= mFaceList[ch].size());
- for(U32 j = 0 ; j < mNumFaces[ch] ; j++)
+ for(U32 j = 0; j < mNumFaces[ch]; j++)
{
te_list.push_back(mFaceList[ch][j]->getTextureEntry());//all textures are in use.
}
@@ -3296,8 +3331,8 @@ void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
if (te_list.empty())
{
- mTextureList.clear() ;
- return ;
+ mTextureList.clear();
+ return;
}
S32 end = te_list.size();
@@ -3307,18 +3342,18 @@ void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
{
S32 i = 0;
- for(i = 0 ; i < end ; i++)
+ for(i = 0; i < end; i++)
{
if(te_list[i] && te_list[i]->getID() == (*iter)->getID())//the texture is in use.
{
- te_list[i] = NULL ;
- break ;
+ te_list[i] = NULL;
+ break;
}
}
if(i == end) //no hit for this texture, remove it.
{
- mTextureList.erase(iter) ; //decrease the reference number for tex by one.
- return ;
+ mTextureList.erase(iter); //decrease the reference number for tex by one.
+ return;
}
}
}
@@ -3330,14 +3365,14 @@ void LLViewerMediaTexture::removeFace(U32 ch, LLFace* facep)
{
if((*iter)->getID() == mID)
{
- mTextureList.erase(iter) ; //decrease the reference number for tex by one.
- return ;
+ mTextureList.erase(iter); //decrease the reference number for tex by one.
+ return;
}
}
if(te && te->getID().notNull()) //should have a texture
{
- llerrs << "mTextureList texture reference number is corrupted." << llendl ;
+ LL_ERRS() << "mTextureList texture reference number is corrupted." << LL_ENDL;
}
}
@@ -3346,9 +3381,9 @@ void LLViewerMediaTexture::stopPlaying()
// Don't stop the media impl playing here -- this breaks non-inworld media (login screen, search, and media browser).
// if(mMediaImplp)
// {
-// mMediaImplp->stop() ;
+// mMediaImplp->stop();
// }
- mIsPlaying = FALSE ;
+ mIsPlaying = FALSE;
}
void LLViewerMediaTexture::switchTexture(U32 ch, LLFace* facep)
@@ -3361,29 +3396,29 @@ void LLViewerMediaTexture::switchTexture(U32 ch, LLFace* facep)
{
if(mID == facep->getTexture()->getID()) //this is a parcel media
{
- return ; //let the prim media win.
+ return; //let the prim media win.
}
}
if(mIsPlaying) //old textures switch to the media texture
{
- facep->switchTexture(ch, this) ;
+ facep->switchTexture(ch, this);
}
else //switch to old textures.
{
- const LLTextureEntry* te = facep->getTextureEntry() ;
+ const LLTextureEntry* te = facep->getTextureEntry();
if(te)
{
- LLViewerTexture* tex = te->getID().notNull() ? gTextureList.findImage(te->getID()) : NULL ;
+ LLViewerTexture* tex = te->getID().notNull() ? gTextureList.findImage(te->getID()) : NULL;
if(!tex && te->getID() != mID)//try parcel media.
{
- tex = gTextureList.findImage(mID) ;
+ tex = gTextureList.findImage(mID);
}
if(!tex)
{
- tex = LLViewerFetchedTexture::sDefaultImagep ;
+ tex = LLViewerFetchedTexture::sDefaultImagep;
}
- facep->switchTexture(ch, tex) ;
+ facep->switchTexture(ch, tex);
}
}
}
@@ -3393,36 +3428,36 @@ void LLViewerMediaTexture::setPlaying(BOOL playing)
{
if(!mMediaImplp)
{
- return ;
+ return;
}
if(!playing && !mIsPlaying)
{
- return ; //media is already off
+ return; //media is already off
}
if(playing == mIsPlaying && !mMediaImplp->isUpdated())
{
- return ; //nothing has changed since last time.
+ return; //nothing has changed since last time.
}
- mIsPlaying = playing ;
+ mIsPlaying = playing;
if(mIsPlaying) //is about to play this media
{
if(findFaces())
{
//about to update all faces.
- mMediaImplp->setUpdated(FALSE) ;
+ mMediaImplp->setUpdated(FALSE);
}
if(mMediaFaceList.empty())//no face pointing to this media
{
- stopPlaying() ;
- return ;
+ stopPlaying();
+ return;
}
for(std::list< LLFace* >::iterator iter = mMediaFaceList.begin(); iter!= mMediaFaceList.end(); ++iter)
{
- switchTexture(LLRender::DIFFUSE_MAP, *iter) ;
+ switchTexture(LLRender::DIFFUSE_MAP, *iter);
}
}
else //stop playing this media
@@ -3430,12 +3465,12 @@ void LLViewerMediaTexture::setPlaying(BOOL playing)
U32 ch = LLRender::DIFFUSE_MAP;
llassert(mNumFaces[ch] <= mFaceList[ch].size());
- for(U32 i = mNumFaces[ch] ; i ; i--)
+ for(U32 i = mNumFaces[ch]; i; i--)
{
- switchTexture(ch, mFaceList[ch][i - 1]) ; //current face could be removed in this function.
+ switchTexture(ch, mFaceList[ch][i - 1]); //current face could be removed in this function.
}
}
- return ;
+ return;
}
//virtual
@@ -3443,13 +3478,13 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
{
if(LLFrameTimer::getFrameCount() == mUpdateVirtualSizeTime)
{
- return mMaxVirtualSize ;
+ return mMaxVirtualSize;
}
- mUpdateVirtualSizeTime = LLFrameTimer::getFrameCount() ;
+ mUpdateVirtualSizeTime = LLFrameTimer::getFrameCount();
if(!mMaxVirtualSizeResetCounter)
{
- addTextureStats(0.f, FALSE) ;//reset
+ addTextureStats(0.f, FALSE);//reset
}
if(mIsPlaying) //media is playing
@@ -3457,28 +3492,28 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
{
llassert(mNumFaces[ch] <= mFaceList[ch].size());
- for(U32 i = 0 ; i < mNumFaces[ch] ; i++)
+ for(U32 i = 0; i < mNumFaces[ch]; i++)
{
- LLFace* facep = mFaceList[ch][i] ;
- if(facep->getDrawable()->isRecentlyVisible())
- {
- addTextureStats(facep->getVirtualSize()) ;
- }
- }
- }
+ LLFace* facep = mFaceList[ch][i];
+ if(facep->getDrawable()->isRecentlyVisible())
+ {
+ addTextureStats(facep->getVirtualSize());
+ }
+ }
+ }
}
else //media is not in playing
{
- findFaces() ;
+ findFaces();
if(!mMediaFaceList.empty())
{
for(std::list< LLFace* >::iterator iter = mMediaFaceList.begin(); iter!= mMediaFaceList.end(); ++iter)
{
- LLFace* facep = *iter ;
+ LLFace* facep = *iter;
if(facep->getDrawable()->isRecentlyVisible())
{
- addTextureStats(facep->getVirtualSize()) ;
+ addTextureStats(facep->getVirtualSize());
}
}
}
@@ -3488,10 +3523,10 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
{
mMaxVirtualSizeResetCounter--;
}
- reorganizeFaceList() ;
+ reorganizeFaceList();
reorganizeVolumeList();
- return mMaxVirtualSize ;
+ return mMaxVirtualSize;
}
//----------------------------------------------------------------------------------------------
//end of LLViewerMediaTexture
@@ -3502,27 +3537,27 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
//----------------------------------------------------------------------------------------------
LLTexturePipelineTester::LLTexturePipelineTester() : LLMetricPerformanceTesterWithSession(sTesterName)
{
- addMetric("TotalBytesLoaded") ;
- addMetric("TotalBytesLoadedFromCache") ;
- addMetric("TotalBytesLoadedForLargeImage") ;
- addMetric("TotalBytesLoadedForSculpties") ;
- addMetric("StartFetchingTime") ;
- addMetric("TotalGrayTime") ;
- addMetric("TotalStablizingTime") ;
- addMetric("StartTimeLoadingSculpties") ;
- addMetric("EndTimeLoadingSculpties") ;
-
- addMetric("Time") ;
- addMetric("TotalBytesBound") ;
- addMetric("TotalBytesBoundForLargeImage") ;
- addMetric("PercentageBytesBound") ;
+ addMetric("TotalBytesLoaded");
+ addMetric("TotalBytesLoadedFromCache");
+ addMetric("TotalBytesLoadedForLargeImage");
+ addMetric("TotalBytesLoadedForSculpties");
+ addMetric("StartFetchingTime");
+ addMetric("TotalGrayTime");
+ addMetric("TotalStablizingTime");
+ addMetric("StartTimeLoadingSculpties");
+ addMetric("EndTimeLoadingSculpties");
+
+ addMetric("Time");
+ addMetric("TotalBytesBound");
+ addMetric("TotalBytesBoundForLargeImage");
+ addMetric("PercentageBytesBound");
- mTotalBytesLoaded = 0 ;
- mTotalBytesLoadedFromCache = 0 ;
- mTotalBytesLoadedForLargeImage = 0 ;
- mTotalBytesLoadedForSculpties = 0 ;
+ mTotalBytesLoaded = (S32Bytes)0;
+ mTotalBytesLoadedFromCache = (S32Bytes)0;
+ mTotalBytesLoadedForLargeImage = (S32Bytes)0;
+ mTotalBytesLoadedForSculpties = (S32Bytes)0;
- reset() ;
+ reset();
}
LLTexturePipelineTester::~LLTexturePipelineTester()
@@ -3532,222 +3567,222 @@ LLTexturePipelineTester::~LLTexturePipelineTester()
void LLTexturePipelineTester::update()
{
- mLastTotalBytesUsed = mTotalBytesUsed ;
- mLastTotalBytesUsedForLargeImage = mTotalBytesUsedForLargeImage ;
- mTotalBytesUsed = 0 ;
- mTotalBytesUsedForLargeImage = 0 ;
+ mLastTotalBytesUsed = mTotalBytesUsed;
+ mLastTotalBytesUsedForLargeImage = mTotalBytesUsedForLargeImage;
+ mTotalBytesUsed = (S32Bytes)0;
+ mTotalBytesUsedForLargeImage = (S32Bytes)0;
if(LLAppViewer::getTextureFetch()->getNumRequests() > 0) //fetching list is not empty
{
if(mPause)
{
//start a new fetching session
- reset() ;
- mStartFetchingTime = LLImageGL::sLastFrameTime ;
- mPause = FALSE ;
+ reset();
+ mStartFetchingTime = LLImageGL::sLastFrameTime;
+ mPause = FALSE;
}
//update total gray time
if(mUsingDefaultTexture)
{
- mUsingDefaultTexture = FALSE ;
- mTotalGrayTime = LLImageGL::sLastFrameTime - mStartFetchingTime ;
+ mUsingDefaultTexture = FALSE;
+ mTotalGrayTime = LLImageGL::sLastFrameTime - mStartFetchingTime;
}
//update the stablizing timer.
- updateStablizingTime() ;
+ updateStablizingTime();
- outputTestResults() ;
+ outputTestResults();
}
else if(!mPause)
{
//stop the current fetching session
- mPause = TRUE ;
- outputTestResults() ;
- reset() ;
+ mPause = TRUE;
+ outputTestResults();
+ reset();
}
}
void LLTexturePipelineTester::reset()
{
- mPause = TRUE ;
+ mPause = TRUE;
- mUsingDefaultTexture = FALSE ;
- mStartStablizingTime = 0.0f ;
- mEndStablizingTime = 0.0f ;
+ mUsingDefaultTexture = FALSE;
+ mStartStablizingTime = 0.0f;
+ mEndStablizingTime = 0.0f;
- mTotalBytesUsed = 0 ;
- mTotalBytesUsedForLargeImage = 0 ;
- mLastTotalBytesUsed = 0 ;
- mLastTotalBytesUsedForLargeImage = 0 ;
+ mTotalBytesUsed = (S32Bytes)0;
+ mTotalBytesUsedForLargeImage = (S32Bytes)0;
+ mLastTotalBytesUsed = (S32Bytes)0;
+ mLastTotalBytesUsedForLargeImage = (S32Bytes)0;
- mStartFetchingTime = 0.0f ;
+ mStartFetchingTime = 0.0f;
- mTotalGrayTime = 0.0f ;
- mTotalStablizingTime = 0.0f ;
+ mTotalGrayTime = 0.0f;
+ mTotalStablizingTime = 0.0f;
- mStartTimeLoadingSculpties = 1.0f ;
- mEndTimeLoadingSculpties = 0.0f ;
+ mStartTimeLoadingSculpties = 1.0f;
+ mEndTimeLoadingSculpties = 0.0f;
}
//virtual
void LLTexturePipelineTester::outputTestRecord(LLSD *sd)
{
std::string currentLabel = getCurrentLabelName();
- (*sd)[currentLabel]["TotalBytesLoaded"] = (LLSD::Integer)mTotalBytesLoaded ;
- (*sd)[currentLabel]["TotalBytesLoadedFromCache"] = (LLSD::Integer)mTotalBytesLoadedFromCache ;
- (*sd)[currentLabel]["TotalBytesLoadedForLargeImage"] = (LLSD::Integer)mTotalBytesLoadedForLargeImage ;
- (*sd)[currentLabel]["TotalBytesLoadedForSculpties"] = (LLSD::Integer)mTotalBytesLoadedForSculpties ;
+ (*sd)[currentLabel]["TotalBytesLoaded"] = (LLSD::Integer)mTotalBytesLoaded.value();
+ (*sd)[currentLabel]["TotalBytesLoadedFromCache"] = (LLSD::Integer)mTotalBytesLoadedFromCache.value();
+ (*sd)[currentLabel]["TotalBytesLoadedForLargeImage"] = (LLSD::Integer)mTotalBytesLoadedForLargeImage.value();
+ (*sd)[currentLabel]["TotalBytesLoadedForSculpties"] = (LLSD::Integer)mTotalBytesLoadedForSculpties.value();
- (*sd)[currentLabel]["StartFetchingTime"] = (LLSD::Real)mStartFetchingTime ;
- (*sd)[currentLabel]["TotalGrayTime"] = (LLSD::Real)mTotalGrayTime ;
- (*sd)[currentLabel]["TotalStablizingTime"] = (LLSD::Real)mTotalStablizingTime ;
+ (*sd)[currentLabel]["StartFetchingTime"] = (LLSD::Real)mStartFetchingTime;
+ (*sd)[currentLabel]["TotalGrayTime"] = (LLSD::Real)mTotalGrayTime;
+ (*sd)[currentLabel]["TotalStablizingTime"] = (LLSD::Real)mTotalStablizingTime;
- (*sd)[currentLabel]["StartTimeLoadingSculpties"] = (LLSD::Real)mStartTimeLoadingSculpties ;
- (*sd)[currentLabel]["EndTimeLoadingSculpties"] = (LLSD::Real)mEndTimeLoadingSculpties ;
+ (*sd)[currentLabel]["StartTimeLoadingSculpties"] = (LLSD::Real)mStartTimeLoadingSculpties;
+ (*sd)[currentLabel]["EndTimeLoadingSculpties"] = (LLSD::Real)mEndTimeLoadingSculpties;
- (*sd)[currentLabel]["Time"] = LLImageGL::sLastFrameTime ;
- (*sd)[currentLabel]["TotalBytesBound"] = (LLSD::Integer)mLastTotalBytesUsed ;
- (*sd)[currentLabel]["TotalBytesBoundForLargeImage"] = (LLSD::Integer)mLastTotalBytesUsedForLargeImage ;
- (*sd)[currentLabel]["PercentageBytesBound"] = (LLSD::Real)(100.f * mLastTotalBytesUsed / mTotalBytesLoaded) ;
+ (*sd)[currentLabel]["Time"] = LLImageGL::sLastFrameTime;
+ (*sd)[currentLabel]["TotalBytesBound"] = (LLSD::Integer)mLastTotalBytesUsed.value();
+ (*sd)[currentLabel]["TotalBytesBoundForLargeImage"] = (LLSD::Integer)mLastTotalBytesUsedForLargeImage.value();
+ (*sd)[currentLabel]["PercentageBytesBound"] = (LLSD::Real)(100.f * mLastTotalBytesUsed / mTotalBytesLoaded);
}
void LLTexturePipelineTester::updateTextureBindingStats(const LLViewerTexture* imagep)
{
- U32 mem_size = (U32)imagep->getTextureMemory() ;
- mTotalBytesUsed += mem_size ;
+ U32Bytes mem_size = imagep->getTextureMemory();
+ mTotalBytesUsed += mem_size;
- if(MIN_LARGE_IMAGE_AREA <= (U32)(mem_size / (U32)imagep->getComponents()))
+ if(MIN_LARGE_IMAGE_AREA <= (U32)(mem_size.value() / (U32)imagep->getComponents()))
{
- mTotalBytesUsedForLargeImage += mem_size ;
+ mTotalBytesUsedForLargeImage += mem_size;
}
}
void LLTexturePipelineTester::updateTextureLoadingStats(const LLViewerFetchedTexture* imagep, const LLImageRaw* raw_imagep, BOOL from_cache)
{
- U32 data_size = (U32)raw_imagep->getDataSize() ;
- mTotalBytesLoaded += data_size ;
+ U32Bytes data_size = (U32Bytes)raw_imagep->getDataSize();
+ mTotalBytesLoaded += data_size;
if(from_cache)
{
- mTotalBytesLoadedFromCache += data_size ;
+ mTotalBytesLoadedFromCache += data_size;
}
- if(MIN_LARGE_IMAGE_AREA <= (U32)(data_size / (U32)raw_imagep->getComponents()))
+ if(MIN_LARGE_IMAGE_AREA <= (U32)(data_size.value() / (U32)raw_imagep->getComponents()))
{
- mTotalBytesLoadedForLargeImage += data_size ;
+ mTotalBytesLoadedForLargeImage += data_size;
}
if(imagep->forSculpt())
{
- mTotalBytesLoadedForSculpties += data_size ;
+ mTotalBytesLoadedForSculpties += data_size;
if(mStartTimeLoadingSculpties > mEndTimeLoadingSculpties)
{
- mStartTimeLoadingSculpties = LLImageGL::sLastFrameTime ;
+ mStartTimeLoadingSculpties = LLImageGL::sLastFrameTime;
}
- mEndTimeLoadingSculpties = LLImageGL::sLastFrameTime ;
+ mEndTimeLoadingSculpties = LLImageGL::sLastFrameTime;
}
}
void LLTexturePipelineTester::updateGrayTextureBinding()
{
- mUsingDefaultTexture = TRUE ;
+ mUsingDefaultTexture = TRUE;
}
void LLTexturePipelineTester::setStablizingTime()
{
if(mStartStablizingTime <= mStartFetchingTime)
{
- mStartStablizingTime = LLImageGL::sLastFrameTime ;
+ mStartStablizingTime = LLImageGL::sLastFrameTime;
}
- mEndStablizingTime = LLImageGL::sLastFrameTime ;
+ mEndStablizingTime = LLImageGL::sLastFrameTime;
}
void LLTexturePipelineTester::updateStablizingTime()
{
if(mStartStablizingTime > mStartFetchingTime)
{
- F32 t = mEndStablizingTime - mStartStablizingTime ;
+ F32 t = mEndStablizingTime - mStartStablizingTime;
if(t > F_ALMOST_ZERO && (t - mTotalStablizingTime) < F_ALMOST_ZERO)
{
//already stablized
- mTotalStablizingTime = LLImageGL::sLastFrameTime - mStartStablizingTime ;
+ mTotalStablizingTime = LLImageGL::sLastFrameTime - mStartStablizingTime;
//cancel the timer
- mStartStablizingTime = 0.f ;
- mEndStablizingTime = 0.f ;
+ mStartStablizingTime = 0.f;
+ mEndStablizingTime = 0.f;
}
else
{
- mTotalStablizingTime = t ;
+ mTotalStablizingTime = t;
}
}
- mTotalStablizingTime = 0.f ;
+ mTotalStablizingTime = 0.f;
}
//virtual
void LLTexturePipelineTester::compareTestSessions(std::ofstream* os)
{
- LLTexturePipelineTester::LLTextureTestSession* base_sessionp = dynamic_cast<LLTexturePipelineTester::LLTextureTestSession*>(mBaseSessionp) ;
- LLTexturePipelineTester::LLTextureTestSession* current_sessionp = dynamic_cast<LLTexturePipelineTester::LLTextureTestSession*>(mCurrentSessionp) ;
+ LLTexturePipelineTester::LLTextureTestSession* base_sessionp = dynamic_cast<LLTexturePipelineTester::LLTextureTestSession*>(mBaseSessionp);
+ LLTexturePipelineTester::LLTextureTestSession* current_sessionp = dynamic_cast<LLTexturePipelineTester::LLTextureTestSession*>(mCurrentSessionp);
if(!base_sessionp || !current_sessionp)
{
- llerrs << "type of test session does not match!" << llendl ;
+ LL_ERRS() << "type of test session does not match!" << LL_ENDL;
}
//compare and output the comparison
- *os << llformat("%s\n", getTesterName().c_str()) ;
- *os << llformat("AggregateResults\n") ;
+ *os << llformat("%s\n", getTesterName().c_str());
+ *os << llformat("AggregateResults\n");
- compareTestResults(os, "TotalFetchingTime", base_sessionp->mTotalFetchingTime, current_sessionp->mTotalFetchingTime) ;
- compareTestResults(os, "TotalGrayTime", base_sessionp->mTotalGrayTime, current_sessionp->mTotalGrayTime) ;
+ compareTestResults(os, "TotalFetchingTime", base_sessionp->mTotalFetchingTime, current_sessionp->mTotalFetchingTime);
+ compareTestResults(os, "TotalGrayTime", base_sessionp->mTotalGrayTime, current_sessionp->mTotalGrayTime);
compareTestResults(os, "TotalStablizingTime", base_sessionp->mTotalStablizingTime, current_sessionp->mTotalStablizingTime);
- compareTestResults(os, "StartTimeLoadingSculpties", base_sessionp->mStartTimeLoadingSculpties, current_sessionp->mStartTimeLoadingSculpties) ;
- compareTestResults(os, "TotalTimeLoadingSculpties", base_sessionp->mTotalTimeLoadingSculpties, current_sessionp->mTotalTimeLoadingSculpties) ;
+ compareTestResults(os, "StartTimeLoadingSculpties", base_sessionp->mStartTimeLoadingSculpties, current_sessionp->mStartTimeLoadingSculpties);
+ compareTestResults(os, "TotalTimeLoadingSculpties", base_sessionp->mTotalTimeLoadingSculpties, current_sessionp->mTotalTimeLoadingSculpties);
- compareTestResults(os, "TotalBytesLoaded", base_sessionp->mTotalBytesLoaded, current_sessionp->mTotalBytesLoaded) ;
- compareTestResults(os, "TotalBytesLoadedFromCache", base_sessionp->mTotalBytesLoadedFromCache, current_sessionp->mTotalBytesLoadedFromCache) ;
- compareTestResults(os, "TotalBytesLoadedForLargeImage", base_sessionp->mTotalBytesLoadedForLargeImage, current_sessionp->mTotalBytesLoadedForLargeImage) ;
- compareTestResults(os, "TotalBytesLoadedForSculpties", base_sessionp->mTotalBytesLoadedForSculpties, current_sessionp->mTotalBytesLoadedForSculpties) ;
+ compareTestResults(os, "TotalBytesLoaded", base_sessionp->mTotalBytesLoaded, current_sessionp->mTotalBytesLoaded);
+ compareTestResults(os, "TotalBytesLoadedFromCache", base_sessionp->mTotalBytesLoadedFromCache, current_sessionp->mTotalBytesLoadedFromCache);
+ compareTestResults(os, "TotalBytesLoadedForLargeImage", base_sessionp->mTotalBytesLoadedForLargeImage, current_sessionp->mTotalBytesLoadedForLargeImage);
+ compareTestResults(os, "TotalBytesLoadedForSculpties", base_sessionp->mTotalBytesLoadedForSculpties, current_sessionp->mTotalBytesLoadedForSculpties);
- *os << llformat("InstantResults\n") ;
- S32 size = llmin(base_sessionp->mInstantPerformanceListCounter, current_sessionp->mInstantPerformanceListCounter) ;
- for(S32 i = 0 ; i < size ; i++)
+ *os << llformat("InstantResults\n");
+ S32 size = llmin(base_sessionp->mInstantPerformanceListCounter, current_sessionp->mInstantPerformanceListCounter);
+ for(S32 i = 0; i < size; i++)
{
- *os << llformat("Time(B-T)-%.4f-%.4f\n", base_sessionp->mInstantPerformanceList[i].mTime, current_sessionp->mInstantPerformanceList[i].mTime) ;
+ *os << llformat("Time(B-T)-%.4f-%.4f\n", base_sessionp->mInstantPerformanceList[i].mTime, current_sessionp->mInstantPerformanceList[i].mTime);
compareTestResults(os, "AverageBytesUsedPerSecond", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond,
- current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond) ;
+ current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond);
compareTestResults(os, "AverageBytesUsedForLargeImagePerSecond", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond,
- current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond) ;
+ current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond);
compareTestResults(os, "AveragePercentageBytesUsedPerSecond", base_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond,
- current_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond) ;
+ current_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond);
}
if(size < base_sessionp->mInstantPerformanceListCounter)
{
- for(S32 i = size ; i < base_sessionp->mInstantPerformanceListCounter ; i++)
+ for(S32 i = size; i < base_sessionp->mInstantPerformanceListCounter; i++)
{
- *os << llformat("Time(B-T)-%.4f- \n", base_sessionp->mInstantPerformanceList[i].mTime) ;
+ *os << llformat("Time(B-T)-%.4f- \n", base_sessionp->mInstantPerformanceList[i].mTime);
- *os << llformat(", AverageBytesUsedPerSecond, %d, N/A \n", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond) ;
- *os << llformat(", AverageBytesUsedForLargeImagePerSecond, %d, N/A \n", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond) ;
- *os << llformat(", AveragePercentageBytesUsedPerSecond, %.4f, N/A \n", base_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond) ;
+ *os << llformat(", AverageBytesUsedPerSecond, %d, N/A \n", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond);
+ *os << llformat(", AverageBytesUsedForLargeImagePerSecond, %d, N/A \n", base_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond);
+ *os << llformat(", AveragePercentageBytesUsedPerSecond, %.4f, N/A \n", base_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond);
}
}
else if(size < current_sessionp->mInstantPerformanceListCounter)
{
- for(S32 i = size ; i < current_sessionp->mInstantPerformanceListCounter ; i++)
+ for(S32 i = size; i < current_sessionp->mInstantPerformanceListCounter; i++)
{
- *os << llformat("Time(B-T)- -%.4f\n", current_sessionp->mInstantPerformanceList[i].mTime) ;
+ *os << llformat("Time(B-T)- -%.4f\n", current_sessionp->mInstantPerformanceList[i].mTime);
- *os << llformat(", AverageBytesUsedPerSecond, N/A, %d\n", current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond) ;
- *os << llformat(", AverageBytesUsedForLargeImagePerSecond, N/A, %d\n", current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond) ;
- *os << llformat(", AveragePercentageBytesUsedPerSecond, N/A, %.4f\n", current_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond) ;
+ *os << llformat(", AverageBytesUsedPerSecond, N/A, %d\n", current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedPerSecond);
+ *os << llformat(", AverageBytesUsedForLargeImagePerSecond, N/A, %d\n", current_sessionp->mInstantPerformanceList[i].mAverageBytesUsedForLargeImagePerSecond);
+ *os << llformat(", AveragePercentageBytesUsedPerSecond, N/A, %.4f\n", current_sessionp->mInstantPerformanceList[i].mAveragePercentageBytesUsedPerSecond);
}
}
}
@@ -3755,144 +3790,144 @@ void LLTexturePipelineTester::compareTestSessions(std::ofstream* os)
//virtual
LLMetricPerformanceTesterWithSession::LLTestSession* LLTexturePipelineTester::loadTestSession(LLSD* log)
{
- LLTexturePipelineTester::LLTextureTestSession* sessionp = new LLTexturePipelineTester::LLTextureTestSession() ;
+ LLTexturePipelineTester::LLTextureTestSession* sessionp = new LLTexturePipelineTester::LLTextureTestSession();
if(!sessionp)
{
- return NULL ;
+ return NULL;
}
- F32 total_fetching_time = 0.f ;
- F32 total_gray_time = 0.f ;
- F32 total_stablizing_time = 0.f ;
- F32 total_loading_sculpties_time = 0.f ;
-
- F32 start_fetching_time = -1.f ;
- F32 start_fetching_sculpties_time = 0.f ;
-
- F32 last_time = 0.0f ;
- S32 frame_count = 0 ;
-
- sessionp->mInstantPerformanceListCounter = 0 ;
- sessionp->mInstantPerformanceList.resize(128) ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond = 0 ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond = 0 ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond = 0.f ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = 0.f ;
+ F32 total_fetching_time = 0.f;
+ F32 total_gray_time = 0.f;
+ F32 total_stablizing_time = 0.f;
+ F32 total_loading_sculpties_time = 0.f;
+
+ F32 start_fetching_time = -1.f;
+ F32 start_fetching_sculpties_time = 0.f;
+
+ F32 last_time = 0.0f;
+ S32 frame_count = 0;
+
+ sessionp->mInstantPerformanceListCounter = 0;
+ sessionp->mInstantPerformanceList.resize(128);
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond = 0;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond = 0;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond = 0.f;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = 0.f;
//load a session
std::string currentLabel = getCurrentLabelName();
- BOOL in_log = (*log).has(currentLabel) ;
+ BOOL in_log = (*log).has(currentLabel);
while (in_log)
{
- LLSD::String label = currentLabel ;
+ LLSD::String label = currentLabel;
if(sessionp->mInstantPerformanceListCounter >= (S32)sessionp->mInstantPerformanceList.size())
{
- sessionp->mInstantPerformanceList.resize(sessionp->mInstantPerformanceListCounter + 128) ;
+ sessionp->mInstantPerformanceList.resize(sessionp->mInstantPerformanceListCounter + 128);
}
//time
- F32 start_time = (*log)[label]["StartFetchingTime"].asReal() ;
- F32 cur_time = (*log)[label]["Time"].asReal() ;
+ F32 start_time = (*log)[label]["StartFetchingTime"].asReal();
+ F32 cur_time = (*log)[label]["Time"].asReal();
if(start_time - start_fetching_time > F_ALMOST_ZERO) //fetching has paused for a while
{
- sessionp->mTotalFetchingTime += total_fetching_time ;
- sessionp->mTotalGrayTime += total_gray_time ;
- sessionp->mTotalStablizingTime += total_stablizing_time ;
+ sessionp->mTotalFetchingTime += total_fetching_time;
+ sessionp->mTotalGrayTime += total_gray_time;
+ sessionp->mTotalStablizingTime += total_stablizing_time;
- sessionp->mStartTimeLoadingSculpties = start_fetching_sculpties_time ;
- sessionp->mTotalTimeLoadingSculpties += total_loading_sculpties_time ;
+ sessionp->mStartTimeLoadingSculpties = start_fetching_sculpties_time;
+ sessionp->mTotalTimeLoadingSculpties += total_loading_sculpties_time;
- start_fetching_time = start_time ;
- total_fetching_time = 0.0f ;
- total_gray_time = 0.f ;
- total_stablizing_time = 0.f ;
- total_loading_sculpties_time = 0.f ;
+ start_fetching_time = start_time;
+ total_fetching_time = 0.0f;
+ total_gray_time = 0.f;
+ total_stablizing_time = 0.f;
+ total_loading_sculpties_time = 0.f;
}
else
{
- total_fetching_time = cur_time - start_time ;
- total_gray_time = (*log)[label]["TotalGrayTime"].asReal() ;
- total_stablizing_time = (*log)[label]["TotalStablizingTime"].asReal() ;
+ total_fetching_time = cur_time - start_time;
+ total_gray_time = (*log)[label]["TotalGrayTime"].asReal();
+ total_stablizing_time = (*log)[label]["TotalStablizingTime"].asReal();
- total_loading_sculpties_time = (*log)[label]["EndTimeLoadingSculpties"].asReal() - (*log)[label]["StartTimeLoadingSculpties"].asReal() ;
+ total_loading_sculpties_time = (*log)[label]["EndTimeLoadingSculpties"].asReal() - (*log)[label]["StartTimeLoadingSculpties"].asReal();
if(start_fetching_sculpties_time < 0.f && total_loading_sculpties_time > 0.f)
{
- start_fetching_sculpties_time = (*log)[label]["StartTimeLoadingSculpties"].asReal() ;
+ start_fetching_sculpties_time = (*log)[label]["StartTimeLoadingSculpties"].asReal();
}
}
//total loaded bytes
- sessionp->mTotalBytesLoaded = (*log)[label]["TotalBytesLoaded"].asInteger() ;
- sessionp->mTotalBytesLoadedFromCache = (*log)[label]["TotalBytesLoadedFromCache"].asInteger() ;
- sessionp->mTotalBytesLoadedForLargeImage = (*log)[label]["TotalBytesLoadedForLargeImage"].asInteger() ;
- sessionp->mTotalBytesLoadedForSculpties = (*log)[label]["TotalBytesLoadedForSculpties"].asInteger() ;
+ sessionp->mTotalBytesLoaded = (*log)[label]["TotalBytesLoaded"].asInteger();
+ sessionp->mTotalBytesLoadedFromCache = (*log)[label]["TotalBytesLoadedFromCache"].asInteger();
+ sessionp->mTotalBytesLoadedForLargeImage = (*log)[label]["TotalBytesLoadedForLargeImage"].asInteger();
+ sessionp->mTotalBytesLoadedForSculpties = (*log)[label]["TotalBytesLoadedForSculpties"].asInteger();
//instant metrics
sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond +=
- (*log)[label]["TotalBytesBound"].asInteger() ;
+ (*log)[label]["TotalBytesBound"].asInteger();
sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond +=
- (*log)[label]["TotalBytesBoundForLargeImage"].asInteger() ;
+ (*log)[label]["TotalBytesBoundForLargeImage"].asInteger();
sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond +=
- (*log)[label]["PercentageBytesBound"].asReal() ;
- frame_count++ ;
+ (*log)[label]["PercentageBytesBound"].asReal();
+ frame_count++;
if(cur_time - last_time >= 1.0f)
{
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond /= frame_count ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond /= frame_count ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond /= frame_count ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = last_time ;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond /= frame_count;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond /= frame_count;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond /= frame_count;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = last_time;
- frame_count = 0 ;
- last_time = cur_time ;
- sessionp->mInstantPerformanceListCounter++ ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond = 0 ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond = 0 ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond = 0.f ;
- sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = 0.f ;
+ frame_count = 0;
+ last_time = cur_time;
+ sessionp->mInstantPerformanceListCounter++;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedPerSecond = 0;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAverageBytesUsedForLargeImagePerSecond = 0;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mAveragePercentageBytesUsedPerSecond = 0.f;
+ sessionp->mInstantPerformanceList[sessionp->mInstantPerformanceListCounter].mTime = 0.f;
}
// Next label
- incrementCurrentCount() ;
+ incrementCurrentCount();
currentLabel = getCurrentLabelName();
- in_log = (*log).has(currentLabel) ;
+ in_log = (*log).has(currentLabel);
}
- sessionp->mTotalFetchingTime += total_fetching_time ;
- sessionp->mTotalGrayTime += total_gray_time ;
- sessionp->mTotalStablizingTime += total_stablizing_time ;
+ sessionp->mTotalFetchingTime += total_fetching_time;
+ sessionp->mTotalGrayTime += total_gray_time;
+ sessionp->mTotalStablizingTime += total_stablizing_time;
if(sessionp->mStartTimeLoadingSculpties < 0.f)
{
- sessionp->mStartTimeLoadingSculpties = start_fetching_sculpties_time ;
+ sessionp->mStartTimeLoadingSculpties = start_fetching_sculpties_time;
}
- sessionp->mTotalTimeLoadingSculpties += total_loading_sculpties_time ;
+ sessionp->mTotalTimeLoadingSculpties += total_loading_sculpties_time;
return sessionp;
}
LLTexturePipelineTester::LLTextureTestSession::LLTextureTestSession()
{
- reset() ;
+ reset();
}
LLTexturePipelineTester::LLTextureTestSession::~LLTextureTestSession()
{
}
void LLTexturePipelineTester::LLTextureTestSession::reset()
{
- mTotalFetchingTime = 0.0f ;
+ mTotalFetchingTime = 0.0f;
- mTotalGrayTime = 0.0f ;
- mTotalStablizingTime = 0.0f ;
+ mTotalGrayTime = 0.0f;
+ mTotalStablizingTime = 0.0f;
- mStartTimeLoadingSculpties = 0.0f ;
- mTotalTimeLoadingSculpties = 0.0f ;
+ mStartTimeLoadingSculpties = 0.0f;
+ mTotalTimeLoadingSculpties = 0.0f;
- mTotalBytesLoaded = 0 ;
- mTotalBytesLoadedFromCache = 0 ;
- mTotalBytesLoadedForLargeImage = 0 ;
- mTotalBytesLoadedForSculpties = 0 ;
+ mTotalBytesLoaded = 0;
+ mTotalBytesLoadedFromCache = 0;
+ mTotalBytesLoadedForLargeImage = 0;
+ mTotalBytesLoadedForSculpties = 0;
- mInstantPerformanceListCounter = 0 ;
+ mInstantPerformanceListCounter = 0;
}
//----------------------------------------------------------------------------------------------
//end of LLTexturePipelineTester
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-30 02:00:46 +0000