Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of git://github.com/Shyotl/SingularityViewer

Browse Source 
Conflicts:
	indra/newview/llpanelmaininventory.cpp
	indra/newview/llpanelmaininventory.h
	indra/newview/llvoavatar.cpp
This commit is contained in:
Lirusaito
2012-01-31 02:47:02 -05:00
parent dfe33963bb eaecc9a4d0
commit 655365247c
55 changed files with 1435 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
indra/llaudio/llstreamingaudio_fmodex.cpp
View File

@@ -74,7 +74,9 @@ LLStreamingAudio_FMODEX::LLStreamingAudio_FMODEX(FMOD::System *system) :
{
// Number of milliseconds of audio to buffer for the audio card.
// Must be larger than the usual Second Life frame stutter time.
mSystem->setStreamBufferSize(200, FMOD_TIMEUNIT_MS);
const U32 buffer_seconds = 5; //sec
const U32 estimated_bitrate = 128; //kbit/sec
mSystem->setStreamBufferSize(estimated_bitrate * buffer_seconds * 128/*bytes/kbit*/, FMOD_TIMEUNIT_RAWBYTES);
// Here's where we set the size of the network buffer and some buffering
// parameters. In this case we want a network buffer of 16k, we want it

7
indra/llcommon/CMakeLists.txt
View File

@@ -17,7 +17,9 @@ include_directories(
set(llcommon_SOURCE_FILES
aiframetimer.cpp
imageids.cpp
indra_constants.cpp
indra_constants.cpp
llallocator.cpp
llallocator_heap_profile.cpp
llapp.cpp
llapr.cpp
llaprpool.cpp
@@ -52,6 +54,7 @@ set(llcommon_SOURCE_FILES
llmd5.cpp
llmemory.cpp
llmemorystream.cpp
llmemtype.cpp
llmetrics.cpp
llmortician.cpp
lloptioninterface.cpp
@@ -101,6 +104,8 @@ set(llcommon_HEADER_FILES
linden_common.h
linked_lists.h
llaccountingcost.h
llallocator.h
llallocator_heap_profile.h
llagentconstants.h
llavatarname.h
llapp.h

134
indra/llcommon/llallocator.cpp Normal file
View File

@@ -0,0 +1,134 @@
/**
* @file llallocator.cpp
* @brief Implementation of the LLAllocator class.
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "llallocator.h"
#if LL_USE_TCMALLOC
#include "google/heap-profiler.h"
#include "google/commandlineflags_public.h"
DECLARE_bool(heap_profile_use_stack_trace);
//DECLARE_double(tcmalloc_release_rate);
// static
void LLAllocator::pushMemType(S32 type)
{
if(isProfiling())
{
PushMemType(type);
}
}
// static
S32 LLAllocator::popMemType()
{
if (isProfiling())
{
return PopMemType();
}
else
{
return -1;
}
}
void LLAllocator::setProfilingEnabled(bool should_enable)
{
// NULL disables dumping to disk
static char const * const PREFIX = NULL;
if(should_enable)
{
HeapProfilerSetUseStackTrace(false);
HeapProfilerStart(PREFIX);
}
else
{
HeapProfilerStop();
}
}
// static
bool LLAllocator::isProfiling()
{
return IsHeapProfilerRunning();
}
std::string LLAllocator::getRawProfile()
{
// *TODO - fix google-perftools to accept an buffer to avoid this
// malloc-copy-free cycle.
char * buffer = GetHeapProfile();
std::string ret = buffer;
free(buffer);
return ret;
}
#else // LL_USE_TCMALLOC
//
// stub implementations for when tcmalloc is disabled
//
// static
void LLAllocator::pushMemType(S32 type)
{
}
// static
S32 LLAllocator::popMemType()
{
return -1;
}
void LLAllocator::setProfilingEnabled(bool should_enable)
{
}
// static
bool LLAllocator::isProfiling()
{
return false;
}
std::string LLAllocator::getRawProfile()
{
return std::string();
}
#endif // LL_USE_TCMALLOC
LLAllocatorHeapProfile const & LLAllocator::getProfile()
{
mProf.mLines.clear();
// *TODO - avoid making all these extra copies of things...
std::string prof_text = getRawProfile();
//std::cout << prof_text << std::endl;
mProf.parse(prof_text);
return mProf;
}

57
indra/llcommon/llallocator.h Normal file
View File

@@ -0,0 +1,57 @@
/**
* @file llallocator.h
* @brief Declaration of the LLAllocator class.
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LL_LLALLOCATOR_H
#define LL_LLALLOCATOR_H
#include <string>
#include "llmemtype.h"
#include "llallocator_heap_profile.h"
class LL_COMMON_API LLAllocator {
friend class LLMemoryView;
friend class LLMemType;
private:
static void pushMemType(S32 type);
static S32 popMemType();
public:
void setProfilingEnabled(bool should_enable);
static bool isProfiling();
LLAllocatorHeapProfile const & getProfile();
private:
std::string getRawProfile();
private:
LLAllocatorHeapProfile mProf;
};
#endif // LL_LLALLOCATOR_H

147
indra/llcommon/llallocator_heap_profile.cpp Normal file
View File

@@ -0,0 +1,147 @@
/**
* @file llallocator_heap_profile.cpp
* @brief Implementation of the parser for tcmalloc heap profile data.
* @author Brad Kittenbrink
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "llallocator_heap_profile.h"
#if LL_MSVC
// disable warning about boost::lexical_cast returning uninitialized data
// when it fails to parse the string
#pragma warning (disable:4701)
#pragma warning (disable:4702)
#endif
#include <boost/algorithm/string/split.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/range/iterator_range.hpp>
static const std::string HEAP_PROFILE_MAGIC_STR = "heap profile:";
static bool is_separator(char c)
{
return isspace(c) || c == '[' || c == ']' || c == ':';
}
void LLAllocatorHeapProfile::parse(std::string const & prof_text)
{
// a typedef for handling a token in the string buffer
// it's a begin/end pair of string::const_iterators
typedef boost::iterator_range<std::string::const_iterator> range_t;
mLines.clear();
if(prof_text.compare(0, HEAP_PROFILE_MAGIC_STR.length(), HEAP_PROFILE_MAGIC_STR) != 0)
{
// *TODO - determine if there should be some better error state than
// mLines being empty. -brad
llwarns << "invalid heap profile data passed into parser." << llendl;
return;
}
std::vector< range_t > prof_lines;
std::string::const_iterator prof_begin = prof_text.begin() + HEAP_PROFILE_MAGIC_STR.length();
range_t prof_range(prof_begin, prof_text.end());
boost::algorithm::split(prof_lines,
prof_range,
boost::bind(std::equal_to<llwchar>(), '\n', _1));
std::vector< range_t >::const_iterator i;
for(i = prof_lines.begin(); i != prof_lines.end() && !i->empty(); ++i)
{
range_t const & line_text = *i;
std::vector<range_t> line_elems;
boost::algorithm::split(line_elems,
line_text,
is_separator);
std::vector< range_t >::iterator j;
j = line_elems.begin();
while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
llassert_always(j != line_elems.end());
U32 live_count = boost::lexical_cast<U32>(*j);
++j;
while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
llassert_always(j != line_elems.end());
U64 live_size = boost::lexical_cast<U64>(*j);
++j;
while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
llassert_always(j != line_elems.end());
U32 tot_count = boost::lexical_cast<U32>(*j);
++j;
while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
llassert_always(j != line_elems.end());
U64 tot_size = boost::lexical_cast<U64>(*j);
++j;
while(j != line_elems.end() && j->empty()) { ++j; } // skip any separator tokens
llassert(j != line_elems.end());
if (j != line_elems.end())
{
++j; // skip the '@'
mLines.push_back(line(live_count, live_size, tot_count, tot_size));
line & current_line = mLines.back();
for(; j != line_elems.end(); ++j)
{
if(!j->empty())
{
U32 marker = boost::lexical_cast<U32>(*j);
current_line.mTrace.push_back(marker);
}
}
}
}
// *TODO - parse MAPPED_LIBRARIES section here if we're ever interested in it
}
void LLAllocatorHeapProfile::dump(std::ostream & out) const
{
lines_t::const_iterator i;
for(i = mLines.begin(); i != mLines.end(); ++i)
{
out << i->mLiveCount << ": " << i->mLiveSize << '[' << i->mTotalCount << ": " << i->mTotalSize << "] @";
stack_trace::const_iterator j;
for(j = i->mTrace.begin(); j != i->mTrace.end(); ++j)
{
out << ' ' << *j;
}
out << '\n';
}
out.flush();
}

71
indra/llcommon/llallocator_heap_profile.h Normal file
View File

@@ -0,0 +1,71 @@
/**
* @file llallocator_heap_profile.h
* @brief Declaration of the parser for tcmalloc heap profile data.
* @author Brad Kittenbrink
*
* $LicenseInfo:firstyear=2009&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LL_LLALLOCATOR_HEAP_PROFILE_H
#define LL_LLALLOCATOR_HEAP_PROFILE_H
#include "stdtypes.h"
#include <map>
#include <vector>
class LLAllocatorHeapProfile
{
public:
typedef int stack_marker;
typedef std::vector<stack_marker> stack_trace;
struct line {
line(U32 live_count, U64 live_size, U32 tot_count, U64 tot_size) :
mLiveSize(live_size),
mTotalSize(tot_size),
mLiveCount(live_count),
mTotalCount(tot_count)
{
}
U64 mLiveSize, mTotalSize;
U32 mLiveCount, mTotalCount;
stack_trace mTrace;
};
typedef std::vector<line> lines_t;
LLAllocatorHeapProfile()
{
}
void parse(std::string const & prof_text);
void dump(std::ostream & out) const;
public:
lines_t mLines;
};
#endif // LL_LLALLOCATOR_HEAP_PROFILE_H

1
indra/llcommon/llfasttimer_class.h
View File

@@ -248,6 +248,7 @@ public:
struct CurTimerData
{
CurTimerData() : mCurTimer(NULL),mFrameState(NULL),mChildTime(0) {}
LLFastTimer* mCurTimer;
FrameState* mFrameState;
U32 mChildTime;

336
indra/llcommon/llmemory.cpp
View File

@@ -32,9 +32,13 @@
#include "linden_common.h"
//#if MEM_TRACK_MEM
#include "llthread.h"
//#endif
#if defined(LL_WINDOWS)
#define _WINSOCKAPI_
# include <windows.h>
//# include <windows.h>
# include <psapi.h>
#elif defined(LL_DARWIN)
# include <sys/types.h>
@@ -45,10 +49,9 @@
#endif
#include "llmemory.h"
#include "llmemtype.h"
#include "llsys.h"
#include "llthread.h"
#include "llsys.h"
#include "llframetimer.h"
//----------------------------------------------------------------------------
//static
@@ -162,6 +165,7 @@ void LLMemory::logMemoryInfo(BOOL update)
if(update)
{
updateMemoryInfo() ;
LLPrivateMemoryPoolManager::getInstance()->updateStatistics() ;
}
llinfos << "Current allocated physical memory(KB): " << sAllocatedMemInKB << llendl ;
@@ -242,161 +246,6 @@ U32 LLMemory::getAllocatedMemKB()
return sAllocatedMemInKB ;
}
//----------------------------------------------------------------------------
//static
#if MEM_TRACK_TYPE
S32 LLMemType::sCurDepth = 0;
S32 LLMemType::sCurType = LLMemType::MTYPE_INIT;
S32 LLMemType::sType[LLMemType::MTYPE_MAX_DEPTH];
S32 LLMemType::sMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
S32 LLMemType::sMaxMemCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
S32 LLMemType::sNewCount[LLMemType::MTYPE_NUM_TYPES] = { 0 };
S32 LLMemType::sOverheadMem = 0;
const char* LLMemType::sTypeDesc[LLMemType::MTYPE_NUM_TYPES] =
{
"INIT",
"STARTUP",
"MAIN",
"IMAGEBASE",
"IMAGERAW",
"IMAGEFORMATTED",
"APPFMTIMAGE",
"APPRAWIMAGE",
"APPAUXRAWIMAGE",
"DRAWABLE",
"OBJECT",
"PIPELINE",
"AVATAR",
"PARTICLES",
"REGIONS",
"INVENTORY",
"ANIMATION",
"NETWORK",
"PHYSICS",
"INTERESTLIST",
"SCRIPT",
"SCRIPT_RUN",
"SCRIPT_BYTECODE",
"IO_PUMP",
"IO_TCP",
"IO_BUFFER",
"IO_HTTP_SERVER"
"IO_SD_SERVER",
"IO_SD_CLIENT",
"IO_URL_REQUEST",
"TEMP1",
"TEMP2",
"TEMP3",
"TEMP4",
"TEMP5",
"TEMP6",
"TEMP7",
"TEMP8",
"TEMP9"
};
#endif
S32 LLMemType::sTotalMem = 0;
S32 LLMemType::sMaxTotalMem = 0;
//static
void LLMemType::printMem()
{
S32 misc_mem = sTotalMem;
#if MEM_TRACK_TYPE
for (S32 i=0; i<MTYPE_NUM_TYPES; i++)
{
if (sMemCount[i])
{
llinfos << llformat("MEM: % 20s %03d MB (%03d MB) in %06d News",sTypeDesc[i],sMemCount[i]>>20,sMaxMemCount[i]>>20, sNewCount[i]) << llendl;
}
misc_mem -= sMemCount[i];
}
#endif
llinfos << llformat("MEM: % 20s %03d MB","MISC",misc_mem>>20) << llendl;
llinfos << llformat("MEM: % 20s %03d MB (Max=%d MB)","TOTAL",sTotalMem>>20,sMaxTotalMem>>20) << llendl;
}
#if MEM_TRACK_MEM
void* ll_allocate (size_t size)
{
if (size == 0)
{
llwarns << "Null allocation" << llendl;
}
size = (size+3)&~3;
S32 alloc_size = size + 4;
#if MEM_TRACK_TYPE
alloc_size += 4;
#endif
char* p = (char*)malloc(alloc_size);
if (p == NULL)
{
LLMemory::freeReserve();
llerrs << "Out of memory Error" << llendl;
}
LLMemType::sTotalMem += size;
LLMemType::sMaxTotalMem = llmax(LLMemType::sTotalMem, LLMemType::sMaxTotalMem);
LLMemType::sOverheadMem += 4;
*(size_t*)p = size;
p += 4;
#if MEM_TRACK_TYPE
if (LLMemType::sCurType < 0 || LLMemType::sCurType >= LLMemType::MTYPE_NUM_TYPES)
{
llerrs << "Memory Type Error: new" << llendl;
}
LLMemType::sOverheadMem += 4;
*(S32*)p = LLMemType::sCurType;
p += 4;
LLMemType::sMemCount[LLMemType::sCurType] += size;
if (LLMemType::sMemCount[LLMemType::sCurType] > LLMemType::sMaxMemCount[LLMemType::sCurType])
{
LLMemType::sMaxMemCount[LLMemType::sCurType] = LLMemType::sMemCount[LLMemType::sCurType];
}
LLMemType::sNewCount[LLMemType::sCurType]++;
#endif
return (void*)p;
}
void ll_release (void *pin)
{
if (!pin)
{
return;
}
char* p = (char*)pin;
#if MEM_TRACK_TYPE
p -= 4;
S32 type = *(S32*)p;
if (type < 0 || type >= LLMemType::MTYPE_NUM_TYPES)
{
llerrs << "Memory Type Error: delete" << llendl;
}
#endif
p -= 4;
S32 size = *(size_t*)p;
LLMemType::sOverheadMem -= 4;
#if MEM_TRACK_TYPE
LLMemType::sMemCount[type] -= size;
LLMemType::sOverheadMem -= 4;
LLMemType::sNewCount[type]--;
#endif
LLMemType::sTotalMem -= size;
free(p);
}
#else
void* ll_allocate (size_t size)
{
if (size == 0)
@@ -412,38 +261,6 @@ void* ll_allocate (size_t size)
return p;
}
void ll_release (void *p)
{
free(p);
}
#endif
#if MEM_TRACK_MEM
void* operator new (size_t size)
{
return ll_allocate(size);
}
void* operator new[] (size_t size)
{
return ll_allocate(size);
}
void operator delete (void *p)
{
ll_release(p);
}
void operator delete[] (void *p)
{
ll_release(p);
}
#endif
//----------------------------------------------------------------------------
#if defined(LL_WINDOWS)
@@ -613,6 +430,141 @@ U32 LLMemory::getWorkingSetSize()
#endif
//--------------------------------------------------------------------------------------------------
#if MEM_TRACK_MEM
#include "llframetimer.h"
//static
LLMemTracker* LLMemTracker::sInstance = NULL ;
LLMemTracker::LLMemTracker()
{
mLastAllocatedMem = LLMemory::getWorkingSetSize() ;
mCapacity = 128 ;
mCurIndex = 0 ;
mCounter = 0 ;
mDrawnIndex = 0 ;
mPaused = FALSE ;
mMutexp = new LLMutex() ;
mStringBuffer = new char*[128] ;
mStringBuffer[0] = new char[mCapacity * 128] ;
for(S32 i = 1 ; i < mCapacity ; i++)
{
mStringBuffer[i] = mStringBuffer[i-1] + 128 ;
}
}
LLMemTracker::~LLMemTracker()
{
delete[] mStringBuffer[0] ;
delete[] mStringBuffer;
delete mMutexp ;
}
//static
LLMemTracker* LLMemTracker::getInstance()
{
if(!sInstance)
{
sInstance = new LLMemTracker() ;
}
return sInstance ;
}
//static
void LLMemTracker::release()
{
if(sInstance)
{
delete sInstance ;
sInstance = NULL ;
}
}
//static
void LLMemTracker::track(const char* function, const int line)
{
static const S32 MIN_ALLOCATION = 0 ; //1KB
if(mPaused)
{
return ;
}
U32 allocated_mem = LLMemory::getWorkingSetSize() ;
LLMutexLock lock(mMutexp) ;
S32 delta_mem = allocated_mem - mLastAllocatedMem ;
mLastAllocatedMem = allocated_mem ;
if(delta_mem <= 0)
{
return ; //occupied memory does not grow
}
if(delta_mem < MIN_ALLOCATION)
{
return ;
}
char* buffer = mStringBuffer[mCurIndex++] ;
F32 time = (F32)LLFrameTimer::getElapsedSeconds() ;
S32 hours = (S32)(time / (60*60));
S32 mins = (S32)((time - hours*(60*60)) / 60);
S32 secs = (S32)((time - hours*(60*60) - mins*60));
strcpy(buffer, function) ;
sprintf(buffer + strlen(function), " line: %d DeltaMem: %d (bytes) Time: %d:%02d:%02d", line, delta_mem, hours,mins,secs) ;
if(mCounter < mCapacity)
{
mCounter++ ;
}
if(mCurIndex >= mCapacity)
{
mCurIndex = 0 ;
}
}
//static
void LLMemTracker::preDraw(BOOL pause)
{
mMutexp->lock() ;
mPaused = pause ;
mDrawnIndex = mCurIndex - 1;
mNumOfDrawn = 0 ;
}
//static
void LLMemTracker::postDraw()
{
mMutexp->unlock() ;
}
//static
const char* LLMemTracker::getNextLine()
{
if(mNumOfDrawn >= mCounter)
{
return NULL ;
}
mNumOfDrawn++;
if(mDrawnIndex < 0)
{
mDrawnIndex = mCapacity - 1 ;
}
return mStringBuffer[mDrawnIndex--] ;
}
#endif //MEM_TRACK_MEM
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
//minimum slot size and minimal slot size interval

1
indra/llcommon/llmemory.h
View File

@@ -40,6 +40,7 @@
#endif
#include "llerror.h"
#include "llmemtype.h"
#if LL_DEBUG
inline void* ll_aligned_malloc( size_t size, int align )
{

232
indra/llcommon/llmemtype.cpp Normal file
View File

@@ -0,0 +1,232 @@
/**
* @file llmemtype.cpp
* @brief Simple memory allocation/deallocation tracking stuff here
*
* $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "llmemtype.h"
#include "llallocator.h"
std::vector<char const *> LLMemType::DeclareMemType::mNameList;
LLMemType::DeclareMemType LLMemType::MTYPE_INIT("Init");
LLMemType::DeclareMemType LLMemType::MTYPE_STARTUP("Startup");
LLMemType::DeclareMemType LLMemType::MTYPE_MAIN("Main");
LLMemType::DeclareMemType LLMemType::MTYPE_FRAME("Frame");
LLMemType::DeclareMemType LLMemType::MTYPE_GATHER_INPUT("GatherInput");
LLMemType::DeclareMemType LLMemType::MTYPE_JOY_KEY("JoyKey");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE("Idle");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_PUMP("IdlePump");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_NETWORK("IdleNetwork");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_REGIONS("IdleUpdateRegions");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_VIEWER_REGION("IdleUpdateViewerRegion");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_SURFACE("IdleUpdateSurface");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_UPDATE_PARCEL_OVERLAY("IdleUpdateParcelOverlay");
LLMemType::DeclareMemType LLMemType::MTYPE_IDLE_AUDIO("IdleAudio");
LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING("CacheProcessPending");
LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING_ASKS("CacheProcessPendingAsks");
LLMemType::DeclareMemType LLMemType::MTYPE_CACHE_PROCESS_PENDING_REPLIES("CacheProcessPendingReplies");
LLMemType::DeclareMemType LLMemType::MTYPE_MESSAGE_CHECK_ALL("MessageCheckAll");
LLMemType::DeclareMemType LLMemType::MTYPE_MESSAGE_PROCESS_ACKS("MessageProcessAcks");
LLMemType::DeclareMemType LLMemType::MTYPE_RENDER("Render");
LLMemType::DeclareMemType LLMemType::MTYPE_SLEEP("Sleep");
LLMemType::DeclareMemType LLMemType::MTYPE_NETWORK("Network");
LLMemType::DeclareMemType LLMemType::MTYPE_PHYSICS("Physics");
LLMemType::DeclareMemType LLMemType::MTYPE_INTERESTLIST("InterestList");
LLMemType::DeclareMemType LLMemType::MTYPE_IMAGEBASE("ImageBase");
LLMemType::DeclareMemType LLMemType::MTYPE_IMAGERAW("ImageRaw");
LLMemType::DeclareMemType LLMemType::MTYPE_IMAGEFORMATTED("ImageFormatted");
LLMemType::DeclareMemType LLMemType::MTYPE_APPFMTIMAGE("AppFmtImage");
LLMemType::DeclareMemType LLMemType::MTYPE_APPRAWIMAGE("AppRawImage");
LLMemType::DeclareMemType LLMemType::MTYPE_APPAUXRAWIMAGE("AppAuxRawImage");
LLMemType::DeclareMemType LLMemType::MTYPE_DRAWABLE("Drawable");
LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT("Object");
LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT_PROCESS_UPDATE("ObjectProcessUpdate");
LLMemType::DeclareMemType LLMemType::MTYPE_OBJECT_PROCESS_UPDATE_CORE("ObjectProcessUpdateCore");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY("Display");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE("DisplayUpdate");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_CAMERA("DisplayUpdateCam");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_GEOM("DisplayUpdateGeom");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_SWAP("DisplaySwap");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_UPDATE_HUD("DisplayUpdateHud");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_GEN_REFLECTION("DisplayGenRefl");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_IMAGE_UPDATE("DisplayImageUpdate");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_STATE_SORT("DisplayStateSort");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_SKY("DisplaySky");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_GEOM("DisplayRenderGeom");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_FLUSH("DisplayRenderFlush");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_UI("DisplayRenderUI");
LLMemType::DeclareMemType LLMemType::MTYPE_DISPLAY_RENDER_ATTACHMENTS("DisplayRenderAttach");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DATA("VertexData");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CONSTRUCTOR("VertexConstr");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTRUCTOR("VertexDestr");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CREATE_VERTICES("VertexCreateVerts");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CREATE_INDICES("VertexCreateIndices");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTROY_BUFFER("VertexDestroyBuff");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_DESTROY_INDICES("VertexDestroyIndices");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UPDATE_VERTS("VertexUpdateVerts");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UPDATE_INDICES("VertexUpdateIndices");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_ALLOCATE_BUFFER("VertexAllocateBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_RESIZE_BUFFER("VertexResizeBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER("VertexMapBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES("VertexMapBufferVerts");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES("VertexMapBufferIndices");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_UNMAP_BUFFER("VertexUnmapBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SET_STRIDE("VertexSetStride");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SET_BUFFER("VertexSetBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_SETUP_VERTEX_BUFFER("VertexSetupVertBuff");
LLMemType::DeclareMemType LLMemType::MTYPE_VERTEX_CLEANUP_CLASS("VertexCleanupClass");
LLMemType::DeclareMemType LLMemType::MTYPE_SPACE_PARTITION("SpacePartition");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE("Pipeline");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_INIT("PipelineInit");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_CREATE_BUFFERS("PipelineCreateBuffs");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RESTORE_GL("PipelineRestroGL");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UNLOAD_SHADERS("PipelineUnloadShaders");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_LIGHTING_DETAIL("PipelineLightingDetail");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_GET_POOL_TYPE("PipelineGetPoolType");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ADD_POOL("PipelineAddPool");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ALLOCATE_DRAWABLE("PipelineAllocDrawable");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_ADD_OBJECT("PipelineAddObj");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_CREATE_OBJECTS("PipelineCreateObjs");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_MOVE("PipelineUpdateMove");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_GEOM("PipelineUpdateGeom");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_VISIBLE("PipelineMarkVisible");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_MOVED("PipelineMarkMoved");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_SHIFT("PipelineMarkShift");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_SHIFT_OBJECTS("PipelineShiftObjs");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_TEXTURED("PipelineMarkTextured");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_MARK_REBUILD("PipelineMarkRebuild");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_UPDATE_CULL("PipelineUpdateCull");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_STATE_SORT("PipelineStateSort");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_POST_SORT("PipelinePostSort");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_HUD_ELS("PipelineHudEls");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_HL("PipelineRenderHL");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM("PipelineRenderGeom");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED("PipelineRenderGeomDef");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_POST_DEF("PipelineRenderGeomPostDef");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_GEOM_SHADOW("PipelineRenderGeomShadow");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_SELECT("PipelineRenderSelect");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_REBUILD_POOLS("PipelineRebuildPools");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_QUICK_LOOKUP("PipelineQuickLookup");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_OBJECTS("PipelineRenderObjs");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_GENERATE_IMPOSTOR("PipelineGenImpostors");
LLMemType::DeclareMemType LLMemType::MTYPE_PIPELINE_RENDER_BLOOM("PipelineRenderBloom");
LLMemType::DeclareMemType LLMemType::MTYPE_UPKEEP_POOLS("UpkeepPools");
LLMemType::DeclareMemType LLMemType::MTYPE_AVATAR("Avatar");
LLMemType::DeclareMemType LLMemType::MTYPE_AVATAR_MESH("AvatarMesh");
LLMemType::DeclareMemType LLMemType::MTYPE_PARTICLES("Particles");
LLMemType::DeclareMemType LLMemType::MTYPE_REGIONS("Regions");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY("Inventory");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_DRAW("InventoryDraw");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_BUILD_NEW_VIEWS("InventoryBuildNewViews");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_DO_FOLDER("InventoryDoFolder");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_POST_BUILD("InventoryPostBuild");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_FROM_XML("InventoryFromXML");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_CREATE_NEW_ITEM("InventoryCreateNewItem");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_INIT("InventoryViewInit");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_SHOW("InventoryViewShow");
LLMemType::DeclareMemType LLMemType::MTYPE_INVENTORY_VIEW_TOGGLE("InventoryViewToggle");
LLMemType::DeclareMemType LLMemType::MTYPE_ANIMATION("Animation");
LLMemType::DeclareMemType LLMemType::MTYPE_VOLUME("Volume");
LLMemType::DeclareMemType LLMemType::MTYPE_PRIMITIVE("Primitive");
LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT("Script");
LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT_RUN("ScriptRun");
LLMemType::DeclareMemType LLMemType::MTYPE_SCRIPT_BYTECODE("ScriptByteCode");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_PUMP("IoPump");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_TCP("IoTCP");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_BUFFER("IoBuffer");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_HTTP_SERVER("IoHttpServer");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_SD_SERVER("IoSDServer");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_SD_CLIENT("IoSDClient");
LLMemType::DeclareMemType LLMemType::MTYPE_IO_URL_REQUEST("IOUrlRequest");
LLMemType::DeclareMemType LLMemType::MTYPE_DIRECTX_INIT("DirectXInit");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP1("Temp1");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP2("Temp2");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP3("Temp3");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP4("Temp4");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP5("Temp5");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP6("Temp6");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP7("Temp7");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP8("Temp8");
LLMemType::DeclareMemType LLMemType::MTYPE_TEMP9("Temp9");
LLMemType::DeclareMemType LLMemType::MTYPE_OTHER("Other");
LLMemType::DeclareMemType::DeclareMemType(char const * st)
{
mID = (S32)mNameList.size();
mName = st;
mNameList.push_back(mName);
}
LLMemType::DeclareMemType::~DeclareMemType()
{
}
LLMemType::LLMemType(LLMemType::DeclareMemType& dt)
{
mTypeIndex = dt.mID;
LLAllocator::pushMemType(dt.mID);
}
LLMemType::~LLMemType()
{
LLAllocator::popMemType();
}
char const * LLMemType::getNameFromID(S32 id)
{
if (id < 0 || id >= (S32)DeclareMemType::mNameList.size())
{
return "INVALID";
}
return DeclareMemType::mNameList[id];
}
//--------------------------------------------------------------------------------------------------

306
indra/llcommon/llmemtype.h
View File

@@ -36,128 +36,210 @@
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
class LLMemType;
extern void* ll_allocate (size_t size);
extern void ll_release (void *p);
#define MEM_TRACK_MEM 0
#define MEM_TRACK_TYPE (1 && MEM_TRACK_MEM)
#if MEM_TRACK_TYPE
#define MEM_DUMP_DATA 1
#define MEM_TYPE_NEW(T) \
static void* operator new(size_t s) { LLMemType mt(T); return ll_allocate(s); } \
static void operator delete(void* p) { ll_release(p); }
#else
#define MEM_TYPE_NEW(T)
#endif // MEM_TRACK_TYPE
//----------------------------------------------------------------------------
#include "linden_common.h"
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// WARNING: Never commit with MEM_TRACK_MEM == 1
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#define MEM_TRACK_MEM (0 && LL_WINDOWS)
#include <vector>
#define MEM_TYPE_NEW(T)
class LL_COMMON_API LLMemType
{
public:
// Also update sTypeDesc in llmemory.cpp
enum EMemType
// class we'll initialize all instances of as
// static members of MemType. Then use
// to construct any new mem type.
class LL_COMMON_API DeclareMemType
{
MTYPE_INIT,
MTYPE_STARTUP,
MTYPE_MAIN,
MTYPE_IMAGEBASE,
MTYPE_IMAGERAW,
MTYPE_IMAGEFORMATTED,
public:
DeclareMemType(char const * st);
~DeclareMemType();
S32 mID;
char const * mName;
MTYPE_APPFMTIMAGE,
MTYPE_APPRAWIMAGE,
MTYPE_APPAUXRAWIMAGE,
MTYPE_DRAWABLE,
MTYPE_OBJECT,
MTYPE_VERTEX_DATA,
MTYPE_SPACE_PARTITION,
MTYPE_PIPELINE,
MTYPE_AVATAR,
MTYPE_AVATAR_MESH,
MTYPE_PARTICLES,
MTYPE_REGIONS,
MTYPE_INVENTORY,
MTYPE_ANIMATION,
MTYPE_VOLUME,
MTYPE_PRIMITIVE,
MTYPE_NETWORK,
MTYPE_PHYSICS,
MTYPE_INTERESTLIST,
MTYPE_SCRIPT,
MTYPE_SCRIPT_RUN,
MTYPE_SCRIPT_BYTECODE,
MTYPE_IO_PUMP,
MTYPE_IO_TCP,
MTYPE_IO_BUFFER,
MTYPE_IO_HTTP_SERVER,
MTYPE_IO_SD_SERVER,
MTYPE_IO_SD_CLIENT,
MTYPE_IO_URL_REQUEST,
MTYPE_TEMP1,
MTYPE_TEMP2,
MTYPE_TEMP3,
MTYPE_TEMP4,
MTYPE_TEMP5,
MTYPE_TEMP6,
MTYPE_TEMP7,
MTYPE_TEMP8,
MTYPE_TEMP9,
MTYPE_OTHER, // Special, used by display code
MTYPE_NUM_TYPES
// array so we can map an index ID to Name
static std::vector<char const *> mNameList;
};
enum { MTYPE_MAX_DEPTH = 64 };
public:
LLMemType(EMemType type)
{
#if MEM_TRACK_TYPE
if (type < 0 || type >= MTYPE_NUM_TYPES)
llerrs << "LLMemType error" << llendl;
if (sCurDepth < 0 || sCurDepth >= MTYPE_MAX_DEPTH)
llerrs << "LLMemType error" << llendl;
sType[sCurDepth] = sCurType;
sCurDepth++;
sCurType = type;
#endif
}
~LLMemType()
{
#if MEM_TRACK_TYPE
sCurDepth--;
sCurType = sType[sCurDepth];
#endif
}
static void reset();
static void printMem();
LLMemType(DeclareMemType& dt);
~LLMemType();
static char const * getNameFromID(S32 id);
static DeclareMemType MTYPE_INIT;
static DeclareMemType MTYPE_STARTUP;
static DeclareMemType MTYPE_MAIN;
static DeclareMemType MTYPE_FRAME;
static DeclareMemType MTYPE_GATHER_INPUT;
static DeclareMemType MTYPE_JOY_KEY;
static DeclareMemType MTYPE_IDLE;
static DeclareMemType MTYPE_IDLE_PUMP;
static DeclareMemType MTYPE_IDLE_NETWORK;
static DeclareMemType MTYPE_IDLE_UPDATE_REGIONS;
static DeclareMemType MTYPE_IDLE_UPDATE_VIEWER_REGION;
static DeclareMemType MTYPE_IDLE_UPDATE_SURFACE;
static DeclareMemType MTYPE_IDLE_UPDATE_PARCEL_OVERLAY;
static DeclareMemType MTYPE_IDLE_AUDIO;
static DeclareMemType MTYPE_CACHE_PROCESS_PENDING;
static DeclareMemType MTYPE_CACHE_PROCESS_PENDING_ASKS;
static DeclareMemType MTYPE_CACHE_PROCESS_PENDING_REPLIES;
static DeclareMemType MTYPE_MESSAGE_CHECK_ALL;
static DeclareMemType MTYPE_MESSAGE_PROCESS_ACKS;
static DeclareMemType MTYPE_RENDER;
static DeclareMemType MTYPE_SLEEP;
static DeclareMemType MTYPE_NETWORK;
static DeclareMemType MTYPE_PHYSICS;
static DeclareMemType MTYPE_INTERESTLIST;
static DeclareMemType MTYPE_IMAGEBASE;
static DeclareMemType MTYPE_IMAGERAW;
static DeclareMemType MTYPE_IMAGEFORMATTED;
public:
#if MEM_TRACK_TYPE
static S32 sCurDepth;
static S32 sCurType;
static S32 sType[MTYPE_MAX_DEPTH];
static S32 sMemCount[MTYPE_NUM_TYPES];
static S32 sMaxMemCount[MTYPE_NUM_TYPES];
static S32 sNewCount[MTYPE_NUM_TYPES];
static S32 sOverheadMem;
static const char* sTypeDesc[MTYPE_NUM_TYPES];
#endif
static S32 sTotalMem;
static S32 sMaxTotalMem;
static DeclareMemType MTYPE_APPFMTIMAGE;
static DeclareMemType MTYPE_APPRAWIMAGE;
static DeclareMemType MTYPE_APPAUXRAWIMAGE;
static DeclareMemType MTYPE_DRAWABLE;
static DeclareMemType MTYPE_OBJECT;
static DeclareMemType MTYPE_OBJECT_PROCESS_UPDATE;
static DeclareMemType MTYPE_OBJECT_PROCESS_UPDATE_CORE;
static DeclareMemType MTYPE_DISPLAY;
static DeclareMemType MTYPE_DISPLAY_UPDATE;
static DeclareMemType MTYPE_DISPLAY_UPDATE_CAMERA;
static DeclareMemType MTYPE_DISPLAY_UPDATE_GEOM;
static DeclareMemType MTYPE_DISPLAY_SWAP;
static DeclareMemType MTYPE_DISPLAY_UPDATE_HUD;
static DeclareMemType MTYPE_DISPLAY_GEN_REFLECTION;
static DeclareMemType MTYPE_DISPLAY_IMAGE_UPDATE;
static DeclareMemType MTYPE_DISPLAY_STATE_SORT;
static DeclareMemType MTYPE_DISPLAY_SKY;
static DeclareMemType MTYPE_DISPLAY_RENDER_GEOM;
static DeclareMemType MTYPE_DISPLAY_RENDER_FLUSH;
static DeclareMemType MTYPE_DISPLAY_RENDER_UI;
static DeclareMemType MTYPE_DISPLAY_RENDER_ATTACHMENTS;
static DeclareMemType MTYPE_VERTEX_DATA;
static DeclareMemType MTYPE_VERTEX_CONSTRUCTOR;
static DeclareMemType MTYPE_VERTEX_DESTRUCTOR;
static DeclareMemType MTYPE_VERTEX_CREATE_VERTICES;
static DeclareMemType MTYPE_VERTEX_CREATE_INDICES;
static DeclareMemType MTYPE_VERTEX_DESTROY_BUFFER;
static DeclareMemType MTYPE_VERTEX_DESTROY_INDICES;
static DeclareMemType MTYPE_VERTEX_UPDATE_VERTS;
static DeclareMemType MTYPE_VERTEX_UPDATE_INDICES;
static DeclareMemType MTYPE_VERTEX_ALLOCATE_BUFFER;
static DeclareMemType MTYPE_VERTEX_RESIZE_BUFFER;
static DeclareMemType MTYPE_VERTEX_MAP_BUFFER;
static DeclareMemType MTYPE_VERTEX_MAP_BUFFER_VERTICES;
static DeclareMemType MTYPE_VERTEX_MAP_BUFFER_INDICES;
static DeclareMemType MTYPE_VERTEX_UNMAP_BUFFER;
static DeclareMemType MTYPE_VERTEX_SET_STRIDE;
static DeclareMemType MTYPE_VERTEX_SET_BUFFER;
static DeclareMemType MTYPE_VERTEX_SETUP_VERTEX_BUFFER;
static DeclareMemType MTYPE_VERTEX_CLEANUP_CLASS;
static DeclareMemType MTYPE_SPACE_PARTITION;
static DeclareMemType MTYPE_PIPELINE;
static DeclareMemType MTYPE_PIPELINE_INIT;
static DeclareMemType MTYPE_PIPELINE_CREATE_BUFFERS;
static DeclareMemType MTYPE_PIPELINE_RESTORE_GL;
static DeclareMemType MTYPE_PIPELINE_UNLOAD_SHADERS;
static DeclareMemType MTYPE_PIPELINE_LIGHTING_DETAIL;
static DeclareMemType MTYPE_PIPELINE_GET_POOL_TYPE;
static DeclareMemType MTYPE_PIPELINE_ADD_POOL;
static DeclareMemType MTYPE_PIPELINE_ALLOCATE_DRAWABLE;
static DeclareMemType MTYPE_PIPELINE_ADD_OBJECT;
static DeclareMemType MTYPE_PIPELINE_CREATE_OBJECTS;
static DeclareMemType MTYPE_PIPELINE_UPDATE_MOVE;
static DeclareMemType MTYPE_PIPELINE_UPDATE_GEOM;
static DeclareMemType MTYPE_PIPELINE_MARK_VISIBLE;
static DeclareMemType MTYPE_PIPELINE_MARK_MOVED;
static DeclareMemType MTYPE_PIPELINE_MARK_SHIFT;
static DeclareMemType MTYPE_PIPELINE_SHIFT_OBJECTS;
static DeclareMemType MTYPE_PIPELINE_MARK_TEXTURED;
static DeclareMemType MTYPE_PIPELINE_MARK_REBUILD;
static DeclareMemType MTYPE_PIPELINE_UPDATE_CULL;
static DeclareMemType MTYPE_PIPELINE_STATE_SORT;
static DeclareMemType MTYPE_PIPELINE_POST_SORT;
static DeclareMemType MTYPE_PIPELINE_RENDER_HUD_ELS;
static DeclareMemType MTYPE_PIPELINE_RENDER_HL;
static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM;
static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED;
static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_POST_DEF;
static DeclareMemType MTYPE_PIPELINE_RENDER_GEOM_SHADOW;
static DeclareMemType MTYPE_PIPELINE_RENDER_SELECT;
static DeclareMemType MTYPE_PIPELINE_REBUILD_POOLS;
static DeclareMemType MTYPE_PIPELINE_QUICK_LOOKUP;
static DeclareMemType MTYPE_PIPELINE_RENDER_OBJECTS;
static DeclareMemType MTYPE_PIPELINE_GENERATE_IMPOSTOR;
static DeclareMemType MTYPE_PIPELINE_RENDER_BLOOM;
static DeclareMemType MTYPE_UPKEEP_POOLS;
static DeclareMemType MTYPE_AVATAR;
static DeclareMemType MTYPE_AVATAR_MESH;
static DeclareMemType MTYPE_PARTICLES;
static DeclareMemType MTYPE_REGIONS;
static DeclareMemType MTYPE_INVENTORY;
static DeclareMemType MTYPE_INVENTORY_DRAW;
static DeclareMemType MTYPE_INVENTORY_BUILD_NEW_VIEWS;
static DeclareMemType MTYPE_INVENTORY_DO_FOLDER;
static DeclareMemType MTYPE_INVENTORY_POST_BUILD;
static DeclareMemType MTYPE_INVENTORY_FROM_XML;
static DeclareMemType MTYPE_INVENTORY_CREATE_NEW_ITEM;
static DeclareMemType MTYPE_INVENTORY_VIEW_INIT;
static DeclareMemType MTYPE_INVENTORY_VIEW_SHOW;
static DeclareMemType MTYPE_INVENTORY_VIEW_TOGGLE;
static DeclareMemType MTYPE_ANIMATION;
static DeclareMemType MTYPE_VOLUME;
static DeclareMemType MTYPE_PRIMITIVE;
static DeclareMemType MTYPE_SCRIPT;
static DeclareMemType MTYPE_SCRIPT_RUN;
static DeclareMemType MTYPE_SCRIPT_BYTECODE;
static DeclareMemType MTYPE_IO_PUMP;
static DeclareMemType MTYPE_IO_TCP;
static DeclareMemType MTYPE_IO_BUFFER;
static DeclareMemType MTYPE_IO_HTTP_SERVER;
static DeclareMemType MTYPE_IO_SD_SERVER;
static DeclareMemType MTYPE_IO_SD_CLIENT;
static DeclareMemType MTYPE_IO_URL_REQUEST;
static DeclareMemType MTYPE_DIRECTX_INIT;
static DeclareMemType MTYPE_TEMP1;
static DeclareMemType MTYPE_TEMP2;
static DeclareMemType MTYPE_TEMP3;
static DeclareMemType MTYPE_TEMP4;
static DeclareMemType MTYPE_TEMP5;
static DeclareMemType MTYPE_TEMP6;
static DeclareMemType MTYPE_TEMP7;
static DeclareMemType MTYPE_TEMP8;
static DeclareMemType MTYPE_TEMP9;
static DeclareMemType MTYPE_OTHER; // Special; used by display code
S32 mTypeIndex;
};
//----------------------------------------------------------------------------

12
indra/llimage/llimage.cpp
View File

@@ -170,7 +170,7 @@ void LLImageBase::deleteData()
// virtual
U8* LLImageBase::allocateData(S32 size)
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
if (size < 0)
{
@@ -209,7 +209,7 @@ U8* LLImageBase::reallocateData(S32 size)
if(mData && (mDataSize == size))
return mData;
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
U8 *new_datap = (U8*)ALLOCATE_MEM(sPrivatePoolp, size);
if (!new_datap)
{
@@ -457,7 +457,7 @@ void LLImageRaw::clear(U8 r, U8 g, U8 b, U8 a)
// Reverses the order of the rows in the image
void LLImageRaw::verticalFlip()
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
S32 row_bytes = getWidth() * getComponents();
U8* line_buffer = new (std::nothrow) U8[row_bytes];
if (!line_buffer )
@@ -595,7 +595,7 @@ void LLImageRaw::composite( LLImageRaw* src )
// Src and dst can be any size. Src has 4 components. Dst has 3 components.
void LLImageRaw::compositeScaled4onto3(LLImageRaw* src)
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
llinfos << "compositeScaled4onto3" << llendl;
LLImageRaw* dst = this; // Just for clarity.
@@ -846,7 +846,7 @@ void LLImageRaw::copyUnscaled3onto4( LLImageRaw* src )
// Src and dst can be any size. Src and dst have same number of components.
void LLImageRaw::copyScaled( LLImageRaw* src )
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
LLImageRaw* dst = this; // Just for clarity.
llassert_always( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) );
@@ -932,7 +932,7 @@ BOOL LLImageRaw::scaleDownWithoutBlending( S32 new_width, S32 new_height)
BOOL LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
llassert((1 == getComponents()) || (3 == getComponents()) || (4 == getComponents()) );
S32 old_width = getWidth();

4
indra/llimage/llimage.h
View File

@@ -35,7 +35,7 @@
#include "lluuid.h"
#include "llstring.h"
#include "llmemory.h"
#include "llmemtype.h"
#include "llthread.h"
#include "aithreadsafe.h"
@@ -162,7 +162,7 @@ private:
static LLPrivateMemoryPool* sPrivatePoolp ;
public:
S16 mMemType; // debug
LLMemType::DeclareMemType& mMemType; // debug
};
// Raw representation of an image (used for textures, and other uncompressed formats

6
indra/llimage/llimagej2c.cpp
View File

@@ -297,7 +297,7 @@ BOOL LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
// Returns TRUE to mean done, whether successful or not.
BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
BOOL res = TRUE;
@@ -347,7 +347,7 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, F32 encode_time)
BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text, F32 encode_time)
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
resetLastError();
BOOL res = mImpl->encodeImpl(*this, *raw_imagep, comment_text, encode_time, mReversible);
if (!mLastError.empty())
@@ -529,7 +529,7 @@ BOOL LLImageJ2C::loadAndValidate(const std::string &filename)
BOOL LLImageJ2C::validate(U8 *data, U32 file_size)
{
LLMemType mt1((LLMemType::EMemType)mMemType);
LLMemType mt1(mMemType);
resetLastError();

5
indra/llmessage/llcachename.cpp
View File

@@ -42,6 +42,7 @@
#include "llsdserialize.h"
#include "lluuid.h"
#include "message.h"
#include "llmemtype.h"
#include <boost/regex.hpp>
@@ -771,6 +772,7 @@ bool LLCacheName::getIfThere(const LLUUID& id, std::string& fullname, BOOL& is_g
// </edit>
void LLCacheName::processPending()
{
LLMemType mt_pp(LLMemType::MTYPE_CACHE_PROCESS_PENDING);
const F32 SECS_BETWEEN_PROCESS = 0.1f;
if(!impl.mProcessTimer.checkExpirationAndReset(SECS_BETWEEN_PROCESS))
{
@@ -873,8 +875,10 @@ std::string LLCacheName::getDefaultLastName()
{
return "Resident";
}
void LLCacheName::Impl::processPendingAsks()
{
LLMemType mt_ppa(LLMemType::MTYPE_CACHE_PROCESS_PENDING_ASKS);
sendRequest(_PREHASH_UUIDNameRequest, mAskNameQueue);
sendRequest(_PREHASH_UUIDGroupNameRequest, mAskGroupQueue);
mAskNameQueue.clear();
@@ -883,6 +887,7 @@ void LLCacheName::Impl::processPendingAsks()
void LLCacheName::Impl::processPendingReplies()
{
LLMemType mt_ppr(LLMemType::MTYPE_CACHE_PROCESS_PENDING_REPLIES);
// First call all the callbacks, because they might send messages.
for(ReplyQueue::iterator it = mReplyQueue.begin(); it != mReplyQueue.end(); ++it)
{

1
indra/llmessage/lliosocket.cpp
View File

@@ -244,6 +244,7 @@ LLSocket::LLSocket() :
mPool(LLThread::tldata().mRootPool),
mPort(PORT_INVALID)
{
LLMemType m1(LLMemType::MTYPE_IO_TCP);
}
LLSocket::~LLSocket()

3
indra/llmessage/message.cpp
View File

@@ -86,6 +86,7 @@
#include "v3math.h"
#include "v4math.h"
#include "lltransfertargetvfile.h"
#include "llmemtype.h"
// <edit>
#include "llrand.h"
@@ -811,6 +812,7 @@ S32 LLMessageSystem::getReceiveBytes() const
void LLMessageSystem::processAcks()
{
LLMemType mt_pa(LLMemType::MTYPE_MESSAGE_PROCESS_ACKS);
F64 mt_sec = getMessageTimeSeconds();
{
gTransferManager.updateTransfers();
@@ -4048,6 +4050,7 @@ void LLMessageSystem::setTimeDecodesSpamThreshold( F32 seconds )
// TODO: babbage: move gServicePump in to LLMessageSystem?
bool LLMessageSystem::checkAllMessages(S64 frame_count, LLPumpIO* http_pump)
{
LLMemType mt_cam(LLMemType::MTYPE_MESSAGE_CHECK_ALL);
if(checkMessages(frame_count))
{
return true;

2
indra/llrender/llgl.cpp
View File

@@ -50,6 +50,7 @@
#include "llmath.h"
#include "m4math.h"
#include "llstring.h"
#include "llmemtype.h"
#include "llstacktrace.h"
#include "llglheaders.h"
@@ -2203,6 +2204,7 @@ void LLGLNamePool::release(GLuint name)
//static
void LLGLNamePool::upkeepPools()
{
LLMemType mt(LLMemType::MTYPE_UPKEEP_POOLS);
for (tracker_t::instance_iter iter = beginInstances(); iter != endInstances(); ++iter)
{
LLGLNamePool & pool = *iter;

82
indra/llrender/llvertexbuffer.cpp
View File

@@ -731,7 +731,7 @@ void LLVertexBuffer::unbind()
//static
void LLVertexBuffer::cleanupClass()
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_CLEANUP_CLASS);
unbind();
sStreamIBOPool.cleanup();
@@ -750,41 +750,26 @@ void LLVertexBuffer::cleanupClass()
S32 LLVertexBuffer::determineUsage(S32 usage)
{
S32 ret_usage = usage;
if (!sEnableVBOs)
{
ret_usage = 0;
}
if (usage == GL_STREAM_DRAW_ARB && !sUseStreamDraw)
{
ret_usage = 0;
}
if (usage == GL_DYNAMIC_DRAW_ARB && sPreferStreamDraw)
{
ret_usage = GL_STREAM_DRAW_ARB;
}
if (usage == 0 && LLRender::sGLCoreProfile)
if (LLRender::sGLCoreProfile)
{ //MUST use VBOs for all rendering
ret_usage = GL_STREAM_DRAW_ARB;
if(!usage)
usage = GL_STREAM_DRAW_ARB;
}
else if (!sEnableVBOs || !usage)
{
return 0;
}
if (usage && usage != GL_STREAM_DRAW_ARB)
{ //only stream_draw and dynamic_draw are supported when using VBOs, dynamic draw is the default
if (sDisableVBOMapping)
{ //always use stream draw if VBO mapping is disabled
ret_usage = GL_STREAM_DRAW_ARB;
}
else
{
ret_usage = GL_DYNAMIC_DRAW_ARB;
}
//Only stream_draw and dynamic_draw are supported when using VBOs, dynamic draw is the default.
//Always use stream_draw VBO if mapping is disabled, or stream is enabled and preferred/expected
if( sDisableVBOMapping || (sUseStreamDraw && (sPreferStreamDraw || usage == GL_STREAM_DRAW_ARB)))
{
return GL_STREAM_DRAW_ARB;
}
else
{
return GL_DYNAMIC_DRAW_ARB;
}
return ret_usage;
}
LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
@@ -812,7 +797,7 @@ LLVertexBuffer::LLVertexBuffer(U32 typemask, S32 usage) :
mMappable(false),
mFence(NULL)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_CONSTRUCTOR);
if (mUsage == GL_DYNAMIC_DRAW_ARB && !sDisableVBOMapping)
{
@@ -880,7 +865,7 @@ S32 LLVertexBuffer::getSize() const
//virtual
LLVertexBuffer::~LLVertexBuffer()
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTRUCTOR);
destroyGLBuffer();
destroyGLIndices();
@@ -997,7 +982,7 @@ void LLVertexBuffer::releaseIndices()
void LLVertexBuffer::createGLBuffer(U32 size)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_VERTICES);
if (mGLBuffer)
{
@@ -1028,7 +1013,7 @@ void LLVertexBuffer::createGLBuffer(U32 size)
void LLVertexBuffer::createGLIndices(U32 size)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_CREATE_INDICES);
if (mGLIndices)
{
@@ -1064,7 +1049,7 @@ void LLVertexBuffer::createGLIndices(U32 size)
void LLVertexBuffer::destroyGLBuffer()
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_BUFFER);
if (mGLBuffer)
{
if (mMappedDataUsingVBOs)
@@ -1085,7 +1070,7 @@ void LLVertexBuffer::destroyGLBuffer()
void LLVertexBuffer::destroyGLIndices()
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_DESTROY_INDICES);
if (mGLIndices)
{
if (mMappedIndexDataUsingVBOs)
@@ -1106,7 +1091,7 @@ void LLVertexBuffer::destroyGLIndices()
void LLVertexBuffer::updateNumVerts(S32 nverts)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_VERTS);
llassert(nverts >= 0);
@@ -1128,7 +1113,7 @@ void LLVertexBuffer::updateNumVerts(S32 nverts)
void LLVertexBuffer::updateNumIndices(S32 nindices)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_UPDATE_INDICES);
llassert(nindices >= 0);
@@ -1144,7 +1129,7 @@ void LLVertexBuffer::updateNumIndices(S32 nindices)
void LLVertexBuffer::allocateBuffer(S32 nverts, S32 nindices, bool create)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_ALLOCATE_BUFFER);
stop_glerror();
@@ -1265,7 +1250,7 @@ void LLVertexBuffer::resizeBuffer(S32 newnverts, S32 newnindices)
llassert(newnverts >= 0);
llassert(newnindices >= 0);
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_RESIZE_BUFFER);
updateNumVerts(newnverts);
updateNumIndices(newnindices);
@@ -1313,7 +1298,7 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_BUFFER("VBO Map");
volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, bool map_range)
{
bindGLBuffer(true);
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
if (mFinal)
{
llerrs << "LLVertexBuffer::mapVeretxBuffer() called on a finalized buffer." << llendl;
@@ -1362,6 +1347,7 @@ volatile U8* LLVertexBuffer::mapVertexBuffer(S32 type, S32 index, S32 count, boo
if (!mVertexLocked)
{
LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_VERTICES);
mVertexLocked = true;
sMappedCount++;
stop_glerror();
@@ -1492,7 +1478,7 @@ static LLFastTimer::DeclareTimer FTM_VBO_MAP_INDEX("IBO Map");
volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_MAP_BUFFER);
bindGLIndices(true);
if (mFinal)
{
@@ -1539,7 +1525,7 @@ volatile U8* LLVertexBuffer::mapIndexBuffer(S32 index, S32 count, bool map_range
if (!mIndexLocked)
{
//LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
LLMemType mt_v(LLMemType::MTYPE_VERTEX_MAP_BUFFER_INDICES);
mIndexLocked = true;
sMappedCount++;
@@ -1663,7 +1649,7 @@ static LLFastTimer::DeclareTimer FTM_IBO_FLUSH_RANGE("Flush IBO Range");
void LLVertexBuffer::unmapBuffer()
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_UNMAP_BUFFER);
if (!useVBOs())
{
return ; //nothing to unmap
@@ -2007,7 +1993,7 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
{
flush();
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_SET_BUFFER);
//set up pointers if the data mask is different ...
bool setup = (sLastMask != data_mask);
@@ -2149,7 +2135,7 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
// virtual (default)
void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
{
LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
LLMemType mt2(LLMemType::MTYPE_VERTEX_SETUP_VERTEX_BUFFER);
stop_glerror();
volatile U8* base = useVBOs() ? (U8*) mAlignedOffset : mMappedData;

11
indra/newview/app_settings/settings.xml
View File

@@ -8043,6 +8043,17 @@
<key>Value</key>
<integer>512</integer>
</map>
<key>MemProfiling</key>
<map>
<key>Comment</key>
<string>You want to use tcmalloc's memory profiling options.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
</map>
<key>MenuAccessKeyTime</key>
<map>
<key>Comment</key>

3
indra/newview/llagentwearables.cpp
View File

@@ -564,7 +564,8 @@ BOOL LLAgentWearables::isWearableCopyable(LLWearableType::EType type, U32 index)
BOOL LLAgentWearables::areWearablesLoaded() const
{
if(gSavedSettings.getBOOL("RenderUnloadedAvatar"))
static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
if(rener_unloaded_avatar)
return TRUE;
return mWearablesLoaded;
}

10
indra/newview/llappviewer.cpp
View File

@@ -629,6 +629,8 @@ bool LLAppViewer::init()
initMaxHeapSize() ;
LLPrivateMemoryPoolManager::initClass((BOOL)gSavedSettings.getBOOL("MemoryPrivatePoolEnabled"), (U32)gSavedSettings.getU32("MemoryPrivatePoolSize")) ;
mAlloc.setProfilingEnabled(gSavedSettings.getBOOL("MemProfiling"));
// *NOTE:Mani - LLCurl::initClass is not thread safe.
// Called before threads are created.
LLCurl::initClass(gSavedSettings.getBOOL("CurlUseMultipleThreads"));
@@ -1022,8 +1024,10 @@ static LLFastTimer::DeclareTimer FTM_PUMP_SERVICE("Service");
static LLFastTimer::DeclareTimer FTM_SERVICE_CALLBACK("Callback");
static LLFastTimer::DeclareTimer FTM_AGENT_AUTOPILOT("Autopilot");
static LLFastTimer::DeclareTimer FTM_AGENT_UPDATE("Update");
bool LLAppViewer::mainLoop()
{
LLMemType mt1(LLMemType::MTYPE_MAIN);
mMainloopTimeout = new LLWatchdogTimeout();
// *FIX:Mani - Make this a setting, once new settings exist in this branch.
@@ -1041,7 +1045,6 @@ bool LLAppViewer::mainLoop()
LLVoiceChannel::initClass();
LLVoiceClient::init(gServicePump);
LLMemType mt1(LLMemType::MTYPE_MAIN);
LLTimer frameTimer,idleTimer;
LLTimer debugTime;
LLFrameTimer memCheckTimer;
@@ -1114,6 +1117,7 @@ bool LLAppViewer::mainLoop()
&& !gViewerWindow->getShowProgress()
&& !gFocusMgr.focusLocked())
{
LLMemType mjk(LLMemType::MTYPE_JOY_KEY);
joystick->scanJoystick();
gKeyboard->scanKeyboard();
if(isCrouch)
@@ -1133,6 +1137,7 @@ bool LLAppViewer::mainLoop()
if (gAres != NULL && gAres->isInitialized())
{
LLMemType mt_ip(LLMemType::MTYPE_IDLE_PUMP);
pingMainloopTimeout("Main:ServicePump");
LLFastTimer t4(FTM_PUMP);
{
@@ -1187,6 +1192,7 @@ bool LLAppViewer::mainLoop()
// Sleep and run background threads
{
LLMemType mt_sleep(LLMemType::MTYPE_SLEEP);
LLFastTimer t2(FTM_SLEEP);
static const LLCachedControl<bool> run_multiple_threads("RunMultipleThreads",false);
@@ -3706,6 +3712,7 @@ static LLFastTimer::DeclareTimer FTM_VLMANAGER("VL Manager");
///////////////////////////////////////////////////////
void LLAppViewer::idle()
{
LLMemType mt_idle(LLMemType::MTYPE_IDLE);
pingMainloopTimeout("Main:Idle");
// Update frame timers
@@ -4286,6 +4293,7 @@ static LLFastTimer::DeclareTimer FTM_DYNAMIC_THROTTLE("Dynamic Throttle");
static LLFastTimer::DeclareTimer FTM_CHECK_REGION_CIRCUIT("Check Region Circuit");
void LLAppViewer::idleNetwork()
{
LLMemType mt_in(LLMemType::MTYPE_IDLE_NETWORK);
pingMainloopTimeout("idleNetwork");
gObjectList.mNumNewObjects = 0;

5
indra/newview/llappviewer.h
View File

@@ -33,7 +33,8 @@
#ifndef LL_LLAPPVIEWER_H
#define LL_LLAPPVIEWER_H
#include "llsys.h" // LLOSInfo
#include "llallocator.h"
#include "llsys.h" // for LLOSInfo
#include "llviewercontrol.h" // settings_map_type
class LLTextureCache;
@@ -158,6 +159,7 @@ public:
// *NOTE:Mani Fix this for login abstraction!!
void handleLoginComplete();
LLAllocator & getAllocator() { return mAlloc; }
void addOnIdleCallback(const boost::function<void()>& cb); // add a callback to fire (once) when idle
void purgeCache(); // Clear the local cache.
@@ -245,6 +247,7 @@ private:
bool mAgentRegionLastAlive;
LLUUID mAgentRegionLastID;
LLAllocator mAlloc;
LLFrameTimer mMemCheckTimer;

10
indra/newview/llconsole.cpp
View File

@@ -160,7 +160,7 @@ void LLConsole::draw()
F32 skip_time = cur_time - mLinePersistTime;
F32 fade_time = cur_time - mFadeTime;
U32 max_lines = gSavedSettings.getS32("ConsoleMaxLines");
static const LLCachedControl<S32> max_lines("ConsoleMaxLines");
U32 num_lines=0;
paragraph_t::reverse_iterator paragraph_it;
@@ -170,7 +170,7 @@ void LLConsole::draw()
while (!mParagraphs.empty() && paragraph_it != mParagraphs.rend())
{
num_lines += (*paragraph_it)->mLines.size();
if(num_lines > max_lines
if(num_lines > (U32)max_lines.get()
|| ( (mLinePersistTime > (F32)0.f) && ((*paragraph_it)->mAddTime - skip_time)/(mLinePersistTime - mFadeTime) <= (F32)0.f))
{ //All lines above here are done. Lose them.
for (U32 i=0;i<paragraph_num;i++)
@@ -198,8 +198,10 @@ void LLConsole::draw()
LLUIImagePtr imagep = LLUI::getUIImage("rounded_square.tga");
F32 console_opacity = llclamp(gSavedSettings.getF32("ConsoleBackgroundOpacity"), 0.f, 1.f);
LLColor4 color = gColors.getColor("ConsoleBackground");
static const LLCachedControl<F32> console_background_opacity("ConsoleBackgroundOpacity");
F32 console_opacity = llclamp(console_background_opacity.get(), 0.f, 1.f);
static const LLCachedControl<LLColor4> console_background(gColors,"ConsoleBackground");
LLColor4 color = console_background;
color.mV[VALPHA] *= console_opacity;
F32 line_height = mFont->getLineHeight();

3
indra/newview/lldrawpoolalpha.cpp
View File

@@ -107,11 +107,12 @@ void LLDrawPoolAlpha::renderDeferred(S32 pass)
S32 LLDrawPoolAlpha::getNumPostDeferredPasses()
{
static const LLCachedControl<bool> render_depth_of_field("RenderDepthOfField");
if (LLPipeline::sImpostorRender)
{ //skip depth buffer filling pass when rendering impostors
return 1;
}
else if (gSavedSettings.getBOOL("RenderDepthOfField"))
else if (render_depth_of_field)
{
return 2;
}

3
indra/newview/lldrawpoolterrain.cpp
View File

@@ -128,7 +128,8 @@ U32 LLDrawPoolTerrain::getVertexDataMask()
void LLDrawPoolTerrain::prerender()
{
mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_ENVIRONMENT);
sDetailMode = gSavedSettings.getS32("RenderTerrainDetail");
static const LLCachedControl<S32> render_terrain_detail("RenderTerrainDetail");
sDetailMode = render_terrain_detail;
}
void LLDrawPoolTerrain::beginRenderPass( S32 pass )

3
indra/newview/lldrawpoolwater.cpp
View File

@@ -573,7 +573,8 @@ void LLDrawPoolWater::shade()
mWaterNormp->addTextureStats(1024.f*1024.f);
gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;
if (gSavedSettings.getBOOL("RenderWaterMipNormal"))
static const LLCachedControl<bool> render_water_mip_normal("RenderWaterMipNormal");
if (render_water_mip_normal)
{
mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
}

246
indra/newview/llmemoryview.cpp
View File

@@ -32,37 +32,28 @@
#include "llviewerprecompiledheaders.h"
#include "indra_constants.h"
#include "llmemoryview.h"
#include "llrect.h"
#include "llerror.h"
#include "llgl.h"
#include "llmath.h"
#include "llfontgl.h"
#include "llmemtype.h"
#include "llcharacter.h"
#include "llui.h"
#include "llappviewer.h"
#include "llallocator_heap_profile.h"
#include "llgl.h" // LLGLSUIDefault
#include "llviewerwindow.h"
#include "llviewercontrol.h"
#include "llstat.h"
#include "llfasttimer.h"
#include <sstream>
#include <boost/algorithm/string/split.hpp>
#include "llmemory.h"
LLMemoryView::LLMemoryView(const std::string& name, const LLRect& rect)
: LLView(name, rect, TRUE),
mDelay(120)
mPaused(FALSE),
//mDelay(120),
mAlloc(NULL)
{
setVisible(FALSE);
mDumpTimer.reset();
#ifdef MEM_DUMP_DATA
// clear out file.
LLFILE *dump = LLFile::fopen("memusagedump.txt", "w");
fclose(dump);
#endif
}
LLMemoryView::~LLMemoryView()
@@ -79,6 +70,7 @@ BOOL LLMemoryView::handleMouseDown(S32 x, S32 y, MASK mask)
}
else
{
mPaused = !mPaused;
}
return TRUE;
}
@@ -94,62 +86,145 @@ BOOL LLMemoryView::handleHover(S32 x, S32 y, MASK mask)
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////
struct mtv_display_info {
S32 memtype;
const char *desc;
const LLColor4 *color;
};
static const LLColor4 red0(0.5f, 0.0f, 0.0f, 1.0f);
static const struct mtv_display_info mtv_display_table[] =
void LLMemoryView::refreshProfile()
{
{ LLMemType::MTYPE_INIT, "Init", &LLColor4::white },
{ LLMemType::MTYPE_STARTUP, "Startup", &LLColor4::cyan1 },
{ LLMemType::MTYPE_MAIN, "Main", &LLColor4::cyan2 },
{ LLMemType::MTYPE_IMAGEBASE, "ImageBase", &LLColor4::yellow1 },
{ LLMemType::MTYPE_IMAGERAW, "ImageRaw", &LLColor4::yellow2 },
{ LLMemType::MTYPE_IMAGEFORMATTED, "ImageFmtd", &LLColor4::yellow3 },
{ LLMemType::MTYPE_APPFMTIMAGE, "ViewerImageFmt", &LLColor4::orange1 },
{ LLMemType::MTYPE_APPRAWIMAGE, "ViewerImageRaw", &LLColor4::orange2 },
{ LLMemType::MTYPE_APPAUXRAWIMAGE, "ViewerImageAux", &LLColor4::orange3 },
{ LLMemType::MTYPE_DRAWABLE, "Drawable", &LLColor4::green1 },
{ LLMemType::MTYPE_OBJECT, "ViewerObject", &LLColor4::green2 },
{ LLMemType::MTYPE_PIPELINE, "Pipeline", &LLColor4::green3 },
{ LLMemType::MTYPE_PARTICLES, "Particles", &LLColor4::green4 },
{ LLMemType::MTYPE_SPACE_PARTITION, "Space Partition", &LLColor4::blue2 },
{ LLMemType::MTYPE_VERTEX_DATA, "Vertex Buffer", &LLColor4::blue3 },
{ LLMemType::MTYPE_AVATAR, "Avatar", &LLColor4::purple1 },
{ LLMemType::MTYPE_AVATAR_MESH, "Avatar Mesh", &LLColor4::purple2 },
{ LLMemType::MTYPE_ANIMATION, "Animation", &LLColor4::purple3 },
{ LLMemType::MTYPE_REGIONS, "Regions", &LLColor4::blue1 },
{ LLMemType::MTYPE_VOLUME, "Volume", &LLColor4::pink1 },
{ LLMemType::MTYPE_PRIMITIVE, "Profile", &LLColor4::pink2 },
{ LLMemType::MTYPE_TEMP1, "Temp1", &LLColor4::red1 },
{ LLMemType::MTYPE_TEMP2, "Temp2", &LLColor4::magenta1 },
{ LLMemType::MTYPE_TEMP3, "Temp3", &LLColor4::red2 },
{ LLMemType::MTYPE_TEMP4, "Temp4", &LLColor4::magenta2 },
{ LLMemType::MTYPE_TEMP5, "Temp5", &LLColor4::red3 },
{ LLMemType::MTYPE_TEMP6, "Temp6", &LLColor4::magenta3 },
{ LLMemType::MTYPE_TEMP7, "Temp7", &LLColor4::red4 },
{ LLMemType::MTYPE_TEMP8, "Temp8", &LLColor4::magenta4 },
/*
LLAllocator & alloc = LLAppViewer::instance()->getAllocator();
if(alloc.isProfiling()) {
std::string profile_text = alloc.getRawProfile();
{ LLMemType::MTYPE_OTHER, "Other", &red0 },
};
static const int MTV_DISPLAY_NUM = LL_ARRAY_SIZE(mtv_display_table);
boost::algorithm::split(mLines, profile_text, boost::bind(std::equal_to<llwchar>(), '\n', _1));
} else {
mLines.clear();
}
*/
if (mAlloc == NULL) {
mAlloc = &LLAppViewer::instance()->getAllocator();
}
mLines.clear();
if(mAlloc->isProfiling())
{
const LLAllocatorHeapProfile &prof = mAlloc->getProfile();
for(size_t i = 0; i < prof.mLines.size(); ++i)
{
std::stringstream ss;
ss << "Unfreed Mem: " << (prof.mLines[i].mLiveSize >> 20) << " M Trace: ";
for(size_t k = 0; k < prof.mLines[i].mTrace.size(); ++k)
{
ss << LLMemType::getNameFromID(prof.mLines[i].mTrace[k]) << " ";
}
mLines.push_back(utf8string_to_wstring(ss.str()));
}
}
}
void LLMemoryView::draw()
{
std::string tdesc;
S32 width = getRect().getWidth();
S32 height = getRect().getHeight();
const S32 UPDATE_INTERVAL = 60;
const S32 MARGIN_AMT = 10;
static S32 curUpdate = UPDATE_INTERVAL;
static const LLCachedControl<LLColor4> console_background(gColors,"ConsoleBackground");
static LLColor4 s_console_color = console_background;
// setup update interval
if (curUpdate >= UPDATE_INTERVAL)
{
refreshProfile();
curUpdate = 0;
}
curUpdate++;
// setup window properly
S32 height = (S32) (gViewerWindow->getWindowRectScaled().getHeight()*0.75f);
S32 width = (S32) (gViewerWindow->getWindowRectScaled().getWidth() * 0.9f);
setRect(LLRect().setLeftTopAndSize(getRect().mLeft, getRect().mTop, width, height));
// setup window color
static const LLCachedControl<F32> console_background_opacity("ConsoleBackgroundOpacity");
F32 console_opacity = llclamp(console_background_opacity.get(), 0.f, 1.f);
LLColor4 color = s_console_color;
color.mV[VALPHA] *= console_opacity;
LLGLSUIDefault gls_ui;
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
gl_rect_2d(0, height, width, 0, LLColor4(0.f, 0.f, 0.f, 0.25f));
gl_rect_2d(0, height, width, 0, color);
LLFontGL * font = LLFontGL::getFontSansSerifSmall();
// draw remaining lines
F32 y_pos = 0.f;
F32 y_off = 0.f;
F32 line_height = font->getLineHeight();
S32 target_width = width - 2 * MARGIN_AMT;
// cut off lines on bottom
U32 max_lines = U32((height - 2 * line_height) / line_height);
y_pos = height - MARGIN_AMT - line_height;
y_off = 0.f;
#if !MEM_TRACK_MEM
std::vector<LLWString>::const_iterator end = mLines.end();
if(mLines.size() > max_lines) {
end = mLines.begin() + max_lines;
}
for (std::vector<LLWString>::const_iterator i = mLines.begin(); i != end; ++i)
{
font->render(*i, 0, MARGIN_AMT, y_pos - y_off,
LLColor4::white,
LLFontGL::LEFT,
LLFontGL::BASELINE,
LLFontGL::NORMAL,
LLFontGL::DROP_SHADOW,
S32_MAX,
target_width
);
y_off += line_height;
}
#else
LLMemTracker::getInstance()->preDraw(mPaused) ;
{
F32 x_pos = MARGIN_AMT ;
U32 lines = 0 ;
const char* str = LLMemTracker::getInstance()->getNextLine() ;
while(str != NULL)
{
lines++ ;
font->renderUTF8(str, 0, x_pos, y_pos - y_off,
LLColor4::white,
LLFontGL::LEFT,
LLFontGL::BASELINE,
LLFontGL::NORMAL,
LLFontGL::DROP_SHADOW,
S32_MAX,
target_width,
NULL, FALSE);
str = LLMemTracker::getInstance()->getNextLine() ;
y_off += line_height;
if(lines >= max_lines)
{
lines = 0 ;
x_pos += 512.f ;
if(x_pos + 512.f > target_width)
{
break ;
}
y_pos = height - MARGIN_AMT - line_height;
y_off = 0.f;
}
}
}
LLMemTracker::getInstance()->postDraw() ;
#endif
#if MEM_TRACK_TYPE
S32 left, top, right, bottom;
@@ -267,40 +342,3 @@ void LLMemoryView::draw()
LLView::draw();
}
void LLMemoryView::setDataDumpInterval(float delay)
{
mDelay = delay;
}
void LLMemoryView::dumpData()
{
#if MEM_TRACK_TYPE && MEM_DUMP_DATA
if (mDelay && (mDumpTimer.getElapsedTimeF32() > mDelay ))
{
// reset timer
mDumpTimer.reset();
// append dump info to text file
LLFILE *dump = LLFile::fopen("memusagedump.txt", "a");
if (dump)
{
// write out total memory usage
fprintf (dump, "Total memory in use = %09d (%03d MB)\n", LLMemType::sTotalMem, LLMemType::sTotalMem>>20);
fprintf (dump, "High Water Mark = %09d (%03d MB)\n\n", LLMemType::sMaxTotalMem, LLMemType::sMaxTotalMem>>20);
// dump out usage of 'new' for each memory type
for (S32 i=0; i<LLMemType::MTYPE_NUM_TYPES; i++)
{
if (LLMemType::sMemCount[i])
{
std::string outData = llformat("MEM: % 20s %09d %03d MB (%09d %03d MB) in %06d News", LLMemType::sTypeDesc[i], LLMemType::sMemCount[i], LLMemType::sMemCount[i]>>20, LLMemType::sMaxMemCount[i], LLMemType::sMaxMemCount[i]>>20, LLMemType::sNewCount[i]);
fprintf (dump, "%s\n", outData.c_str());
}
}
fprintf (dump, "\n\n");
fclose(dump);
}
}
#endif
}

13
indra/newview/llmemoryview.h
View File

@@ -35,6 +35,8 @@
#include "llview.h"
class LLAllocator;
class LLMemoryView : public LLView
{
public:
@@ -46,14 +48,13 @@ public:
virtual BOOL handleHover(S32 x, S32 y, MASK mask);
virtual void draw();
private:
void setDataDumpInterval(float delay);
void dumpData();
float mDelay;
LLFrameTimer mDumpTimer;
void refreshProfile();
private:
std::vector<LLWString> mLines;
LLAllocator* mAlloc;
BOOL mPaused ;
};
#endif

9
indra/newview/llmeshrepository.cpp
View File

@@ -2240,7 +2240,8 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
void LLMeshRepository::notifyLoadedMeshes()
{ //called from main thread
LLMeshRepoThread::sMaxConcurrentRequests = gSavedSettings.getU32("MeshMaxConcurrentRequests");
static const LLCachedControl<U32> max_concurrent_requests("MeshMaxConcurrentRequests");
LLMeshRepoThread::sMaxConcurrentRequests = max_concurrent_requests;
#if MESH_IMPORT
//clean up completed upload threads
@@ -3580,7 +3581,8 @@ void LLMeshRepository::buildPhysicsMesh(LLModel::Decomposition& decomp)
bool LLMeshRepository::meshUploadEnabled()
{
LLViewerRegion *region = gAgent.getRegion();
if(gSavedSettings.getBOOL("MeshEnabled") &&
static const LLCachedControl<bool> mesh_enabled("MeshEnabled");
if(mesh_enabled &&
region)
{
return region->meshUploadEnabled();
@@ -3591,7 +3593,8 @@ bool LLMeshRepository::meshUploadEnabled()
bool LLMeshRepository::meshRezEnabled()
{
LLViewerRegion *region = gAgent.getRegion();
if(gSavedSettings.getBOOL("MeshEnabled") &&
static const LLCachedControl<bool> mesh_enabled("MeshEnabled");
if(mesh_enabled &&
region)
{
return region->meshRezEnabled();

59
indra/newview/llpanelmaininventory.cpp
View File

@@ -56,10 +56,10 @@ const S32 INV_FINDER_WIDTH = 160;
const S32 INV_FINDER_HEIGHT = 408;
//BOOL LLInventoryView::sOpenNextNewItem = FALSE;
class LLInventoryViewFinder : public LLFloater
class LLFloaterInventoryFinder : public LLFloater
{
public:
LLInventoryViewFinder(const std::string& name,
LLFloaterInventoryFinder(const std::string& name,
const LLRect& rect,
LLInventoryView* inventory_view);
virtual void draw();
@@ -116,6 +116,7 @@ LLInventoryView::LLInventoryView(const std::string& name,
void LLInventoryView::init(LLInventoryModel* inventory)
{
LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_INIT);
// Callbacks
init_inventory_actions(this);
@@ -497,7 +498,7 @@ void LLInventoryView::updateSortControls()
void LLInventoryView::resetFilters()
{
LLInventoryViewFinder *finder = getFinder();
LLFloaterInventoryFinder *finder = getFinder();
getActivePanel()->getFilter()->resetDefault();
if (finder)
{
@@ -531,7 +532,7 @@ void LLInventoryView::onClearSearch(void* user_data)
if (finder)
{
LLInventoryViewFinder::selectAllTypes(finder);
LLFloaterInventoryFinder::selectAllTypes(finder);
}
// re-open folders that were initially open
@@ -678,7 +679,7 @@ void LLInventoryView::onQuickFilterCommit(LLUICtrl* ctrl, void* user_data)
// Force the filters window to update itself, if it's open.
LLInventoryViewFinder* finder = view->getFinder();
LLFloaterInventoryFinder* finder = view->getFinder();
if( finder )
{
finder->updateElementsFromFilter();
@@ -897,7 +898,7 @@ void LLInventoryView::onFilterSelected(void* userdata, bool from_click)
LLInventoryView* self = (LLInventoryView*) userdata;
LLInventoryFilter* filter;
LLInventoryViewFinder *finder = self->getFinder();
LLFloaterInventoryFinder *finder = self->getFinder();
// Find my index
self->mActivePanel = (LLInventoryPanel*)self->childGetVisibleTab("inventory filter tabs");
@@ -1016,10 +1017,11 @@ void LLInventoryView::setFilterTextFromFilter()
void LLInventoryView::toggleFindOptions()
{
LLMemType mt(LLMemType::MTYPE_INVENTORY_VIEW_TOGGLE);
LLFloater *floater = getFinder();
if (!floater)
{
LLInventoryViewFinder * finder = new LLInventoryViewFinder(std::string("Inventory Finder"),
LLFloaterInventoryFinder * finder = new LLFloaterInventoryFinder(std::string("Inventory Finder"),
LLRect(getRect().mLeft - INV_FINDER_WIDTH, getRect().mTop, getRect().mLeft, getRect().mTop - INV_FINDER_HEIGHT),
this);
mFinderHandle = finder->getHandle();
@@ -1039,15 +1041,15 @@ void LLInventoryView::toggleFindOptions()
}
}
///----------------------------------------------------------------------------
/// LLInventoryViewFinder
/// LLFloaterInventoryFinder
///----------------------------------------------------------------------------
LLInventoryViewFinder* LLInventoryView::getFinder()
LLFloaterInventoryFinder* LLInventoryView::getFinder()
{
return (LLInventoryViewFinder*)mFinderHandle.get();
return (LLFloaterInventoryFinder*)mFinderHandle.get();
}
LLInventoryViewFinder::LLInventoryViewFinder(const std::string& name,
LLFloaterInventoryFinder::LLFloaterInventoryFinder(const std::string& name,
const LLRect& rect,
LLInventoryView* inventory_view) :
LLFloater(name, rect, std::string("Filters"), RESIZE_NO,
@@ -1061,7 +1063,7 @@ LLInventoryViewFinder::LLInventoryViewFinder(const std::string& name,
updateElementsFromFilter();
}
BOOL LLInventoryViewFinder::postBuild()
BOOL LLFloaterInventoryFinder::postBuild()
{
childSetAction("All", selectAllTypes, this);
childSetAction("None", selectNoTypes, this);
@@ -1082,9 +1084,9 @@ BOOL LLInventoryViewFinder::postBuild()
}
void LLInventoryViewFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
void LLFloaterInventoryFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
{
LLInventoryViewFinder *self = (LLInventoryViewFinder *)user_data;
LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
if (!self) return;
bool since_logoff= self->childGetValue("check_since_logoff");
@@ -1096,9 +1098,9 @@ void LLInventoryViewFinder::onCheckSinceLogoff(LLUICtrl *ctrl, void *user_data)
}
}
void LLInventoryViewFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
void LLFloaterInventoryFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
{
LLInventoryViewFinder *self = (LLInventoryViewFinder *)user_data;
LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
if (!self) return;
bool since_logoff=true;
@@ -1109,13 +1111,13 @@ void LLInventoryViewFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
self->childSetValue("check_since_logoff", since_logoff);
}
void LLInventoryViewFinder::changeFilter(LLInventoryFilter* filter)
void LLFloaterInventoryFinder::changeFilter(LLInventoryFilter* filter)
{
mFilter = filter;
updateElementsFromFilter();
}
void LLInventoryViewFinder::updateElementsFromFilter()
void LLFloaterInventoryFinder::updateElementsFromFilter()
{
if (!mFilter)
return;
@@ -1146,8 +1148,9 @@ void LLInventoryViewFinder::updateElementsFromFilter()
mSpinSinceDays->set((F32)(hours / 24));
}
void LLInventoryViewFinder::draw()
void LLFloaterInventoryFinder::draw()
{
LLMemType mt(LLMemType::MTYPE_INVENTORY_DRAW);
U32 filter = 0xffffffff;
BOOL filtered_by_all_types = TRUE;
@@ -1253,7 +1256,7 @@ void LLInventoryViewFinder::draw()
LLFloater::draw();
}
void LLInventoryViewFinder::onClose(bool app_quitting)
void LLFloaterInventoryFinder::onClose(bool app_quitting)
{
if (mInventoryView) mInventoryView->getControl("Inventory.ShowFilters")->setValue(FALSE);
// If you want to reset the filter on close, do it here. This functionality was
@@ -1268,26 +1271,26 @@ void LLInventoryViewFinder::onClose(bool app_quitting)
}
BOOL LLInventoryViewFinder::getCheckShowEmpty()
BOOL LLFloaterInventoryFinder::getCheckShowEmpty()
{
return childGetValue("check_show_empty");
}
BOOL LLInventoryViewFinder::getCheckSinceLogoff()
BOOL LLFloaterInventoryFinder::getCheckSinceLogoff()
{
return childGetValue("check_since_logoff");
}
void LLInventoryViewFinder::onCloseBtn(void* user_data)
void LLFloaterInventoryFinder::onCloseBtn(void* user_data)
{
LLInventoryViewFinder* finderp = (LLInventoryViewFinder*)user_data;
LLFloaterInventoryFinder* finderp = (LLFloaterInventoryFinder*)user_data;
finderp->close();
}
// static
void LLInventoryViewFinder::selectAllTypes(void* user_data)
void LLFloaterInventoryFinder::selectAllTypes(void* user_data)
{
LLInventoryViewFinder* self = (LLInventoryViewFinder*)user_data;
LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
if(!self) return;
self->childSetValue("check_animation", TRUE);
@@ -1316,9 +1319,9 @@ void LLInventoryViewFinder::selectAllTypes(void* user_data)
}
//static
void LLInventoryViewFinder::selectNoTypes(void* user_data)
void LLFloaterInventoryFinder::selectNoTypes(void* user_data)
{
LLInventoryViewFinder* self = (LLInventoryViewFinder*)user_data;
LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
if(!self) return;
/*

5
indra/newview/llpanelmaininventory.h
View File

@@ -33,7 +33,6 @@
#include "llfolderview.h"
class LLInventoryViewFinder;
class LLFolderViewItem;
class LLInventoryPanel;
class LLSaveFolderState;
@@ -48,7 +47,7 @@ class LLComboBox;
class LLInventoryView : public LLFloater, LLInventoryObserver
{
friend class LLInventoryViewFinder;
friend class LLFloaterInventoryFinder;
public:
LLInventoryView(const std::string& name, const std::string& rect,
@@ -157,7 +156,7 @@ protected:
void init(LLInventoryModel* inventory);
protected:
LLInventoryViewFinder* getFinder();
LLFloaterInventoryFinder* getFinder();
LLSearchEditor* mSearchEditor;
LLComboBox* mQuickFilterCombo;
LLTabContainer* mFilterTabs;

6
indra/newview/llviewerdisplay.cpp
View File

@@ -1063,7 +1063,8 @@ void render_hud_attachments()
hud_cam.setAxes(LLVector3(1,0,0), LLVector3(0,1,0), LLVector3(0,0,1));
LLViewerCamera::updateFrustumPlanes(hud_cam, TRUE);
bool render_particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) && gSavedSettings.getBOOL("RenderHUDParticles");
static const LLCachedControl<bool> render_hud_particles("RenderHUDParticles");
bool render_particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES) && render_hud_particles;
//only render hud objects
gPipeline.pushRenderTypeMask();
@@ -1407,7 +1408,8 @@ void render_ui_3d()
}
// Coordinate axes
if (gSavedSettings.getBOOL("ShowAxes"))
static const LLCachedControl<bool> show_axes("ShowAxes");
if (show_axes)
{
draw_axes();
}

3
indra/newview/llviewerjointmesh.cpp
View File

@@ -568,7 +568,8 @@ U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass, BOOL is_dummy)
{
// This warning will always trigger if you've hacked the avatar to show as incomplete.
// Ignore the warning if that's the case.
if (!gSavedSettings.getBOOL("RenderUnloadedAvatar"))
static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
if (!rener_unloaded_avatar)
{
llwarns << "Layerset without composite" << llendl;
}

4
indra/newview/llviewermenu.cpp
View File

@@ -947,14 +947,14 @@ void init_client_menu(LLMenuGL* menu)
&get_visibility,
(void*)gDebugView->mFastTimerView,
'9', MASK_CONTROL|MASK_SHIFT ) );
#if MEM_TRACK_MEM
//#if MEM_TRACK_MEM
sub->append(new LLMenuItemCheckGL("Memory",
&toggle_visibility,
NULL,
&get_visibility,
(void*)gDebugView->mMemoryView,
'0', MASK_CONTROL|MASK_SHIFT ) );
#endif
//#endif
sub->appendSeparator();

2
indra/newview/llviewertexture.cpp
View File

@@ -2126,7 +2126,7 @@ bool LLViewerFetchedTexture::updateFetch()
c = mComponents;
}
const U32 override_tex_discard_level = gSavedSettings.getU32("TextureDiscardLevel");
static const LLCachedControl<U32> override_tex_discard_level("TextureDiscardLevel");
if (override_tex_discard_level != 0)
{
desired_discard = override_tex_discard_level;

104
indra/newview/llvoavatar.cpp
View File

@@ -3258,29 +3258,6 @@ void LLVOAvatar::getClientInfo(std::string& client, LLColor4& color, BOOL useCom
return;
std::string uuid_str = getTE(TEX_HEAD_BODYPAINT)->getID().asString(); //UUID of the head texture
if(isFullyLoaded())
{
//Zwagoth's new client identification - HgB
// Overwrite the current tag/color settings if new method
// exists -- charbl.
const LLTextureEntry* texentry = getTE(0);
if(texentry->getGlow() > 0.0)
{
///llinfos << "Using new client identifier." << llendl;
U8 tag_buffer[UUID_BYTES+1];
memset(&tag_buffer, 0, UUID_BYTES);
memcpy(&tag_buffer[0], &texentry->getID().mData, UUID_BYTES);
tag_buffer[UUID_BYTES] = 0;
U32 tag_len = strlen((const char*)&tag_buffer[0]);
tag_len = (tag_len>UUID_BYTES) ? (UUID_BYTES) : tag_len;
client = std::string((char*)&tag_buffer[0], tag_len);
LLStringFn::replace_ascii_controlchars(mClientTag, LL_UNKNOWN_CHAR);
mNameString.clear();
color = texentry->getColor();
return;
}
}
static const LLCachedControl<LLColor4> avatar_name_color(gColors,"AvatarNameColor",LLColor4(LLColor4U(251, 175, 93, 255)) );
if (isSelf())
{
@@ -3574,24 +3551,48 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
new_name = TRUE;
}
LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
static const LLCachedControl<LLColor4> avatar_name_color(gColors, "AvatarNameColor" );
//As pointed out by Zwagoth, we really shouldn't be doing this per-frame. Skip if we already have the data. -HgB
if (mClientTag == "")
{
mClientColor = gColors.getColor( "AvatarNameColor" );
getClientInfo(mClientTag,mClientColor);
if(mClientTag == "")
mClientColor = avatar_name_color;
if(isFullyLoaded())
{
client = "?"; //prevent console spam..
//Zwagoth's new client identification - HgB
// Overwrite the current tag/color settings if new method
// exists -- charbl.
const LLTextureEntry* texentry = getTE(0);
if(texentry->getGlow() > 0.0)
{
llinfos << "Using new client identifier." << llendl;
U8 tag_buffer[UUID_BYTES+1];
memset(&tag_buffer, 0, UUID_BYTES);
memcpy(&tag_buffer[0], &texentry->getID().mData, UUID_BYTES);
tag_buffer[UUID_BYTES] = 0;
U32 tag_len = strlen((const char*)&tag_buffer[0]);
tag_len = (tag_len>UUID_BYTES) ? (UUID_BYTES) : tag_len;
mClientTag = std::string((char*)&tag_buffer[0], tag_len);
LLStringFn::replace_ascii_controlchars(mClientTag, LL_UNKNOWN_CHAR);
mNameString.clear();
mClientColor = texentry->getColor();
}
else
{
//llinfos << "Using Emerald-style client identifier." << llendl;
//The old client identification. Used only if the new method doesn't exist, so that it isn't automatically overwritten. -HgB
getClientInfo(mClientTag,mClientColor);
if(mClientTag == "")
client = "?"; //prevent console spam..
}
}
// Overwrite the tag/color shit yet again if we want to see
// friends in a special color. -- charbl
if (LLAvatarTracker::instance().getBuddyInfo(this->getID()) != NULL)
{
if (gSavedSettings.getBOOL("AscentShowFriendsTag"))
static const LLCachedControl<bool> ascent_show_friends_tag("AscentShowFriendsTag");
if (ascent_show_friends_tag)
{
mClientTag = "Friend";
}
@@ -3611,33 +3612,41 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
//Lindens are always more Linden than your friend, make that take precedence
if(LLMuteList::getInstance()->isLinden(getFullname()))
{
mClientColor = gSavedSettings.getColor4("AscentLindenColor");
static const LLCachedControl<LLColor4> ascent_linden_color(gColors, "AscentLindenColor" );
mClientColor = ascent_linden_color;
}
//check if they are an estate owner at their current position
else if(estate_owner.notNull() && this->getID() == estate_owner)
{
mClientColor = gSavedSettings.getColor4("AscentEstateOwnerColor");
static const LLCachedControl<LLColor4> ascent_estate_owner_color(gColors, "AscentEstateOwnerColor" );
mClientColor = ascent_estate_owner_color;
}
//without these dots, SL would suck.
else if (LLAvatarTracker::instance().getBuddyInfo(this->getID()) != NULL)
{
mClientColor = gSavedSettings.getColor4("AscentFriendColor");
static const LLCachedControl<LLColor4> ascent_friend_color(gColors, "AscentFriendColor" );
mClientColor = ascent_friend_color;
}
//big fat jerkface who is probably a jerk, display them as such.
else if(LLMuteList::getInstance()->isMuted(this->getID()))
{
mClientColor = gSavedSettings.getColor4("AscentMutedColor");
static const LLCachedControl<LLColor4> ascent_muted_color(gColors, "AscentMutedColor" );
mClientColor = ascent_muted_color;
}
}
client = mClientTag;
if ((isSelf() && gSavedSettings.getBOOL("AscentShowSelfTagColor"))
|| (!isSelf() && gSavedSettings.getBOOL("AscentShowOthersTagColor")))
avatar_name_color = mClientColor;
static const LLCachedControl<bool> ascent_show_self_tag_color("AscentShowSelfTagColor");
static const LLCachedControl<bool> ascent_show_others_tag_color("AscentShowOthersTagColor");
LLColor4 name_color = avatar_name_color;
if ((isSelf() && ascent_show_self_tag_color)
|| (!isSelf() && ascent_show_others_tag_color))
name_color = mClientColor;
avatar_name_color.setAlpha(alpha);
mNameText->setColor(avatar_name_color);
name_color.setAlpha(alpha);
mNameText->setColor(name_color);
LLQuaternion root_rot = mRoot.getWorldRotation();
//mNameText->setUsePixelSize(TRUE);
@@ -3719,7 +3728,8 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
}
//idle text
std::string idle_string;
if(!isSelf() && mIdleTimer.getElapsedTimeF32() > 120.f && gSavedSettings.getBOOL("AscentShowIdleTime"))
static LLCachedControl<bool> ascent_show_idle_time("AscentShowIdleTime");
if(!isSelf() && mIdleTimer.getElapsedTimeF32() > 120.f && ascent_show_idle_time)
{
idle_string = getIdleTime();
}
@@ -4049,6 +4059,7 @@ void LLVOAvatar::slamPosition()
bool LLVOAvatar::isVisuallyMuted()
{
if(isSelf())return false;
static LLCachedControl<U32> max_attachment_bytes(gSavedSettings, "RenderAutoMuteByteLimit");
static LLCachedControl<F32> max_attachment_area(gSavedSettings, "RenderAutoMuteSurfaceAreaLimit");
@@ -4907,8 +4918,8 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
if (pass == AVATAR_RENDER_PASS_SINGLE)
{
const bool should_alpha_mask = shouldAlphaMask();
bool is_muted = isVisuallyMuted(); //Disable masking and also disable alpha in LLViewerJoint::render
const bool should_alpha_mask = !is_muted && shouldAlphaMask();
LLGLState test(GL_ALPHA_TEST, should_alpha_mask);
if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction)
@@ -4923,19 +4934,19 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
{
if (isTextureVisible(TEX_HEAD_BAKED) || mIsDummy)
{
num_indices += mMeshLOD[MESH_ID_HEAD]->render(mAdjustedPixelArea, TRUE, mIsDummy);
num_indices += mMeshLOD[MESH_ID_HEAD]->render(mAdjustedPixelArea, TRUE, mIsDummy || is_muted);
first_pass = FALSE;
}
}
if (isTextureVisible(TEX_UPPER_BAKED) || mIsDummy)
{
num_indices += mMeshLOD[MESH_ID_UPPER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
num_indices += mMeshLOD[MESH_ID_UPPER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy || is_muted);
first_pass = FALSE;
}
if (isTextureVisible(TEX_LOWER_BAKED) || mIsDummy)
{
num_indices += mMeshLOD[MESH_ID_LOWER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy);
num_indices += mMeshLOD[MESH_ID_LOWER_BODY]->render(mAdjustedPixelArea, first_pass, mIsDummy || is_muted);
first_pass = FALSE;
}
}
@@ -7912,7 +7923,8 @@ BOOL LLVOAvatar::isFullyLoaded() const
{
// [SL:KB] - Patch: Appearance-SyncAttach | Checked: 2010-09-22 (Catznip-2.2.0a) | Added: Catznip-2.2.0a
// Changes to LLAppearanceMgr::updateAppearanceFromCOF() expect this function to actually return mFullyLoaded for gAgentAvatarp
if ( (!isSelf()) && (gSavedSettings.getBOOL("RenderUnloadedAvatar")) )
static const LLCachedControl<bool> rener_unloaded_avatar("RenderUnloadedAvatar");
if ( (!isSelf()) && (rener_unloaded_avatar) )
return TRUE;
else
return mFullyLoaded;

2
indra/newview/llvovolume.cpp
View File

@@ -821,7 +821,7 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &params_in, const S32 detail, bo
if (is404)
{
setIcon(LLViewerTextureManager::getFetchedTextureFromFile("icons/Inv_Mesh.png", TRUE, LLViewerTexture::BOOST_UI));
setIcon(LLViewerTextureManager::getFetchedTextureFromFile("inv_item_mesh.tga", TRUE, LLViewerTexture::BOOST_UI));
//render prim proxy when mesh loading attempts give up
volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_NONE);

90
indra/newview/pipeline.cpp
View File

@@ -388,7 +388,7 @@ LLPipeline::LLPipeline() :
void LLPipeline::init()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_INIT);
refreshCachedSettings();
@@ -868,6 +868,7 @@ void LLPipeline::releaseScreenBuffers()
void LLPipeline::createGLBuffers()
{
stop_glerror();
LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_CREATE_BUFFERS);
assertInitialized();
updateRenderDeferred();
@@ -954,7 +955,8 @@ void LLPipeline::createGLBuffers()
//F32 sp = acosf(sa)/(1.f-spec);
sa = powf(sa, gSavedSettings.getF32("RenderSpecularExponent"));
static const LLCachedControl<F32> render_specular_exponent("RenderSpecularExponent");
sa = powf(sa, render_specular_exponent);
F32 a = acosf(sa*0.25f+0.75f);
F32 m = llmax(0.5f-spec*0.5f, 0.001f);
F32 t2 = tanf(a)/m;
@@ -982,6 +984,7 @@ void LLPipeline::createGLBuffers()
void LLPipeline::restoreGL()
{
LLMemType mt_cb(LLMemType::MTYPE_PIPELINE_RESTORE_GL);
assertInitialized();
if (mVertexShadersEnabled)
@@ -1043,6 +1046,7 @@ BOOL LLPipeline::canUseAntiAliasing() const
void LLPipeline::unloadShaders()
{
LLMemType mt_us(LLMemType::MTYPE_PIPELINE_UNLOAD_SHADERS);
LLViewerShaderMgr::instance()->unloadShaders();
mVertexShadersLoaded = 0;
@@ -1074,6 +1078,7 @@ S32 LLPipeline::getMaxLightingDetail() const
S32 LLPipeline::setLightingDetail(S32 level)
{
LLMemType mt_ld(LLMemType::MTYPE_PIPELINE_LIGHTING_DETAIL);
refreshCachedSettings();
if (level < 0)
@@ -1264,7 +1269,7 @@ LLDrawPool* LLPipeline::getPoolFromTE(const LLTextureEntry* te, LLViewerTexture*
//static
U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt_gpt(LLMemType::MTYPE_PIPELINE_GET_POOL_TYPE);
if (!te || !imagep)
{
@@ -1294,7 +1299,7 @@ U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* ima
void LLPipeline::addPool(LLDrawPool *new_poolp)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt_a(LLMemType::MTYPE_PIPELINE_ADD_POOL);
assertInitialized();
mPools.insert(new_poolp);
addToQuickLookup( new_poolp );
@@ -1306,7 +1311,7 @@ void LLPipeline::allocDrawable(LLViewerObject *vobj)
{
llerrs << "Null object passed to allocDrawable!" << llendl;
}
LLMemType mt(LLMemType::MTYPE_DRAWABLE);
LLMemType mt_ad(LLMemType::MTYPE_PIPELINE_ALLOCATE_DRAWABLE);
LLDrawable *drawable = new LLDrawable();
vobj->mDrawable = drawable;
@@ -1399,7 +1404,7 @@ U32 LLPipeline::addObject(LLViewerObject *vobj)
{
return 0;
}
LLMemType mt_ao(LLMemType::MTYPE_PIPELINE_ADD_OBJECT);
static const LLCachedControl<bool> render_delay_creation("RenderDelayCreation",false);
if (!vobj->isAvatar() && render_delay_creation)
{
@@ -1416,7 +1421,7 @@ U32 LLPipeline::addObject(LLViewerObject *vobj)
void LLPipeline::createObjects(F32 max_dtime)
{
LLFastTimer ftm(FTM_GEO_UPDATE);
LLMemType mt(LLMemType::MTYPE_DRAWABLE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_CREATE_OBJECTS);
LLTimer update_timer;
@@ -1591,7 +1596,7 @@ static LLFastTimer::DeclareTimer FTM_UPDATE_MOVE("Update Move");
void LLPipeline::updateMove()
{
LLFastTimer t(FTM_UPDATE_MOVE);
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt_um(LLMemType::MTYPE_PIPELINE_UPDATE_MOVE);
static const LLCachedControl<bool> freeze_time("FreezeTime",false);
if (freeze_time)
@@ -1945,7 +1950,7 @@ static LLFastTimer::DeclareTimer FTM_CULL("Object Culling");
void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip, LLPlane* planep)
{
LLFastTimer t(FTM_CULL);
LLMemType mt_uc(LLMemType::MTYPE_PIPELINE);
LLMemType mt_uc(LLMemType::MTYPE_PIPELINE_UPDATE_CULL);
grabReferences(result);
@@ -2314,7 +2319,7 @@ void LLPipeline::rebuildGroups()
void LLPipeline::updateGeom(F32 max_dtime)
{
LLTimer update_timer;
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_UPDATE_GEOM);
LLPointer<LLDrawable> drawablep;
LLFastTimer t(FTM_GEO_UPDATE);
@@ -2417,7 +2422,7 @@ void LLPipeline::updateGeom(F32 max_dtime)
void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_VISIBLE);
if(drawablep && !drawablep->isDead())
{
@@ -2462,7 +2467,7 @@ void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
void LLPipeline::markMoved(LLDrawable *drawablep, BOOL damped_motion)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt_mm(LLMemType::MTYPE_PIPELINE_MARK_MOVED);
if (!drawablep)
{
@@ -2508,7 +2513,7 @@ void LLPipeline::markMoved(LLDrawable *drawablep, BOOL damped_motion)
void LLPipeline::markShift(LLDrawable *drawablep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_SHIFT);
if (!drawablep || drawablep->isDead())
{
@@ -2531,7 +2536,7 @@ void LLPipeline::markShift(LLDrawable *drawablep)
void LLPipeline::shiftObjects(const LLVector3 &offset)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_SHIFT_OBJECTS);
assertInitialized();
@@ -2575,7 +2580,7 @@ void LLPipeline::shiftObjects(const LLVector3 &offset)
void LLPipeline::markTextured(LLDrawable *drawablep)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_TEXTURED);
if (drawablep && !drawablep->isDead() && assertInitialized())
{
@@ -2666,7 +2671,7 @@ void LLPipeline::markRebuild(LLSpatialGroup* group, BOOL priority)
void LLPipeline::markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag, BOOL priority)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_MARK_REBUILD);
if (drawablep && !drawablep->isDead() && assertInitialized())
{
@@ -2714,7 +2719,7 @@ void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
}
LLFastTimer ftm(FTM_STATESORT);
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
//LLVertexBuffer::unbind();
@@ -2815,7 +2820,7 @@ void LLPipeline::stateSort(LLCamera& camera, LLCullResult &result)
void LLPipeline::stateSort(LLSpatialGroup* group, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (!sSkipUpdate && group->changeLOD())
{
for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
@@ -2834,7 +2839,7 @@ void LLPipeline::stateSort(LLSpatialGroup* group, LLCamera& camera)
void LLPipeline::stateSort(LLSpatialBridge* bridge, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (/*!sShadowRender && */!sSkipUpdate && bridge->getSpatialGroup()->changeLOD())
{
bool force_update = false;
@@ -2844,7 +2849,7 @@ void LLPipeline::stateSort(LLSpatialBridge* bridge, LLCamera& camera)
void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_STATE_SORT);
if (!drawablep
|| drawablep->isDead()
@@ -3093,7 +3098,7 @@ void renderSoundHighlights(LLDrawable* drawablep)
void LLPipeline::postSort(LLCamera& camera)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_POST_SORT);
LLFastTimer ftm(FTM_STATESORT_POSTSORT);
assertInitialized();
@@ -3333,6 +3338,7 @@ void LLPipeline::postSort(LLCamera& camera)
void render_hud_elements()
{
LLMemType mt_rhe(LLMemType::MTYPE_PIPELINE_RENDER_HUD_ELS);
LLFastTimer t(FTM_RENDER_UI);
gPipeline.disableLights();
@@ -3352,25 +3358,22 @@ void render_hud_elements()
}
LLGLDepthTest depth(GL_TRUE, GL_FALSE);
if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
if (!LLPipeline::sReflectionRender && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI))
{
if(!LLPipeline::sReflectionRender)
{
static const LLCachedControl<U32> RenderFSAASamples("RenderFSAASamples",0);
LLGLEnable multisample(RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
gViewerWindow->renderSelections(FALSE, FALSE, FALSE); // For HUD version in render_ui_3d()
static const LLCachedControl<U32> RenderFSAASamples("RenderFSAASamples",0);
LLGLEnable multisample(RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
gViewerWindow->renderSelections(FALSE, FALSE, FALSE); // For HUD version in render_ui_3d()
// Draw the tracking overlays
LLTracker::render3D();
// Draw the tracking overlays
LLTracker::render3D();
// Show the property lines
LLWorld::getInstance()->renderPropertyLines();
LLViewerParcelMgr::getInstance()->render();
LLViewerParcelMgr::getInstance()->renderParcelCollision();
// Show the property lines
LLWorld::getInstance()->renderPropertyLines();
LLViewerParcelMgr::getInstance()->render();
LLViewerParcelMgr::getInstance()->renderParcelCollision();
// Render name tags.
LLHUDObject::renderAll();
}
// Render name tags.
LLHUDObject::renderAll();
}
else if (gForceRenderLandFence)
{
@@ -3391,7 +3394,7 @@ void render_hud_elements()
void LLPipeline::renderHighlights()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_HL);
assertInitialized();
@@ -3456,9 +3459,10 @@ void LLPipeline::renderHighlights()
//debug use
U32 LLPipeline::sCurRenderPoolType = 0 ;
void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate)
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_RENDER_GEOM);
LLFastTimer t(FTM_RENDER_GEOMETRY);
assertInitialized();
@@ -3723,6 +3727,7 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate)
void LLPipeline::renderGeomDeferred(LLCamera& camera)
{
LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderGeomDeferred");
LLMemType mt_rgd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_DEFFERRED);
LLFastTimer t(FTM_RENDER_GEOMETRY);
LLFastTimer t2(FTM_POOLS);
@@ -3822,6 +3827,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera)
void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
{
LLMemType mt_rgpd(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_POST_DEF);
LLFastTimer t(FTM_POOLS);
U32 cur_type = 0;
@@ -3918,6 +3924,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera)
void LLPipeline::renderGeomShadow(LLCamera& camera)
{
LLMemType mt_rgs(LLMemType::MTYPE_PIPELINE_RENDER_GEOM_SHADOW);
U32 cur_type = 0;
LLGLEnable cull(GL_CULL_FACE);
@@ -4351,7 +4358,7 @@ void LLPipeline::renderDebug()
void LLPipeline::rebuildPools()
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_REBUILD_POOLS);
assertInitialized();
@@ -4391,7 +4398,7 @@ void LLPipeline::rebuildPools()
void LLPipeline::addToQuickLookup( LLDrawPool* new_poolp )
{
LLMemType mt(LLMemType::MTYPE_PIPELINE);
LLMemType mt(LLMemType::MTYPE_PIPELINE_QUICK_LOOKUP);
assertInitialized();
@@ -6000,6 +6007,7 @@ void LLPipeline::doResetVertexBuffers()
void LLPipeline::renderObjects(U32 type, U32 mask, BOOL texture, BOOL batch_texture)
{
LLMemType mt_ro(LLMemType::MTYPE_PIPELINE_RENDER_OBJECTS);
assertInitialized();
gGL.loadMatrix(gGLModelView);
gGLLastMatrix = NULL;
@@ -6075,6 +6083,7 @@ void LLPipeline::bindScreenToTexture()
static LLFastTimer::DeclareTimer FTM_RENDER_BLOOM("Bloom");
void LLPipeline::renderBloom(BOOL for_snapshot, F32 zoom_factor, int subfield, bool tiling)
{
LLMemType mt_ru(LLMemType::MTYPE_PIPELINE_RENDER_BLOOM);
if (!(gPipeline.canUseVertexShaders() &&
sRenderGlow))
{
@@ -9201,6 +9210,7 @@ void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL textu
void LLPipeline::generateImpostor(LLVOAvatar* avatar)
{
LLMemType mt_gi(LLMemType::MTYPE_PIPELINE_GENERATE_IMPOSTOR);
LLGLState::checkStates();
LLGLState::checkTextureChannels();
LLGLState::checkClientArrays();

3
indra/newview/skins/Pony-Aquablue/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/Pony-Purple/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/dark/textures/textures.xml
View File

@@ -154,6 +154,9 @@
<inv_item_object.tga/>
<inv_item_object_multi.tga/>
<inv_item_pants.tga/>
<inv_item_mesh.tga/>
<inv_item_physics.tga/>
<inv_item_tattoo.tga/>
<inv_item_script.tga/>
<inv_item_shape.tga/>
<inv_item_shirt.tga/>

3
indra/newview/skins/darkgred/textures/textures.xml
View File

@@ -154,6 +154,9 @@
<inv_item_object.tga/>
<inv_item_object_multi.tga/>
<inv_item_pants.tga/>
<inv_item_mesh.tga/>
<inv_item_physics.tga/>
<inv_item_tattoo.tga/>
<inv_item_script.tga/>
<inv_item_shape.tga/>
<inv_item_shirt.tga/>

3
indra/newview/skins/darkorange/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

BIN
indra/newview/skins/default/textures/inv_item_mesh.tga Normal file
View File

Binary file not shown.

3
indra/newview/skins/default/textures/textures.xml
View File

@@ -133,6 +133,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/emerald/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/gemini/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/gred/textures/textures.xml
View File

@@ -154,6 +154,9 @@
<inv_item_object.tga/>
<inv_item_object_multi.tga/>
<inv_item_pants.tga/>
<inv_item_mesh.tga/>
<inv_item_physics.tga/>
<inv_item_tattoo.tga/>
<inv_item_script.tga/>
<inv_item_shape.tga/>
<inv_item_shirt.tga/>

3
indra/newview/skins/kdarknv/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/kliteat/textures/textures.xml
View File

@@ -134,6 +134,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/openlife/textures/textures.xml
View File

@@ -134,6 +134,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>

3
indra/newview/skins/pslgreen/textures/textures.xml
View File

@@ -154,6 +154,9 @@
<inv_item_object.tga/>
<inv_item_object_multi.tga/>
<inv_item_pants.tga/>
<inv_item_mesh.tga/>
<inv_item_physics.tga/>
<inv_item_tattoo.tga/>
<inv_item_script.tga/>
<inv_item_shape.tga/>
<inv_item_shirt.tga/>

3
indra/newview/skins/pslpurple/textures/textures.xml
View File

@@ -154,6 +154,9 @@
<inv_item_object.tga/>
<inv_item_object_multi.tga/>
<inv_item_pants.tga/>
<inv_item_mesh.tga/>
<inv_item_physics.tga/>
<inv_item_tattoo.tga/>
<inv_item_script.tga/>
<inv_item_shape.tga/>
<inv_item_shirt.tga/>

3
indra/newview/skins/wisdom/textures/textures.xml
View File

@@ -130,6 +130,9 @@
<texture name="inv_item_object.tga"/>
<texture name="inv_item_object_multi.tga"/>
<texture name="inv_item_pants.tga"/>
<texture name="inv_item_mesh.tga"/>
<texture name="inv_item_physics.tga"/>
<texture name="inv_item_tattoo.tga"/>
<texture name="inv_item_script.tga"/>
<texture name="inv_item_shape.tga"/>
<texture name="inv_item_shirt.tga"/>