diff --git a/indra/CMakeLists.txt b/indra/CMakeLists.txt
index e1bd0751e5ffd752e72edb8ac44e1a5efc6e68f7..d53e80b0ced1e4298ce02b3e2c4110bf1d94acc9 100644
--- a/indra/CMakeLists.txt
+++ b/indra/CMakeLists.txt
@@ -49,7 +49,7 @@ add_subdirectory(${LIBS_OPEN_PREFIX}llmath)
add_subdirectory(${LIBS_OPEN_PREFIX}llmessage)
add_subdirectory(${LIBS_OPEN_PREFIX}llprimitive)
add_subdirectory(${LIBS_OPEN_PREFIX}llrender)
-add_subdirectory(${LIBS_OPEN_PREFIX}llvfs)
+add_subdirectory(${LIBS_OPEN_PREFIX}llfilesystem)
add_subdirectory(${LIBS_OPEN_PREFIX}llwindow)
add_subdirectory(${LIBS_OPEN_PREFIX}llxml)
diff --git a/indra/cmake/CMakeLists.txt b/indra/cmake/CMakeLists.txt
index c9c3ad5f780d306cba8ed94c786d9ae9610a06c3..37591e94e6c7205ed3608d0aaa6e845fb68d2914 100644
--- a/indra/cmake/CMakeLists.txt
+++ b/indra/cmake/CMakeLists.txt
@@ -60,7 +60,7 @@ set(cmake_SOURCE_FILES
LLSharedLibs.cmake
LLTestCommand.cmake
LLUI.cmake
- LLVFS.cmake
+ LLFileSystem.cmake
LLWindow.cmake
LLXML.cmake
Linking.cmake
diff --git a/indra/cmake/LLFileSystem.cmake b/indra/cmake/LLFileSystem.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2e6c42c30c229028e0e5a9dc2c46081aa99088f9
--- /dev/null
+++ b/indra/cmake/LLFileSystem.cmake
@@ -0,0 +1,7 @@
+# -*- cmake -*-
+
+set(LLFILESYSTEM_INCLUDE_DIRS
+ ${LIBS_OPEN_DIR}/llfilesystem
+ )
+
+set(LLFILESYSTEM_LIBRARIES llfilesystem)
diff --git a/indra/cmake/LLVFS.cmake b/indra/cmake/LLVFS.cmake
deleted file mode 100644
index 0fe87cdea6da7f455a0d5dd3ca4129f2790be026..0000000000000000000000000000000000000000
--- a/indra/cmake/LLVFS.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-# -*- cmake -*-
-
-set(LLVFS_INCLUDE_DIRS
- ${LIBS_OPEN_DIR}/llvfs
- )
-
-set(LLVFS_LIBRARIES llvfs)
diff --git a/indra/integration_tests/llimage_libtest/CMakeLists.txt b/indra/integration_tests/llimage_libtest/CMakeLists.txt
index 5787d4d600a6187cc5d49e7c1de7461f2484a60c..bd59f57e492948c12ef39b88737a405f0514bdec 100644
--- a/indra/integration_tests/llimage_libtest/CMakeLists.txt
+++ b/indra/integration_tests/llimage_libtest/CMakeLists.txt
@@ -10,11 +10,11 @@ include(LLImage)
include(LLMath)
include(LLImageJ2COJ)
include(LLKDU)
-include(LLVFS)
+include(LLFileSystem)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLIMAGE_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
)
@@ -66,7 +66,7 @@ endif (DARWIN)
target_link_libraries(llimage_libtest
${LEGACY_STDIO_LIBS}
${LLCOMMON_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLIMAGE_LIBRARIES}
${LLKDU_LIBRARIES}
diff --git a/indra/integration_tests/llui_libtest/CMakeLists.txt b/indra/integration_tests/llui_libtest/CMakeLists.txt
index 1cec660eb06426fd1dbed99f18c32d48cb53b48b..d7706e73b24ed6033609482a852323aaf077b04b 100644
--- a/indra/integration_tests/llui_libtest/CMakeLists.txt
+++ b/indra/integration_tests/llui_libtest/CMakeLists.txt
@@ -16,7 +16,7 @@ include(LLMessage)
include(LLRender)
include(LLWindow)
include(LLUI)
-include(LLVFS) # ugh, needed for LLDir
+include(LLFileSystem)
include(LLXML)
include(Hunspell)
include(Linking)
@@ -29,7 +29,7 @@ include_directories(
${LLMATH_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
${LLUI_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LIBS_PREBUILD_DIR}/include/hunspell
diff --git a/indra/llappearance/CMakeLists.txt b/indra/llappearance/CMakeLists.txt
index 20eb4678dd223b987fc535d89ef06ba43421b1ee..268849ad74b6e2dfb78b16f1ef8803b5f61fae96 100644
--- a/indra/llappearance/CMakeLists.txt
+++ b/indra/llappearance/CMakeLists.txt
@@ -11,7 +11,7 @@ include(LLMath)
include(LLMessage)
include(LLCoreHttp)
include(LLRender)
-include(LLVFS)
+include(LLFileSystem)
include(LLWindow)
include(LLXML)
include(Linking)
@@ -23,7 +23,7 @@ include_directories(
${LLINVENTORY_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
)
@@ -83,7 +83,7 @@ target_link_libraries(llappearance
${LLINVENTORY_LIBRARIES}
${LLIMAGE_LIBRARIES}
${LLRENDER_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLXML_LIBRARIES}
${LLMATH_LIBRARIES}
@@ -100,7 +100,7 @@ if (BUILD_HEADLESS)
${LLINVENTORY_LIBRARIES}
${LLIMAGE_LIBRARIES}
${LLRENDERHEADLESS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLXML_LIBRARIES}
${LLMATH_LIBRARIES}
@@ -109,15 +109,3 @@ if (BUILD_HEADLESS)
${LLCOMMON_LIBRARIES}
)
endif (BUILD_HEADLESS)
-
-#add unit tests
-#if (LL_TESTS)
-# INCLUDE(LLAddBuildTest)
-# SET(llappearance_TEST_SOURCE_FILES
-# # no real unit tests yet!
-# )
-# LL_ADD_PROJECT_UNIT_TESTS(llappearance "${llappearance_TEST_SOURCE_FILES}")
-
- #set(TEST_DEBUG on)
-# set(test_libs llappearance ${LLCOMMON_LIBRARIES})
-#endif (LL_TESTS)
diff --git a/indra/llappearance/llavatarappearancedefines.cpp b/indra/llappearance/llavatarappearancedefines.cpp
index aba42ee8c5e8ecfb63e1a603bb842248e7004525..85ab831c264d7ae040a4559e8cf2e31cbede9ae2 100644
--- a/indra/llappearance/llavatarappearancedefines.cpp
+++ b/indra/llappearance/llavatarappearancedefines.cpp
@@ -30,7 +30,6 @@
const S32 LLAvatarAppearanceDefines::SCRATCH_TEX_WIDTH = 1024;
const S32 LLAvatarAppearanceDefines::SCRATCH_TEX_HEIGHT = 1024;
-const S32 LLAvatarAppearanceDefines::IMPOSTOR_PERIOD = 2;
using namespace LLAvatarAppearanceDefines;
diff --git a/indra/llappearance/llavatarappearancedefines.h b/indra/llappearance/llavatarappearancedefines.h
index f7e93c5696b805d4c8bd66fcd84a771eb78e244e..858c1ec9bc2dec2cbdd17e374ec3781218d31298 100644
--- a/indra/llappearance/llavatarappearancedefines.h
+++ b/indra/llappearance/llavatarappearancedefines.h
@@ -39,7 +39,6 @@ namespace LLAvatarAppearanceDefines
extern const S32 SCRATCH_TEX_WIDTH;
extern const S32 SCRATCH_TEX_HEIGHT;
-extern const S32 IMPOSTOR_PERIOD;
static const U32 AVATAR_HOVER = 11001;
diff --git a/indra/llappearance/lltexlayer.cpp b/indra/llappearance/lltexlayer.cpp
index eb9b180dc3bb7cadf5958d173e9e512984564cfc..8e8d2f74cd666b41947be64100f1e7427e6ceba4 100644
--- a/indra/llappearance/lltexlayer.cpp
+++ b/indra/llappearance/lltexlayer.cpp
@@ -33,8 +33,6 @@
#include "llimagej2c.h"
#include "llimagetga.h"
#include "lldir.h"
-#include "llvfile.h"
-#include "llvfs.h"
#include "lltexlayerparams.h"
#include "lltexturemanagerbridge.h"
#include "lllocaltextureobject.h"
diff --git a/indra/llaudio/CMakeLists.txt b/indra/llaudio/CMakeLists.txt
index f03d7fdaf54ae6c746f143fbf6ae36da96bccb4e..2850c352159e892a3fe73e373cf83971c88de26f 100644
--- a/indra/llaudio/CMakeLists.txt
+++ b/indra/llaudio/CMakeLists.txt
@@ -9,14 +9,14 @@ include(OPENAL)
include(LLCommon)
include(LLMath)
include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
include_directories(
${LLAUDIO_INCLUDE_DIRS}
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLMESSAGE_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${OGG_INCLUDE_DIRS}
${VORBISENC_INCLUDE_DIRS}
${VORBISFILE_INCLUDE_DIRS}
@@ -88,7 +88,7 @@ target_link_libraries(
${LLCOMMON_LIBRARIES}
${LLMATH_LIBRARIES}
${LLMESSAGE_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${VORBISENC_LIBRARIES}
${VORBISFILE_LIBRARIES}
${VORBIS_LIBRARIES}
diff --git a/indra/llaudio/llaudiodecodemgr.cpp b/indra/llaudio/llaudiodecodemgr.cpp
index 3a728785d74340197ac8e09298045433d14c2f09..af8a0a88f04b319b04fe3096293cd45c21c3d384 100644
--- a/indra/llaudio/llaudiodecodemgr.cpp
+++ b/indra/llaudio/llaudiodecodemgr.cpp
@@ -29,7 +29,7 @@
#include "llaudioengine.h"
#include "lllfsthread.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llstring.h"
#include "lldir.h"
#include "llendianswizzle.h"
@@ -98,19 +98,17 @@ class LLVorbisDecodeState final : public LLRefCount
LLUUID mUUID;
std::vector<U8> mWAVBuffer;
-#if !defined(USE_WAV_VFILE)
std::string mOutFilename;
LLLFSThread::handle_t mFileHandle;
-#endif
- LLVFile *mInFilep;
+ LLFileSystem *mInFilep;
OggVorbis_File mVF;
S32 mCurrentSection;
};
-size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+size_t cache_read(void *ptr, size_t size, size_t nmemb, void *datasource)
{
- LLVFile *file = (LLVFile *)datasource;
+ LLFileSystem *file = (LLFileSystem *)datasource;
if (file->read((U8*)ptr, (S32)(size * nmemb))) /*Flawfinder: ignore*/
{
@@ -123,11 +121,11 @@ size_t vfs_read(void *ptr, size_t size, size_t nmemb, void *datasource)
}
}
-S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
+S32 cache_seek(void *datasource, ogg_int64_t offset, S32 whence)
{
- LLVFile *file = (LLVFile *)datasource;
+ LLFileSystem *file = (LLFileSystem *)datasource;
- // vfs has 31-bit files
+ // cache has 31-bit files
if (offset > S32_MAX)
{
return -1;
@@ -145,7 +143,7 @@ S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
origin = -1;
break;
default:
- LL_ERRS("AudioEngine") << "Invalid whence argument to vfs_seek" << LL_ENDL;
+ LL_ERRS("AudioEngine") << "Invalid whence argument to cache_seek" << LL_ENDL;
return -1;
}
@@ -159,16 +157,16 @@ S32 vfs_seek(void *datasource, ogg_int64_t offset, S32 whence)
}
}
-S32 vfs_close (void *datasource)
+S32 cache_close (void *datasource)
{
- LLVFile *file = (LLVFile *)datasource;
+ LLFileSystem *file = (LLFileSystem *)datasource;
delete file;
return 0;
}
-long vfs_tell (void *datasource)
+long cache_tell (void *datasource)
{
- LLVFile *file = (LLVFile *)datasource;
+ LLFileSystem *file = (LLFileSystem *)datasource;
return file->tell();
}
@@ -180,11 +178,10 @@ LLVorbisDecodeState::LLVorbisDecodeState(const LLUUID &uuid, const std::string &
mUUID = uuid;
mInFilep = NULL;
mCurrentSection = 0;
-#if !defined(USE_WAV_VFILE)
mOutFilename = out_filename;
mFileHandle = LLLFSThread::nullHandle();
-#endif
- // No default value for mVF, it's an ogg structure?
+
+ // No default value for mVF, it's an ogg structure?
// Hey, let's zero it anyway, for predictability.
memset(&mVF, 0, sizeof(mVF));
}
@@ -201,15 +198,15 @@ LLVorbisDecodeState::~LLVorbisDecodeState()
BOOL LLVorbisDecodeState::initDecode()
{
- ov_callbacks vfs_callbacks;
- vfs_callbacks.read_func = vfs_read;
- vfs_callbacks.seek_func = vfs_seek;
- vfs_callbacks.close_func = vfs_close;
- vfs_callbacks.tell_func = vfs_tell;
+ ov_callbacks cache_callbacks;
+ cache_callbacks.read_func = cache_read;
+ cache_callbacks.seek_func = cache_seek;
+ cache_callbacks.close_func = cache_close;
+ cache_callbacks.tell_func = cache_tell;
LL_DEBUGS("AudioEngine") << "Initing decode from vfile: " << mUUID << LL_ENDL;
- mInFilep = new LLVFile(gVFS, mUUID, LLAssetType::AT_SOUND);
+ mInFilep = new LLFileSystem(mUUID, LLAssetType::AT_SOUND);
if (!mInFilep || !mInFilep->getSize())
{
LL_WARNS("AudioEngine") << "unable to open vorbis source vfile for reading" << LL_ENDL;
@@ -218,7 +215,7 @@ BOOL LLVorbisDecodeState::initDecode()
return FALSE;
}
- S32 r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, vfs_callbacks);
+ S32 r = ov_open_callbacks(mInFilep, &mVF, NULL, 0, cache_callbacks);
if(r < 0)
{
LL_WARNS("AudioEngine") << r << " Input to vorbis decode does not appear to be an Ogg bitstream: " << mUUID << LL_ENDL;
@@ -378,7 +375,7 @@ BOOL LLVorbisDecodeState::decodeSection()
{
if (!mInFilep)
{
- LL_WARNS("AudioEngine") << "No VFS file to decode in vorbis!" << LL_ENDL;
+ LL_WARNS("AudioEngine") << "No cache file to decode in vorbis!" << LL_ENDL;
return TRUE;
}
if (mDone)
@@ -428,9 +425,7 @@ BOOL LLVorbisDecodeState::finishDecode()
return TRUE; // We've finished
}
-#if !defined(USE_WAV_VFILE)
if (mFileHandle == LLLFSThread::nullHandle())
-#endif
{
ov_clear(&mVF);
@@ -503,11 +498,9 @@ BOOL LLVorbisDecodeState::finishDecode()
mValid = FALSE;
return TRUE; // we've finished
}
-#if !defined(USE_WAV_VFILE)
mBytesRead = -1;
mFileHandle = LLLFSThread::sLocal->write(mOutFilename, &mWAVBuffer[0], 0, mWAVBuffer.size(),
new WriteResponder(this));
-#endif
}
if (mFileHandle != LLLFSThread::nullHandle())
@@ -529,11 +522,6 @@ BOOL LLVorbisDecodeState::finishDecode()
mDone = TRUE;
-#if defined(USE_WAV_VFILE)
- // write the data.
- LLVFile output(gVFS, mUUID, LLAssetType::AT_SOUND_WAV);
- output.write(&mWAVBuffer[0], mWAVBuffer.size());
-#endif
LL_DEBUGS("AudioEngine") << "Finished decode for " << getUUID() << LL_ENDL;
return TRUE;
@@ -543,7 +531,7 @@ void LLVorbisDecodeState::flushBadFile()
{
if (mInFilep)
{
- LL_WARNS("AudioEngine") << "Flushing bad vorbis file from VFS for " << mUUID << LL_ENDL;
+ LL_WARNS("AudioEngine") << "Flushing bad vorbis file from cache for " << mUUID << LL_ENDL;
mInFilep->remove();
}
}
diff --git a/indra/llaudio/llaudiodecodemgr.h b/indra/llaudio/llaudiodecodemgr.h
index 8228e20e8cb0b523a099148c39237131fe24f768..ceaff3f2d8254a97cf2f865a67fb2dc02cbb15c6 100644
--- a/indra/llaudio/llaudiodecodemgr.h
+++ b/indra/llaudio/llaudiodecodemgr.h
@@ -33,7 +33,6 @@
#include "llassettype.h"
#include "llframetimer.h"
-class LLVFS;
class LLVorbisDecodeState;
class LLAudioDecodeMgr
diff --git a/indra/llaudio/llaudioengine.cpp b/indra/llaudio/llaudioengine.cpp
index b19ca87c5be8279e1caadc8f4d618063b2e762ab..4daa03c0c29dfbd1962cd43074603f120cda400e 100644
--- a/indra/llaudio/llaudioengine.cpp
+++ b/indra/llaudio/llaudioengine.cpp
@@ -35,7 +35,7 @@
#include "sound_ids.h" // temporary hack for min/max distances
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "lldir.h"
#include "llaudiodecodemgr.h"
#include "llassetstorage.h"
@@ -684,13 +684,9 @@ bool LLAudioEngine::preloadSound(const LLUUID &uuid)
return true;
}
- // At some point we need to have the audio/asset system check the static VFS
- // before it goes off and fetches stuff from the server.
- //LL_WARNS() << "Used internal preload for non-local sound" << LL_ENDL;
return false;
}
-
bool LLAudioEngine::isWindEnabled()
{
return mEnableWind;
@@ -1019,13 +1015,12 @@ bool LLAudioEngine::hasDecodedFile(const LLUUID &uuid)
bool LLAudioEngine::hasLocalFile(const LLUUID &uuid)
{
- // See if it's in the VFS.
- bool have_local = gVFS->getExists(uuid, LLAssetType::AT_SOUND);
- LL_DEBUGS("AudioEngine") << "sound uuid "<<uuid<<" exists in VFS"<<LL_ENDL;
+ // See if it's in the cache.
+ bool have_local = LLFileSystem::getExists(uuid, LLAssetType::AT_SOUND);
+ LL_DEBUGS("AudioEngine") << "sound uuid " << uuid << " exists in cache" << LL_ENDL;
return have_local;
}
-
void LLAudioEngine::startNextTransfer()
{
//LL_INFOS() << "LLAudioEngine::startNextTransfer()" << LL_ENDL;
@@ -1226,7 +1221,7 @@ void LLAudioEngine::startNextTransfer()
// static
-void LLAudioEngine::assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status)
+void LLAudioEngine::assetCallback(const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status)
{
if (!gAudiop)
{
diff --git a/indra/llaudio/llaudioengine.h b/indra/llaudio/llaudioengine.h
index b4e22fae8c308332f6588460efb061e89c05ec18..d0241839b1a55f56dfb0ca4f3f8539ec2a088f96 100644
--- a/indra/llaudio/llaudioengine.h
+++ b/indra/llaudio/llaudioengine.h
@@ -50,15 +50,6 @@ const F32 DEFAULT_MIN_DISTANCE = 2.0f;
#define MAX_CHANNELS 30
#define MAX_BUFFERS 40 // Some extra for preloading, maybe?
-// This define is intended to allow us to switch from os based wav
-// file loading to vfs based wav file loading. The problem is that I
-// am unconvinced that the LLWaveFile works for loading sounds from
-// memory. So, until that is fixed up, changed, whatever, this remains
-// undefined.
-//#define USE_WAV_VFILE
-
-class LLVFS;
-
class LLAudioSource;
class LLAudioData;
class LLAudioChannel;
@@ -67,11 +58,9 @@ class LLAudioBuffer;
class LLStreamingAudioInterface;
struct SoundData;
-
//
// LLAudioEngine definition
//
-
class LLAudioEngine
{
friend class LLAudioChannelOpenAL; // bleh. channel needs some listener methods.
@@ -182,7 +171,7 @@ class LLAudioEngine
// Asset callback when we're retrieved a sound from the asset server.
void startNextTransfer();
- static void assetCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status);
+ static void assetCallback(const LLUUID &uuid, LLAssetType::EType type, void *user_data, S32 result_code, LLExtStat ext_status);
friend class LLPipeline; // For debugging
public:
diff --git a/indra/llcharacter/CMakeLists.txt b/indra/llcharacter/CMakeLists.txt
index 902054c678fd233aaa6de8638ad4110fd88135fc..c0d8c5981137aacde8de356f213911bcc78b76ca 100644
--- a/indra/llcharacter/CMakeLists.txt
+++ b/indra/llcharacter/CMakeLists.txt
@@ -6,14 +6,14 @@ include(00-Common)
include(LLCommon)
include(LLMath)
include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
include(LLXML)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLMESSAGE_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
)
include_directories(SYSTEM
@@ -81,18 +81,6 @@ target_link_libraries(
${LLCOMMON_LIBRARIES}
${LLMATH_LIBRARIES}
${LLMESSAGE_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLXML_LIBRARIES}
)
-
-
-# Add tests
-#if (LL_TESTS)
-# include(LLAddBuildTest)
-# # UNIT TESTS
-# SET(llcharacter_TEST_SOURCE_FILES
-# lljoint.cpp
-# )
-# LL_ADD_PROJECT_UNIT_TESTS(llcharacter "${llcharacter_TEST_SOURCE_FILES}")
-#endif (LL_TESTS)
-
diff --git a/indra/llcharacter/llkeyframefallmotion.cpp b/indra/llcharacter/llkeyframefallmotion.cpp
index eb74eee65fd21aed1723ba193caffdb2c18945b5..e3ff1123ed46edd2480b19142158d53d01de636f 100644
--- a/indra/llcharacter/llkeyframefallmotion.cpp
+++ b/indra/llcharacter/llkeyframefallmotion.cpp
@@ -61,6 +61,11 @@ LLMotion::LLMotionInitStatus LLKeyframeFallMotion::onInitialize(LLCharacter *cha
// load keyframe data, setup pose and joint states
LLMotion::LLMotionInitStatus result = LLKeyframeMotion::onInitialize(character);
+ if (result != LLMotion::STATUS_SUCCESS)
+ {
+ return result;
+ }
+
for (U32 jm=0; jm<mJointMotionList->getNumJointMotions(); jm++)
{
if (!mJointStates[jm]->getJoint())
diff --git a/indra/llcharacter/llkeyframemotion.cpp b/indra/llcharacter/llkeyframemotion.cpp
index 938cc35cb3f7b69e6c5f8fe3db6ee5770189b8ad..2146aa886d65b6bc50d63eb9ab7124181a1b9a3d 100644
--- a/indra/llcharacter/llkeyframemotion.cpp
+++ b/indra/llcharacter/llkeyframemotion.cpp
@@ -39,14 +39,13 @@
#include "llendianswizzle.h"
#include "llkeyframemotion.h"
#include "llquantize.h"
-#include "llvfile.h"
#include "m3math.h"
#include "message.h"
+#include "llfilesystem.h"
//-----------------------------------------------------------------------------
// Static Definitions
//-----------------------------------------------------------------------------
-LLVFS* LLKeyframeMotion::sVFS = NULL;
LLKeyframeDataCache::keyframe_data_map_t LLKeyframeDataCache::sKeyframeDataMap;
//-----------------------------------------------------------------------------
@@ -265,7 +264,7 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
return STATUS_SUCCESS;
default:
// we don't know what state the asset is in yet, so keep going
- // check keyframe cache first then static vfs then asset request
+ // check keyframe cache first then file cache then asset request
break;
}
@@ -309,13 +308,8 @@ LLMotion::LLMotionInitStatus LLKeyframeMotion::onInitialize(LLCharacter *charact
U8 *anim_data;
S32 anim_file_size;
- if (!sVFS)
- {
- LL_ERRS() << "Must call LLKeyframeMotion::setVFS() first before loading a keyframe file!" << LL_ENDL;
- }
-
BOOL success = FALSE;
- LLVFile* anim_file = new LLVFile(sVFS, mID, LLAssetType::AT_ANIMATION);
+ LLFileSystem* anim_file = new LLFileSystem(mID, LLAssetType::AT_ANIMATION);
if (!anim_file || !anim_file->getSize())
{
delete anim_file;
@@ -2058,10 +2052,9 @@ void LLKeyframeMotion::setLoopOut(F32 out_point)
//-----------------------------------------------------------------------------
// onLoadComplete()
//-----------------------------------------------------------------------------
-void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void LLKeyframeMotion::onLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LLUUID* id = (LLUUID*)user_data;
@@ -2093,7 +2086,7 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
// asset already loaded
return;
}
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 size = file.getSize();
U8* buffer = new U8[size];
diff --git a/indra/llcharacter/llkeyframemotion.h b/indra/llcharacter/llkeyframemotion.h
index b441c75cfb83186805da8a4e4fb477c2d57e4506..37ea1cb4f5197e1b42a2c2ae30166550eeef79a9 100644
--- a/indra/llcharacter/llkeyframemotion.h
+++ b/indra/llcharacter/llkeyframemotion.h
@@ -46,7 +46,6 @@
#include <absl/container/flat_hash_map.h>
class LLKeyframeDataCache;
-class LLVFS;
class LLDataPacker;
#define MIN_REQUIRED_PIXEL_AREA_KEYFRAME (40.f)
@@ -159,10 +158,7 @@ class LLKeyframeMotion :
virtual void setStopTime(F32 time);
- static void setVFS(LLVFS* vfs) { sVFS = vfs; }
-
- static void onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+ static void onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
@@ -417,13 +413,7 @@ class LLKeyframeMotion :
U32 getNumJointMotions() const { return mJointMotionArray.size(); }
};
-
protected:
- static LLVFS* sVFS;
-
- //-------------------------------------------------------------------------
- // Member Data
- //-------------------------------------------------------------------------
JointMotionList* mJointMotionList;
std::vector<LLPointer<LLJointState> > mJointStates;
LLJoint* mPelvisp;
diff --git a/indra/llcommon/llerror.cpp b/indra/llcommon/llerror.cpp
index 39b851ae3fa678fa03307cd73e6767607834f678..71716f5ba1cd929687504eea46fb94afcf144b92 100644
--- a/indra/llcommon/llerror.cpp
+++ b/indra/llcommon/llerror.cpp
@@ -207,23 +207,64 @@ namespace {
{
return LLError::getEnabledLogTypesMask() & 0x04;
}
-
+
+ LL_FORCE_INLINE std::string createBoldANSI()
+ {
+ std::string ansi_code;
+ ansi_code += '\033';
+ ansi_code += "[";
+ ansi_code += "1";
+ ansi_code += "m";
+
+ return ansi_code;
+ }
+
+ LL_FORCE_INLINE std::string createResetANSI()
+ {
+ std::string ansi_code;
+ ansi_code += '\033';
+ ansi_code += "[";
+ ansi_code += "0";
+ ansi_code += "m";
+
+ return ansi_code;
+ }
+
LL_FORCE_INLINE std::string createANSI(const std::string& color)
{
std::string ansi_code;
- ansi_code += '\033';
- ansi_code += "[";
- ansi_code += color;
+ ansi_code += '\033';
+ ansi_code += "[";
+ ansi_code += "38;5;";
+ ansi_code += color;
ansi_code += "m";
+
return ansi_code;
}
virtual void recordMessage(LLError::ELevel level,
const std::string& message) override
{
- static std::string s_ansi_error = createANSI("31"); // red
- static std::string s_ansi_warn = createANSI("34"); // blue
- static std::string s_ansi_debug = createANSI("35"); // magenta
+ // The default colors for error, warn and debug are now a bit more pastel
+ // and easier to read on the default (black) terminal background but you
+ // now have the option to set the color of each via an environment variables:
+ // LL_ANSI_ERROR_COLOR_CODE (default is red)
+ // LL_ANSI_WARN_COLOR_CODE (default is blue)
+ // LL_ANSI_DEBUG_COLOR_CODE (default is magenta)
+ // The list of color codes can be found in many places but I used this page:
+ // https://www.lihaoyi.com/post/BuildyourownCommandLinewithANSIescapecodes.html#256-colors
+ // (Note: you may need to restart Visual Studio to pick environment changes)
+ char* val = nullptr;
+ std::string s_ansi_error_code = "160";
+ if ((val = getenv("LL_ANSI_ERROR_COLOR_CODE")) != nullptr) s_ansi_error_code = std::string(val);
+ std::string s_ansi_warn_code = "33";
+ if ((val = getenv("LL_ANSI_WARN_COLOR_CODE")) != nullptr) s_ansi_warn_code = std::string(val);
+ std::string s_ansi_debug_code = "177";
+ if ((val = getenv("LL_ANSI_DEBUG_COLOR_CODE")) != nullptr) s_ansi_debug_code = std::string(val);
+
+ static std::string s_ansi_error = createANSI(s_ansi_error_code); // default is red
+ static std::string s_ansi_warn = createANSI(s_ansi_warn_code); // default is blue
+ static std::string s_ansi_debug = createANSI(s_ansi_debug_code); // default is magenta
if (mUseANSI)
{
@@ -242,11 +283,11 @@ namespace {
LL_FORCE_INLINE void writeANSI(const std::string& ansi_code, const std::string& message)
{
- static std::string s_ansi_bold = createANSI("1"); // bold
- static std::string s_ansi_reset = createANSI("0"); // reset
+ static std::string s_ansi_bold = createBoldANSI(); // bold text
+ static std::string s_ansi_reset = createResetANSI(); // reset
// ANSI color code escape sequence, message, and reset in one fprintf call
// Default all message levels to bold so we can distinguish our own messages from those dumped by subprocesses and libraries.
- fprintf(stderr, "%s%s%s\n%s", s_ansi_bold.c_str(), ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
+ fprintf(stderr, "%s%s\n%s", ansi_code.c_str(), message.c_str(), s_ansi_reset.c_str() );
}
static bool checkANSI(void)
diff --git a/indra/llvfs/CMakeLists.txt b/indra/llfilesystem/CMakeLists.txt
similarity index 52%
rename from indra/llvfs/CMakeLists.txt
rename to indra/llfilesystem/CMakeLists.txt
index ea0d7e498ea01ed026a6dc36169433bcb229c8ea..e5efcf6dfd622753125d4296cc6c6719a53a5fdd 100644
--- a/indra/llvfs/CMakeLists.txt
+++ b/indra/llfilesystem/CMakeLists.txt
@@ -1,6 +1,6 @@
# -*- cmake -*-
-project(llvfs)
+project(llfilesystem)
include(00-Common)
include(LLCommon)
@@ -11,39 +11,34 @@ include_directories(
${LLCOMMON_SYSTEM_INCLUDE_DIRS}
)
-set(llvfs_SOURCE_FILES
+set(llfilesystem_SOURCE_FILES
lldir.cpp
lldiriterator.cpp
lllfsthread.cpp
- llpidlock.cpp
- llvfile.cpp
- llvfs.cpp
- llvfsthread.cpp
+ lldiskcache.cpp
+ llfilesystem.cpp
)
-set(llvfs_HEADER_FILES
+set(llfilesystem_HEADER_FILES
CMakeLists.txt
-
lldir.h
lldirguard.h
lldiriterator.h
lllfsthread.h
- llpidlock.h
- llvfile.h
- llvfs.h
- llvfsthread.h
+ lldiskcache.h
+ llfilesystem.h
)
if (DARWIN)
- LIST(APPEND llvfs_SOURCE_FILES lldir_mac.cpp)
- LIST(APPEND llvfs_HEADER_FILES lldir_mac.h)
- LIST(APPEND llvfs_SOURCE_FILES llvfs_objc.mm)
- LIST(APPEND llvfs_HEADER_FILES llvfs_objc.h)
+ LIST(APPEND llfilesystem_SOURCE_FILES lldir_utils_objc.mm)
+ LIST(APPEND llfilesystem_SOURCE_FILES lldir_utils_objc.h)
+ LIST(APPEND llfilesystem_SOURCE_FILES lldir_mac.cpp)
+ LIST(APPEND llfilesystem_HEADER_FILES lldir_mac.h)
endif (DARWIN)
if (LINUX)
- LIST(APPEND llvfs_SOURCE_FILES lldir_linux.cpp)
- LIST(APPEND llvfs_HEADER_FILES lldir_linux.h)
+ LIST(APPEND llfilesystem_SOURCE_FILES lldir_linux.cpp)
+ LIST(APPEND llfilesystem_HEADER_FILES lldir_linux.h)
if (INSTALL)
set_source_files_properties(lldir_linux.cpp
@@ -54,25 +49,25 @@ if (LINUX)
endif (LINUX)
if (WINDOWS)
- LIST(APPEND llvfs_SOURCE_FILES lldir_win32.cpp)
- LIST(APPEND llvfs_HEADER_FILES lldir_win32.h)
+ LIST(APPEND llfilesystem_SOURCE_FILES lldir_win32.cpp)
+ LIST(APPEND llfilesystem_HEADER_FILES lldir_win32.h)
endif (WINDOWS)
-set_source_files_properties(${llvfs_HEADER_FILES}
+set_source_files_properties(${llfilesystem_HEADER_FILES}
PROPERTIES HEADER_FILE_ONLY TRUE)
-list(APPEND llvfs_SOURCE_FILES ${llvfs_HEADER_FILES})
+list(APPEND llfilesystem_SOURCE_FILES ${llfilesystem_HEADER_FILES})
-add_library (llvfs ${llvfs_SOURCE_FILES})
+add_library (llfilesystem ${llfilesystem_SOURCE_FILES})
-set(vfs_BOOST_LIBRARIES
+set(cache_BOOST_LIBRARIES
${BOOST_FILESYSTEM_LIBRARY}
${BOOST_SYSTEM_LIBRARY}
)
-target_link_libraries(llvfs
+target_link_libraries(llfilesystem
${LLCOMMON_LIBRARIES}
- ${vfs_BOOST_LIBRARIES}
+ ${cache_BOOST_LIBRARIES}
)
if (WINDOWS)
@@ -82,7 +77,7 @@ endif (WINDOWS)
if (DARWIN)
include(CMakeFindFrameworks)
find_library(COCOA_LIBRARY Cocoa)
- target_link_libraries(llvfs ${COCOA_LIBRARY})
+ target_link_libraries(llfilesystem ${COCOA_LIBRARY})
endif (DARWIN)
@@ -90,18 +85,18 @@ endif (DARWIN)
if (LL_TESTS)
include(LLAddBuildTest)
# UNIT TESTS
- SET(llvfs_TEST_SOURCE_FILES
+ SET(llfilesystem_TEST_SOURCE_FILES
lldiriterator.cpp
)
set_source_files_properties(lldiriterator.cpp
PROPERTIES
- LL_TEST_ADDITIONAL_LIBRARIES "${vfs_BOOST_LIBRARIES}"
+ LL_TEST_ADDITIONAL_LIBRARIES "${cache_BOOST_LIBRARIES}"
)
- LL_ADD_PROJECT_UNIT_TESTS(llvfs "${llvfs_TEST_SOURCE_FILES}")
+ LL_ADD_PROJECT_UNIT_TESTS(llfilesystem "${llfilesystem_TEST_SOURCE_FILES}")
# INTEGRATION TESTS
- set(test_libs llmath llcommon llvfs ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
+ set(test_libs llmath llcommon llfilesystem ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
# TODO: Some of these need refactoring to be proper Unit tests rather than Integration tests.
LL_ADD_INTEGRATION_TEST(lldir "" "${test_libs}")
diff --git a/indra/llvfs/lldir.cpp b/indra/llfilesystem/lldir.cpp
similarity index 100%
rename from indra/llvfs/lldir.cpp
rename to indra/llfilesystem/lldir.cpp
diff --git a/indra/llvfs/lldir.h b/indra/llfilesystem/lldir.h
similarity index 100%
rename from indra/llvfs/lldir.h
rename to indra/llfilesystem/lldir.h
diff --git a/indra/llvfs/lldir_linux.cpp b/indra/llfilesystem/lldir_linux.cpp
similarity index 100%
rename from indra/llvfs/lldir_linux.cpp
rename to indra/llfilesystem/lldir_linux.cpp
diff --git a/indra/llvfs/lldir_linux.h b/indra/llfilesystem/lldir_linux.h
similarity index 100%
rename from indra/llvfs/lldir_linux.h
rename to indra/llfilesystem/lldir_linux.h
diff --git a/indra/llvfs/lldir_mac.cpp b/indra/llfilesystem/lldir_mac.cpp
similarity index 99%
rename from indra/llvfs/lldir_mac.cpp
rename to indra/llfilesystem/lldir_mac.cpp
index 9a45d75be4a999d23cd1ba0822b3a6f9e336177f..cc430bb957b4960e64abf5681b0de1b39832fc12 100644
--- a/indra/llvfs/lldir_mac.cpp
+++ b/indra/llfilesystem/lldir_mac.cpp
@@ -36,7 +36,7 @@
#include <unistd.h>
#include <glob.h>
#include <boost/filesystem.hpp>
-#include "llvfs_objc.h"
+#include "lldir_utils_objc.h"
// --------------------------------------------------------------------------------
diff --git a/indra/llvfs/lldir_mac.h b/indra/llfilesystem/lldir_mac.h
similarity index 100%
rename from indra/llvfs/lldir_mac.h
rename to indra/llfilesystem/lldir_mac.h
diff --git a/indra/llvfs/lldir_solaris.cpp b/indra/llfilesystem/lldir_solaris.cpp
similarity index 100%
rename from indra/llvfs/lldir_solaris.cpp
rename to indra/llfilesystem/lldir_solaris.cpp
diff --git a/indra/llvfs/lldir_solaris.h b/indra/llfilesystem/lldir_solaris.h
similarity index 100%
rename from indra/llvfs/lldir_solaris.h
rename to indra/llfilesystem/lldir_solaris.h
diff --git a/indra/llvfs/llvfs_objc.h b/indra/llfilesystem/lldir_utils_objc.h
similarity index 85%
rename from indra/llvfs/llvfs_objc.h
rename to indra/llfilesystem/lldir_utils_objc.h
index 686a082995d5f3818699a248a5fea9e1577f065b..59dbeb4aec26f525850d43be3af29a3fb6a40e30 100644
--- a/indra/llvfs/llvfs_objc.h
+++ b/indra/llfilesystem/lldir_utils_objc.h
@@ -1,10 +1,10 @@
/**
- * @file llvfs_objc.h
+ * @file lldir_utils_objc.h
* @brief Definition of directory utilities class for Mac OS X
*
- * $LicenseInfo:firstyear=2000&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2020&license=viewerlgpl$
* Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * Copyright (C) 2020, 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
@@ -28,8 +28,8 @@
#error This header must not be included when compiling for any target other than Mac OS. Consider including lldir.h instead.
#endif // !LL_DARWIN
-#ifndef LL_LLVFS_OBJC_H
-#define LL_LLVFS_OBJC_H
+#ifndef LL_LLDIR_UTILS_OBJC_H
+#define LL_LLDIR_UTILS_OBJC_H
#include <iostream>
@@ -40,4 +40,4 @@ std::string getSystemResourceFolder();
std::string getSystemExecutableFolder();
-#endif // LL_LLVFS_OBJC_H
+#endif // LL_LLDIR_UTILS_OBJC_H
diff --git a/indra/llvfs/llvfs_objc.mm b/indra/llfilesystem/lldir_utils_objc.mm
similarity index 95%
rename from indra/llvfs/llvfs_objc.mm
rename to indra/llfilesystem/lldir_utils_objc.mm
index 9218b618ea1f56bee8a165874122bf11296df74d..663e756818bf002ccbc2fac9fd37a50cc4798f0d 100644
--- a/indra/llvfs/llvfs_objc.mm
+++ b/indra/llfilesystem/lldir_utils_objc.mm
@@ -1,10 +1,10 @@
/**
- * @file llvfs_objc.cpp
+ * @file lldir_utils_objc.mm
* @brief Cocoa implementation of directory utilities for Mac OS X
*
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * $LicenseInfo:firstyear=2020&license=viewerlgpl$
* Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * Copyright (C) 2020, 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
@@ -27,7 +27,7 @@
//WARNING: This file CANNOT use standard linden includes due to conflicts between definitions of BOOL
-#include "llvfs_objc.h"
+#include "lldir_utils_objc.h"
#import <Cocoa/Cocoa.h>
std::string getSystemTempFolder()
diff --git a/indra/llvfs/lldir_win32.cpp b/indra/llfilesystem/lldir_win32.cpp
similarity index 100%
rename from indra/llvfs/lldir_win32.cpp
rename to indra/llfilesystem/lldir_win32.cpp
diff --git a/indra/llvfs/lldir_win32.h b/indra/llfilesystem/lldir_win32.h
similarity index 100%
rename from indra/llvfs/lldir_win32.h
rename to indra/llfilesystem/lldir_win32.h
diff --git a/indra/llvfs/lldirguard.h b/indra/llfilesystem/lldirguard.h
similarity index 100%
rename from indra/llvfs/lldirguard.h
rename to indra/llfilesystem/lldirguard.h
diff --git a/indra/llvfs/lldiriterator.cpp b/indra/llfilesystem/lldiriterator.cpp
similarity index 100%
rename from indra/llvfs/lldiriterator.cpp
rename to indra/llfilesystem/lldiriterator.cpp
diff --git a/indra/llvfs/lldiriterator.h b/indra/llfilesystem/lldiriterator.h
similarity index 100%
rename from indra/llvfs/lldiriterator.h
rename to indra/llfilesystem/lldiriterator.h
diff --git a/indra/llfilesystem/lldiskcache.cpp b/indra/llfilesystem/lldiskcache.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c9f7684b5a6e08bfbee396531aa95a5e0f0b7251
--- /dev/null
+++ b/indra/llfilesystem/lldiskcache.cpp
@@ -0,0 +1,327 @@
+/**
+ * @file lldiskcache.cpp
+ * @brief The disk cache implementation.
+ *
+ * Note: Rather than keep the top level function comments up
+ * to date in both the source and header files, I elected to
+ * only have explicit comments about each function and variable
+ * in the header - look there for details. The same is true for
+ * description of how this code is supposed to work.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2020, 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 "llassettype.h"
+#include "lldir.h"
+#include <boost/filesystem.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <chrono>
+
+#include "lldiskcache.h"
+
+LLDiskCache::LLDiskCache(const std::string cache_dir,
+ const int max_size_bytes,
+ const bool enable_cache_debug_info) :
+ mCacheDir(cache_dir),
+ mMaxSizeBytes(max_size_bytes),
+ mEnableCacheDebugInfo(enable_cache_debug_info)
+{
+ mCacheFilenamePrefix = "sl_cache";
+
+ LLFile::mkdir(cache_dir);
+}
+
+void LLDiskCache::purge()
+{
+ if (mEnableCacheDebugInfo)
+ {
+ LL_INFOS() << "Total dir size before purge is " << dirFileSize(mCacheDir) << LL_ENDL;
+ }
+
+ auto start_time = std::chrono::high_resolution_clock::now();
+
+ typedef std::pair<std::time_t, std::pair<uintmax_t, std::string>> file_info_t;
+ std::vector<file_info_t> file_info;
+
+#if LL_WINDOWS
+ std::wstring cache_path(utf8str_to_utf16str(mCacheDir));
+#else
+ std::string cache_path(mCacheDir);
+#endif
+ if (boost::filesystem::is_directory(cache_path))
+ {
+ for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(cache_path), {}))
+ {
+ if (boost::filesystem::is_regular_file(entry))
+ {
+ if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+ {
+ uintmax_t file_size = boost::filesystem::file_size(entry);
+ const std::string file_path = entry.path().string();
+ const std::time_t file_time = boost::filesystem::last_write_time(entry);
+
+ file_info.push_back(file_info_t(file_time, { file_size, file_path }));
+ }
+ }
+ }
+ }
+
+ std::sort(file_info.begin(), file_info.end(), [](file_info_t& x, file_info_t& y)
+ {
+ return x.first > y.first;
+ });
+
+ LL_INFOS() << "Purging cache to a maximum of " << mMaxSizeBytes << " bytes" << LL_ENDL;
+
+ uintmax_t file_size_total = 0;
+ for (file_info_t& entry : file_info)
+ {
+ file_size_total += entry.second.first;
+
+ std::string action = "";
+ if (file_size_total > mMaxSizeBytes)
+ {
+ action = "DELETE:";
+ boost::filesystem::remove(entry.second.second);
+ }
+ else
+ {
+ action = " KEEP:";
+ }
+
+ if (mEnableCacheDebugInfo)
+ {
+ // have to do this because of LL_INFO/LL_END weirdness
+ std::ostringstream line;
+
+ line << action << " ";
+ line << entry.first << " ";
+ line << entry.second.first << " ";
+ line << entry.second.second;
+ line << " (" << file_size_total << "/" << mMaxSizeBytes << ")";
+ LL_INFOS() << line.str() << LL_ENDL;
+ }
+ }
+
+ if (mEnableCacheDebugInfo)
+ {
+ auto end_time = std::chrono::high_resolution_clock::now();
+ auto execute_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
+ LL_INFOS() << "Total dir size after purge is " << dirFileSize(mCacheDir) << LL_ENDL;
+ LL_INFOS() << "Cache purge took " << execute_time << " ms to execute for " << file_info.size() << " files" << LL_ENDL;
+ }
+}
+
+const std::string LLDiskCache::assetTypeToString(LLAssetType::EType at)
+{
+ /**
+ * Make use of the handy C++17 feature that allows
+ * for inline initialization of an std::map<>
+ */
+ typedef std::map<LLAssetType::EType, std::string> asset_type_to_name_t;
+ asset_type_to_name_t asset_type_to_name =
+ {
+ { LLAssetType::AT_TEXTURE, "TEXTURE" },
+ { LLAssetType::AT_SOUND, "SOUND" },
+ { LLAssetType::AT_CALLINGCARD, "CALLINGCARD" },
+ { LLAssetType::AT_LANDMARK, "LANDMARK" },
+ { LLAssetType::AT_SCRIPT, "SCRIPT" },
+ { LLAssetType::AT_CLOTHING, "CLOTHING" },
+ { LLAssetType::AT_OBJECT, "OBJECT" },
+ { LLAssetType::AT_NOTECARD, "NOTECARD" },
+ { LLAssetType::AT_CATEGORY, "CATEGORY" },
+ { LLAssetType::AT_LSL_TEXT, "LSL_TEXT" },
+ { LLAssetType::AT_LSL_BYTECODE, "LSL_BYTECODE" },
+ { LLAssetType::AT_TEXTURE_TGA, "TEXTURE_TGA" },
+ { LLAssetType::AT_BODYPART, "BODYPART" },
+ { LLAssetType::AT_SOUND_WAV, "SOUND_WAV" },
+ { LLAssetType::AT_IMAGE_TGA, "IMAGE_TGA" },
+ { LLAssetType::AT_IMAGE_JPEG, "IMAGE_JPEG" },
+ { LLAssetType::AT_ANIMATION, "ANIMATION" },
+ { LLAssetType::AT_GESTURE, "GESTURE" },
+ { LLAssetType::AT_SIMSTATE, "SIMSTATE" },
+ { LLAssetType::AT_LINK, "LINK" },
+ { LLAssetType::AT_LINK_FOLDER, "LINK_FOLDER" },
+ { LLAssetType::AT_MARKETPLACE_FOLDER, "MARKETPLACE_FOLDER" },
+ { LLAssetType::AT_WIDGET, "WIDGET" },
+ { LLAssetType::AT_PERSON, "PERSON" },
+ { LLAssetType::AT_MESH, "MESH" },
+ { LLAssetType::AT_SETTINGS, "SETTINGS" },
+ { LLAssetType::AT_UNKNOWN, "UNKNOWN" }
+ };
+
+ asset_type_to_name_t::iterator iter = asset_type_to_name.find(at);
+ if (iter != asset_type_to_name.end())
+ {
+ return iter->second;
+ }
+
+ return std::string("UNKNOWN");
+}
+
+const std::string LLDiskCache::metaDataToFilepath(const std::string id,
+ LLAssetType::EType at,
+ const std::string extra_info)
+{
+ std::ostringstream file_path;
+
+ file_path << mCacheDir;
+ file_path << gDirUtilp->getDirDelimiter();
+ file_path << mCacheFilenamePrefix;
+ file_path << "_";
+ file_path << id;
+ file_path << "_";
+ file_path << (extra_info.empty() ? "0" : extra_info);
+ //file_path << "_";
+ //file_path << assetTypeToString(at); // see SL-14210 Prune descriptive tag from new cache filenames
+ // for details of why it was removed. Note that if you put it
+ // back or change the format of the filename, the cache files
+ // files will be invalidated (and perhaps, more importantly,
+ // never deleted unless you delete them manually).
+ file_path << ".asset";
+
+ return file_path.str();
+}
+
+void LLDiskCache::updateFileAccessTime(const std::string file_path)
+{
+ /**
+ * Threshold in time_t units that is used to decide if the last access time
+ * time of the file is updated or not. Added as a precaution for the concern
+ * outlined in SL-14582 about frequent writes on older SSDs reducing their
+ * lifespan. I think this is the right place for the threshold value - rather
+ * than it being a pref - do comment on that Jira if you disagree...
+ *
+ * Let's start with 1 hour in time_t units and see how that unfolds
+ */
+ const std::time_t time_threshold = 1 * 60 * 60;
+
+ // current time
+ const std::time_t cur_time = std::time(nullptr);
+
+#if LL_WINDOWS
+ // file last write time
+ const std::time_t last_write_time = boost::filesystem::last_write_time(utf8str_to_utf16str(file_path));
+
+ // delta between cur time and last time the file was written
+ const std::time_t delta_time = cur_time - last_write_time;
+
+ // we only write the new value if the time in time_threshold has elapsed
+ // before the last one
+ if (delta_time > time_threshold)
+ {
+ boost::filesystem::last_write_time(utf8str_to_utf16str(file_path), cur_time);
+ }
+#else
+ // file last write time
+ const std::time_t last_write_time = boost::filesystem::last_write_time(file_path);
+
+ // delta between cur time and last time the file was written
+ const std::time_t delta_time = cur_time - last_write_time;
+
+ // we only write the new value if the time in time_threshold has elapsed
+ // before the last one
+ if (delta_time > time_threshold)
+ {
+ boost::filesystem::last_write_time(file_path, cur_time);
+ }
+#endif
+}
+
+const std::string LLDiskCache::getCacheInfo()
+{
+ std::ostringstream cache_info;
+
+ F32 max_in_mb = (F32)mMaxSizeBytes / (1024.0 * 1024.0);
+ F32 percent_used = ((F32)dirFileSize(mCacheDir) / (F32)mMaxSizeBytes) * 100.0;
+
+ cache_info << std::fixed;
+ cache_info << std::setprecision(1);
+ cache_info << "Max size " << max_in_mb << " MB ";
+ cache_info << "(" << percent_used << "% used)";
+
+ return cache_info.str();
+}
+
+void LLDiskCache::clearCache()
+{
+ /**
+ * See notes on performance in dirFileSize(..) - there may be
+ * a quicker way to do this by operating on the parent dir vs
+ * the component files but it's called infrequently so it's
+ * likely just fine
+ */
+#if LL_WINDOWS
+ std::wstring cache_path(utf8str_to_utf16str(mCacheDir));
+#else
+ std::string cache_path(mCacheDir);
+#endif
+ if (boost::filesystem::is_directory(cache_path))
+ {
+ for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(cache_path), {}))
+ {
+ if (boost::filesystem::is_regular_file(entry))
+ {
+ if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+ {
+ boost::filesystem::remove(entry);
+ }
+ }
+ }
+ }
+}
+
+uintmax_t LLDiskCache::dirFileSize(const std::string dir)
+{
+ uintmax_t total_file_size = 0;
+
+ /**
+ * There may be a better way that works directly on the folder (similar to
+ * right clicking on a folder in the OS and asking for size vs right clicking
+ * on all files and adding up manually) but this is very fast - less than 100ms
+ * for 10,000 files in my testing so, so long as it's not called frequently,
+ * it should be okay. Note that's it's only currently used for logging/debugging
+ * so if performance is ever an issue, optimizing this or removing it altogether,
+ * is an easy win.
+ */
+#if LL_WINDOWS
+ std::wstring dir_path(utf8str_to_utf16str(dir));
+#else
+ std::string dir_path(dir);
+#endif
+ if (boost::filesystem::is_directory(dir_path))
+ {
+ for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(dir_path), {}))
+ {
+ if (boost::filesystem::is_regular_file(entry))
+ {
+ if (entry.path().string().find(mCacheFilenamePrefix) != std::string::npos)
+ {
+ total_file_size += boost::filesystem::file_size(entry);
+ }
+ }
+ }
+ }
+
+ return total_file_size;
+}
diff --git a/indra/llfilesystem/lldiskcache.h b/indra/llfilesystem/lldiskcache.h
new file mode 100644
index 0000000000000000000000000000000000000000..997884da319c8d4ecb53ca427c8ad6ea5fa9a827
--- /dev/null
+++ b/indra/llfilesystem/lldiskcache.h
@@ -0,0 +1,183 @@
+/**
+ * @file lldiskcache.h
+ * @brief The disk cache implementation declarations.
+ *
+ * @Description:
+ * This code implements a disk cache using the following ideas:
+ * 1/ The metadata for a file can be encapsulated in the filename.
+ The filenames will be composed of the following fields:
+ Prefix: Used to identify the file as a part of the cache.
+ An additional reason for using a prefix is that it
+ might be possible, either accidentally or maliciously
+ to end up with the cache dir set to a non-cache
+ location such as your OS system dir or a work folder.
+ Purging files from that would obviously be a disaster
+ so this is an extra step to help avoid that scenario.
+ ID: Typically the asset ID (UUID) of the asset being
+ saved but can be anything valid for a filename
+ Extra Info: A field for use in the future that can be used
+ to store extra identifiers - e.g. the discard
+ level of a JPEG2000 file
+ Asset Type: A text string created from the LLAssetType enum
+ that identifies the type of asset being stored.
+ .asset A file extension of .asset is used to help
+ identify this as a Viewer asset file
+ * 2/ The time of last access for a file can be updated instantly
+ * for file reads and automatically as part of the file writes.
+ * 3/ The purge algorithm collects a list of all files in the
+ * directory, sorts them by date of last access (write) and then
+ * deletes any files based on age until the total size of all
+ * the files is less than the maximum size specified.
+ * 4/ An LLSingleton idiom is used since there will only ever be
+ * a single cache and we want to access it from numerous places.
+ * 5/ Performance on my modest system seems very acceptable. For
+ * example, in testing, I was able to purge a directory of
+ * 10,000 files, deleting about half of them in ~ 1700ms. For
+ * the same sized directory of files, writing the last updated
+ * time to each took less than 600ms indicating that this
+ * important part of the mechanism has almost no overhead.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2020, 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 _LLDISKCACHE
+#define _LLDISKCACHE
+
+#include "llsingleton.h"
+
+class LLDiskCache :
+ public LLParamSingleton<LLDiskCache>
+{
+ public:
+ /**
+ * Since this is using the LLSingleton pattern but we
+ * want to allow the constructor to be called first
+ * with various parameters, we also invoke the
+ * LLParamSingleton idiom and use it to initialize
+ * the class via a call in LLAppViewer.
+ */
+ LLSINGLETON(LLDiskCache,
+ /**
+ * The full name of the cache folder - typically a
+ * a child of the main Viewer cache directory. Defined
+ * by the setting at 'DiskCacheDirName'
+ */
+ const std::string cache_dir,
+ /**
+ * The maximum size of the cache in bytes - Based on the
+ * setting at 'CacheSize' and 'DiskCachePercentOfTotal'
+ */
+ const int max_size_bytes,
+ /**
+ * A flag that enables extra cache debugging so that
+ * if there are bugs, we can ask uses to enable this
+ * setting and send us their logs
+ */
+ const bool enable_cache_debug_info);
+
+ virtual ~LLDiskCache() = default;
+
+ public:
+ /**
+ * Construct a filename and path to it based on the file meta data
+ * (id, asset type, additional 'extra' info like discard level perhaps)
+ * Worth pointing out that this function used to be in LLFileSystem but
+ * so many things had to be pushed back there to accomodate it, that I
+ * decided to move it here. Still not sure that's completely right.
+ */
+ const std::string metaDataToFilepath(const std::string id,
+ LLAssetType::EType at,
+ const std::string extra_info);
+
+ /**
+ * Update the "last write time" of a file to "now". This must be called whenever a
+ * file in the cache is read (not written) so that the last time the file was
+ * accessed is up to date (This is used in the mechanism for purging the cache)
+ */
+ void updateFileAccessTime(const std::string file_path);
+
+ /**
+ * Purge the oldest items in the cache so that the combined size of all files
+ * is no bigger than mMaxSizeBytes.
+ */
+ void purge();
+
+ /**
+ * Clear the cache by removing all the files in the specified cache
+ * directory individually. Only the files that contain a prefix defined
+ * by mCacheFilenamePrefix will be removed.
+ */
+ void clearCache();
+
+ /**
+ * Return some information about the cache for use in About Box etc.
+ */
+ const std::string getCacheInfo();
+
+ private:
+ /**
+ * Utility function to gather the total size the files in a given
+ * directory. Primarily used here to determine the directory size
+ * before and after the cache purge
+ */
+ uintmax_t dirFileSize(const std::string dir);
+
+ /**
+ * Utility function to convert an LLAssetType enum into a
+ * string that we use as part of the cache file filename
+ */
+ const std::string assetTypeToString(LLAssetType::EType at);
+
+ private:
+ /**
+ * The maximum size of the cache in bytes. After purge is called, the
+ * total size of the cache files in the cache directory will be
+ * less than this value
+ */
+ uintmax_t mMaxSizeBytes;
+
+ /**
+ * The folder that holds the cached files. The consumer of this
+ * class must avoid letting the user set this location as a malicious
+ * setting could potentially point it at a non-cache directory (for example,
+ * the Windows System dir) with disastrous results.
+ */
+ std::string mCacheDir;
+
+ /**
+ * The prefix inserted at the start of a cache file filename to
+ * help identify it as a cache file. It's probably not required
+ * (just the presence in the cache folder is enough) but I am
+ * paranoid about the cache folder being set to something bad
+ * like the users' OS system dir by mistake or maliciously and
+ * this will help to offset any damage if that happens.
+ */
+ std::string mCacheFilenamePrefix;
+
+ /**
+ * When enabled, displays additional debugging information in
+ * various parts of the code
+ */
+ bool mEnableCacheDebugInfo;
+};
+
+#endif // _LLDISKCACHE
diff --git a/indra/llfilesystem/llfilesystem.cpp b/indra/llfilesystem/llfilesystem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..64e0b9f19322a339991e86006485ca3b266600e3
--- /dev/null
+++ b/indra/llfilesystem/llfilesystem.cpp
@@ -0,0 +1,283 @@
+/**
+ * @file filesystem.h
+ * @brief Simulate local file system operations.
+ * @Note The initial implementation does actually use standard C++
+ * file operations but eventually, there will be another
+ * layer that caches and manages file meta data too.
+ *
+ * $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 "linden_common.h"
+
+#include "lldir.h"
+#include "llfilesystem.h"
+#include "llfasttimer.h"
+#include "lldiskcache.h"
+
+const S32 LLFileSystem::READ = 0x00000001;
+const S32 LLFileSystem::WRITE = 0x00000002;
+const S32 LLFileSystem::READ_WRITE = 0x00000003; // LLFileSystem::READ & LLFileSystem::WRITE
+const S32 LLFileSystem::APPEND = 0x00000006; // 0x00000004 & LLFileSystem::WRITE
+
+static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");
+
+LLFileSystem::LLFileSystem(const LLUUID& file_id, const LLAssetType::EType file_type, S32 mode)
+{
+ mFileType = file_type;
+ mFileID = file_id;
+ mPosition = 0;
+ mBytesRead = 0;
+ mMode = mode;
+}
+
+LLFileSystem::~LLFileSystem()
+{
+}
+
+// static
+bool LLFileSystem::getExists(const LLUUID& file_id, const LLAssetType::EType file_type)
+{
+ std::string id_str;
+ file_id.toString(id_str);
+ const std::string extra_info = "";
+ const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+ llifstream file(filename, std::ios::binary);
+ if (file.is_open())
+ {
+ file.seekg(0, std::ios::end);
+ return file.tellg() > 0;
+ }
+ return false;
+}
+
+// static
+bool LLFileSystem::removeFile(const LLUUID& file_id, const LLAssetType::EType file_type)
+{
+ std::string id_str;
+ file_id.toString(id_str);
+ const std::string extra_info = "";
+ const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+ LLFile::remove(filename.c_str());
+
+ return true;
+}
+
+// static
+bool LLFileSystem::renameFile(const LLUUID& old_file_id, const LLAssetType::EType old_file_type,
+ const LLUUID& new_file_id, const LLAssetType::EType new_file_type)
+{
+ std::string old_id_str;
+ old_file_id.toString(old_id_str);
+ const std::string extra_info = "";
+ const std::string old_filename = LLDiskCache::getInstance()->metaDataToFilepath(old_id_str, old_file_type, extra_info);
+
+ std::string new_id_str;
+ new_file_id.toString(new_id_str);
+ const std::string new_filename = LLDiskCache::getInstance()->metaDataToFilepath(new_id_str, new_file_type, extra_info);
+
+ // Rename needs the new file to not exist.
+ LLFileSystem::removeFile(new_file_id, new_file_type);
+
+ if (LLFile::rename(old_filename, new_filename) != 0)
+ {
+ // We would like to return FALSE here indicating the operation
+ // failed but the original code does not and doing so seems to
+ // break a lot of things so we go with the flow...
+ //return FALSE;
+ LL_WARNS() << "Failed to rename " << old_file_id << " to " << new_id_str << " reason: " << strerror(errno) << LL_ENDL;
+ }
+
+ return TRUE;
+}
+
+// static
+S32 LLFileSystem::getFileSize(const LLUUID& file_id, const LLAssetType::EType file_type)
+{
+ std::string id_str;
+ file_id.toString(id_str);
+ const std::string extra_info = "";
+ const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id_str, file_type, extra_info);
+
+ S32 file_size = 0;
+ llifstream file(filename, std::ios::binary);
+ if (file.is_open())
+ {
+ file.seekg(0, std::ios::end);
+ file_size = file.tellg();
+ }
+
+ return file_size;
+}
+
+BOOL LLFileSystem::read(U8* buffer, S32 bytes)
+{
+ BOOL success = TRUE;
+
+ std::string id;
+ mFileID.toString(id);
+ const std::string extra_info = "";
+ const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id, mFileType, extra_info);
+
+ llifstream file(filename, std::ios::binary);
+ if (file.is_open())
+ {
+ file.seekg(mPosition, std::ios::beg);
+
+ file.read((char*)buffer, bytes);
+
+ if (file)
+ {
+ mBytesRead = bytes;
+ }
+ else
+ {
+ mBytesRead = file.gcount();
+ }
+
+ file.close();
+
+ mPosition += mBytesRead;
+ if (!mBytesRead)
+ {
+ success = FALSE;
+ }
+ }
+
+ // update the last access time for the file - this is required
+ // even though we are reading and not writing because this is the
+ // way the cache works - it relies on a valid "last accessed time" for
+ // each file so it knows how to remove the oldest, unused files
+ LLDiskCache::getInstance()->updateFileAccessTime(filename);
+
+ return success;
+}
+
+S32 LLFileSystem::getLastBytesRead()
+{
+ return mBytesRead;
+}
+
+BOOL LLFileSystem::eof()
+{
+ return mPosition >= getSize();
+}
+
+BOOL LLFileSystem::write(const U8* buffer, S32 bytes)
+{
+ std::string id_str;
+ mFileID.toString(id_str);
+ const std::string extra_info = "";
+ const std::string filename = LLDiskCache::getInstance()->metaDataToFilepath(id_str, mFileType, extra_info);
+
+ BOOL success = FALSE;
+
+ if (mMode == APPEND)
+ {
+ llofstream ofs(filename, std::ios::app | std::ios::binary);
+ if (ofs)
+ {
+ ofs.write((const char*)buffer, bytes);
+
+ success = TRUE;
+ }
+ }
+ else
+ {
+ llofstream ofs(filename, std::ios::binary);
+ if (ofs)
+ {
+ ofs.write((const char*)buffer, bytes);
+
+ mPosition += bytes;
+
+ success = TRUE;
+ }
+ }
+
+ return success;
+}
+
+BOOL LLFileSystem::seek(S32 offset, S32 origin)
+{
+ if (-1 == origin)
+ {
+ origin = mPosition;
+ }
+
+ S32 new_pos = origin + offset;
+
+ S32 size = getSize();
+
+ if (new_pos > size)
+ {
+ LL_WARNS() << "Attempt to seek past end of file" << LL_ENDL;
+
+ mPosition = size;
+ return FALSE;
+ }
+ else if (new_pos < 0)
+ {
+ LL_WARNS() << "Attempt to seek past beginning of file" << LL_ENDL;
+
+ mPosition = 0;
+ return FALSE;
+ }
+
+ mPosition = new_pos;
+ return TRUE;
+}
+
+S32 LLFileSystem::tell() const
+{
+ return mPosition;
+}
+
+S32 LLFileSystem::getSize()
+{
+ return LLFileSystem::getFileSize(mFileID, mFileType);
+}
+
+S32 LLFileSystem::getMaxSize()
+{
+ // offer up a huge size since we don't care what the max is
+ return INT_MAX;
+}
+
+BOOL LLFileSystem::rename(const LLUUID& new_id, const LLAssetType::EType new_type)
+{
+ LLFileSystem::renameFile(mFileID, mFileType, new_id, new_type);
+
+ mFileID = new_id;
+ mFileType = new_type;
+
+ return TRUE;
+}
+
+BOOL LLFileSystem::remove()
+{
+ LLFileSystem::removeFile(mFileID, mFileType);
+
+ return TRUE;
+}
diff --git a/indra/llfilesystem/llfilesystem.h b/indra/llfilesystem/llfilesystem.h
new file mode 100644
index 0000000000000000000000000000000000000000..89bfff5798f7eddd8ee4bc06cc1d4470585dd188
--- /dev/null
+++ b/indra/llfilesystem/llfilesystem.h
@@ -0,0 +1,78 @@
+/**
+ * @file filesystem.h
+ * @brief Simulate local file system operations.
+ * @Note The initial implementation does actually use standard C++
+ * file operations but eventually, there will be another
+ * layer that caches and manages file meta data too.
+ *
+ * $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$
+ */
+
+#ifndef LL_FILESYSTEM_H
+#define LL_FILESYSTEM_H
+
+#include "lluuid.h"
+#include "llassettype.h"
+#include "lldiskcache.h"
+
+class LLFileSystem
+{
+ public:
+ LLFileSystem(const LLUUID& file_id, const LLAssetType::EType file_type, S32 mode = LLFileSystem::READ);
+ ~LLFileSystem();
+
+ BOOL read(U8* buffer, S32 bytes);
+ S32 getLastBytesRead();
+ BOOL eof();
+
+ BOOL write(const U8* buffer, S32 bytes);
+ BOOL seek(S32 offset, S32 origin = -1);
+ S32 tell() const;
+
+ S32 getSize();
+ S32 getMaxSize();
+ BOOL rename(const LLUUID& new_id, const LLAssetType::EType new_type);
+ BOOL remove();
+
+ static bool getExists(const LLUUID& file_id, const LLAssetType::EType file_type);
+ static bool removeFile(const LLUUID& file_id, const LLAssetType::EType file_type);
+ static bool renameFile(const LLUUID& old_file_id, const LLAssetType::EType old_file_type,
+ const LLUUID& new_file_id, const LLAssetType::EType new_file_type);
+ static S32 getFileSize(const LLUUID& file_id, const LLAssetType::EType file_type);
+
+ public:
+ static const S32 READ;
+ static const S32 WRITE;
+ static const S32 READ_WRITE;
+ static const S32 APPEND;
+
+ protected:
+ LLAssetType::EType mFileType;
+ LLUUID mFileID;
+ S32 mPosition;
+ S32 mMode;
+ S32 mBytesRead;
+//private:
+// static const std::string idToFilepath(const std::string id, LLAssetType::EType at);
+};
+
+#endif // LL_FILESYSTEM_H
diff --git a/indra/llvfs/lllfsthread.cpp b/indra/llfilesystem/lllfsthread.cpp
similarity index 100%
rename from indra/llvfs/lllfsthread.cpp
rename to indra/llfilesystem/lllfsthread.cpp
diff --git a/indra/llvfs/lllfsthread.h b/indra/llfilesystem/lllfsthread.h
similarity index 100%
rename from indra/llvfs/lllfsthread.h
rename to indra/llfilesystem/lllfsthread.h
diff --git a/indra/llvfs/tests/lldir_test.cpp b/indra/llfilesystem/tests/lldir_test.cpp
similarity index 100%
rename from indra/llvfs/tests/lldir_test.cpp
rename to indra/llfilesystem/tests/lldir_test.cpp
diff --git a/indra/llvfs/tests/lldiriterator_test.cpp b/indra/llfilesystem/tests/lldiriterator_test.cpp
similarity index 100%
rename from indra/llvfs/tests/lldiriterator_test.cpp
rename to indra/llfilesystem/tests/lldiriterator_test.cpp
diff --git a/indra/llimage/CMakeLists.txt b/indra/llimage/CMakeLists.txt
index 5b4c2093e7231743b990d510ab87ab7b405fe983..0e9934d0825db32783f5c525307e45d973603042 100644
--- a/indra/llimage/CMakeLists.txt
+++ b/indra/llimage/CMakeLists.txt
@@ -6,7 +6,7 @@ include(00-Common)
include(LLCommon)
include(LLImage)
include(LLMath)
-include(LLVFS)
+include(LLFileSystem)
include(LLKDU)
include(LLImageJ2COJ)
include(WebP)
@@ -18,7 +18,7 @@ include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLCOMMON_SYSTEM_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${WEBP_INCLUDE_DIRS}
${PNG_INCLUDE_DIRS}
${ZLIB_INCLUDE_DIRS}
@@ -72,7 +72,7 @@ else (USE_KDU)
endif (USE_KDU)
target_link_libraries(llimage
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLCOMMON_LIBRARIES}
${WEBP_LIBRARIES}
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 2f2ca37207a9a3f11986089fd089f24c8df5d21a..51d4ac331b5a72696879c9bd4ff5201f78df0b09 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -2224,20 +2224,11 @@ bool LLImageFormatted::save(const std::string &filename)
return true;
}
-// bool LLImageFormatted::save(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
-// Depricated to remove VFS dependency.
-// Use:
-// LLVFile::writeFile(image->getData(), image->getDataSize(), vfs, uuid, type);
-
-//----------------------------------------------------------------------------
-
S8 LLImageFormatted::getCodec() const
{
return mCodec;
}
-//============================================================================
-
static void avg4_colors4(const U8* a, const U8* b, const U8* c, const U8* d, U8* dst)
{
dst[0] = (U8)(((U32)(a[0]) + b[0] + c[0] + d[0])>>2);
diff --git a/indra/llinventory/CMakeLists.txt b/indra/llinventory/CMakeLists.txt
index b8ddb357c75e6642ee5dae5e928c65a0c262a8f1..d9035d8dcff23a28368400017daa470b6a08433f 100644
--- a/indra/llinventory/CMakeLists.txt
+++ b/indra/llinventory/CMakeLists.txt
@@ -7,7 +7,7 @@ include(LLCommon)
include(LLCoreHttp)
include(LLMath)
include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
include(LLXML)
include_directories(
@@ -85,7 +85,7 @@ if (LL_TESTS)
LL_ADD_PROJECT_UNIT_TESTS(llinventory "${llinventory_TEST_SOURCE_FILES}")
#set(TEST_DEBUG on)
- set(test_libs llinventory ${LLMESSAGE_LIBRARIES} ${LLVFS_LIBRARIES} ${LLCOREHTTP_LIBRARIES} ${LLMATH_LIBRARIES} ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
+ set(test_libs llinventory ${LLMESSAGE_LIBRARIES} ${LLFILESYSTEM_LIBRARIES} ${LLCOREHTTP_LIBRARIES} ${LLMATH_LIBRARIES} ${LLCOMMON_LIBRARIES} ${WINDOWS_LIBRARIES})
LL_ADD_INTEGRATION_TEST(inventorymisc "" "${test_libs}")
LL_ADD_INTEGRATION_TEST(llparcel "" "${test_libs}")
endif (LL_TESTS)
diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 44181a387e92b83ad3e91c0c9646bdcfee640cd0..4f58f3aad93ccd0a9c9d0e027d80595c43c95d3e 100644
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -11,7 +11,7 @@ include(LLCommon)
include(LLCoreHttp)
include(LLMath)
include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
include(LLAddBuildTest)
include(Python)
include(Tut)
@@ -24,7 +24,7 @@ include_directories(
${LLCOREHTTP_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLMESSAGE_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
)
set(llmessage_SOURCE_FILES
@@ -209,7 +209,7 @@ target_link_libraries(
llmessage
${CURL_LIBRARIES}
${LLCOMMON_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${OPENSSL_LIBRARIES}
${CRYPTO_LIBRARIES}
@@ -226,7 +226,7 @@ target_link_libraries(
llmessage
${CURL_LIBRARIES}
${LLCOMMON_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${OPENSSL_LIBRARIES}
${CRYPTO_LIBRARIES}
@@ -255,7 +255,7 @@ if (LL_TESTS)
if (LINUX)
set(test_libs
${WINDOWS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${CURL_LIBRARIES}
${NGHTTP2_LIBRARIES}
@@ -269,7 +269,7 @@ if (LINUX)
else (LINUX)
set(test_libs
${WINDOWS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${CURL_LIBRARIES}
${NGHTTP2_LIBRARIES}
diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp
index 27df8418f3e30de68ef6ff6fda3993fa95dd82ad..318c554e753cec06d96b497a4e1a0c8f64170a61 100644
--- a/indra/llmessage/llassetstorage.cpp
+++ b/indra/llmessage/llassetstorage.cpp
@@ -42,8 +42,7 @@
// this library includes
#include "message.h"
#include "llxfermanager.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "lldbstrings.h"
#include "lltransfersourceasset.h"
@@ -202,7 +201,7 @@ LLBaseDownloadRequest::LLBaseDownloadRequest(const LLUUID &uuid, const LLAssetTy
mIsTemp(FALSE),
mIsPriority(FALSE),
mDataSentInFirstPacket(FALSE),
- mDataIsInVFS(FALSE)
+ mDataIsInCache(FALSE)
{
// Need to guarantee that this time is up to date, we may be creating a circuit even though we haven't been
// running a message system loop.
@@ -256,7 +255,8 @@ LLSD LLAssetRequest::getFullDetails() const
sd["is_local"] = mIsLocal;
sd["is_priority"] = mIsPriority;
sd["data_send_in_first_packet"] = mDataSentInFirstPacket;
- sd["data_is_in_vfs"] = mDataIsInVFS;
+ // Note: cannot change this (easily) since it is consumed by server
+ sd["data_is_in_vfs"] = mDataIsInCache;
return sd;
}
@@ -310,28 +310,23 @@ LLBaseDownloadRequest* LLEstateAssetRequest::getCopy()
// TODO: rework tempfile handling?
-LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host)
+LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host)
{
- _init(msg, xfer, vfs, static_vfs, upstream_host);
+ _init(msg, xfer, upstream_host);
}
-LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs)
+LLAssetStorage::LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer)
{
- _init(msg, xfer, vfs, static_vfs, LLHost());
+ _init(msg, xfer, LLHost());
}
void LLAssetStorage::_init(LLMessageSystem *msg,
LLXferManager *xfer,
- LLVFS *vfs,
- LLVFS *static_vfs,
const LLHost &upstream_host)
{
mShutDown = FALSE;
mMessageSys = msg;
mXferManager = xfer;
- mVFS = vfs;
- mStaticVFS = static_vfs;
setUpstream(upstream_host);
msg->setHandlerFuncFast(_PREHASH_AssetUploadComplete, processUploadComplete, (void **)this);
@@ -410,7 +405,7 @@ void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
}
if (tmp->mDownCallback)
{
- tmp->mDownCallback(mVFS, tmp->getUUID(), tmp->getType(), tmp->mUserData, error, LLExtStat::NONE);
+ tmp->mDownCallback(tmp->getUUID(), tmp->getType(), tmp->mUserData, error, LLExtStat::NONE);
}
if (tmp->mInfoCallback)
{
@@ -423,10 +418,10 @@ void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
BOOL LLAssetStorage::hasLocalAsset(const LLUUID &uuid, const LLAssetType::EType type)
{
- return mStaticVFS->getExists(uuid, type) || mVFS->getExists(uuid, type);
+ return LLFileSystem::getExists(uuid, type);
}
-bool LLAssetStorage::findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
+bool LLAssetStorage::findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
LLGetAssetCallback callback, void *user_data)
{
if (user_data)
@@ -435,17 +430,17 @@ bool LLAssetStorage::findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAsse
llassert(callback != NULL);
}
- BOOL exists = mStaticVFS->getExists(uuid, type);
+ BOOL exists = LLFileSystem::getExists(uuid, type);
if (exists)
{
- LLVFile file(mStaticVFS, uuid, type);
+ LLFileSystem file(uuid, type);
U32 size = file.getSize();
if (size > 0)
{
// we've already got the file
if (callback)
{
- callback(mStaticVFS, uuid, type, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+ callback(uuid, type, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
}
return true;
}
@@ -486,7 +481,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
if (callback)
{
add(sFailedDownloadCount, 1);
- callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::NONE);
+ callback(uuid, type, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::NONE);
}
return;
}
@@ -497,20 +492,19 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
if (callback)
{
add(sFailedDownloadCount, 1);
- callback(mVFS, uuid, type, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
+ callback(uuid, type, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
}
return;
}
- // Try static VFS first.
- if (findInStaticVFSAndInvokeCallback(uuid,type,callback,user_data))
+ if (findInCacheAndInvokeCallback(uuid,type,callback,user_data))
{
- LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in static VFS" << LL_ENDL;
+ LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in cache" << LL_ENDL;
return;
}
- BOOL exists = mVFS->getExists(uuid, type);
- LLVFile file(mVFS, uuid, type);
+ BOOL exists = LLFileSystem::getExists(uuid, type);
+ LLFileSystem file(uuid, type);
U32 size = exists ? file.getSize() : 0;
if (size > 0)
@@ -520,10 +514,10 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
// unless there's a weird error
if (callback)
{
- callback(mVFS, uuid, type, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+ callback(uuid, type, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
}
- LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in VFS" << LL_ENDL;
+ LL_DEBUGS("AssetStorage") << "ASSET_TRACE asset " << uuid << " found in cache" << LL_ENDL;
}
else
{
@@ -596,7 +590,7 @@ void LLAssetStorage::removeAndCallbackPendingDownloads(const LLUUID& file_id, LL
{
add(sFailedDownloadCount, 1);
}
- tmp->mDownCallback(gAssetStorage->mVFS, callback_id, callback_type, tmp->mUserData, result_code, ext_status);
+ tmp->mDownCallback(callback_id, callback_type, tmp->mUserData, result_code, ext_status);
}
delete tmp;
}
@@ -650,7 +644,7 @@ void LLAssetStorage::downloadCompleteCallback(
if (LL_ERR_NOERR == result)
{
// we might have gotten a zero-size file
- LLVFile vfile(gAssetStorage->mVFS, callback_id, callback_type);
+ LLFileSystem vfile(callback_id, callback_type);
if (vfile.getSize() <= 0)
{
LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset " << callback_id << LL_ENDL;
@@ -699,19 +693,19 @@ void LLAssetStorage::getEstateAsset(
if (callback)
{
add(sFailedDownloadCount, 1);
- callback(mVFS, asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
+ callback(asset_id, atype, user_data, LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE, LLExtStat::NULL_UUID);
}
return;
}
- // Try static VFS first.
- if (findInStaticVFSAndInvokeCallback(asset_id,atype,callback,user_data))
+ // Try static first.
+ if (findInCacheAndInvokeCallback(asset_id,atype,callback,user_data))
{
return;
}
- BOOL exists = mVFS->getExists(asset_id, atype);
- LLVFile file(mVFS, asset_id, atype);
+ BOOL exists = LLFileSystem::getExists(asset_id, atype);
+ LLFileSystem file(asset_id, atype);
U32 size = exists ? file.getSize() : 0;
if (size > 0)
@@ -721,7 +715,7 @@ void LLAssetStorage::getEstateAsset(
// unless there's a weird error
if (callback)
{
- callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+ callback(asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
}
}
else
@@ -772,7 +766,7 @@ void LLAssetStorage::getEstateAsset(
if (callback)
{
add(sFailedDownloadCount, 1);
- callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
+ callback(asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
}
}
}
@@ -804,7 +798,7 @@ void LLAssetStorage::downloadEstateAssetCompleteCallback(
if (LL_ERR_NOERR == result)
{
// we might have gotten a zero-size file
- LLVFile vfile(gAssetStorage->mVFS, req->getUUID(), req->getAType());
+ LLFileSystem vfile(req->getUUID(), req->getAType());
if (vfile.getSize() <= 0)
{
LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset!" << LL_ENDL;
@@ -818,7 +812,7 @@ void LLAssetStorage::downloadEstateAssetCompleteCallback(
{
add(sFailedDownloadCount, 1);
}
- req->mDownCallback(gAssetStorage->mVFS, req->getUUID(), req->getAType(), req->mUserData, result, ext_status);
+ req->mDownCallback(req->getUUID(), req->getAType(), req->mUserData, result, ext_status);
}
void LLAssetStorage::getInvItemAsset(
@@ -841,14 +835,13 @@ void LLAssetStorage::getInvItemAsset(
if(asset_id.notNull())
{
- // Try static VFS first.
- if (findInStaticVFSAndInvokeCallback( asset_id, atype, callback, user_data))
+ if (findInCacheAndInvokeCallback( asset_id, atype, callback, user_data))
{
return;
}
- exists = mVFS->getExists(asset_id, atype);
- LLVFile file(mVFS, asset_id, atype);
+ exists = LLFileSystem::getExists(asset_id, atype);
+ LLFileSystem file(asset_id, atype);
size = exists ? file.getSize() : 0;
if(exists && size < 1)
{
@@ -865,7 +858,7 @@ void LLAssetStorage::getInvItemAsset(
// unless there's a weird error
if (callback)
{
- callback(mVFS, asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::VFS_CACHED);
+ callback(asset_id, atype, user_data, LL_ERR_NOERR, LLExtStat::CACHE_CACHED);
}
}
else
@@ -916,7 +909,7 @@ void LLAssetStorage::getInvItemAsset(
if (callback)
{
add(sFailedDownloadCount, 1);
- callback(mVFS, asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
+ callback(asset_id, atype, user_data, LL_ERR_CIRCUIT_GONE, LLExtStat::NO_UPSTREAM);
}
}
}
@@ -948,7 +941,7 @@ void LLAssetStorage::downloadInvItemCompleteCallback(
if (LL_ERR_NOERR == result)
{
// we might have gotten a zero-size file
- LLVFile vfile(gAssetStorage->mVFS, req->getUUID(), req->getType());
+ LLFileSystem vfile(req->getUUID(), req->getType());
if (vfile.getSize() <= 0)
{
LL_WARNS("AssetStorage") << "downloadCompleteCallback has non-existent or zero-size asset!" << LL_ENDL;
@@ -962,7 +955,7 @@ void LLAssetStorage::downloadInvItemCompleteCallback(
{
add(sFailedDownloadCount, 1);
}
- req->mDownCallback(gAssetStorage->mVFS, req->getUUID(), req->getType(), req->mUserData, result, ext_status);
+ req->mDownCallback(req->getUUID(), req->getType(), req->mUserData, result, ext_status);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1273,7 +1266,7 @@ bool LLAssetStorage::deletePendingRequestImpl(LLAssetStorage::request_list_t* re
if (req->mDownCallback)
{
add(sFailedDownloadCount, 1);
- req->mDownCallback(mVFS, req->getUUID(), req->getType(), req->mUserData, error, LLExtStat::REQUEST_DROPPED);
+ req->mDownCallback(req->getUUID(), req->getType(), req->mUserData, error, LLExtStat::REQUEST_DROPPED);
}
if (req->mInfoCallback)
{
@@ -1343,8 +1336,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
{
LLAssetRequest* tmp = *iter++;
- //void(*const* cbptr)(LLVFS *, const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat)
- auto cbptr = tmp->mDownCallback.target<void(*)(LLVFS *, const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat)>();
+ auto cbptr = tmp->mDownCallback.target<void(*)(const LLUUID &, LLAssetType::EType, void *, S32, LLExtStat)>();
if (type == tmp->getType() &&
uuid == tmp->getUUID() &&
@@ -1369,8 +1361,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid,
}
// static
-void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs,
- const LLUUID &uuid,
+void LLAssetStorage::legacyGetDataCallback(const LLUUID &uuid,
LLAssetType::EType type,
void *user_data,
S32 status,
@@ -1385,7 +1376,7 @@ void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs,
if ( !status
&& !toxic )
{
- LLVFile file(vfs, uuid, type);
+ LLFileSystem file(uuid, type);
std::string uuid_str;
diff --git a/indra/llmessage/llassetstorage.h b/indra/llmessage/llassetstorage.h
index 921ab05d7de97627916ad341b423e551fbd7bc95..adebe851c4efac7d3f60d902539ac3ead4c203ce 100644
--- a/indra/llmessage/llassetstorage.h
+++ b/indra/llmessage/llassetstorage.h
@@ -44,7 +44,6 @@
class LLMessageSystem;
class LLXferManager;
class LLAssetStorage;
-class LLVFS;
class LLSD;
// anything that takes longer than this to download will abort.
@@ -60,11 +59,11 @@ const int LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE = -4;
const int LL_ERR_INSUFFICIENT_PERMISSIONS = -5;
const int LL_ERR_PRICE_MISMATCH = -23018;
-// *TODO: these typedefs are passed into the VFS via a legacy C function pointer
+// *TODO: these typedefs are passed into the cache via a legacy C function pointer
// future project would be to convert these to C++ callables (std::function<>) so that
// we can use bind and remove the userData parameter.
//
-typedef std::function<void(LLVFS *vfs, const LLUUID &asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)> LLGetAssetCallback;
+typedef std::function<void(const LLUUID &asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status)> LLGetAssetCallback;
typedef std::function<void(const LLUUID &asset_id, void *user_data, S32 status, LLExtStat ext_status)> LLStoreAssetCallback;
@@ -120,7 +119,6 @@ class LLBaseDownloadRequest
public:
LLGetAssetCallback mDownCallback;
-// void(*mDownCallback)(LLVFS*, const LLUUID&, LLAssetType::EType, void *, S32, LLExtStat);
void *mUserData;
LLHost mHost;
@@ -128,7 +126,7 @@ class LLBaseDownloadRequest
F64Seconds mTime; // Message system time
BOOL mIsPriority;
BOOL mDataSentInFirstPacket;
- BOOL mDataIsInVFS;
+ BOOL mDataIsInCache;
};
class LLAssetRequest : public LLBaseDownloadRequest
@@ -198,9 +196,6 @@ typedef std::map<LLUUID,U64,lluuid_less> toxic_asset_map_t;
class LLAssetStorage
{
public:
- // VFS member is public because static child methods need it :(
- LLVFS *mVFS;
- LLVFS *mStaticVFS;
typedef ::LLStoreAssetCallback LLStoreAssetCallback;
typedef ::LLGetAssetCallback LLGetAssetCallback;
@@ -230,11 +225,9 @@ class LLAssetStorage
toxic_asset_map_t mToxicAssetMap; // Objects in this list are known to cause problems and are not loaded
public:
- LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host);
+ LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host);
- LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs);
+ LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer);
virtual ~LLAssetStorage();
void setUpstream(const LLHost &upstream_host);
@@ -284,7 +277,7 @@ class LLAssetStorage
void markAssetToxic( const LLUUID& uuid );
protected:
- bool findInStaticVFSAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
+ bool findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetType::EType type,
LLGetAssetCallback callback, void *user_data);
LLSD getPendingDetailsImpl(const request_list_t* requests,
@@ -375,7 +368,7 @@ class LLAssetStorage
bool user_waiting = false,
F64Seconds timeout = LL_ASSET_STORAGE_TIMEOUT) = 0;
- static void legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType, void *user_data, S32 status, LLExtStat ext_status);
+ static void legacyGetDataCallback(const LLUUID &uuid, LLAssetType::EType, void *user_data, S32 status, LLExtStat ext_status);
static void legacyStoreDataCallback(const LLUUID &uuid, void *user_data, S32 status, LLExtStat ext_status);
// add extra methods to handle metadata
@@ -385,15 +378,12 @@ class LLAssetStorage
void _callUploadCallbacks(const LLUUID &uuid, const LLAssetType::EType asset_type, BOOL success, LLExtStat ext_status);
virtual void _queueDataRequest(const LLUUID& uuid, LLAssetType::EType type, LLGetAssetCallback callback,
-// void (*callback)(LLVFS *vfs, const LLUUID&, LLAssetType::EType, void *, S32, LLExtStat),
void *user_data, BOOL duplicate,
BOOL is_priority) = 0;
private:
void _init(LLMessageSystem *msg,
LLXferManager *xfer,
- LLVFS *vfs,
- LLVFS *static_vfs,
const LLHost &upstream_host);
protected:
@@ -408,7 +398,7 @@ class LLAssetStorage
MR_FILE_NONEXIST = 3, // Old format store call - source file does not exist
MR_NO_FILENAME = 4, // Old format store call - source filename is NULL/0-length
MR_NO_UPSTREAM = 5, // Upstream provider is missing
- MR_VFS_CORRUPTION = 6 // VFS is corrupt - too-large or mismatched stated/returned sizes
+ MR_CACHE_CORRUPTION = 6 // cache is corrupt - too-large or mismatched stated/returned sizes
};
static class LLMetrics *metric_recipient;
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 662b55aeb000b43ba741db24bc0d34ae248aadd3..c4d9e8818252d5ec2a3ef5e2bd9863d8fae2958e 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -37,7 +37,7 @@
#include "llsd.h"
#include "llsdjson.h"
#include "llsdserialize.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "message.h" // for getting the port
@@ -794,7 +794,7 @@ LLSD HttpCoroutineAdapter::postFileAndSuspend(LLCore::HttpRequest::ptr_t request
// scoping for our streams so that they go away when we no longer need them.
{
LLCore::BufferArrayStream outs(fileData.get());
- LLVFile vfile(gVFS, assetId, assetType, LLVFile::READ);
+ LLFileSystem vfile(assetId, assetType, LLFileSystem::READ);
S32 fileSize = vfile.getSize();
U8* fileBuffer;
diff --git a/indra/llmessage/llextendedstatus.h b/indra/llmessage/llextendedstatus.h
index 9923d73c1a9b0370ab50f7f212915ff040c1168a..2a53dced80fdcc63ed75fdbbd8838a3df6dd8cff 100644
--- a/indra/llmessage/llextendedstatus.h
+++ b/indra/llmessage/llextendedstatus.h
@@ -1,7 +1,7 @@
/**
* @file llextendedstatus.h
* @date August 2007
- * @brief extended status codes for curl/vfs/resident asset storage and delivery
+ * @brief extended status codes for curl/resident asset storage and delivery
*
* $LicenseInfo:firstyear=2007&license=viewerlgpl$
* Second Life Viewer Source Code
@@ -32,9 +32,9 @@ enum class LLExtStat: uint32_t
{
// Status provider groups - Top bits indicate which status type it is
// Zero is common status code (next section)
- CURL_RESULT = 1UL<<30, // serviced by curl - use 1L if we really implement the below
- RES_RESULT = 2UL<<30, // serviced by resident copy
- VFS_RESULT = 3UL<<30, // serviced by vfs
+ CURL_RESULT = 1UL<<30, // serviced by curl - use 1L if we really implement the below
+ RES_RESULT = 2UL<<30, // serviced by resident copy
+ CACHE_RESULT = 3UL<<30, // serviced by cache
// Common Status Codes
@@ -54,9 +54,9 @@ enum class LLExtStat: uint32_t
// Memory-Resident status codes:
// None at present
- // VFS status codes:
- VFS_CACHED = VFS_RESULT | 0x0001,
- VFS_CORRUPT = VFS_RESULT | 0x0002,
+ // CACHE status codes:
+ CACHE_CACHED = CACHE_RESULT | 0x0001,
+ CACHE_CORRUPT = CACHE_RESULT | 0x0002,
};
diff --git a/indra/llmessage/lltransfersourceasset.cpp b/indra/llmessage/lltransfersourceasset.cpp
index 80ed3340c622d970f11f7d3797ffcedf46da305e..027283232dd6e0f7539710b4e0a112aecc49891b 100644
--- a/indra/llmessage/lltransfersourceasset.cpp
+++ b/indra/llmessage/lltransfersourceasset.cpp
@@ -32,7 +32,7 @@
#include "message.h"
#include "lldatapacker.h"
#include "lldir.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
LLTransferSourceAsset::LLTransferSourceAsset(const LLUUID &request_id, const F32 priority) :
LLTransferSource(LLTST_ASSET, request_id, priority),
@@ -99,7 +99,7 @@ LLTSCode LLTransferSourceAsset::dataCallback(const S32 packet_id,
return LLTS_SKIP;
}
- LLVFile vf(gAssetStorage->mVFS, mParams.getAssetID(), mParams.getAssetType(), LLVFile::READ);
+ LLFileSystem vf(mParams.getAssetID(), mParams.getAssetType(), LLFileSystem::READ);
if (!vf.getSize())
{
@@ -171,7 +171,7 @@ BOOL LLTransferSourceAsset::unpackParams(LLDataPacker &dp)
}
-void LLTransferSourceAsset::responderCallback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type,
+void LLTransferSourceAsset::responderCallback(const LLUUID& uuid, LLAssetType::EType type,
void *user_data, S32 result, LLExtStat ext_status )
{
LLUUID *tidp = ((LLUUID*) user_data);
@@ -198,7 +198,7 @@ void LLTransferSourceAsset::responderCallback(LLVFS *vfs, const LLUUID& uuid, LL
if (LL_ERR_NOERR == result)
{
// Everything's OK.
- LLVFile vf(gAssetStorage->mVFS, uuid, type, LLVFile::READ);
+ LLFileSystem vf(uuid, type, LLFileSystem::READ);
tsap->mSize = vf.getSize();
status = LLTS_OK;
}
diff --git a/indra/llmessage/lltransfersourceasset.h b/indra/llmessage/lltransfersourceasset.h
index 3abda83cf8dd189ac5869ab240ea8eb542d296be..585e683cb33ce92937759e64e58ac768a0ecd541 100644
--- a/indra/llmessage/lltransfersourceasset.h
+++ b/indra/llmessage/lltransfersourceasset.h
@@ -30,7 +30,7 @@
#include "lltransfermanager.h"
#include "llassetstorage.h"
-class LLVFile;
+class LLFileSystem;
class LLTransferSourceParamsAsset : public LLTransferSourceParams
{
@@ -56,7 +56,7 @@ class LLTransferSourceAsset : public LLTransferSource
LLTransferSourceAsset(const LLUUID &request_id, const F32 priority);
virtual ~LLTransferSourceAsset();
- static void responderCallback(LLVFS *vfs, const LLUUID& uuid, LLAssetType::EType type,
+ static void responderCallback(const LLUUID& uuid, LLAssetType::EType type,
void *user_data, S32 result, LLExtStat ext_status );
protected:
/*virtual*/ void initTransfer();
diff --git a/indra/llmessage/lltransfertargetvfile.cpp b/indra/llmessage/lltransfertargetvfile.cpp
index b27f0881e0fcc54792accd829506afd3ec1fef58..f6faadf87fc49c4cfbd6fb8275ff7198fb05dc5d 100644
--- a/indra/llmessage/lltransfertargetvfile.cpp
+++ b/indra/llmessage/lltransfertargetvfile.cpp
@@ -30,7 +30,7 @@
#include "lldatapacker.h"
#include "llerror.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
//static
void LLTransferTargetVFile::updateQueue(bool shutdown)
@@ -138,10 +138,9 @@ LLTSCode LLTransferTargetVFile::dataCallback(const S32 packet_id, U8 *in_datap,
//LL_INFOS() << "LLTransferTargetFile::dataCallback" << LL_ENDL;
//LL_INFOS() << "Packet: " << packet_id << LL_ENDL;
- LLVFile vf(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::APPEND);
+ LLFileSystem vf(mTempID, mParams.getAssetType(), LLFileSystem::APPEND);
if (mNeedsCreate)
{
- vf.setMaxSize(mSize);
mNeedsCreate = FALSE;
}
@@ -176,7 +175,7 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
case LLTS_DONE:
if (!mNeedsCreate)
{
- LLVFile file(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::WRITE);
+ LLFileSystem file(mTempID, mParams.getAssetType(), LLFileSystem::WRITE);
if (!file.rename(mParams.getAssetID(), mParams.getAssetType()))
{
LL_ERRS() << "LLTransferTargetVFile: rename failed" << LL_ENDL;
@@ -195,7 +194,7 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
{
// We're aborting this transfer, we don't want to keep this file.
LL_WARNS() << "Aborting vfile transfer for " << mParams.getAssetID() << LL_ENDL;
- LLVFile vf(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::APPEND);
+ LLFileSystem vf(mTempID, mParams.getAssetType(), LLFileSystem::APPEND);
vf.remove();
}
break;
diff --git a/indra/llmessage/lltransfertargetvfile.h b/indra/llmessage/lltransfertargetvfile.h
index c819c1e2f269917c61cca08a362139ec1b832ea0..39a9125f1b0aeaf481ae62bfa676ead534870a2b 100644
--- a/indra/llmessage/lltransfertargetvfile.h
+++ b/indra/llmessage/lltransfertargetvfile.h
@@ -29,9 +29,9 @@
#include "lltransfermanager.h"
#include "llassetstorage.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
-class LLVFile;
+class LLFileSystem;
// Lame, an S32 for now until I figure out the deal with how we want to do
// error codes.
diff --git a/indra/llmessage/llxfer_vfile.cpp b/indra/llmessage/llxfer_vfile.cpp
index ddc24342f68ce895de29d95aa8d6d87fd9da476e..12419b342df9ba715f0d7bb387ab4582bacedab5 100644
--- a/indra/llmessage/llxfer_vfile.cpp
+++ b/indra/llmessage/llxfer_vfile.cpp
@@ -30,8 +30,7 @@
#include "lluuid.h"
#include "llerror.h"
#include "llmath.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "lldir.h"
// size of chunks read from/written to disk
@@ -42,13 +41,13 @@ const U32 LL_MAX_XFER_FILE_BUFFER = 65536;
LLXfer_VFile::LLXfer_VFile ()
: LLXfer(-1)
{
- init(NULL, LLUUID::null, LLAssetType::AT_NONE);
+ init(LLUUID::null, LLAssetType::AT_NONE);
}
-LLXfer_VFile::LLXfer_VFile (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
+LLXfer_VFile::LLXfer_VFile (const LLUUID &local_id, LLAssetType::EType type)
: LLXfer(-1)
{
- init(vfs, local_id, type);
+ init(local_id, type);
}
///////////////////////////////////////////////////////////
@@ -60,10 +59,8 @@ LLXfer_VFile::~LLXfer_VFile ()
///////////////////////////////////////////////////////////
-void LLXfer_VFile::init (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type)
+void LLXfer_VFile::init (const LLUUID &local_id, LLAssetType::EType type)
{
-
- mVFS = vfs;
mLocalID = local_id;
mType = type;
@@ -82,14 +79,14 @@ void LLXfer_VFile::cleanup ()
if (mTempID.notNull() &&
mDeleteTempFile)
{
- if (mVFS->getExists(mTempID, mType))
+ if (LLFileSystem::getExists(mTempID, mType))
{
- LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
+ LLFileSystem file(mTempID, mType, LLFileSystem::WRITE);
file.remove();
}
else
{
- LL_WARNS("Xfer") << "LLXfer_VFile::cleanup() can't open to delete VFS file " << mTempID << "." << LLAssetType::lookup(mType)
+ LL_WARNS("Xfer") << "LLXfer_VFile::cleanup() can't open to delete cache file " << mTempID << "." << LLAssetType::lookup(mType)
<< ", mRemoteID is " << mRemoteID << LL_ENDL;
}
}
@@ -103,7 +100,6 @@ void LLXfer_VFile::cleanup ()
///////////////////////////////////////////////////////////
S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
- LLVFS* vfs,
const LLUUID& local_id,
const LLUUID& remote_id,
LLAssetType::EType type,
@@ -115,7 +111,6 @@ S32 LLXfer_VFile::initializeRequest(U64 xfer_id,
mRemoteHost = remote_host;
- mVFS = vfs;
mLocalID = local_id;
mRemoteID = remote_id;
mType = type;
@@ -192,13 +187,13 @@ S32 LLXfer_VFile::startSend (U64 xfer_id, const LLHost &remote_host)
delete mVFile;
mVFile = NULL;
- if(mVFS->getExists(mLocalID, mType))
+ if(LLFileSystem::getExists(mLocalID, mType))
{
- mVFile = new LLVFile(mVFS, mLocalID, mType, LLVFile::READ);
+ mVFile = new LLFileSystem(mLocalID, mType, LLFileSystem::READ);
if (mVFile->getSize() <= 0)
{
- LL_WARNS("Xfer") << "LLXfer_VFile::startSend() VFS file " << mLocalID << "." << LLAssetType::lookup(mType)
+ LL_WARNS("Xfer") << "LLXfer_VFile::startSend() cache file " << mLocalID << "." << LLAssetType::lookup(mType)
<< " has unexpected file size of " << mVFile->getSize() << LL_ENDL;
delete mVFile;
mVFile = NULL;
@@ -214,7 +209,7 @@ S32 LLXfer_VFile::startSend (U64 xfer_id, const LLHost &remote_host)
}
else
{
- LL_WARNS("Xfer") << "LLXfer_VFile::startSend() can't read VFS file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+ LL_WARNS("Xfer") << "LLXfer_VFile::startSend() can't read cache file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
retval = LL_ERR_FILE_NOT_FOUND;
}
@@ -240,13 +235,13 @@ S32 LLXfer_VFile::reopenFileHandle()
if (mVFile == NULL)
{
- if (mVFS->getExists(mLocalID, mType))
+ if (LLFileSystem::getExists(mLocalID, mType))
{
- mVFile = new LLVFile(mVFS, mLocalID, mType, LLVFile::READ);
+ mVFile = new LLFileSystem(mLocalID, mType, LLFileSystem::READ);
}
else
{
- LL_WARNS("Xfer") << "LLXfer_VFile::reopenFileHandle() can't read VFS file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+ LL_WARNS("Xfer") << "LLXfer_VFile::reopenFileHandle() can't read cache file " << mLocalID << "." << LLAssetType::lookup(mType) << LL_ENDL;
retval = LL_ERR_FILE_NOT_FOUND;
}
}
@@ -265,8 +260,7 @@ void LLXfer_VFile::setXferSize (S32 xfer_size)
// It would be nice if LLXFers could tell which end of the pipe they were
if (! mVFile)
{
- LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);
- file.setMaxSize(xfer_size);
+ LLFileSystem file(mTempID, mType, LLFileSystem::APPEND);
}
}
@@ -320,7 +314,7 @@ S32 LLXfer_VFile::flush()
S32 retval = 0;
if (mBufferLength)
{
- LLVFile file(mVFS, mTempID, mType, LLVFile::APPEND);
+ LLFileSystem file(mTempID, mType, LLFileSystem::APPEND);
file.write((U8*)mBuffer, mBufferLength);
@@ -340,22 +334,15 @@ S32 LLXfer_VFile::processEOF()
if (!mCallbackResult)
{
- if (mVFS->getExists(mTempID, mType))
+ if (LLFileSystem::getExists(mTempID, mType))
{
- LLVFile file(mVFS, mTempID, mType, LLVFile::WRITE);
+ LLFileSystem file(mTempID, mType, LLFileSystem::WRITE);
if (!file.rename(mLocalID, mType))
{
- LL_WARNS("Xfer") << "VFS rename of temp file failed: unable to rename " << mTempID << " to " << mLocalID << LL_ENDL;
+ LL_WARNS("Xfer") << "Cache rename of temp file failed: unable to rename " << mTempID << " to " << mLocalID << LL_ENDL;
}
else
- {
- #ifdef VFS_SPAM
- // Debugging spam
- LL_INFOS("Xfer") << "VFS rename of temp file done: renamed " << mTempID << " to " << mLocalID
- << " LLVFile size is " << file.getSize()
- << LL_ENDL;
- #endif
-
+ {
// Rename worked: the original file is gone. Clear mDeleteTempFile
// so we don't attempt to delete the file in cleanup()
mDeleteTempFile = FALSE;
@@ -363,7 +350,7 @@ S32 LLXfer_VFile::processEOF()
}
else
{
- LL_WARNS("Xfer") << "LLXfer_VFile::processEOF() can't open for renaming VFS file " << mTempID << "." << LLAssetType::lookup(mType) << LL_ENDL;
+ LL_WARNS("Xfer") << "LLXfer_VFile::processEOF() can't open for renaming cache file " << mTempID << "." << LLAssetType::lookup(mType) << LL_ENDL;
}
}
diff --git a/indra/llmessage/llxfer_vfile.h b/indra/llmessage/llxfer_vfile.h
index 5bf9a5cfba7a6eb84b4909ef03bc67ecf2f53489..d82bab5f6c928c44eec0f801e738e6b605590d75 100644
--- a/indra/llmessage/llxfer_vfile.h
+++ b/indra/llmessage/llxfer_vfile.h
@@ -30,8 +30,7 @@
#include "llxfer.h"
#include "llassetstorage.h"
-class LLVFS;
-class LLVFile;
+class LLFileSystem;
class LLXfer_VFile : public LLXfer
{
@@ -41,9 +40,7 @@ class LLXfer_VFile : public LLXfer
LLUUID mTempID;
LLAssetType::EType mType;
- LLVFile *mVFile;
-
- LLVFS *mVFS;
+ LLFileSystem *mVFile;
std::string mName;
@@ -51,14 +48,13 @@ class LLXfer_VFile : public LLXfer
public:
LLXfer_VFile ();
- LLXfer_VFile (LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type);
+ LLXfer_VFile (const LLUUID &local_id, LLAssetType::EType type);
virtual ~LLXfer_VFile();
- virtual void init(LLVFS *vfs, const LLUUID &local_id, LLAssetType::EType type);
+ virtual void init(const LLUUID &local_id, LLAssetType::EType type);
virtual void cleanup();
virtual S32 initializeRequest(U64 xfer_id,
- LLVFS *vfs,
const LLUUID &local_id,
const LLUUID &remote_id,
const LLAssetType::EType type,
diff --git a/indra/llmessage/llxfermanager.cpp b/indra/llmessage/llxfermanager.cpp
index 8a4107a7b5821b4121153ef12568828ba52f9ddb..3edcb29025dbf6cdfe25b785823e9b595b3cc179 100644
--- a/indra/llmessage/llxfermanager.cpp
+++ b/indra/llmessage/llxfermanager.cpp
@@ -56,9 +56,9 @@ const S32 LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS = 500;
///////////////////////////////////////////////////////////
-LLXferManager::LLXferManager (LLVFS *vfs)
+LLXferManager::LLXferManager ()
{
- init(vfs);
+ init();
}
///////////////////////////////////////////////////////////
@@ -70,7 +70,7 @@ LLXferManager::~LLXferManager ()
///////////////////////////////////////////////////////////
-void LLXferManager::init (LLVFS *vfs)
+void LLXferManager::init()
{
cleanup();
@@ -78,8 +78,6 @@ void LLXferManager::init (LLVFS *vfs)
setHardLimitOutgoingXfersPerCircuit(LL_DEFAULT_MAX_HARD_LIMIT_SIMULTANEOUS_XFERS);
setMaxIncomingXfers(LL_DEFAULT_MAX_REQUEST_FIFO_XFERS);
- mVFS = vfs;
-
// Turn on or off ack throttling
mUseAckThrottling = FALSE;
setAckThrottleBPS(100000);
@@ -462,7 +460,7 @@ U64 LLXferManager::requestFile(const std::string& local_filename,
void LLXferManager::requestVFile(const LLUUID& local_id,
const LLUUID& remote_id,
- LLAssetType::EType type, LLVFS* vfs,
+ LLAssetType::EType type,
const LLHost& remote_host,
void (*callback)(void**,S32,LLExtStat),
void** user_data,
@@ -508,7 +506,6 @@ void LLXferManager::requestVFile(const LLUUID& local_id,
addToList(xfer_p, mReceiveList, is_priority);
((LLXfer_VFile *)xfer_p)->initializeRequest(getNextID(),
- vfs,
local_id,
remote_id,
type,
@@ -784,33 +781,17 @@ void LLXferManager::processFileRequest (LLMessageSystem *mesgsys, void ** /*user
LLXfer *xferp;
if (uuid.notNull())
- { // Request for an asset - use a VFS file
+ { // Request for an asset - use a cache file
if(NULL == LLAssetType::lookup(type))
{
LL_WARNS("Xfer") << "Invalid type for xfer request: " << uuid << ":"
<< type_s16 << " to " << mesgsys->getSender() << LL_ENDL;
return;
}
-
- if (! mVFS)
- {
- LL_WARNS("Xfer") << "Attempt to send VFile w/o available VFS" << LL_ENDL;
- return;
- }
-
- /* Present in fireengine, not used by viewer
- if (!validateVFileForTransfer(uuid.asString()))
- {
- // it is up to the app sending the file to mark it for expected
- // transfer before the request arrives or it will be dropped
- LL_WARNS("Xfer") << "SECURITY: Unapproved VFile '" << uuid << "'" << LL_ENDL;
- return;
- }
- */
LL_INFOS("Xfer") << "starting vfile transfer: " << uuid << "," << LLAssetType::lookup(type) << " to " << mesgsys->getSender() << LL_ENDL;
- xferp = (LLXfer *)new LLXfer_VFile(mVFS, uuid, type);
+ xferp = (LLXfer *)new LLXfer_VFile(uuid, type);
if (xferp)
{
mSendList.push_front(xferp);
@@ -1273,9 +1254,9 @@ void LLXferManager::addToList(LLXfer* xferp, xfer_list_t & xfer_list, BOOL is_pr
LLXferManager *gXferManager = NULL;
-void start_xfer_manager(LLVFS *vfs)
+void start_xfer_manager()
{
- gXferManager = new LLXferManager(vfs);
+ gXferManager = new LLXferManager();
}
void cleanup_xfer_manager()
diff --git a/indra/llmessage/llxfermanager.h b/indra/llmessage/llxfermanager.h
index 45ae2ffdd3d6097055c9568e1891c28d4c2d42c3..f49209bed0f2054069dff6f618f07e0513f95e80 100644
--- a/indra/llmessage/llxfermanager.h
+++ b/indra/llmessage/llxfermanager.h
@@ -35,7 +35,6 @@
//Forward declaration to avoid circular dependencies
class LLXfer;
-class LLVFS;
#include "llxfer.h"
#include "message.h"
@@ -72,9 +71,6 @@ class LLXferAckInfo
class LLXferManager
{
- private:
- LLVFS *mVFS;
-
protected:
S32 mMaxOutgoingXfersPerCircuit;
S32 mHardLimitOutgoingXfersPerCircuit; // At this limit, kill off the connection
@@ -111,10 +107,10 @@ class LLXferManager
std::multiset<std::string> mExpectedVFileRequests; // files that are authorized to be downloaded on top of
public:
- LLXferManager(LLVFS *vfs);
+ LLXferManager();
virtual ~LLXferManager();
- virtual void init(LLVFS *vfs);
+ virtual void init();
virtual void cleanup();
void setUseAckThrottling(const BOOL use);
@@ -166,7 +162,7 @@ class LLXferManager
// vfile requesting
// .. to vfile
virtual void requestVFile(const LLUUID &local_id, const LLUUID& remote_id,
- LLAssetType::EType type, LLVFS* vfs,
+ LLAssetType::EType type,
const LLHost& remote_host,
void (*callback)(void**,S32,LLExtStat), void** user_data,
BOOL is_priority = FALSE);
@@ -213,7 +209,7 @@ class LLXferManager
extern LLXferManager* gXferManager;
// initialization and garbage collection
-void start_xfer_manager(LLVFS *vfs);
+void start_xfer_manager();
void cleanup_xfer_manager();
// message system callbacks
diff --git a/indra/llrender/CMakeLists.txt b/indra/llrender/CMakeLists.txt
index c65798879e7e071a4ca10109487175b77ec516a0..0788f3a30c383087cbf87eae15cdc2a99c1a6fd1 100644
--- a/indra/llrender/CMakeLists.txt
+++ b/indra/llrender/CMakeLists.txt
@@ -10,10 +10,9 @@ include(LLCommon)
include(LLImage)
include(LLMath)
include(LLRender)
-include(LLVFS)
include(LLWindow)
include(LLXML)
-include(LLVFS)
+include(LLFileSystem)
include_directories(
${FREETYPE_INCLUDE_DIRS}
@@ -22,10 +21,9 @@ include_directories(
${LLIMAGE_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
)
include_directories(SYSTEM
${LLCOMMON_SYSTEM_INCLUDE_DIRS}
@@ -106,9 +104,8 @@ if (BUILD_HEADLESS)
${LLIMAGE_LIBRARIES}
${LLMATH_LIBRARIES}
${LLRENDER_HEADLESS_LIBRARIES}
- ${LLVFS_LIBRARIES}
${LLXML_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLWINDOW_HEADLESS_LIBRARIES}
${OPENGL_HEADLESS_LIBRARIES})
@@ -130,9 +127,8 @@ target_link_libraries(llrender
${LLCOMMON_LIBRARIES}
${LLIMAGE_LIBRARIES}
${LLMATH_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLXML_LIBRARIES}
- ${LLVFS_LIBRARIES}
${LLWINDOW_LIBRARIES}
${FREETYPE_LIBRARIES}
${EPOXY_LIBRARIES}
diff --git a/indra/llui/CMakeLists.txt b/indra/llui/CMakeLists.txt
index cce618487b08f2c8bda030f732ec8be3e1b17302..7401e6130a21920bdc8a9c1c36defa252dd1c9c3 100644
--- a/indra/llui/CMakeLists.txt
+++ b/indra/llui/CMakeLists.txt
@@ -13,7 +13,7 @@ include(LLCoreHttp)
include(LLRender)
include(LLWindow)
include(LLCoreHttp)
-include(LLVFS)
+include(LLFileSystem)
include(LLXML)
include_directories(
@@ -25,7 +25,7 @@ include_directories(
${LLMESSAGE_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LIBS_PREBUILD_DIR}/include/hunspell
)
@@ -283,7 +283,7 @@ target_link_libraries(llui
${LLINVENTORY_LIBRARIES}
${LLMESSAGE_LIBRARIES}
${LLCOREHTTP_LIBRARIES}
- ${LLVFS_LIBRARIES} # ugh, just for LLDir
+ ${LLFILESYSTEM_LIBRARIES}
${LLXUIXML_LIBRARIES}
${LLXML_LIBRARIES}
${LLMATH_LIBRARIES}
diff --git a/indra/llui/llviewereventrecorder.h b/indra/llui/llviewereventrecorder.h
index a25e656280f5b1b50b89d15be34475b167595895..2b7a560e1f0265a9bba827c6b468dfe4b6dd23ad 100644
--- a/indra/llui/llviewereventrecorder.h
+++ b/indra/llui/llviewereventrecorder.h
@@ -34,7 +34,6 @@
#include "lldir.h"
#include "llsd.h"
#include "llfile.h"
-#include "llvfile.h"
#include "lldate.h"
#include "llsdserialize.h"
#include "llkeyboard.h"
diff --git a/indra/llvfs/llpidlock.cpp b/indra/llvfs/llpidlock.cpp
deleted file mode 100644
index f770e93d45aa678e286d55e2ecef24cbcbd10e65..0000000000000000000000000000000000000000
--- a/indra/llvfs/llpidlock.cpp
+++ /dev/null
@@ -1,276 +0,0 @@
-/**
- * @file llformat.cpp
- * @date January 2007
- * @brief string formatting utility
- *
- * $LicenseInfo:firstyear=2007&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 "llapr.h" // thread-related functions
-#include "llpidlock.h"
-#include "lldir.h"
-#include "llsd.h"
-#include "llsdserialize.h"
-#include "llnametable.h"
-#include "llframetimer.h"
-
-#if LL_WINDOWS //For windows platform.
-
-#include <windows.h>
-
-bool isProcessAlive(U32 pid)
-{
- return (bool) GetProcessVersion((DWORD)pid);
-}
-
-#else //Everyone Else
-bool isProcessAlive(U32 pid)
-{
- return (bool) kill( (pid_t)pid, 0);
-}
-#endif //Everyone else.
-
-
-
-class LLPidLockFile
-{
- public:
- LLPidLockFile( ) :
- mAutosave(false),
- mSaving(false),
- mWaiting(false),
- mPID(getpid()),
- mNameTable(NULL),
- mClean(true)
- {
- mLockName = gDirUtilp->getTempDir() + gDirUtilp->getDirDelimiter() + "savelock";
- }
- bool requestLock(LLNameTable<void *> *name_table, bool autosave,
- bool force_immediate=FALSE, F32 timeout=300.0);
- bool checkLock();
- void releaseLock();
-
- private:
- void writeLockFile(LLSD pids);
- public:
- static LLPidLockFile& instance(); // return the singleton black list file
-
- bool mAutosave;
- bool mSaving;
- bool mWaiting;
- LLFrameTimer mTimer;
- U32 mPID;
- std::string mLockName;
- std::string mSaveName;
- LLSD mPIDS_sd;
- LLNameTable<void*> *mNameTable;
- bool mClean;
-};
-
-LLPidLockFile& LLPidLockFile::instance()
-{
- static LLPidLockFile the_file;
- return the_file;
-}
-
-void LLPidLockFile::writeLockFile(LLSD pids)
-{
- llofstream ofile(mLockName.c_str());
-
- if (!LLSDSerialize::toXML(pids,ofile))
- {
- LL_WARNS() << "Unable to write concurrent save lock file." << LL_ENDL;
- }
- ofile.close();
-}
-
-bool LLPidLockFile::requestLock(LLNameTable<void *> *name_table, bool autosave,
- bool force_immediate, F32 timeout)
-{
- bool readyToSave = FALSE;
-
- if (mSaving) return FALSE; //Bail out if we're currently saving. Will not queue another save.
-
- if (!mWaiting){
- mNameTable=name_table;
- mAutosave = autosave;
- }
-
- LLSD out_pids;
- out_pids.append( (LLSD::Integer)mPID );
-
- llifstream ifile(mLockName.c_str());
-
- if (ifile.is_open())
- { //If file exists, we need to decide whether or not to continue.
- if ( force_immediate
- || mTimer.hasExpired() ) //Only deserialize if we REALLY need to.
- {
-
- LLSD in_pids;
-
- LLSDSerialize::fromXML(in_pids, ifile);
-
- //Clean up any dead PIDS that might be in there.
- for (LLSD::array_iterator i=in_pids.beginArray();
- i !=in_pids.endArray();
- ++i)
- {
- U32 stored_pid=(*i).asInteger();
-
- if (isProcessAlive(stored_pid))
- {
- out_pids.append( (*i) );
- }
- }
-
- readyToSave=TRUE;
- }
- ifile.close();
- }
- else
- {
- readyToSave=TRUE;
- }
-
- if (!mWaiting) //Not presently waiting to save. Queue up.
- {
- mTimer.resetWithExpiry(timeout);
- mWaiting=TRUE;
- }
-
- if (readyToSave)
- { //Potential race condition won't kill us. Ignore it.
- writeLockFile(out_pids);
- mSaving=TRUE;
- }
-
- return readyToSave;
-}
-
-bool LLPidLockFile::checkLock()
-{
- return mWaiting;
-}
-
-void LLPidLockFile::releaseLock()
-{
- llifstream ifile(mLockName.c_str());
- LLSD in_pids;
- LLSD out_pids;
- bool write_file=FALSE;
-
- LLSDSerialize::fromXML(in_pids, ifile);
-
- //Clean up this PID and any dead ones.
- for (LLSD::array_iterator i=in_pids.beginArray();
- i !=in_pids.endArray();
- ++i)
- {
- U32 stored_pid=(*i).asInteger();
-
- if (stored_pid != mPID && isProcessAlive(stored_pid))
- {
- out_pids.append( (*i) );
- write_file=TRUE;
- }
- }
- ifile.close();
-
- if (write_file)
- {
- writeLockFile(out_pids);
- }
- else
- {
- unlink(mLockName.c_str());
- }
-
- mSaving=FALSE;
- mWaiting=FALSE;
-}
-
-//LLPidLock
-
-void LLPidLock::initClass() {
- (void) LLPidLockFile::instance();
-}
-
-bool LLPidLock::checkLock()
-{
- return LLPidLockFile::instance().checkLock();
-}
-
-bool LLPidLock::requestLock(LLNameTable<void *> *name_table, bool autosave,
- bool force_immediate, F32 timeout)
-{
- return LLPidLockFile::instance().requestLock(name_table,autosave,force_immediate,timeout);
-}
-
-void LLPidLock::releaseLock()
-{
- return LLPidLockFile::instance().releaseLock();
-}
-
-bool LLPidLock::isClean()
-{
- return LLPidLockFile::instance().mClean;
-}
-
-//getters
-LLNameTable<void *> * LLPidLock::getNameTable()
-{
- return LLPidLockFile::instance().mNameTable;
-}
-
-bool LLPidLock::getAutosave()
-{
- return LLPidLockFile::instance().mAutosave;
-}
-
-bool LLPidLock::getClean()
-{
- return LLPidLockFile::instance().mClean;
-}
-
-std::string LLPidLock::getSaveName()
-{
- return LLPidLockFile::instance().mSaveName;
-}
-
-//setters
-void LLPidLock::setClean(bool clean)
-{
- LLPidLockFile::instance().mClean=clean;
-}
-
-void LLPidLock::setSaveName(std::string savename)
-{
- LLPidLockFile::instance().mSaveName=savename;
-}
-
-S32 LLPidLock::getPID()
-{
- return (S32)getpid();
-}
diff --git a/indra/llvfs/llpidlock.h b/indra/llvfs/llpidlock.h
deleted file mode 100644
index 334f26bb294b13a4bd2c30e16ad581bd97a9c693..0000000000000000000000000000000000000000
--- a/indra/llvfs/llpidlock.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * @file llpidlock.h
- * @brief System information debugging classes.
- *
- * $LicenseInfo:firstyear=2001&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_PIDLOCK_H
-#define LL_PIDLOCK_H
-#include "llnametable.h"
-
-class LLSD;
-class LLFrameTimer;
-
-#if !LL_WINDOWS //For non-windows platforms.
-#include <signal.h>
-#endif
-
-namespace LLPidLock
-{
- void initClass(); // { (void) LLPidLockFile::instance(); }
-
- bool requestLock( LLNameTable<void *> *name_table=NULL, bool autosave=TRUE,
- bool force_immediate=FALSE, F32 timeout=300.0);
- bool checkLock();
- void releaseLock();
- bool isClean();
-
- //getters
- LLNameTable<void *> * getNameTable();
- bool getAutosave();
- bool getClean();
- std::string getSaveName();
- S32 getPID();
-
- //setters
- void setClean(bool clean);
- void setSaveName(std::string savename);
-};
-
-#endif // LL_PIDLOCK_H
diff --git a/indra/llvfs/llvfile.cpp b/indra/llvfs/llvfile.cpp
deleted file mode 100644
index b8588e99f4f71c93fffb95015ab65d7281ede264..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfile.cpp
+++ /dev/null
@@ -1,437 +0,0 @@
-/**
- * @file llvfile.cpp
- * @brief Implementation of virtual file
- *
- * $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 "linden_common.h"
-
-#include "llvfile.h"
-
-#include "llerror.h"
-#include "llthread.h"
-#include "lltimer.h"
-#include "llfasttimer.h"
-#include "llmemory.h"
-#include "llvfs.h"
-
-const S32 LLVFile::READ = 0x00000001;
-const S32 LLVFile::WRITE = 0x00000002;
-const S32 LLVFile::READ_WRITE = 0x00000003; // LLVFile::READ & LLVFile::WRITE
-const S32 LLVFile::APPEND = 0x00000006; // 0x00000004 & LLVFile::WRITE
-
-static LLTrace::BlockTimerStatHandle FTM_VFILE_WAIT("VFile Wait");
-
-//----------------------------------------------------------------------------
-LLVFSThread* LLVFile::sVFSThread = NULL;
-BOOL LLVFile::sAllocdVFSThread = FALSE;
-//----------------------------------------------------------------------------
-
-//============================================================================
-
-LLVFile::LLVFile(LLVFS *vfs, const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode)
-{
- mFileType = file_type;
-
- mFileID = file_id;
- mPosition = 0;
- mMode = mode;
- mVFS = vfs;
-
- mBytesRead = 0;
- mHandle = LLVFSThread::nullHandle();
- mPriority = 128.f;
-
- mVFS->incLock(mFileID, mFileType, VFSLOCK_OPEN);
-}
-
-LLVFile::~LLVFile()
-{
- if (!isReadComplete())
- {
- if (mHandle != LLVFSThread::nullHandle())
- {
- if (!(mMode & LLVFile::WRITE))
- {
- //LL_WARNS() << "Destroying LLVFile with pending async read/write, aborting..." << LL_ENDL;
- sVFSThread->setFlags(mHandle, LLVFSThread::FLAG_AUTO_COMPLETE | LLVFSThread::FLAG_ABORT);
- }
- else // WRITE
- {
- sVFSThread->setFlags(mHandle, LLVFSThread::FLAG_AUTO_COMPLETE);
- }
- }
- }
- mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
-}
-
-BOOL LLVFile::read(U8 *buffer, S32 bytes, BOOL async, F32 priority)
-{
- if (! (mMode & READ))
- {
- LL_WARNS() << "Attempt to read from file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
- return FALSE;
- }
-
- if (mHandle != LLVFSThread::nullHandle())
- {
- LL_WARNS() << "Attempt to read from vfile object " << mFileID << " with pending async operation" << LL_ENDL;
- return FALSE;
- }
- mPriority = priority;
-
- BOOL success = TRUE;
-
- // We can't do a read while there are pending async writes
- waitForLock(VFSLOCK_APPEND);
-
- // *FIX: (?)
- if (async)
- {
- mHandle = sVFSThread->read(mVFS, mFileID, mFileType, buffer, mPosition, bytes, threadPri());
- }
- else
- {
- // We can't do a read while there are pending async writes on this file
- mBytesRead = sVFSThread->readImmediate(mVFS, mFileID, mFileType, buffer, mPosition, bytes);
- mPosition += mBytesRead;
- if (! mBytesRead)
- {
- success = FALSE;
- }
- }
-
- return success;
-}
-
-//static
-U8* LLVFile::readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S32* bytes_read)
-{
- U8 *data;
- LLVFile file(vfs, uuid, type, LLVFile::READ);
- S32 file_size = file.getSize();
- if (file_size == 0)
- {
- // File is empty.
- data = NULL;
- }
- else
- {
- data = (U8*) ll_aligned_malloc<16>(file_size);
- file.read(data, file_size); /* Flawfinder: ignore */
-
- if (file.getLastBytesRead() != (S32)file_size)
- {
- ll_aligned_free<16>(data);
- data = NULL;
- file_size = 0;
- }
- }
- if (bytes_read)
- {
- *bytes_read = file_size;
- }
- return data;
-}
-
-void LLVFile::setReadPriority(const F32 priority)
-{
- mPriority = priority;
- if (mHandle != LLVFSThread::nullHandle())
- {
- sVFSThread->setPriority(mHandle, threadPri());
- }
-}
-
-BOOL LLVFile::isReadComplete()
-{
- BOOL res = TRUE;
- if (mHandle != LLVFSThread::nullHandle())
- {
- LLVFSThread::Request* req = (LLVFSThread::Request*)sVFSThread->getRequest(mHandle);
- LLVFSThread::status_t status = req->getStatus();
- if (status == LLVFSThread::STATUS_COMPLETE)
- {
- mBytesRead = req->getBytesRead();
- mPosition += mBytesRead;
- sVFSThread->completeRequest(mHandle);
- mHandle = LLVFSThread::nullHandle();
- }
- else
- {
- res = FALSE;
- }
- }
- return res;
-}
-
-S32 LLVFile::getLastBytesRead()
-{
- return mBytesRead;
-}
-
-BOOL LLVFile::eof()
-{
- return mPosition >= getSize();
-}
-
-BOOL LLVFile::write(const U8 *buffer, S32 bytes)
-{
- if (! (mMode & WRITE))
- {
- LL_WARNS() << "Attempt to write to file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
- }
- if (mHandle != LLVFSThread::nullHandle())
- {
- LL_ERRS() << "Attempt to write to vfile object " << mFileID << " with pending async operation" << LL_ENDL;
- return FALSE;
- }
- BOOL success = TRUE;
-
- // *FIX: allow async writes? potential problem wit mPosition...
- if (mMode == APPEND) // all appends are async (but WRITEs are not)
- {
- U8* writebuf = new U8[bytes];
- memcpy(writebuf, buffer, bytes);
- S32 offset = -1;
- mHandle = sVFSThread->write(mVFS, mFileID, mFileType,
- writebuf, offset, bytes,
- LLVFSThread::FLAG_AUTO_COMPLETE | LLVFSThread::FLAG_AUTO_DELETE);
- mHandle = LLVFSThread::nullHandle(); // FLAG_AUTO_COMPLETE means we don't track this
- }
- else
- {
- // We can't do a write while there are pending reads or writes on this file
- waitForLock(VFSLOCK_READ);
- waitForLock(VFSLOCK_APPEND);
-
- S32 pos = (mMode & APPEND) == APPEND ? -1 : mPosition;
-
- S32 wrote = sVFSThread->writeImmediate(mVFS, mFileID, mFileType, (U8*)buffer, pos, bytes);
-
- mPosition += wrote;
-
- if (wrote < bytes)
- {
- LL_WARNS() << "Tried to write " << bytes << " bytes, actually wrote " << wrote << LL_ENDL;
-
- success = FALSE;
- }
- }
- return success;
-}
-
-//static
-BOOL LLVFile::writeFile(const U8 *buffer, S32 bytes, LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
-{
- LLVFile file(vfs, uuid, type, LLVFile::WRITE);
- file.setMaxSize(bytes);
- return file.write(buffer, bytes);
-}
-
-BOOL LLVFile::seek(S32 offset, S32 origin)
-{
- if (mMode == APPEND)
- {
- LL_WARNS() << "Attempt to seek on append-only file" << LL_ENDL;
- return FALSE;
- }
-
- if (-1 == origin)
- {
- origin = mPosition;
- }
-
- S32 new_pos = origin + offset;
-
- S32 size = getSize(); // Calls waitForLock(VFSLOCK_APPEND)
-
- if (new_pos > size)
- {
- LL_WARNS() << "Attempt to seek past end of file" << LL_ENDL;
-
- mPosition = size;
- return FALSE;
- }
- else if (new_pos < 0)
- {
- LL_WARNS() << "Attempt to seek past beginning of file" << LL_ENDL;
-
- mPosition = 0;
- return FALSE;
- }
-
- mPosition = new_pos;
- return TRUE;
-}
-
-S32 LLVFile::tell() const
-{
- return mPosition;
-}
-
-S32 LLVFile::getSize()
-{
- waitForLock(VFSLOCK_APPEND);
- S32 size = mVFS->getSize(mFileID, mFileType);
-
- return size;
-}
-
-S32 LLVFile::getMaxSize()
-{
- S32 size = mVFS->getMaxSize(mFileID, mFileType);
-
- return size;
-}
-
-BOOL LLVFile::setMaxSize(S32 size)
-{
- if (! (mMode & WRITE))
- {
- LL_WARNS() << "Attempt to change size of file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-
- return FALSE;
- }
-
- if (!mVFS->checkAvailable(size))
- {
- //LL_RECORD_BLOCK_TIME(FTM_VFILE_WAIT);
- S32 count = 0;
- while (sVFSThread->getPending() > 1000)
- {
- if (count % 100 == 0)
- {
- LL_INFOS() << "VFS catching up... Pending: " << sVFSThread->getPending() << LL_ENDL;
- }
- if (sVFSThread->isPaused())
- {
- sVFSThread->update(0);
- }
- ms_sleep(10);
- }
- }
- return mVFS->setMaxSize(mFileID, mFileType, size);
-}
-
-BOOL LLVFile::rename(const LLUUID &new_id, const LLAssetType::EType new_type)
-{
- if (! (mMode & WRITE))
- {
- LL_WARNS() << "Attempt to rename file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
-
- return FALSE;
- }
-
- if (mHandle != LLVFSThread::nullHandle())
- {
- LL_WARNS() << "Renaming file with pending async read" << LL_ENDL;
- }
-
- waitForLock(VFSLOCK_READ);
- waitForLock(VFSLOCK_APPEND);
-
- // we need to release / replace our own lock
- // since the renamed file will inherit locks from the new name
- mVFS->decLock(mFileID, mFileType, VFSLOCK_OPEN);
- mVFS->renameFile(mFileID, mFileType, new_id, new_type);
- mVFS->incLock(new_id, new_type, VFSLOCK_OPEN);
-
- mFileID = new_id;
- mFileType = new_type;
-
- return TRUE;
-}
-
-BOOL LLVFile::remove()
-{
-// LL_INFOS() << "Removing file " << mFileID << LL_ENDL;
-
- if (! (mMode & WRITE))
- {
- // Leaving paranoia warning just because this should be a very infrequent
- // operation.
- LL_WARNS() << "Remove file " << mFileID << " opened with mode " << std::hex << mMode << std::dec << LL_ENDL;
- }
-
- if (mHandle != LLVFSThread::nullHandle())
- {
- LL_WARNS() << "Removing file with pending async read" << LL_ENDL;
- }
-
- // why not seek back to the beginning of the file too?
- mPosition = 0;
-
- waitForLock(VFSLOCK_READ);
- waitForLock(VFSLOCK_APPEND);
- mVFS->removeFile(mFileID, mFileType);
-
- return TRUE;
-}
-
-// static
-void LLVFile::initClass(LLVFSThread* vfsthread)
-{
- if (!vfsthread)
- {
- if (LLVFSThread::sLocal != NULL)
- {
- vfsthread = LLVFSThread::sLocal;
- }
- else
- {
- vfsthread = new LLVFSThread();
- sAllocdVFSThread = TRUE;
- }
- }
- sVFSThread = vfsthread;
-}
-
-// static
-void LLVFile::cleanupClass()
-{
- if (sAllocdVFSThread)
- {
- delete sVFSThread;
- }
- sVFSThread = NULL;
-}
-
-bool LLVFile::isLocked(EVFSLock lock)
-{
- return mVFS->isLocked(mFileID, mFileType, lock) ? true : false;
-}
-
-void LLVFile::waitForLock(EVFSLock lock)
-{
- //LL_RECORD_BLOCK_TIME(FTM_VFILE_WAIT);
- // spin until the lock clears
- while (isLocked(lock))
- {
- if (sVFSThread->isPaused())
- {
- sVFSThread->update(0);
- }
- ms_sleep(1);
- }
-}
diff --git a/indra/llvfs/llvfile.h b/indra/llvfs/llvfile.h
deleted file mode 100644
index 7e9d9f73e564fe129f0cfb6f77812b7d43b8683f..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfile.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/**
- * @file llvfile.h
- * @brief Definition of virtual file
- *
- * $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$
- */
-
-#ifndef LL_LLVFILE_H
-#define LL_LLVFILE_H
-
-#include "lluuid.h"
-#include "llassettype.h"
-#include "llvfs.h"
-#include "llvfsthread.h"
-
-class LLVFile
-{
-public:
- LLVFile(LLVFS *vfs, const LLUUID &file_id, const LLAssetType::EType file_type, S32 mode = LLVFile::READ);
- ~LLVFile();
-
- BOOL read(U8 *buffer, S32 bytes, BOOL async = FALSE, F32 priority = 128.f); /* Flawfinder: ignore */
- static U8* readFile(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type, S32* bytes_read = 0);
- void setReadPriority(const F32 priority);
- BOOL isReadComplete();
- S32 getLastBytesRead();
- BOOL eof();
-
- BOOL write(const U8 *buffer, S32 bytes);
- static BOOL writeFile(const U8 *buffer, S32 bytes, LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type);
- BOOL seek(S32 offset, S32 origin = -1);
- S32 tell() const;
-
- S32 getSize();
- S32 getMaxSize();
- BOOL setMaxSize(S32 size);
- BOOL rename(const LLUUID &new_id, const LLAssetType::EType new_type);
- BOOL remove();
-
- bool isLocked(EVFSLock lock);
- void waitForLock(EVFSLock lock);
-
- static void initClass(LLVFSThread* vfsthread = NULL);
- static void cleanupClass();
- static LLVFSThread* getVFSThread() { return sVFSThread; }
-
-protected:
- static LLVFSThread* sVFSThread;
- static BOOL sAllocdVFSThread;
- U32 threadPri() { return LLVFSThread::PRIORITY_NORMAL + llmin((U32)mPriority,(U32)0xfff); }
-
-public:
- static const S32 READ;
- static const S32 WRITE;
- static const S32 READ_WRITE;
- static const S32 APPEND;
-
-protected:
- LLAssetType::EType mFileType;
-
- LLUUID mFileID;
- S32 mPosition;
- S32 mMode;
- LLVFS *mVFS;
- F32 mPriority;
-
- S32 mBytesRead;
- LLVFSThread::handle_t mHandle;
-};
-
-#endif
diff --git a/indra/llvfs/llvfs.cpp b/indra/llvfs/llvfs.cpp
deleted file mode 100644
index 3be39adee3f3cfb2b05746a9316d18b78361a15c..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfs.cpp
+++ /dev/null
@@ -1,2221 +0,0 @@
-/**
- * @file llvfs.cpp
- * @brief Implementation of virtual file system
- *
- * $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 "linden_common.h"
-
-#include "llvfs.h"
-
-#include <sys/stat.h>
-#include <set>
-#include <map>
-#if LL_WINDOWS
-#include <share.h>
-#elif LL_SOLARIS
-#include <sys/types.h>
-#include <unistd.h>
-#include <fcntl.h>
-#else
-#include <sys/file.h>
-#endif
-
-#include "llstl.h"
-#include "lltimer.h"
-
-const S32 FILE_BLOCK_MASK = 0x000003FF; // 1024-byte blocks
-const S32 VFS_CLEANUP_SIZE = 5242880; // how much space we free up in a single stroke
-const S32 BLOCK_LENGTH_INVALID = -1; // mLength for invalid LLVFSFileBlocks
-
-LLVFS *gVFS = NULL;
-
-// internal class definitions
-class LLVFSBlock
-{
-public:
- LLVFSBlock()
- {
- mLocation = 0;
- mLength = 0;
- }
-
- LLVFSBlock(U32 loc, S32 size)
- {
- mLocation = loc;
- mLength = size;
- }
-
- static bool locationSortPredicate(
- const LLVFSBlock* lhs,
- const LLVFSBlock* rhs)
- {
- return lhs->mLocation < rhs->mLocation;
- }
-
-public:
- U32 mLocation;
- S32 mLength; // allocated block size
-};
-
-LLVFSFileSpecifier::LLVFSFileSpecifier()
-: mFileID(),
- mFileType( LLAssetType::AT_NONE )
-{
-}
-
-LLVFSFileSpecifier::LLVFSFileSpecifier(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
- mFileID = file_id;
- mFileType = file_type;
-}
-
-bool LLVFSFileSpecifier::operator<(const LLVFSFileSpecifier &rhs) const
-{
- return (mFileID == rhs.mFileID)
- ? mFileType < rhs.mFileType
- : mFileID < rhs.mFileID;
-}
-
-bool LLVFSFileSpecifier::operator==(const LLVFSFileSpecifier &rhs) const
-{
- return (mFileID == rhs.mFileID &&
- mFileType == rhs.mFileType);
-}
-
-
-class LLVFSFileBlock : public LLVFSBlock, public LLVFSFileSpecifier
-{
-public:
- LLVFSFileBlock() : LLVFSBlock(), LLVFSFileSpecifier()
- {
- init();
- }
-
- LLVFSFileBlock(const LLUUID &file_id, LLAssetType::EType file_type, U32 loc = 0, S32 size = 0)
- : LLVFSBlock(loc, size), LLVFSFileSpecifier( file_id, file_type )
- {
- init();
- }
-
- void init()
- {
- mSize = 0;
- mIndexLocation = -1;
- mAccessTime = (U32)time(NULL);
-
- for (S32 i = 0; i < (S32)VFSLOCK_COUNT; i++)
- {
- mLocks[(EVFSLock)i] = 0;
- }
- }
-
- #ifdef LL_LITTLE_ENDIAN
- inline void swizzleCopy(void *dst, void *src, int size) { memcpy(dst, src, size); /* Flawfinder: ignore */}
-
- #else
-
- inline U32 swizzle32(U32 x)
- {
- return(((x >> 24) & 0x000000FF) | ((x >> 8) & 0x0000FF00) | ((x << 8) & 0x00FF0000) |((x << 24) & 0xFF000000));
- }
-
- inline U16 swizzle16(U16 x)
- {
- return( ((x >> 8) & 0x000000FF) | ((x << 8) & 0x0000FF00) );
- }
-
- inline void swizzleCopy(void *dst, void *src, int size)
- {
- if(size == 4)
- {
- ((U32*)dst)[0] = swizzle32(((U32*)src)[0]);
- }
- else if(size == 2)
- {
- ((U16*)dst)[0] = swizzle16(((U16*)src)[0]);
- }
- else
- {
- // Perhaps this should assert...
- memcpy(dst, src, size); /* Flawfinder: ignore */
- }
- }
-
- #endif
-
- void serialize(U8 *buffer)
- {
- swizzleCopy(buffer, &mLocation, 4);
- buffer += 4;
- swizzleCopy(buffer, &mLength, 4);
- buffer +=4;
- swizzleCopy(buffer, &mAccessTime, 4);
- buffer +=4;
- memcpy(buffer, &mFileID.mData, 16); /* Flawfinder: ignore */
- buffer += 16;
- S16 temp_type = mFileType;
- swizzleCopy(buffer, &temp_type, 2);
- buffer += 2;
- swizzleCopy(buffer, &mSize, 4);
- }
-
- void deserialize(U8 *buffer, const S32 index_loc)
- {
- mIndexLocation = index_loc;
-
- swizzleCopy(&mLocation, buffer, 4);
- buffer += 4;
- swizzleCopy(&mLength, buffer, 4);
- buffer += 4;
- swizzleCopy(&mAccessTime, buffer, 4);
- buffer += 4;
- memcpy(&mFileID.mData, buffer, 16);
- buffer += 16;
- S16 temp_type;
- swizzleCopy(&temp_type, buffer, 2);
- mFileType = (LLAssetType::EType)temp_type;
- buffer += 2;
- swizzleCopy(&mSize, buffer, 4);
- }
-
- static BOOL insertLRU(LLVFSFileBlock* const& first,
- LLVFSFileBlock* const& second)
- {
- return (first->mAccessTime == second->mAccessTime)
- ? *first < *second
- : first->mAccessTime < second->mAccessTime;
- }
-
-public:
- S32 mSize;
- S32 mIndexLocation; // location of index entry
- U32 mAccessTime;
- BOOL mLocks[VFSLOCK_COUNT]; // number of outstanding locks of each type
-
- static const S32 SERIAL_SIZE;
-};
-
-// Helper structure for doing lru w/ stl... is there a simpler way?
-struct LLVFSFileBlock_less
-{
- bool operator()(LLVFSFileBlock* const& lhs, LLVFSFileBlock* const& rhs) const
- {
- return (LLVFSFileBlock::insertLRU(lhs, rhs)) ? true : false;
- }
-};
-
-
-const S32 LLVFSFileBlock::SERIAL_SIZE = 34;
-
-
-LLVFS::LLVFS(const std::string& index_filename, const std::string& data_filename, const BOOL read_only, const U32 presize, const BOOL remove_after_crash)
-: mRemoveAfterCrash(remove_after_crash),
- mDataFP(NULL),
- mIndexFP(NULL)
-{
- mDataMutex = new LLMutex();
-
- S32 i;
- for (i = 0; i < VFSLOCK_COUNT; i++)
- {
- mLockCounts[i] = 0;
- }
- mValid = VFSVALID_OK;
- mReadOnly = read_only;
- mIndexFilename = index_filename;
- mDataFilename = data_filename;
-
- const char *file_mode = mReadOnly ? "rb" : "r+b";
-
- LL_INFOS("VFS") << "Attempting to open VFS index file " << mIndexFilename << LL_ENDL;
- LL_INFOS("VFS") << "Attempting to open VFS data file " << mDataFilename << LL_ENDL;
-
- mDataFP = openAndLock(mDataFilename, file_mode, mReadOnly);
- if (!mDataFP)
- {
- if (mReadOnly)
- {
- LL_WARNS("VFS") << "Can't find " << mDataFilename << " to open read-only VFS" << LL_ENDL;
- mValid = VFSVALID_BAD_CANNOT_OPEN_READONLY;
- return;
- }
-
- mDataFP = openAndLock(mDataFilename, "w+b", FALSE);
- if (mDataFP)
- {
- // Since we're creating this data file, assume any index file is bogus
- // remove the index, since this vfs is now blank
- LLFile::remove(mIndexFilename);
- }
- else
- {
- LL_WARNS("VFS") << "Couldn't open vfs data file "
- << mDataFilename << LL_ENDL;
- mValid = VFSVALID_BAD_CANNOT_CREATE;
- return;
- }
-
- if (presize)
- {
- presizeDataFile(presize);
- }
- }
-
- // Did we leave this file open for writing last time?
- // If so, close it and start over.
- if (!mReadOnly && mRemoveAfterCrash)
- {
- llstat marker_info;
- std::string marker = mDataFilename + ".open";
- if (!LLFile::stat(marker, &marker_info))
- {
- // marker exists, kill the lock and the VFS files
- unlockAndClose(mDataFP);
- mDataFP = NULL;
-
- LL_WARNS("VFS") << "VFS: File left open on last run, removing old VFS file " << mDataFilename << LL_ENDL;
- LLFile::remove(mIndexFilename);
- LLFile::remove(mDataFilename);
- LLFile::remove(marker);
-
- mDataFP = openAndLock(mDataFilename, "w+b", FALSE);
- if (!mDataFP)
- {
- LL_WARNS("VFS") << "Can't open VFS data file in crash recovery" << LL_ENDL;
- mValid = VFSVALID_BAD_CANNOT_CREATE;
- return;
- }
-
- if (presize)
- {
- presizeDataFile(presize);
- }
- }
- }
-
- // determine the real file size
- fseek(mDataFP, 0, SEEK_END);
- U32 data_size = ftell(mDataFP);
-
- // read the index file
- // make sure there's at least one file in it too
- // if not, we'll treat this as a new vfs
- llstat fbuf;
- if (! LLFile::stat(mIndexFilename, &fbuf) &&
- fbuf.st_size >= LLVFSFileBlock::SERIAL_SIZE &&
- (mIndexFP = openAndLock(mIndexFilename, file_mode, mReadOnly)) // Yes, this is an assignment and not '=='
- )
- {
- std::vector<U8> buffer(fbuf.st_size);
- size_t buf_offset = 0;
- size_t nread = fread(&buffer[0], 1, fbuf.st_size, mIndexFP);
-
- std::vector<LLVFSFileBlock*> files_by_loc;
-
- while (buf_offset < nread)
- {
- LLVFSFileBlock *block = new LLVFSFileBlock();
-
- block->deserialize(&buffer[buf_offset], (S32)buf_offset);
-
- // Do sanity check on this block.
- // Note that this skips zero size blocks, which helps VFS
- // to heal after some errors. JC
- if (block->mLength > 0 &&
- (U32)block->mLength <= data_size &&
- block->mLocation < data_size &&
- block->mSize > 0 &&
- block->mSize <= block->mLength &&
- block->mFileType >= LLAssetType::AT_NONE &&
- block->mFileType < LLAssetType::AT_COUNT)
- {
- mFileBlocks.insert(fileblock_map::value_type(*block, block));
- files_by_loc.push_back(block);
- }
- else
- if (block->mLength && block->mSize > 0)
- {
- // this is corrupt, not empty
- LL_WARNS("VFS") << "VFS corruption: " << block->mFileID << " (" << block->mFileType << ") at index " << block->mIndexLocation << " DS: " << data_size << LL_ENDL;
- LL_WARNS("VFS") << "Length: " << block->mLength << "\tLocation: " << block->mLocation << "\tSize: " << block->mSize << LL_ENDL;
- LL_WARNS("VFS") << "File has bad data - VFS removed" << LL_ENDL;
-
- delete block;
-
- unlockAndClose( mIndexFP );
- mIndexFP = NULL;
- LLFile::remove( mIndexFilename );
-
- unlockAndClose( mDataFP );
- mDataFP = NULL;
- LLFile::remove( mDataFilename );
-
- LL_WARNS("VFS") << "Deleted corrupt VFS files "
- << mDataFilename
- << " and "
- << mIndexFilename
- << LL_ENDL;
-
- mValid = VFSVALID_BAD_CORRUPT;
- return;
- }
- else
- {
- // this is a null or bad entry, skip it
- mIndexHoles.push_back(buf_offset);
-
- delete block;
- }
-
- buf_offset += LLVFSFileBlock::SERIAL_SIZE;
- }
-
- std::sort(
- files_by_loc.begin(),
- files_by_loc.end(),
- LLVFSFileBlock::locationSortPredicate);
-
- // There are 3 cases that have to be considered.
- // 1. No blocks
- // 2. One block.
- // 3. Two or more blocks.
- if (!files_by_loc.empty())
- {
- // cur walks through the list.
- std::vector<LLVFSFileBlock*>::iterator cur = files_by_loc.begin();
- std::vector<LLVFSFileBlock*>::iterator end = files_by_loc.end();
- LLVFSFileBlock* last_file_block = *cur;
-
- // Check to see if there is an empty space before the first file.
- if (last_file_block->mLocation > 0)
- {
- // If so, create a free block.
- addFreeBlock(new LLVFSBlock(0, last_file_block->mLocation));
- }
-
- // Walk through the 2nd+ block. If there is a free space
- // between cur_file_block and last_file_block, add it to
- // the free space collection. This block will not need to
- // run in the case there is only one entry in the VFS.
- ++cur;
- while( cur != end )
- {
- LLVFSFileBlock* cur_file_block = *cur;
-
- // Dupe check on the block
- if (cur_file_block->mLocation == last_file_block->mLocation
- && cur_file_block->mLength == last_file_block->mLength)
- {
- LL_WARNS("VFS") << "VFS: removing duplicate entry"
- << " at " << cur_file_block->mLocation
- << " length " << cur_file_block->mLength
- << " size " << cur_file_block->mSize
- << " ID " << cur_file_block->mFileID
- << " type " << cur_file_block->mFileType
- << LL_ENDL;
-
- // Duplicate entries. Nuke them both for safety.
- mFileBlocks.erase(*cur_file_block); // remove ID/type entry
- if (cur_file_block->mLength > 0)
- {
- // convert to hole
- addFreeBlock(
- new LLVFSBlock(
- cur_file_block->mLocation,
- cur_file_block->mLength));
- }
- lockData(); // needed for sync()
- sync(cur_file_block, TRUE); // remove first on disk
- sync(last_file_block, TRUE); // remove last on disk
- unlockData(); // needed for sync()
- last_file_block = cur_file_block;
- ++cur;
- continue;
- }
-
- // Figure out where the last block ended.
- S32 loc = last_file_block->mLocation+last_file_block->mLength;
-
- // Figure out how much space there is between where
- // the last block ended and this block begins.
- S32 length = cur_file_block->mLocation - loc;
-
- // Check for more errors... Seeing if the current
- // entry and the last entry make sense together.
- if (length < 0 || loc < 0 || (U32)loc > data_size)
- {
- // Invalid VFS
- unlockAndClose( mIndexFP );
- mIndexFP = NULL;
- LLFile::remove( mIndexFilename );
-
- unlockAndClose( mDataFP );
- mDataFP = NULL;
- LLFile::remove( mDataFilename );
-
- LL_WARNS("VFS") << "VFS: overlapping entries"
- << " at " << cur_file_block->mLocation
- << " length " << cur_file_block->mLength
- << " ID " << cur_file_block->mFileID
- << " type " << cur_file_block->mFileType
- << LL_ENDL;
-
- LL_WARNS("VFS") << "Deleted corrupt VFS files "
- << mDataFilename
- << " and "
- << mIndexFilename
- << LL_ENDL;
-
- mValid = VFSVALID_BAD_CORRUPT;
- return;
- }
-
- // we don't want to add empty blocks to the list...
- if (length > 0)
- {
- addFreeBlock(new LLVFSBlock(loc, length));
- }
- last_file_block = cur_file_block;
- ++cur;
- }
-
- // also note any empty space at the end
- U32 loc = last_file_block->mLocation + last_file_block->mLength;
- if (loc < data_size)
- {
- addFreeBlock(new LLVFSBlock(loc, data_size - loc));
- }
- }
- else // There where no blocks in the file.
- {
- addFreeBlock(new LLVFSBlock(0, data_size));
- }
- }
- else // Pre-existing index file wasn't opened
- {
- if (mReadOnly)
- {
- LL_WARNS("VFS") << "Can't find " << mIndexFilename << " to open read-only VFS" << LL_ENDL;
- mValid = VFSVALID_BAD_CANNOT_OPEN_READONLY;
- return;
- }
-
-
- mIndexFP = openAndLock(mIndexFilename, "w+b", FALSE);
- if (!mIndexFP)
- {
- LL_WARNS("VFS") << "Couldn't open an index file for the VFS, probably a sharing violation!" << LL_ENDL;
-
- unlockAndClose( mDataFP );
- mDataFP = NULL;
- LLFile::remove( mDataFilename );
-
- mValid = VFSVALID_BAD_CANNOT_CREATE;
- return;
- }
-
- // no index file, start from scratch w/ 1GB allocation
- LLVFSBlock *first_block = new LLVFSBlock(0, data_size ? data_size : 0x40000000);
- addFreeBlock(first_block);
- }
-
- // Open marker file to look for bad shutdowns
- if (!mReadOnly && mRemoveAfterCrash)
- {
- std::string marker = mDataFilename + ".open";
- LLFILE* marker_fp = LLFile::fopen(marker, "w"); /* Flawfinder: ignore */
- if (marker_fp)
- {
- fclose(marker_fp);
- marker_fp = NULL;
- }
- }
-
- LL_INFOS("VFS") << "Using VFS index file " << mIndexFilename << LL_ENDL;
- LL_INFOS("VFS") << "Using VFS data file " << mDataFilename << LL_ENDL;
-
- mValid = VFSVALID_OK;
-}
-
-LLVFS::~LLVFS()
-{
- if (mDataMutex->isLocked())
- {
- LL_ERRS("VFS") << "LLVFS destroyed with mutex locked" << LL_ENDL;
- }
-
- unlockAndClose(mIndexFP);
- mIndexFP = NULL;
-
- fileblock_map::const_iterator it;
- for (it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- delete (*it).second;
- }
- mFileBlocks.clear();
-
- mFreeBlocksByLength.clear();
-
- for_each(mFreeBlocksByLocation.begin(), mFreeBlocksByLocation.end(), DeletePairedPointer());
- mFreeBlocksByLocation.clear();
-
- unlockAndClose(mDataFP);
- mDataFP = NULL;
-
- // Remove marker file
- if (!mReadOnly && mRemoveAfterCrash)
- {
- std::string marker = mDataFilename + ".open";
- LLFile::remove(marker);
- }
-
- delete mDataMutex;
-}
-
-
-// Use this function normally to create LLVFS files.
-// Will append digits to the end of the filename with multiple re-trys
-// static
-LLVFS * LLVFS::createLLVFS(const std::string& index_filename,
- const std::string& data_filename,
- const BOOL read_only,
- const U32 presize,
- const BOOL remove_after_crash)
-{
- LLVFS * new_vfs = new LLVFS(index_filename, data_filename, read_only, presize, remove_after_crash);
-
- if( !new_vfs->isValid() )
- { // First name failed, retry with new names
- std::string retry_vfs_index_name;
- std::string retry_vfs_data_name;
- S32 count = 0;
- while (!new_vfs->isValid() &&
- count < 256)
- { // Append '.<number>' to end of filenames
- retry_vfs_index_name = index_filename + llformat(".%u",count);
- retry_vfs_data_name = data_filename + llformat(".%u", count);
-
- delete new_vfs; // Delete bad VFS and try again
- new_vfs = new LLVFS(retry_vfs_index_name, retry_vfs_data_name, read_only, presize, remove_after_crash);
-
- count++;
- }
- }
-
- if( !new_vfs->isValid() )
- {
- delete new_vfs; // Delete bad VFS
- new_vfs = NULL; // Total failure
- }
-
- return new_vfs;
-}
-
-
-
-void LLVFS::presizeDataFile(const U32 size)
-{
- if (!mDataFP)
- {
- LL_ERRS() << "LLVFS::presizeDataFile() with no data file open" << LL_ENDL;
- return;
- }
-
- // we're creating this file for the first time, size it
- fseek(mDataFP, size-1, SEEK_SET);
- S32 tmp = 0;
- tmp = (S32)fwrite(&tmp, 1, 1, mDataFP);
- // fflush(mDataFP);
-
- // also remove any index, since this vfs is now blank
- LLFile::remove(mIndexFilename);
-
- if (tmp)
- {
- LL_INFOS() << "Pre-sized VFS data file to " << ftell(mDataFP) << " bytes" << LL_ENDL;
- }
- else
- {
- LL_WARNS() << "Failed to pre-size VFS data file" << LL_ENDL;
- }
-}
-
-BOOL LLVFS::getExists(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
- LLVFSFileBlock *block = NULL;
-
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- block = (*it).second;
- block->mAccessTime = (U32)time(NULL);
- }
-
- BOOL res = (block && block->mLength > 0) ? TRUE : FALSE;
-
- unlockData();
-
- return res;
-}
-
-S32 LLVFS::getSize(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
- S32 size = 0;
-
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-
- }
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
-
- block->mAccessTime = (U32)time(NULL);
- size = block->mSize;
- }
-
- unlockData();
-
- return size;
-}
-
-S32 LLVFS::getMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
- S32 size = 0;
-
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
-
- block->mAccessTime = (U32)time(NULL);
- size = block->mLength;
- }
-
- unlockData();
-
- return size;
-}
-
-BOOL LLVFS::checkAvailable(S32 max_size)
-{
- lockData();
-
- blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(max_size); // first entry >= size
- const BOOL res(iter == mFreeBlocksByLength.end() ? FALSE : TRUE);
-
- unlockData();
-
- return res;
-}
-
-BOOL LLVFS::setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type, S32 max_size)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- if (mReadOnly)
- {
- LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
- }
- if (max_size <= 0)
- {
- LL_WARNS() << "VFS: Attempt to assign size " << max_size << " to vfile " << file_id << LL_ENDL;
- return FALSE;
- }
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- LLVFSFileBlock *block = NULL;
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- block = (*it).second;
- }
-
- // round all sizes upward to KB increments
- // SJB: Need to not round for the new texture-pipeline code so we know the correct
- // max file size. Need to investigate the potential problems with this...
- if (file_type != LLAssetType::AT_TEXTURE)
- {
- if (max_size & FILE_BLOCK_MASK)
- {
- max_size += FILE_BLOCK_MASK;
- max_size &= ~FILE_BLOCK_MASK;
- }
- }
-
- if (block && block->mLength > 0)
- {
- block->mAccessTime = (U32)time(NULL);
-
- if (max_size == block->mLength)
- {
- unlockData();
- return TRUE;
- }
- else if (max_size < block->mLength)
- {
- // this file is shrinking
- LLVFSBlock *free_block = new LLVFSBlock(block->mLocation + max_size, block->mLength - max_size);
-
- addFreeBlock(free_block);
-
- block->mLength = max_size;
-
- if (block->mLength < block->mSize)
- {
- // JC: Was a warning, but Ian says it's bad.
- LL_ERRS() << "Truncating virtual file " << file_id << " to " << block->mLength << " bytes" << LL_ENDL;
- block->mSize = block->mLength;
- }
-
- sync(block);
- //mergeFreeBlocks();
-
- unlockData();
- return TRUE;
- }
- else if (max_size > block->mLength)
- {
- // this file is growing
- // first check for an adjacent free block to grow into
- S32 size_increase = max_size - block->mLength;
-
- // Find the first free block with and addres > block->mLocation
- LLVFSBlock *free_block;
- blocks_location_map_t::iterator iter = mFreeBlocksByLocation.upper_bound(block->mLocation);
- if (iter != mFreeBlocksByLocation.end())
- {
- free_block = iter->second;
-
- if (free_block->mLocation == block->mLocation + block->mLength &&
- free_block->mLength >= size_increase)
- {
- // this free block is at the end of the file and is large enough
-
- // Must call useFreeSpace before sync(), as sync()
- // unlocks data structures.
- useFreeSpace(free_block, size_increase);
- block->mLength += size_increase;
- sync(block);
-
- unlockData();
- return TRUE;
- }
- }
-
- // no adjecent free block, find one in the list
- free_block = findFreeBlock(max_size, block);
-
- if (free_block)
- {
- // Save location where data is going, useFreeSpace will move free_block->mLocation;
- U32 new_data_location = free_block->mLocation;
-
- //mark the free block as used so it does not
- //interfere with other operations such as addFreeBlock
- useFreeSpace(free_block, max_size); // useFreeSpace takes ownership (and may delete) free_block
-
- if (block->mLength > 0)
- {
- // create a new free block where this file used to be
- LLVFSBlock *new_free_block = new LLVFSBlock(block->mLocation, block->mLength);
-
- addFreeBlock(new_free_block);
-
- if (block->mSize > 0)
- {
- // move the file into the new block
- std::vector<U8> buffer(block->mSize);
- fseek(mDataFP, block->mLocation, SEEK_SET);
- if (fread(&buffer[0], block->mSize, 1, mDataFP) == 1)
- {
- fseek(mDataFP, new_data_location, SEEK_SET);
- if (fwrite(&buffer[0], block->mSize, 1, mDataFP) != 1)
- {
- LL_WARNS() << "Short write" << LL_ENDL;
- }
- } else {
- LL_WARNS() << "Short read" << LL_ENDL;
- }
- }
- }
-
- block->mLocation = new_data_location;
-
- block->mLength = max_size;
-
-
- sync(block);
-
- unlockData();
- return TRUE;
- }
- else
- {
- LL_WARNS() << "VFS: No space (" << max_size << ") to resize existing vfile " << file_id << LL_ENDL;
- //dumpMap();
- unlockData();
- dumpStatistics();
- return FALSE;
- }
- }
- }
- else
- {
- // find a free block in the list
- LLVFSBlock *free_block = findFreeBlock(max_size);
-
- if (free_block)
- {
- if (block)
- {
- block->mLocation = free_block->mLocation;
- block->mLength = max_size;
- }
- else
- {
- // this file doesn't exist, create it
- block = new LLVFSFileBlock(file_id, file_type, free_block->mLocation, max_size);
- mFileBlocks.insert(fileblock_map::value_type(spec, block));
- }
-
- // Must call useFreeSpace before sync(), as sync()
- // unlocks data structures.
- useFreeSpace(free_block, max_size);
- block->mAccessTime = (U32)time(NULL);
-
- sync(block);
- }
- else
- {
- LL_WARNS() << "VFS: No space (" << max_size << ") for new virtual file " << file_id << LL_ENDL;
- //dumpMap();
- unlockData();
- dumpStatistics();
- return FALSE;
- }
- }
- unlockData();
- return TRUE;
-}
-
-
-// WARNING: HERE BE DRAGONS!
-// rename is the weirdest VFS op, because the file moves but the locks don't!
-void LLVFS::renameFile(const LLUUID &file_id, const LLAssetType::EType file_type,
- const LLUUID &new_id, const LLAssetType::EType &new_type)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- if (mReadOnly)
- {
- LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
- }
-
- lockData();
-
- LLVFSFileSpecifier new_spec(new_id, new_type);
- LLVFSFileSpecifier old_spec(file_id, file_type);
-
- fileblock_map::iterator it = mFileBlocks.find(old_spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *src_block = (*it).second;
-
- // this will purge the data but leave the file block in place, w/ locks, if any
- // WAS: removeFile(new_id, new_type); NOW uses removeFileBlock() to avoid mutex lock recursion
- fileblock_map::iterator new_it = mFileBlocks.find(new_spec);
- if (new_it != mFileBlocks.end())
- {
- LLVFSFileBlock *new_block = (*new_it).second;
- removeFileBlock(new_block);
- }
-
- // if there's something in the target location, remove it but inherit its locks
- it = mFileBlocks.find(new_spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *dest_block = (*it).second;
-
- for (S32 i = 0; i < (S32)VFSLOCK_COUNT; i++)
- {
- if(dest_block->mLocks[i])
- {
- LL_ERRS() << "Renaming VFS block to a locked file." << LL_ENDL;
- }
- dest_block->mLocks[i] = src_block->mLocks[i];
- }
-
- mFileBlocks.erase(new_spec);
- delete dest_block;
- }
-
- src_block->mFileID = new_id;
- src_block->mFileType = new_type;
- src_block->mAccessTime = (U32)time(NULL);
-
- mFileBlocks.erase(old_spec);
- mFileBlocks.insert(fileblock_map::value_type(new_spec, src_block));
-
- sync(src_block);
- }
- else
- {
- LL_WARNS() << "VFS: Attempt to rename nonexistent vfile " << file_id << ":" << file_type << LL_ENDL;
- }
- unlockData();
-}
-
-// mDataMutex must be LOCKED before calling this
-void LLVFS::removeFileBlock(LLVFSFileBlock *fileblock)
-{
- // convert this into an unsaved, dummy fileblock to preserve locks
- // a more rubust solution would store the locks in a seperate data structure
- sync(fileblock, TRUE);
-
- if (fileblock->mLength > 0)
- {
- // turn this file into an empty block
- LLVFSBlock *free_block = new LLVFSBlock(fileblock->mLocation, fileblock->mLength);
-
- addFreeBlock(free_block);
- }
-
- fileblock->mLocation = 0;
- fileblock->mSize = 0;
- fileblock->mLength = BLOCK_LENGTH_INVALID;
- fileblock->mIndexLocation = -1;
-
- //mergeFreeBlocks();
-}
-
-void LLVFS::removeFile(const LLUUID &file_id, const LLAssetType::EType file_type)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- if (mReadOnly)
- {
- LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
- }
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
- removeFileBlock(block);
- }
- else
- {
- LL_WARNS() << "VFS: attempting to remove nonexistent file " << file_id << " type " << file_type << LL_ENDL;
- }
-
- unlockData();
-}
-
-
-S32 LLVFS::getData(const LLUUID &file_id, const LLAssetType::EType file_type, U8 *buffer, S32 location, S32 length)
-{
- S32 bytesread = 0;
-
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- llassert(location >= 0);
- llassert(length >= 0);
-
- BOOL do_read = FALSE;
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
-
- block->mAccessTime = (U32)time(NULL);
-
- if (location > block->mSize)
- {
- LL_WARNS() << "VFS: Attempt to read location " << location << " in file " << file_id << " of length " << block->mSize << LL_ENDL;
- }
- else
- {
- if (length > block->mSize - location)
- {
- length = block->mSize - location;
- }
- location += block->mLocation;
- do_read = TRUE;
- }
- }
-
- if (do_read)
- {
- fseek(mDataFP, location, SEEK_SET);
- bytesread = (S32)fread(buffer, 1, length, mDataFP);
- }
-
- unlockData();
-
- return bytesread;
-}
-
-S32 LLVFS::storeData(const LLUUID &file_id, const LLAssetType::EType file_type, const U8 *buffer, S32 location, S32 length)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- if (mReadOnly)
- {
- LL_ERRS() << "Attempt to write to read-only VFS" << LL_ENDL;
- }
-
- llassert(length > 0);
-
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
-
- S32 in_loc = location;
- if (location == -1)
- {
- location = block->mSize;
- }
- llassert(location >= 0);
-
- block->mAccessTime = (U32)time(NULL);
-
- if (block->mLength == BLOCK_LENGTH_INVALID)
- {
- // Block was removed, ignore write
- LL_WARNS() << "VFS: Attempt to write to invalid block"
- << " in file " << file_id
- << " location: " << in_loc
- << " bytes: " << length
- << LL_ENDL;
- unlockData();
- return length;
- }
- else if (location > block->mLength)
- {
- LL_WARNS() << "VFS: Attempt to write to location " << location
- << " in file " << file_id
- << " type " << S32(file_type)
- << " of size " << block->mSize
- << " block length " << block->mLength
- << LL_ENDL;
- unlockData();
- return length;
- }
- else
- {
- if (length > block->mLength - location )
- {
- LL_WARNS() << "VFS: Truncating write to virtual file " << file_id << " type " << S32(file_type) << LL_ENDL;
- length = block->mLength - location;
- }
- U32 file_location = location + block->mLocation;
-
- fseek(mDataFP, file_location, SEEK_SET);
- S32 write_len = (S32)fwrite(buffer, 1, length, mDataFP);
- if (write_len != length)
- {
- LL_WARNS() << llformat("VFS Write Error: %d != %d",write_len,length) << LL_ENDL;
- }
- // fflush(mDataFP);
-
- if (location + length > block->mSize)
- {
- block->mSize = location + write_len;
- sync(block);
- }
- unlockData();
-
- return write_len;
- }
- }
- else
- {
- unlockData();
- return 0;
- }
-}
-
-void LLVFS::incLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- LLVFSFileBlock *block;
-
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- block = (*it).second;
- }
- else
- {
- // Create a dummy block which isn't saved
- block = new LLVFSFileBlock(file_id, file_type, 0, BLOCK_LENGTH_INVALID);
- block->mAccessTime = (U32)time(NULL);
- mFileBlocks.insert(fileblock_map::value_type(spec, block));
- }
-
- block->mLocks[lock]++;
- mLockCounts[lock]++;
-
- unlockData();
-}
-
-void LLVFS::decLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
- lockData();
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
-
- if (block->mLocks[lock] > 0)
- {
- block->mLocks[lock]--;
- }
- else
- {
- LL_WARNS() << "VFS: Decrementing zero-value lock " << lock << LL_ENDL;
- }
- mLockCounts[lock]--;
- }
-
- unlockData();
-}
-
-BOOL LLVFS::isLocked(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock)
-{
- lockData();
-
- BOOL res = FALSE;
-
- LLVFSFileSpecifier spec(file_id, file_type);
- fileblock_map::iterator it = mFileBlocks.find(spec);
- if (it != mFileBlocks.end())
- {
- LLVFSFileBlock *block = (*it).second;
- res = (block->mLocks[lock] > 0);
- }
-
- unlockData();
-
- return res;
-}
-
-//============================================================================
-// protected
-//============================================================================
-
-void LLVFS::eraseBlockLength(LLVFSBlock *block)
-{
- // find the corresponding map entry in the length map and erase it
- S32 length = block->mLength;
- blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(length);
- blocks_length_map_t::iterator end = mFreeBlocksByLength.end();
- bool found_block = false;
- while(iter != end)
- {
- LLVFSBlock *tblock = iter->second;
- llassert(tblock->mLength == length); // there had -better- be an entry with our length!
- if (tblock == block)
- {
- mFreeBlocksByLength.erase(iter);
- found_block = true;
- break;
- }
- ++iter;
- }
- if(!found_block)
- {
- LL_ERRS() << "eraseBlock could not find block" << LL_ENDL;
- }
-}
-
-
-// Remove block from both free lists (by location and by length).
-void LLVFS::eraseBlock(LLVFSBlock *block)
-{
- eraseBlockLength(block);
- // find the corresponding map entry in the location map and erase it
- U32 location = block->mLocation;
- llverify(mFreeBlocksByLocation.erase(location) == 1); // we should only have one entry per location.
-}
-
-
-// Add the region specified by block location and length to the free lists.
-// Also incrementally defragment by merging with previous and next free blocks.
-void LLVFS::addFreeBlock(LLVFSBlock *block)
-{
-#if LL_DEBUG
- size_t dbgcount = mFreeBlocksByLocation.count(block->mLocation);
- if(dbgcount > 0)
- {
- LL_ERRS() << "addFreeBlock called with block already in list" << LL_ENDL;
- }
-#endif
-
- // Get a pointer to the next free block (by location).
- blocks_location_map_t::iterator next_free_it = mFreeBlocksByLocation.lower_bound(block->mLocation);
-
- // We can merge with previous if it ends at our requested location.
- LLVFSBlock* prev_block = NULL;
- bool merge_prev = false;
- if (next_free_it != mFreeBlocksByLocation.begin())
- {
- blocks_location_map_t::iterator prev_free_it = next_free_it;
- --prev_free_it;
- prev_block = prev_free_it->second;
- merge_prev = (prev_block->mLocation + prev_block->mLength == block->mLocation);
- }
-
- // We can merge with next if our block ends at the next block's location.
- LLVFSBlock* next_block = NULL;
- bool merge_next = false;
- if (next_free_it != mFreeBlocksByLocation.end())
- {
- next_block = next_free_it->second;
- merge_next = (block->mLocation + block->mLength == next_block->mLocation);
- }
-
- if (merge_prev && merge_next)
- {
- // LL_INFOS() << "VFS merge BOTH" << LL_ENDL;
- // Previous block is changing length (a lot), so only need to update length map.
- // Next block is going away completely. JC
- eraseBlockLength(prev_block);
- eraseBlock(next_block);
- prev_block->mLength += block->mLength + next_block->mLength;
- mFreeBlocksByLength.insert(blocks_length_map_t::value_type(prev_block->mLength, prev_block));
- delete block;
- block = NULL;
- delete next_block;
- next_block = NULL;
- }
- else if (merge_prev)
- {
- // LL_INFOS() << "VFS merge previous" << LL_ENDL;
- // Previous block is maintaining location, only changing length,
- // therefore only need to update the length map. JC
- eraseBlockLength(prev_block);
- prev_block->mLength += block->mLength;
- mFreeBlocksByLength.insert(blocks_length_map_t::value_type(prev_block->mLength, prev_block)); // multimap insert
- delete block;
- block = NULL;
- }
- else if (merge_next)
- {
- // LL_INFOS() << "VFS merge next" << LL_ENDL;
- // Next block is changing both location and length,
- // so both free lists must update. JC
- eraseBlock(next_block);
- next_block->mLocation = block->mLocation;
- next_block->mLength += block->mLength;
- // Don't hint here, next_free_it iterator may be invalid.
- mFreeBlocksByLocation.insert(blocks_location_map_t::value_type(next_block->mLocation, next_block)); // multimap insert
- mFreeBlocksByLength.insert(blocks_length_map_t::value_type(next_block->mLength, next_block)); // multimap insert
- delete block;
- block = NULL;
- }
- else
- {
- // Can't merge with other free blocks.
- // Hint that insert should go near next_free_it.
- mFreeBlocksByLocation.insert(next_free_it, blocks_location_map_t::value_type(block->mLocation, block)); // multimap insert
- mFreeBlocksByLength.insert(blocks_length_map_t::value_type(block->mLength, block)); // multimap insert
- }
-}
-
-// Superceeded by new addFreeBlock which does incremental free space merging.
-// Incremental is faster overall.
-//void LLVFS::mergeFreeBlocks()
-//{
-// if (!isValid())
-// {
-// LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
-// }
-// // TODO: could we optimize this with hints from the calling code?
-// blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin();
-// blocks_location_map_t::iterator end = mFreeBlocksByLocation.end();
-// LLVFSBlock *first_block = iter->second;
-// while(iter != end)
-// {
-// blocks_location_map_t::iterator first_iter = iter; // save for if we do a merge
-// if (++iter == end)
-// break;
-// LLVFSBlock *second_block = iter->second;
-// if (first_block->mLocation + first_block->mLength == second_block->mLocation)
-// {
-// // remove the first block from the length map
-// eraseBlockLength(first_block);
-// // merge first_block with second_block, since they're adjacent
-// first_block->mLength += second_block->mLength;
-// // add the first block to the length map (with the new size)
-// mFreeBlocksByLength.insert(blocks_length_map_t::value_type(first_block->mLength, first_block)); // multimap insert
-//
-// // erase and delete the second block
-// eraseBlock(second_block);
-// delete second_block;
-//
-// // reset iterator
-// iter = first_iter; // haven't changed first_block, so corresponding iterator is still valid
-// end = mFreeBlocksByLocation.end();
-// }
-// first_block = second_block;
-// }
-//}
-
-// length bytes from free_block are going to be used (so they are no longer free)
-void LLVFS::useFreeSpace(LLVFSBlock *free_block, S32 length)
-{
- if (free_block->mLength == length)
- {
- eraseBlock(free_block);
- delete free_block;
- }
- else
- {
- eraseBlock(free_block);
-
- free_block->mLocation += length;
- free_block->mLength -= length;
-
- addFreeBlock(free_block);
- }
-}
-
-// NOTE! mDataMutex must be LOCKED before calling this
-// sync this index entry out to the index file
-// we need to do this constantly to avoid corruption on viewer crash
-void LLVFS::sync(LLVFSFileBlock *block, BOOL remove)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- if (mReadOnly)
- {
- LL_WARNS() << "Attempt to sync read-only VFS" << LL_ENDL;
- return;
- }
- if (block->mLength == BLOCK_LENGTH_INVALID)
- {
- // This is a dummy file, don't save
- return;
- }
- if (block->mLength == 0)
- {
- LL_ERRS() << "VFS syncing zero-length block" << LL_ENDL;
- }
-
- BOOL set_index_to_end = FALSE;
- long seek_pos = block->mIndexLocation;
-
- if (-1 == seek_pos)
- {
- if (!mIndexHoles.empty())
- {
- seek_pos = mIndexHoles.front();
- mIndexHoles.pop_front();
- }
- else
- {
- set_index_to_end = TRUE;
- }
- }
-
- if (set_index_to_end)
- {
- // Need fseek/ftell to update the seek_pos and hence data
- // structures, so can't unlockData() before this.
- fseek(mIndexFP, 0, SEEK_END);
- seek_pos = ftell(mIndexFP);
- }
-
- block->mIndexLocation = seek_pos;
- if (remove)
- {
- mIndexHoles.push_back(seek_pos);
- }
-
- U8 buffer[LLVFSFileBlock::SERIAL_SIZE];
- if (remove)
- {
- memset(buffer, 0, LLVFSFileBlock::SERIAL_SIZE);
- }
- else
- {
- block->serialize(buffer);
- }
-
- // If set_index_to_end, file pointer is already at seek_pos
- // and we don't need to do anything. Only seek if not at end.
- if (!set_index_to_end)
- {
- fseek(mIndexFP, seek_pos, SEEK_SET);
- }
-
- if (fwrite(buffer, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
- {
- LL_WARNS() << "Short write" << LL_ENDL;
- }
-
- // *NOTE: Why was this commented out?
- // fflush(mIndexFP);
-
- return;
-}
-
-// mDataMutex must be LOCKED before calling this
-// Can initiate LRU-based file removal to make space.
-// The immune file block will not be removed.
-LLVFSBlock *LLVFS::findFreeBlock(S32 size, LLVFSFileBlock *immune)
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
-
- LLVFSBlock *block = NULL;
- BOOL have_lru_list = FALSE;
-
- typedef std::set<LLVFSFileBlock*, LLVFSFileBlock_less> lru_set;
- lru_set lru_list;
-
- LLTimer timer;
-
- while (! block)
- {
- // look for a suitable free block
- blocks_length_map_t::iterator iter = mFreeBlocksByLength.lower_bound(size); // first entry >= size
- if (iter != mFreeBlocksByLength.end())
- block = iter->second;
-
- // no large enough free blocks, time to clean out some junk
- if (! block)
- {
- // create a list of files sorted by usage time
- // this is far faster than sorting a linked list
- if (! have_lru_list)
- {
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileBlock *tmp = (*it).second;
-
- if (tmp != immune &&
- tmp->mLength > 0 &&
- ! tmp->mLocks[VFSLOCK_READ] &&
- ! tmp->mLocks[VFSLOCK_APPEND] &&
- ! tmp->mLocks[VFSLOCK_OPEN])
- {
- lru_list.insert(tmp);
- }
- }
-
- have_lru_list = TRUE;
- }
-
- if (lru_list.size() == 0)
- {
- // No more files to delete, and still not enough room!
- LL_WARNS() << "VFS: Can't make " << size << " bytes of free space in VFS, giving up" << LL_ENDL;
- break;
- }
-
- // is the oldest file big enough? (Should be about half the time)
- lru_set::iterator it = lru_list.begin();
- LLVFSFileBlock *file_block = *it;
- if (file_block->mLength >= size && file_block != immune)
- {
- // ditch this file and look again for a free block - should find it
- // TODO: it'll be faster just to assign the free block and break
- LL_INFOS() << "LRU: Removing " << file_block->mFileID << ":" << file_block->mFileType << LL_ENDL;
- lru_list.erase(it);
- removeFileBlock(file_block);
- file_block = NULL;
- continue;
- }
-
-
- LL_INFOS() << "VFS: LRU: Aggressive: " << (S32)lru_list.size() << " files remain" << LL_ENDL;
- dumpLockCounts();
-
- // Now it's time to aggressively make more space
- // Delete the oldest 5MB of the vfs or enough to hold the file, which ever is larger
- // This may yield too much free space, but we'll use it up soon enough
- U32 cleanup_target = (size > VFS_CLEANUP_SIZE) ? size : VFS_CLEANUP_SIZE;
- U32 cleaned_up = 0;
- for (it = lru_list.begin();
- it != lru_list.end() && cleaned_up < cleanup_target;
- )
- {
- file_block = *it;
-
- // TODO: it would be great to be able to batch all these sync() calls
- // LL_INFOS() << "LRU2: Removing " << file_block->mFileID << ":" << file_block->mFileType << " last accessed" << file_block->mAccessTime << LL_ENDL;
-
- cleaned_up += file_block->mLength;
- lru_list.erase(it++);
- removeFileBlock(file_block);
- file_block = NULL;
- }
- //mergeFreeBlocks();
- }
- }
-
- F32 time = timer.getElapsedTimeF32();
- if (time > 0.5f)
- {
- LL_WARNS() << "VFS: Spent " << time << " seconds in findFreeBlock!" << LL_ENDL;
- }
-
- return block;
-}
-
-//============================================================================
-// public
-//============================================================================
-
-void LLVFS::pokeFiles()
-{
- if (!isValid())
- {
- LL_ERRS() << "Attempting to use invalid VFS!" << LL_ENDL;
- }
- U32 word;
-
- // only write data if we actually read 4 bytes
- // otherwise we're writing garbage and screwing up the file
- fseek(mDataFP, 0, SEEK_SET);
- if (fread(&word, sizeof(word), 1, mDataFP) == 1)
- {
- fseek(mDataFP, 0, SEEK_SET);
- if (fwrite(&word, sizeof(word), 1, mDataFP) != 1)
- {
- LL_WARNS() << "Could not write to data file" << LL_ENDL;
- }
- fflush(mDataFP);
- }
-
- fseek(mIndexFP, 0, SEEK_SET);
- if (fread(&word, sizeof(word), 1, mIndexFP) == 1)
- {
- fseek(mIndexFP, 0, SEEK_SET);
- if (fwrite(&word, sizeof(word), 1, mIndexFP) != 1)
- {
- LL_WARNS() << "Could not write to index file" << LL_ENDL;
- }
- fflush(mIndexFP);
- }
-}
-
-
-void LLVFS::dumpMap()
-{
- LL_INFOS() << "Files:" << LL_ENDL;
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileBlock *file_block = (*it).second;
- LL_INFOS() << "Location: " << file_block->mLocation << "\tLength: " << file_block->mLength << "\t" << file_block->mFileID << "\t" << file_block->mFileType << LL_ENDL;
- }
-
- LL_INFOS() << "Free Blocks:" << LL_ENDL;
- for (blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin(),
- end = mFreeBlocksByLocation.end();
- iter != end; iter++)
- {
- LLVFSBlock *free_block = iter->second;
- LL_INFOS() << "Location: " << free_block->mLocation << "\tLength: " << free_block->mLength << LL_ENDL;
- }
-}
-
-// verify that the index file contents match the in-memory file structure
-// Very slow, do not call routinely. JC
-void LLVFS::audit()
-{
- // Lock the mutex through this whole function.
- LLMutexLock lock_data(mDataMutex);
-
- fflush(mIndexFP);
-
- fseek(mIndexFP, 0, SEEK_END);
- size_t index_size = ftell(mIndexFP);
- fseek(mIndexFP, 0, SEEK_SET);
-
- BOOL vfs_corrupt = FALSE;
-
- // since we take the address of element 0, we need to have at least one element.
- std::vector<U8> buffer(llmax<size_t>(index_size,1U));
-
- if (fread(&buffer[0], 1, index_size, mIndexFP) != index_size)
- {
- LL_WARNS() << "Index truncated" << LL_ENDL;
- vfs_corrupt = TRUE;
- }
-
- size_t buf_offset = 0;
-
- std::map<LLVFSFileSpecifier, LLVFSFileBlock*> found_files;
- U32 cur_time = (U32)time(NULL);
-
- std::vector<LLVFSFileBlock*> audit_blocks;
- while (!vfs_corrupt && buf_offset < index_size)
- {
- LLVFSFileBlock *block = new LLVFSFileBlock();
- audit_blocks.push_back(block);
-
- block->deserialize(&buffer[buf_offset], (S32)buf_offset);
- buf_offset += block->SERIAL_SIZE;
-
- // do sanity check on this block
- if (block->mLength >= 0 &&
- block->mSize >= 0 &&
- block->mSize <= block->mLength &&
- block->mFileType >= LLAssetType::AT_NONE &&
- block->mFileType < LLAssetType::AT_COUNT &&
- block->mAccessTime <= cur_time &&
- block->mFileID.notNull())
- {
- if (mFileBlocks.find(*block) == mFileBlocks.end())
- {
- LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " on disk, not in memory, loc " << block->mIndexLocation << LL_ENDL;
- }
- else if (found_files.find(*block) != found_files.end())
- {
- std::map<LLVFSFileSpecifier, LLVFSFileBlock*>::iterator it;
- it = found_files.find(*block);
- LLVFSFileBlock* dupe = it->second;
- // try to keep data from being lost
- unlockAndClose(mIndexFP);
- mIndexFP = NULL;
- unlockAndClose(mDataFP);
- mDataFP = NULL;
- LL_WARNS() << "VFS: Original block index " << block->mIndexLocation
- << " location " << block->mLocation
- << " length " << block->mLength
- << " size " << block->mSize
- << " id " << block->mFileID
- << " type " << block->mFileType
- << LL_ENDL;
- LL_WARNS() << "VFS: Duplicate block index " << dupe->mIndexLocation
- << " location " << dupe->mLocation
- << " length " << dupe->mLength
- << " size " << dupe->mSize
- << " id " << dupe->mFileID
- << " type " << dupe->mFileType
- << LL_ENDL;
- LL_WARNS() << "VFS: Index size " << index_size << LL_ENDL;
- LL_WARNS() << "VFS: INDEX CORRUPT" << LL_ENDL;
- vfs_corrupt = TRUE;
- break;
- }
- else
- {
- found_files[*block] = block;
- }
- }
- else
- {
- if (block->mLength)
- {
- LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " corrupt on disk" << LL_ENDL;
- }
- // else this is just a hole
- }
- }
-
- if (!vfs_corrupt)
- {
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileBlock* block = (*it).second;
-
- if (block->mSize > 0)
- {
- if (! found_files.count(*block))
- {
- LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " in memory, not on disk, loc " << block->mIndexLocation<< LL_ENDL;
- fseek(mIndexFP, block->mIndexLocation, SEEK_SET);
- U8 buf[LLVFSFileBlock::SERIAL_SIZE];
- if (fread(buf, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
- {
- LL_WARNS() << "VFile " << block->mFileID
- << " gave short read" << LL_ENDL;
- }
-
- LLVFSFileBlock disk_block;
- disk_block.deserialize(buf, block->mIndexLocation);
-
- LL_WARNS() << "Instead found " << disk_block.mFileID << ":" << block->mFileType << LL_ENDL;
- }
- else
- {
- block = found_files.find(*block)->second;
- found_files.erase(*block);
- }
- }
- }
-
- for (std::map<LLVFSFileSpecifier, LLVFSFileBlock*>::iterator iter = found_files.begin();
- iter != found_files.end(); iter++)
- {
- LLVFSFileBlock* block = iter->second;
- LL_WARNS() << "VFile " << block->mFileID << ":" << block->mFileType << " szie:" << block->mSize << " leftover" << LL_ENDL;
- }
-
- LL_INFOS() << "VFS: audit OK" << LL_ENDL;
- // mutex released by LLMutexLock() destructor.
- }
-
- for_each(audit_blocks.begin(), audit_blocks.end(), DeletePointer());
- audit_blocks.clear();
-}
-
-
-// quick check for uninitialized blocks
-// Slow, do not call in release.
-void LLVFS::checkMem()
-{
- lockData();
-
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileBlock *block = (*it).second;
- llassert(block->mFileType >= LLAssetType::AT_NONE &&
- block->mFileType < LLAssetType::AT_COUNT &&
- block->mFileID.notNull());
-
- for (std::deque<S32>::iterator iter = mIndexHoles.begin();
- iter != mIndexHoles.end(); ++iter)
- {
- S32 index_loc = *iter;
- if (index_loc == block->mIndexLocation)
- {
- LL_WARNS() << "VFile block " << block->mFileID << ":" << block->mFileType << " is marked as a hole" << LL_ENDL;
- }
- }
- }
-
- LL_INFOS() << "VFS: mem check OK" << LL_ENDL;
-
- unlockData();
-}
-
-void LLVFS::dumpLockCounts()
-{
- S32 i;
- for (i = 0; i < VFSLOCK_COUNT; i++)
- {
- LL_INFOS() << "LockType: " << i << ": " << mLockCounts[i] << LL_ENDL;
- }
-}
-
-void LLVFS::dumpStatistics()
-{
- lockData();
-
- // Investigate file blocks.
- std::map<S32, S32> size_counts;
- std::map<U32, S32> location_counts;
- std::map<LLAssetType::EType, std::pair<S32,S32> > filetype_counts;
-
- S32 max_file_size = 0;
- S32 total_file_size = 0;
- S32 invalid_file_count = 0;
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileBlock *file_block = (*it).second;
- if (file_block->mLength == BLOCK_LENGTH_INVALID)
- {
- invalid_file_count++;
- }
- else if (file_block->mLength <= 0)
- {
- LL_INFOS() << "Bad file block at: " << file_block->mLocation << "\tLength: " << file_block->mLength << "\t" << file_block->mFileID << "\t" << file_block->mFileType << LL_ENDL;
- size_counts[file_block->mLength]++;
- location_counts[file_block->mLocation]++;
- }
- else
- {
- total_file_size += file_block->mLength;
- }
-
- if (file_block->mLength > max_file_size)
- {
- max_file_size = file_block->mLength;
- }
-
- filetype_counts[file_block->mFileType].first++;
- filetype_counts[file_block->mFileType].second += file_block->mLength;
- }
-
- for (std::map<S32,S32>::iterator it = size_counts.begin(); it != size_counts.end(); ++it)
- {
- S32 size = it->first;
- S32 size_count = it->second;
- LL_INFOS() << "Bad files size " << size << " count " << size_count << LL_ENDL;
- }
- for (std::map<U32,S32>::iterator it = location_counts.begin(); it != location_counts.end(); ++it)
- {
- U32 location = it->first;
- S32 location_count = it->second;
- LL_INFOS() << "Bad files location " << location << " count " << location_count << LL_ENDL;
- }
-
- // Investigate free list.
- S32 max_free_size = 0;
- S32 total_free_size = 0;
- std::map<S32, S32> free_length_counts;
- for (blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin(),
- end = mFreeBlocksByLocation.end();
- iter != end; iter++)
- {
- LLVFSBlock *free_block = iter->second;
- if (free_block->mLength <= 0)
- {
- LL_INFOS() << "Bad free block at: " << free_block->mLocation << "\tLength: " << free_block->mLength << LL_ENDL;
- }
- else
- {
- LL_INFOS() << "Block: " << free_block->mLocation
- << "\tLength: " << free_block->mLength
- << "\tEnd: " << free_block->mLocation + free_block->mLength
- << LL_ENDL;
- total_free_size += free_block->mLength;
- }
-
- if (free_block->mLength > max_free_size)
- {
- max_free_size = free_block->mLength;
- }
-
- free_length_counts[free_block->mLength]++;
- }
-
- // Dump histogram of free block sizes
- for (std::map<S32,S32>::iterator it = free_length_counts.begin(); it != free_length_counts.end(); ++it)
- {
- LL_INFOS() << "Free length " << it->first << " count " << it->second << LL_ENDL;
- }
-
- LL_INFOS() << "Invalid blocks: " << invalid_file_count << LL_ENDL;
- LL_INFOS() << "File blocks: " << mFileBlocks.size() << LL_ENDL;
-
- S32 length_list_count = (S32)mFreeBlocksByLength.size();
- S32 location_list_count = (S32)mFreeBlocksByLocation.size();
- if (length_list_count == location_list_count)
- {
- LL_INFOS() << "Free list lengths match, free blocks: " << location_list_count << LL_ENDL;
- }
- else
- {
- LL_WARNS() << "Free list lengths do not match!" << LL_ENDL;
- LL_WARNS() << "By length: " << length_list_count << LL_ENDL;
- LL_WARNS() << "By location: " << location_list_count << LL_ENDL;
- }
- LL_INFOS() << "Max file: " << max_file_size/1024 << "K" << LL_ENDL;
- LL_INFOS() << "Max free: " << max_free_size/1024 << "K" << LL_ENDL;
- LL_INFOS() << "Total file size: " << total_file_size/1024 << "K" << LL_ENDL;
- LL_INFOS() << "Total free size: " << total_free_size/1024 << "K" << LL_ENDL;
- LL_INFOS() << "Sum: " << (total_file_size + total_free_size) << " bytes" << LL_ENDL;
- LL_INFOS() << llformat("%.0f%% full",((F32)(total_file_size)/(F32)(total_file_size+total_free_size))*100.f) << LL_ENDL;
-
- LL_INFOS() << " " << LL_ENDL;
- for (std::map<LLAssetType::EType, std::pair<S32,S32> >::iterator iter = filetype_counts.begin();
- iter != filetype_counts.end(); ++iter)
- {
- LL_INFOS() << "Type: " << LLAssetType::getDesc(iter->first)
- << " Count: " << iter->second.first
- << " Bytes: " << (iter->second.second>>20) << " MB" << LL_ENDL;
- }
-
- // Look for potential merges
- {
- blocks_location_map_t::iterator iter = mFreeBlocksByLocation.begin();
- blocks_location_map_t::iterator end = mFreeBlocksByLocation.end();
- LLVFSBlock *first_block = iter->second;
- while(iter != end)
- {
- if (++iter == end)
- break;
- LLVFSBlock *second_block = iter->second;
- if (first_block->mLocation + first_block->mLength == second_block->mLocation)
- {
- LL_INFOS() << "Potential merge at " << first_block->mLocation << LL_ENDL;
- }
- first_block = second_block;
- }
- }
- unlockData();
-}
-
-// Debug Only!
-std::string get_extension(LLAssetType::EType type)
-{
- std::string extension;
- switch(type)
- {
- case LLAssetType::AT_TEXTURE:
- extension = ".jp2"; // formerly ".j2c"
- break;
- case LLAssetType::AT_SOUND:
- extension = ".ogg";
- break;
- case LLAssetType::AT_SOUND_WAV:
- extension = ".wav";
- break;
- case LLAssetType::AT_TEXTURE_TGA:
- extension = ".tga";
- break;
- case LLAssetType::AT_ANIMATION:
- extension = ".lla";
- break;
- case LLAssetType::AT_MESH:
- extension = ".slm";
- break;
- default:
- // Just use the asset server filename extension in most cases
- extension += ".";
- extension += LLAssetType::lookup(type);
- break;
- }
- return extension;
-}
-
-void LLVFS::listFiles()
-{
- lockData();
-
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileSpecifier file_spec = it->first;
- LLVFSFileBlock *file_block = it->second;
- S32 length = file_block->mLength;
- S32 size = file_block->mSize;
- if (length != BLOCK_LENGTH_INVALID && size > 0)
- {
- LLUUID id = file_spec.mFileID;
- std::string extension = get_extension(file_spec.mFileType);
- LL_INFOS() << " File: " << id
- << " Type: " << LLAssetType::getDesc(file_spec.mFileType)
- << " Size: " << size
- << LL_ENDL;
- }
- }
-
- unlockData();
-}
-
-#include "llapr.h"
-void LLVFS::dumpFiles()
-{
- lockData();
-
- S32 files_extracted = 0;
- for (fileblock_map::iterator it = mFileBlocks.begin(); it != mFileBlocks.end(); ++it)
- {
- LLVFSFileSpecifier file_spec = it->first;
- LLVFSFileBlock *file_block = it->second;
- S32 length = file_block->mLength;
- S32 size = file_block->mSize;
- if (length != BLOCK_LENGTH_INVALID && size > 0)
- {
- LLUUID id = file_spec.mFileID;
- LLAssetType::EType type = file_spec.mFileType;
- std::vector<U8> buffer(size);
-
- unlockData();
- getData(id, type, &buffer[0], 0, size);
- lockData();
-
- std::string extension = get_extension(type);
- std::string filename = id.asString() + extension;
- LL_INFOS() << " Writing " << filename << LL_ENDL;
-
- LLAPRFile outfile;
- outfile.open(filename, LL_APR_WB);
- outfile.write(&buffer[0], size);
- outfile.close();
-
- files_extracted++;
- }
- }
-
- unlockData();
-
- LL_INFOS() << "Extracted " << files_extracted << " files out of " << mFileBlocks.size() << LL_ENDL;
-}
-
-time_t LLVFS::creationTime()
-{
- llstat data_file_stat;
- int errors = LLFile::stat(mDataFilename, &data_file_stat);
- if (0 == errors)
- {
-#if LL_DARWIN
- time_t creation_time = data_file_stat.st_birthtime;
-#else
- time_t creation_time = data_file_stat.st_ctime;
-#endif
- return creation_time;
- }
- return 0;
-}
-
-//============================================================================
-// protected
-//============================================================================
-
-// static
-LLFILE *LLVFS::openAndLock(const std::string& filename, const char* mode, BOOL read_lock)
-{
-#if LL_WINDOWS
-
- return LLFile::_fsopen(filename, mode, (read_lock ? _SH_DENYWR : _SH_DENYRW));
-
-#else
-
- LLFILE *fp;
- int fd;
-
- // first test the lock in a non-destructive way
-#if LL_SOLARIS
- struct flock fl;
- fl.l_whence = SEEK_SET;
- fl.l_start = 0;
- fl.l_len = 1;
-#else // !LL_SOLARIS
- if (strchr(mode, 'w') != NULL)
- {
- fp = LLFile::fopen(filename, "rb"); /* Flawfinder: ignore */
- if (fp)
- {
- fd = fileno(fp);
- if (flock(fd, (read_lock ? LOCK_SH : LOCK_EX) | LOCK_NB) == -1)
- {
- fclose(fp);
- return NULL;
- }
-
- fclose(fp);
- }
- }
-#endif // !LL_SOLARIS
-
- // now actually open the file for use
- fp = LLFile::fopen(filename, mode); /* Flawfinder: ignore */
- if (fp)
- {
- fd = fileno(fp);
-#if LL_SOLARIS
- fl.l_type = read_lock ? F_RDLCK : F_WRLCK;
- if (fcntl(fd, F_SETLK, &fl) == -1)
-#else
- if (flock(fd, (read_lock ? LOCK_SH : LOCK_EX) | LOCK_NB) == -1)
-#endif
- {
- fclose(fp);
- fp = NULL;
- }
- }
-
- return fp;
-
-#endif
-}
-
-// static
-void LLVFS::unlockAndClose(LLFILE *fp)
-{
- if (fp)
- {
- // IW: we don't actually want to unlock on linux
- // this is because a forked process can kill the parent's lock
- // with an explicit unlock
- // however, fclose() will implicitly remove the lock
- // but only once both parent and child have closed the file
- /*
- #if !LL_WINDOWS
- int fd = fileno(fp);
- flock(fd, LOCK_UN);
- #endif
- */
-#if LL_SOLARIS
- struct flock fl;
- fl.l_whence = SEEK_SET;
- fl.l_start = 0;
- fl.l_len = 1;
- fl.l_type = F_UNLCK;
- fcntl(fileno(fp), F_SETLK, &fl);
-#endif
- fclose(fp);
- }
-}
diff --git a/indra/llvfs/llvfs.h b/indra/llvfs/llvfs.h
deleted file mode 100644
index 42feafe20b867a6d37ddd0a3a17b54f4a3c271df..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfs.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/**
- * @file llvfs.h
- * @brief Definition of virtual file system
- *
- * $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$
- */
-
-#ifndef LL_LLVFS_H
-#define LL_LLVFS_H
-
-#include <deque>
-#include "lluuid.h"
-#include "llassettype.h"
-#include "llthread.h"
-#include "llmutex.h"
-
-enum EVFSValid
-{
- VFSVALID_UNKNOWN = 0,
- VFSVALID_OK = 1,
- VFSVALID_BAD_CORRUPT = 2,
- VFSVALID_BAD_CANNOT_OPEN_READONLY = 3,
- VFSVALID_BAD_CANNOT_CREATE = 4
-};
-
-// Lock types for open vfiles, pending async reads, and pending async appends
-// (There are no async normal writes, currently)
-enum EVFSLock
-{
- VFSLOCK_OPEN = 0,
- VFSLOCK_READ = 1,
- VFSLOCK_APPEND = 2,
-
- VFSLOCK_COUNT = 3
-};
-
-// internal classes
-class LLVFSBlock;
-class LLVFSFileBlock;
-class LLVFSFileSpecifier
-{
-public:
- LLVFSFileSpecifier();
- LLVFSFileSpecifier(const LLUUID &file_id, const LLAssetType::EType file_type);
- bool operator<(const LLVFSFileSpecifier &rhs) const;
- bool operator==(const LLVFSFileSpecifier &rhs) const;
-
-public:
- LLUUID mFileID;
- LLAssetType::EType mFileType;
-};
-
-class LLVFS
-{
-private:
- // Use createLLVFS() to open a VFS file
- // Pass 0 to not presize
- LLVFS(const std::string& index_filename,
- const std::string& data_filename,
- const BOOL read_only,
- const U32 presize,
- const BOOL remove_after_crash);
-public:
- ~LLVFS();
-
- // Use this function normally to create LLVFS files
- // Pass 0 to not presize
- static LLVFS * createLLVFS(const std::string& index_filename,
- const std::string& data_filename,
- const BOOL read_only,
- const U32 presize,
- const BOOL remove_after_crash);
-
- BOOL isValid() const { return (VFSVALID_OK == mValid); }
- EVFSValid getValidState() const { return mValid; }
-
- // ---------- The following fucntions lock/unlock mDataMutex ----------
- BOOL getExists(const LLUUID &file_id, const LLAssetType::EType file_type);
- S32 getSize(const LLUUID &file_id, const LLAssetType::EType file_type);
-
- BOOL checkAvailable(S32 max_size);
-
- S32 getMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type);
- BOOL setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type, S32 max_size);
-
- void renameFile(const LLUUID &file_id, const LLAssetType::EType file_type,
- const LLUUID &new_id, const LLAssetType::EType &new_type);
- void removeFile(const LLUUID &file_id, const LLAssetType::EType file_type);
-
- S32 getData(const LLUUID &file_id, const LLAssetType::EType file_type, U8 *buffer, S32 location, S32 length);
- S32 storeData(const LLUUID &file_id, const LLAssetType::EType file_type, const U8 *buffer, S32 location, S32 length);
-
- void incLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
- void decLock(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
- BOOL isLocked(const LLUUID &file_id, const LLAssetType::EType file_type, EVFSLock lock);
- // ----------------------------------------------------------------
-
- // Used to trigger evil WinXP behavior of "preloading" entire file into memory.
- void pokeFiles();
-
- // Verify that the index file contents match the in-memory file structure
- // Very slow, do not call routinely. JC
- void audit();
- // Check for uninitialized blocks. Slow, do not call in release. JC
- void checkMem();
- // for debugging, prints a map of the vfs
- void dumpMap();
- void dumpLockCounts();
- void dumpStatistics();
- void listFiles();
- void dumpFiles();
- time_t creationTime();
-
-protected:
- void removeFileBlock(LLVFSFileBlock *fileblock);
-
- void eraseBlockLength(LLVFSBlock *block);
- void eraseBlock(LLVFSBlock *block);
- void addFreeBlock(LLVFSBlock *block);
- //void mergeFreeBlocks();
- void useFreeSpace(LLVFSBlock *free_block, S32 length);
- void sync(LLVFSFileBlock *block, BOOL remove = FALSE);
- void presizeDataFile(const U32 size);
-
- static LLFILE *openAndLock(const std::string& filename, const char* mode, BOOL read_lock);
- static void unlockAndClose(FILE *fp);
-
- // Can initiate LRU-based file removal to make space.
- // The immune file block will not be removed.
- LLVFSBlock *findFreeBlock(S32 size, LLVFSFileBlock *immune = NULL);
-
- // lock/unlock data mutex (mDataMutex)
- void lockData() { mDataMutex->lock(); }
- void unlockData() { mDataMutex->unlock(); }
-
-protected:
- LLMutex* mDataMutex;
-
- typedef std::map<LLVFSFileSpecifier, LLVFSFileBlock*> fileblock_map;
- fileblock_map mFileBlocks;
-
- typedef std::multimap<S32, LLVFSBlock*> blocks_length_map_t;
- blocks_length_map_t mFreeBlocksByLength;
- typedef std::multimap<U32, LLVFSBlock*> blocks_location_map_t;
- blocks_location_map_t mFreeBlocksByLocation;
-
- LLFILE *mDataFP;
- LLFILE *mIndexFP;
-
- std::deque<S32> mIndexHoles;
-
- std::string mIndexFilename;
- std::string mDataFilename;
- BOOL mReadOnly;
-
- EVFSValid mValid;
-
- S32 mLockCounts[VFSLOCK_COUNT];
- BOOL mRemoveAfterCrash;
-};
-
-extern LLVFS *gVFS;
-
-#endif
diff --git a/indra/llvfs/llvfsthread.cpp b/indra/llvfs/llvfsthread.cpp
deleted file mode 100644
index 8cd85929e2aa8cec6b2e4fa3bdc68a958f34368b..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfsthread.cpp
+++ /dev/null
@@ -1,300 +0,0 @@
-/**
- * @file llvfsthread.cpp
- * @brief LLVFSThread implementation
- *
- * $LicenseInfo:firstyear=2001&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 "llvfsthread.h"
-#include "llstl.h"
-
-//============================================================================
-
-/*static*/ std::string LLVFSThread::sDataPath = "";
-
-/*static*/ LLVFSThread* LLVFSThread::sLocal = NULL;
-
-//============================================================================
-// Run on MAIN thread
-//static
-void LLVFSThread::initClass(bool local_is_threaded)
-{
- llassert(sLocal == NULL);
- sLocal = new LLVFSThread(local_is_threaded);
-}
-
-//static
-S32 LLVFSThread::updateClass(U32 ms_elapsed)
-{
- sLocal->update((F32)ms_elapsed);
- return sLocal->getPending();
-}
-
-//static
-void LLVFSThread::cleanupClass()
-{
- sLocal->setQuitting();
- while (sLocal->getPending())
- {
- sLocal->update(0);
- }
- delete sLocal;
- sLocal = 0;
-}
-
-//----------------------------------------------------------------------------
-
-LLVFSThread::LLVFSThread(bool threaded) :
- LLQueuedThread("VFS", threaded)
-{
-}
-
-LLVFSThread::~LLVFSThread()
-{
- // ~LLQueuedThread() will be called here
-}
-
-//----------------------------------------------------------------------------
-
-LLVFSThread::handle_t LLVFSThread::read(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes, U32 priority, U32 flags)
-{
- handle_t handle = generateHandle();
-
- priority = llmax(priority, (U32)PRIORITY_LOW); // All reads are at least PRIORITY_LOW
- Request* req = new Request(handle, priority, flags, FILE_READ, vfs, file_id, file_type,
- buffer, offset, numbytes);
-
- bool res = addRequest(req);
- if (!res)
- {
- LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
- req->deleteRequest();
- handle = nullHandle();
- }
-
- return handle;
-}
-
-S32 LLVFSThread::readImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes)
-{
- handle_t handle = generateHandle();
-
- Request* req = new Request(handle, PRIORITY_IMMEDIATE, 0, FILE_READ, vfs, file_id, file_type,
- buffer, offset, numbytes);
-
- S32 res = addRequest(req) ? 1 : 0;
- if (res == 0)
- {
- LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
- req->deleteRequest();
- }
- else
- {
- llverify(waitForResult(handle, false) == true);
- res = req->getBytesRead();
- completeRequest(handle);
- }
- return res;
-}
-
-LLVFSThread::handle_t LLVFSThread::write(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes, U32 flags)
-{
- handle_t handle = generateHandle();
-
- Request* req = new Request(handle, 0, flags, FILE_WRITE, vfs, file_id, file_type,
- buffer, offset, numbytes);
-
- bool res = addRequest(req);
- if (!res)
- {
- LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
- req->deleteRequest();
- handle = nullHandle();
- }
-
- return handle;
-}
-
-S32 LLVFSThread::writeImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes)
-{
- handle_t handle = generateHandle();
-
- Request* req = new Request(handle, PRIORITY_IMMEDIATE, 0, FILE_WRITE, vfs, file_id, file_type,
- buffer, offset, numbytes);
-
- S32 res = addRequest(req) ? 1 : 0;
- if (res == 0)
- {
- LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
- req->deleteRequest();
- }
- else
- {
- llverify(waitForResult(handle, false) == true);
- res = req->getBytesRead();
- completeRequest(handle);
- }
- return res;
-}
-
-
-// LLVFSThread::handle_t LLVFSThread::rename(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-// const LLUUID &new_id, const LLAssetType::EType new_type, U32 flags)
-// {
-// handle_t handle = generateHandle();
-
-// LLUUID* new_idp = new LLUUID(new_id); // deleted with Request
-// // new_type is passed as "numbytes"
-// Request* req = new Request(handle, 0, flags, FILE_RENAME, vfs, file_id, file_type,
-// (U8*)new_idp, 0, (S32)new_type);
-
-// bool res = addRequest(req);
-// if (!res)
-// {
-// LL_ERRS() << "LLVFSThread::read called after LLVFSThread::cleanupClass()" << LL_ENDL;
-// req->deleteRequest();
-// handle = nullHandle();
-// }
-
-// return handle;
-// }
-
-//============================================================================
-
-LLVFSThread::Request::Request(handle_t handle, U32 priority, U32 flags,
- operation_t op, LLVFS* vfs,
- const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes) :
- QueuedRequest(handle, priority, flags),
- mOperation(op),
- mVFS(vfs),
- mFileID(file_id),
- mFileType(file_type),
- mBuffer(buffer),
- mOffset(offset),
- mBytes(numbytes),
- mBytesRead(0)
-{
- llassert(mBuffer);
-
- if (numbytes <= 0 && mOperation != FILE_RENAME)
- {
- LL_WARNS() << "LLVFSThread: Request with numbytes = " << numbytes
- << " operation = " << op
- << " offset " << offset
- << " file_type " << file_type << LL_ENDL;
- }
- if (mOperation == FILE_WRITE)
- {
- S32 blocksize = mVFS->getMaxSize(mFileID, mFileType);
- if (blocksize < 0)
- {
- LL_WARNS() << "VFS write to temporary block (shouldn't happen)" << LL_ENDL;
- }
- mVFS->incLock(mFileID, mFileType, VFSLOCK_APPEND);
- }
- else if (mOperation == FILE_RENAME)
- {
- mVFS->incLock(mFileID, mFileType, VFSLOCK_APPEND);
- }
- else // if (mOperation == FILE_READ)
- {
- mVFS->incLock(mFileID, mFileType, VFSLOCK_READ);
- }
-}
-
-// dec locks as soon as a request finishes
-void LLVFSThread::Request::finishRequest(bool completed)
-{
- if (mOperation == FILE_WRITE)
- {
- mVFS->decLock(mFileID, mFileType, VFSLOCK_APPEND);
- }
- else if (mOperation == FILE_RENAME)
- {
- mVFS->decLock(mFileID, mFileType, VFSLOCK_APPEND);
- }
- else // if (mOperation == FILE_READ)
- {
- mVFS->decLock(mFileID, mFileType, VFSLOCK_READ);
- }
-}
-
-void LLVFSThread::Request::deleteRequest()
-{
- if (getStatus() == STATUS_QUEUED)
- {
- LL_ERRS() << "Attempt to delete a queued LLVFSThread::Request!" << LL_ENDL;
- }
- if (mOperation == FILE_WRITE)
- {
- if (mFlags & FLAG_AUTO_DELETE)
- {
- delete [] mBuffer;
- }
- }
- else if (mOperation == FILE_RENAME)
- {
- LLUUID* new_idp = (LLUUID*)mBuffer;
- delete new_idp;
- }
- LLQueuedThread::QueuedRequest::deleteRequest();
-}
-
-bool LLVFSThread::Request::processRequest()
-{
- bool complete = false;
- if (mOperation == FILE_READ)
- {
- llassert(mOffset >= 0);
- mBytesRead = mVFS->getData(mFileID, mFileType, mBuffer, mOffset, mBytes);
- complete = true;
- //LL_INFOS() << llformat("LLVFSThread::READ '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
- }
- else if (mOperation == FILE_WRITE)
- {
- mBytesRead = mVFS->storeData(mFileID, mFileType, mBuffer, mOffset, mBytes);
- complete = true;
- //LL_INFOS() << llformat("LLVFSThread::WRITE '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
- }
- else if (mOperation == FILE_RENAME)
- {
- LLUUID* new_idp = (LLUUID*)mBuffer;
- LLAssetType::EType new_type = (LLAssetType::EType)mBytes;
- mVFS->renameFile(mFileID, mFileType, *new_idp, new_type);
- mFileID = *new_idp;
- complete = true;
- //LL_INFOS() << llformat("LLVFSThread::RENAME '%s': %d bytes arg:%d",getFilename(),mBytesRead) << LL_ENDL;
- }
- else
- {
- LL_ERRS() << llformat("LLVFSThread::unknown operation: %d", mOperation) << LL_ENDL;
- }
- return complete;
-}
-
-//============================================================================
diff --git a/indra/llvfs/llvfsthread.h b/indra/llvfs/llvfsthread.h
deleted file mode 100644
index 7814de4a2d91ae9721a31a3803ed40f4c88b8450..0000000000000000000000000000000000000000
--- a/indra/llvfs/llvfsthread.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * @file llvfsthread.h
- * @brief LLVFSThread definition
- *
- * $LicenseInfo:firstyear=2001&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_LLVFSTHREAD_H
-#define LL_LLVFSTHREAD_H
-
-#include <queue>
-#include <string>
-#include <map>
-#include <set>
-
-#include "llqueuedthread.h"
-
-#include "llvfs.h"
-
-//============================================================================
-
-class LLVFSThread : public LLQueuedThread
-{
- //------------------------------------------------------------------------
-public:
- enum operation_t {
- FILE_READ,
- FILE_WRITE,
- FILE_RENAME
- };
-
- //------------------------------------------------------------------------
-public:
-
- class Request : public QueuedRequest
- {
- protected:
- ~Request() {}; // use deleteRequest()
-
- public:
- Request(handle_t handle, U32 priority, U32 flags,
- operation_t op, LLVFS* vfs,
- const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes);
-
- S32 getBytesRead()
- {
- return mBytesRead;
- }
- S32 getOperation()
- {
- return mOperation;
- }
- U8* getBuffer()
- {
- return mBuffer;
- }
- LLVFS* getVFS()
- {
- return mVFS;
- }
- std::string getFilename()
- {
- std::string tstring;
- mFileID.toString(tstring);
- return tstring;
- }
-
- /*virtual*/ bool processRequest();
- /*virtual*/ void finishRequest(bool completed);
- /*virtual*/ void deleteRequest();
-
- private:
- operation_t mOperation;
-
- LLVFS* mVFS;
- LLUUID mFileID;
- LLAssetType::EType mFileType;
-
- U8* mBuffer; // dest for reads, source for writes, new UUID for rename
- S32 mOffset; // offset into file, -1 = append (WRITE only)
- S32 mBytes; // bytes to read from file, -1 = all (new mFileType for rename)
- S32 mBytesRead; // bytes read from file
- };
-
- //------------------------------------------------------------------------
-public:
- static std::string sDataPath;
- static LLVFSThread* sLocal; // Default worker thread
-
-public:
- LLVFSThread(bool threaded = TRUE);
- ~LLVFSThread();
-
- // Return a Request handle
- handle_t read(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type, /* Flawfinder: ignore */
- U8* buffer, S32 offset, S32 numbytes, U32 pri=PRIORITY_NORMAL, U32 flags = 0);
- handle_t write(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes, U32 flags);
- // SJB: rename seems to have issues, especially when threaded
-// handle_t rename(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
-// const LLUUID &new_id, const LLAssetType::EType new_type, U32 flags);
- // Return number of bytes read
- S32 readImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes);
- S32 writeImmediate(LLVFS* vfs, const LLUUID &file_id, const LLAssetType::EType file_type,
- U8* buffer, S32 offset, S32 numbytes);
-
- /*virtual*/ bool processRequest(QueuedRequest* req);
-
-public:
- static void initClass(bool local_is_threaded = TRUE); // Setup sLocal
- static S32 updateClass(U32 ms_elapsed);
- static void cleanupClass(); // Delete sLocal
- static void setDataPath(const std::string& path) { sDataPath = path; }
-};
-
-//============================================================================
-
-
-#endif // LL_LLVFSTHREAD_H
diff --git a/indra/llwindow/CMakeLists.txt b/indra/llwindow/CMakeLists.txt
index 89204cbb147e9e946e12972d2b821583dd958909..05505d7867855a966ed397f201edd4a18aae9120 100644
--- a/indra/llwindow/CMakeLists.txt
+++ b/indra/llwindow/CMakeLists.txt
@@ -16,7 +16,7 @@ include(LLCommon)
include(LLImage)
include(LLMath)
include(LLRender)
-include(LLVFS)
+include(LLFileSystem)
include(LLWindow)
include(LLXML)
include(UI)
@@ -27,7 +27,7 @@ include_directories(
${LLIMAGE_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
)
@@ -73,7 +73,7 @@ if (LINUX)
${LLIMAGE_LIBRARIES}
${LLMATH_LIBRARIES}
${LLRENDER_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLXML_LIBRARIES}
${UI_LIBRARIES} # for GTK
${SDL_LIBRARIES}
@@ -95,7 +95,7 @@ if (LINUX)
${LLIMAGE_LIBRARIES}
${LLMATH_LIBRARIES}
${LLRENDER_HEADLESS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLWINDOW_HEADLESS_LIBRARIES}
${LLXML_LIBRARIES}
fontconfig # For FCInit and other FC* functions.
diff --git a/indra/llxml/CMakeLists.txt b/indra/llxml/CMakeLists.txt
index 013a422d35b07863647a3d6309cc94db869e571d..3a7a54e51d04402d3fd2481bbbece95299174d41 100644
--- a/indra/llxml/CMakeLists.txt
+++ b/indra/llxml/CMakeLists.txt
@@ -5,13 +5,13 @@ project(llxml)
include(00-Common)
include(LLCommon)
include(LLMath)
-include(LLVFS)
+include(LLFileSystem)
include(LLXML)
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLMATH_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
)
include_directories(
${LLCOMMON_SYSTEM_INCLUDE_DIRS}
@@ -42,7 +42,7 @@ add_library (llxml ${llxml_SOURCE_FILES})
# Libraries on which this library depends, needed for Linux builds
# Sort by high-level to low-level
target_link_libraries( llxml
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLCOMMON_LIBRARIES}
${EXPAT_LIBRARIES}
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 8ed2d096f253aaf3718d12adf0f926ef996c24e2..d8451407390a89287077f78d504b616be538655f 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -39,7 +39,7 @@ include(LLPlugin)
include(LLPrimitive)
include(LLRender)
include(LLUI)
-include(LLVFS)
+include(LLFileSystem)
include(LLWindow)
include(LLXML)
include(NDOF)
@@ -87,7 +87,7 @@ include_directories(
${LLPRIMITIVE_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}
${LLUI_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LLLOGIN_INCLUDE_DIRS}
@@ -2098,7 +2098,7 @@ target_link_libraries(${VIEWER_BINARY_NAME}
${LLRENDER_LIBRARIES}
${FREETYPE_LIBRARIES}
${LLUI_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLWINDOW_LIBRARIES}
${LLXML_LIBRARIES}
${LLMATH_LIBRARIES}
@@ -2590,7 +2590,7 @@ if (LL_TESTS)
set(test_libs
${LLMESSAGE_LIBRARIES}
${WINDOWS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLCOMMON_LIBRARIES}
)
@@ -2604,7 +2604,7 @@ if (LL_TESTS)
set(test_libs
${WINDOWS_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLMATH_LIBRARIES}
${LLCOMMON_LIBRARIES}
${LLMESSAGE_LIBRARIES}
diff --git a/indra/newview/VIEWER_VERSION.txt b/indra/newview/VIEWER_VERSION.txt
index d613169e8896c11271275886f09efa7954d4589f..9cc52c876b3efd56dfe0002e3178b25cd7b1d4db 100644
--- a/indra/newview/VIEWER_VERSION.txt
+++ b/indra/newview/VIEWER_VERSION.txt
@@ -1 +1 @@
-6.4.12
+6.4.15
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 225c20245d1d31e8193071fc8296efaab63a55d7..b105e490aa51c031e5852cc28d2b5edc5661a5bd 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -1685,6 +1685,39 @@
<key>Value</key>
<integer>23</integer>
</map>
+ <key>EnableCacheDebugInfo</key>
+ <map>
+ <key>Comment</key>
+ <string>When set, display additional cache debugging information</string>
+ <key>Persist</key>
+ <integer>1</integer>
+ <key>Type</key>
+ <string>Boolean</string>
+ <key>Value</key>
+ <integer>0</integer>
+ </map>
+ <key>DiskCachePercentOfTotal</key>
+ <map>
+ <key>Comment</key>
+ <string>The percent of total cache size (defined by CacheSize) to use for the disk cache</string>
+ <key>Persist</key>
+ <integer>1</integer>
+ <key>Type</key>
+ <string>F32</string>
+ <key>Value</key>
+ <real>20.0</real>
+ </map>
+ <key>DiskCacheDirName</key>
+ <map>
+ <key>Comment</key>
+ <string>The name of the disk cache (within the standard Viewer disk cache directory)</string>
+ <key>Persist</key>
+ <integer>1</integer>
+ <key>Type</key>
+ <string>String</string>
+ <key>Value</key>
+ <string>cache</string>
+ </map>
<key>CacheLocation</key>
<map>
<key>Comment</key>
@@ -3158,17 +3191,6 @@
<key>Value</key>
<integer>-1</integer>
</map>
- <key>DebugStatModeVFSPendingOps</key>
- <map>
- <key>Comment</key>
- <string>Mode of stat in Statistics floater</string>
- <key>Persist</key>
- <integer>1</integer>
- <key>Type</key>
- <string>S32</string>
- <key>Value</key>
- <integer>-1</integer>
- </map>
<key>DebugStatModeTimeDialation</key>
<map>
<key>Comment</key>
@@ -3961,17 +3983,6 @@
<key>Value</key>
<integer>4</integer>
</map>
- <key>DumpVFSCaches</key>
- <map>
- <key>Comment</key>
- <string>Dump VFS caches on startup.</string>
- <key>Persist</key>
- <integer>1</integer>
- <key>Type</key>
- <string>Boolean</string>
- <key>Value</key>
- <integer>0</integer>
- </map>
<key>DynamicCameraStrength</key>
<map>
<key>Comment</key>
@@ -11936,7 +11947,7 @@
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
- </map>
+ </map>
<key>NearbyListShowMap</key>
<map>
<key>Comment</key>
@@ -14614,28 +14625,6 @@
<key>Value</key>
<string/>
</map>
- <key>VFSOldSize</key>
- <map>
- <key>Comment</key>
- <string>[DO NOT MODIFY] Controls resizing of local file cache</string>
- <key>Persist</key>
- <integer>1</integer>
- <key>Type</key>
- <string>U32</string>
- <key>Value</key>
- <integer>0</integer>
- </map>
- <key>VFSSalt</key>
- <map>
- <key>Comment</key>
- <string>[DO NOT MODIFY] Controls local file caching behavior</string>
- <key>Persist</key>
- <integer>1</integer>
- <key>Type</key>
- <string>U32</string>
- <key>Value</key>
- <integer>1</integer>
- </map>
<key>VelocityInterpolate</key>
<map>
<key>Comment</key>
@@ -16998,7 +16987,7 @@
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
- <integer>1</integer>
+ <integer>1</integer>
</map>
</map>
</llsd>
diff --git a/indra/newview/app_settings/static_data.db2 b/indra/newview/app_settings/static_data.db2
deleted file mode 100644
index f85aa81601787e0643162d85f1086f548577809d..0000000000000000000000000000000000000000
Binary files a/indra/newview/app_settings/static_data.db2 and /dev/null differ
diff --git a/indra/newview/app_settings/static_index.db2 b/indra/newview/app_settings/static_index.db2
deleted file mode 100644
index a5440f96f2b16bd93bb9eeffe561ea1db8b93c25..0000000000000000000000000000000000000000
Binary files a/indra/newview/app_settings/static_index.db2 and /dev/null differ
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 993716f14640ef8f3afed67e1402bdfd79ecf647..7e23a609ac4b93ce543744128541237a922cdd3c 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -98,6 +98,7 @@
#include "lllogininstance.h"
#include "llprogressview.h"
#include "llvocache.h"
+#include "lldiskcache.h"
#include "llvopartgroup.h"
// [SL:KB] - Patch: Appearance-Misc | Checked: 2013-02-12 (Catznip-3.4)
#include "llappearancemgr.h"
@@ -126,8 +127,6 @@
#include "llprimitive.h"
#include "llurlaction.h"
#include "llurlentry.h"
-#include "llvfile.h"
-#include "llvfsthread.h"
#include "llvolumemgr.h"
#include "llxfermanager.h"
#include "llphysicsextensions.h"
@@ -346,9 +345,6 @@ bool gUseWireframe = FALSE;
//use for remember deferred mode in wireframe switch
bool gInitialDeferredModeForWireframe = FALSE;
-// VFS globals - see llappviewer.h
-LLVFS* gStaticVFS = NULL;
-
LLMemoryInfo gSysMemory;
U64Bytes gMemoryAllocated(0); // updated in display_stats() in llviewerdisplay.cpp
@@ -440,12 +436,6 @@ void init_default_trans_args()
default_trans_args.insert("create_account_url");
}
-//----------------------------------------------------------------------------
-// File scope definitons
-const char *VFS_DATA_FILE_BASE = "data.db2.x.";
-const char *VFS_INDEX_FILE_BASE = "index.db2.x.";
-
-
struct SettingsFile : public LLInitParam::Block<SettingsFile>
{
Mandatory<std::string> name;
@@ -979,10 +969,6 @@ bool LLAppViewer::init()
// *Note: this is where gViewerStats used to be created.
- //
- // Initialize the VFS, and gracefully handle initialization errors
- //
-
if (!initCache())
{
LL_WARNS("InitInfo") << "Failed to init cache" << LL_ENDL;
@@ -1377,7 +1363,6 @@ static LLTrace::BlockTimerStatHandle FTM_TEXTURE_CACHE("Texture Cache");
static LLTrace::BlockTimerStatHandle FTM_DECODE("Image Decode");
static LLTrace::BlockTimerStatHandle FTM_FETCH("Image Fetch");
-static LLTrace::BlockTimerStatHandle FTM_VFS("VFS Thread");
static LLTrace::BlockTimerStatHandle FTM_LFS("LFS Thread");
static LLTrace::BlockTimerStatHandle FTM_PAUSE_THREADS("Pause Threads");
static LLTrace::BlockTimerStatHandle FTM_IDLE("Idle");
@@ -1611,10 +1596,6 @@ bool LLAppViewer::doFrame()
work_pending += updateTextureThreads(max_time);
- {
- LL_RECORD_BLOCK_TIME(FTM_VFS);
- io_pending += LLVFSThread::updateClass(1);
- }
{
LL_RECORD_BLOCK_TIME(FTM_LFS);
io_pending += LLLFSThread::updateClass(1);
@@ -1622,7 +1603,7 @@ bool LLAppViewer::doFrame()
if (io_pending > 1000)
{
- ms_sleep(llmin(io_pending/100,100)); // give the vfs some time to catch up
+ ms_sleep(llmin(io_pending/100,100)); // give the lfs some time to catch up
}
total_work_pending += work_pending ;
@@ -1639,7 +1620,6 @@ bool LLAppViewer::doFrame()
}
if(!total_io_pending) //pause file threads if nothing to process.
{
- LLVFSThread::sLocal->pause();
LLLFSThread::sLocal->pause();
}
@@ -1701,12 +1681,11 @@ S32 LLAppViewer::updateTextureThreads(F32 max_time)
return work_pending;
}
-void LLAppViewer::flushVFSIO()
+void LLAppViewer::flushLFSIO()
{
while (1)
{
- S32 pending = LLVFSThread::updateClass(0);
- pending += LLLFSThread::updateClass(0);
+ S32 pending = LLLFSThread::updateClass(0);
if (!pending)
{
break;
@@ -1794,7 +1773,7 @@ bool LLAppViewer::cleanup()
LLKeyframeDataCache::clear();
- // End TransferManager before deleting systems it depends on (Audio, VFS, AssetStorage)
+ // End TransferManager before deleting systems it depends on (Audio, AssetStorage)
#if 0 // this seems to get us stuck in an infinite loop...
gTransferManager.cleanup();
#endif
@@ -1854,8 +1833,8 @@ bool LLAppViewer::cleanup()
LL_INFOS() << "Cache files removed" << LL_ENDL;
- // Wait for any pending VFS IO
- flushVFSIO();
+ // Wait for any pending LFS IO
+ flushLFSIO();
LL_INFOS() << "Shutting down Views" << LL_ENDL;
// Destroy the UI
@@ -1939,15 +1918,6 @@ bool LLAppViewer::cleanup()
SUBSYSTEM_CLEANUP(LLWorldMapView);
SUBSYSTEM_CLEANUP(LLFolderViewItem);
- //
- // Shut down the VFS's AFTER the decode manager cleans up (since it cleans up vfiles).
- // Also after viewerwindow is deleted, since it may have image pointers (which have vfiles)
- // Also after shutting down the messaging system since it has VFS dependencies
-
- //
- LL_INFOS() << "Cleaning up VFS" << LL_ENDL;
- SUBSYSTEM_CLEANUP(LLVFile);
-
LL_INFOS() << "Saving Data" << LL_ENDL;
// Store the time of our current logoff
@@ -2034,7 +2004,6 @@ bool LLAppViewer::cleanup()
pending += LLAppViewer::getTextureCache()->update(1); // unpauses the worker thread
pending += LLAppViewer::getImageDecodeThread()->update(1); // unpauses the image thread
pending += LLAppViewer::getTextureFetch()->update(1); // unpauses the texture fetch thread
- pending += LLVFSThread::updateClass(0);
pending += LLLFSThread::updateClass(0);
F64 idle_time = idleTimer.getElapsedTimeF64();
if(!pending)
@@ -2109,28 +2078,11 @@ bool LLAppViewer::cleanup()
gTextureList.shutdown(); // shutdown again in case a callback added something
LLUIImageList::getInstance()->cleanUp();
- // This should eventually be done in LLAppViewer
SUBSYSTEM_CLEANUP(LLImage);
- SUBSYSTEM_CLEANUP(LLVFSThread);
SUBSYSTEM_CLEANUP(LLLFSThread);
-#ifndef LL_RELEASE_FOR_DOWNLOAD
- LL_INFOS() << "Auditing VFS" << LL_ENDL;
- if(gVFS)
- {
- gVFS->audit();
- }
-#endif
-
LL_INFOS() << "Misc Cleanup" << LL_ENDL;
- // For safety, the LLVFS has to be deleted *after* LLVFSThread. This should be cleaned up.
- // (LLVFS doesn't know about LLVFSThread so can't kill pending requests) -Steve
- delete gStaticVFS;
- gStaticVFS = NULL;
- delete gVFS;
- gVFS = NULL;
-
gSavedSettings.cleanup();
LLUIColorTable::instance().clear();
@@ -2212,7 +2164,6 @@ bool LLAppViewer::initThreads()
LLImage::initClass(gSavedSettings.getBOOL("TextureNewByteRange"),gSavedSettings.getS32("TextureReverseByteRange"));
- LLVFSThread::initClass(enable_threads && false);
LLLFSThread::initClass(enable_threads && false);
// Image decoding
@@ -3258,10 +3209,6 @@ LLSD LLAppViewer::getViewerInfo() const
info["GPU_SHADERS"] = gSavedSettings.getBOOL("RenderDeferred") ? "Enabled" : "Disabled";
info["TEXTURE_MEMORY"] = gSavedSettings.getS32("TextureMemory");
- LLSD substitution;
- substitution["datetime"] = (S32)(gVFS ? gVFS->creationTime() : 0);
- info["VFS_TIME"] = LLTrans::getString("AboutTime", substitution);
-
#if LL_DARWIN
info["HIDPI"] = TRUE;
#endif
@@ -3353,6 +3300,9 @@ LLSD LLAppViewer::getViewerInfo() const
info["SERVER_RELEASE_NOTES_URL"] = mServerReleaseNotesURL;
}
+ // populate field for new local disk cache with some details
+ info["DISK_CACHE_INFO"] = LLDiskCache::getInstance()->getCacheInfo();
+
return info;
}
@@ -3989,7 +3939,7 @@ void LLAppViewer::forceQuit()
void LLAppViewer::fastQuit(S32 error_code)
{
// finish pending transfers
- flushVFSIO();
+ flushLFSIO();
// let sim know we're logging out
sendLogoutRequest();
// flush network buffers by shutting down messaging system
@@ -4181,39 +4131,6 @@ void LLAppViewer::migrateCacheDirectory()
#endif // LL_WINDOWS || LL_DARWIN
}
-void dumpVFSCaches()
-{
- LL_INFOS() << "======= Static VFS ========" << LL_ENDL;
- gStaticVFS->listFiles();
-#if LL_WINDOWS
- LL_INFOS() << "======= Dumping static VFS to StaticVFSDump ========" << LL_ENDL;
- WCHAR w_str[MAX_PATH];
- GetCurrentDirectory(MAX_PATH, w_str);
- S32 res = LLFile::mkdir("StaticVFSDump");
- if (res == -1)
- {
- LL_WARNS() << "Couldn't create dir StaticVFSDump" << LL_ENDL;
- }
- SetCurrentDirectory(ll_convert_string_to_wide("StaticVFSDump").c_str());
- gStaticVFS->dumpFiles();
- SetCurrentDirectory(w_str);
-#endif
-
- LL_INFOS() << "========= Dynamic VFS ====" << LL_ENDL;
- gVFS->listFiles();
-#if LL_WINDOWS
- LL_INFOS() << "========= Dumping dynamic VFS to VFSDump ====" << LL_ENDL;
- res = LLFile::mkdir("VFSDump");
- if (res == -1)
- {
- LL_WARNS() << "Couldn't create dir VFSDump" << LL_ENDL;
- }
- SetCurrentDirectory(ll_convert_string_to_wide("VFSDump").c_str());
- gVFS->dumpFiles();
- SetCurrentDirectory(w_str);
-#endif
-}
-
//static
U32 LLAppViewer::getTextureCacheVersion()
{
@@ -4240,6 +4157,19 @@ bool LLAppViewer::initCache()
LLAppViewer::getTextureCache()->setReadOnly(read_only) ;
LLVOCache::initParamSingleton(read_only);
+ // initialize the new disk cache using saved settings
+ const std::string cache_dir_name = gSavedSettings.getString("DiskCacheDirName");
+
+ // note that the maximum size of this cache is defined as a percentage of the
+ // total cache size - the 'CacheSize' pref - for all caches.
+ const unsigned int cache_total_size_mb = gSavedSettings.getU32("CacheSize");
+ const double disk_cache_percent = gSavedSettings.getF32("DiskCachePercentOfTotal");
+ const unsigned int disk_cache_mb = cache_total_size_mb * disk_cache_percent / 100;
+ const unsigned int disk_cache_bytes = disk_cache_mb * 1024 * 1024;
+ const bool enable_cache_debug_info = gSavedSettings.getBOOL("EnableDiskCacheDebugInfo");
+ const std::string cache_dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, cache_dir_name);
+ LLDiskCache::initParamSingleton(cache_dir, disk_cache_bytes, enable_cache_debug_info);
+
bool texture_cache_mismatch = false;
if (gSavedSettings.getS32("LocalCacheVersion") != LLAppViewer::getTextureCacheVersion())
{
@@ -4286,10 +4216,21 @@ bool LLAppViewer::initCache()
gSavedSettings.setString("CacheLocationTopFolder", "");
}
- if (mPurgeCache && !read_only)
+ if (!read_only)
{
- LLSplashScreen::update(LLTrans::getString("StartupClearingCache"));
- purgeCache();
+ if (mPurgeCache)
+ {
+ LLSplashScreen::update(LLTrans::getString("StartupClearingCache"));
+ purgeCache();
+
+ // clear the new C++ file system based cache
+ LLDiskCache::getInstance()->clearCache();
+ }
+ else
+ {
+ // purge excessive files from the new file system based cache
+ LLDiskCache::getInstance()->purge();
+ }
}
LLSplashScreen::update(LLTrans::getString("StartupInitializingTextureCache"));
@@ -4299,172 +4240,18 @@ bool LLAppViewer::initCache()
const S32 MB = 1024 * 1024;
const S64 MIN_CACHE_SIZE = 256 * MB;
const S64 MAX_CACHE_SIZE = 9984ll * MB;
- const S64 MAX_VFS_SIZE = 1024 * MB; // 1 GB
S64 cache_size = (S64)(gSavedSettings.getU32("CacheSize")) * MB;
cache_size = llclamp(cache_size, MIN_CACHE_SIZE, MAX_CACHE_SIZE);
- S64 vfs_size = llmin((S64)((cache_size * 2) / 10), MAX_VFS_SIZE);
- S64 texture_cache_size = cache_size - vfs_size;
+ S64 texture_cache_size = cache_size;
S64 extra = LLAppViewer::getTextureCache()->initCache(LL_PATH_CACHE, texture_cache_size, texture_cache_mismatch);
texture_cache_size -= extra;
-
LLVOCache::getInstance()->initCache(LL_PATH_CACHE, gSavedSettings.getU32("CacheNumberOfRegionsForObjects"), getObjectCacheVersion());
- LLSplashScreen::update(LLTrans::getString("StartupInitializingVFS"));
-
- // Init the VFS
- vfs_size = llmin(vfs_size + extra, MAX_VFS_SIZE);
- vfs_size = (vfs_size / MB) * MB; // make sure it is MB aligned
- U32 vfs_size_u32 = (U32)vfs_size;
- U32 old_vfs_size = gSavedSettings.getU32("VFSOldSize") * MB;
- bool resize_vfs = (vfs_size_u32 != old_vfs_size);
- if (resize_vfs)
- {
- gSavedSettings.setU32("VFSOldSize", vfs_size_u32 / MB);
- }
- LL_INFOS("AppCache") << "VFS CACHE SIZE: " << vfs_size / (1024*1024) << " MB" << LL_ENDL;
-
- // This has to happen BEFORE starting the vfs
- // time_t ltime;
- srand(time(NULL)); // Flawfinder: ignore
- U32 old_salt = gSavedSettings.getU32("VFSSalt");
- U32 new_salt;
- std::string old_vfs_data_file;
- std::string old_vfs_index_file;
- std::string new_vfs_data_file;
- std::string new_vfs_index_file;
- std::string static_vfs_index_file;
- std::string static_vfs_data_file;
-
- if (gSavedSettings.getBOOL("AllowMultipleViewers"))
- {
- // don't mess with renaming the VFS in this case
- new_salt = old_salt;
- }
- else
- {
- do
- {
- new_salt = ll_rand(S32_MAX);
- } while(new_salt == old_salt);
- }
-
- old_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_DATA_FILE_BASE) + llformat("%u", old_salt);
-
- // make sure this file exists
- llstat s;
- S32 stat_result = LLFile::stat(old_vfs_data_file, &s);
- if (stat_result)
- {
- // doesn't exist, look for a data file
- std::string mask;
- mask = VFS_DATA_FILE_BASE;
- mask += "*";
-
- std::string dir;
- dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
-
- std::string found_file;
- LLDirIterator iter(dir, mask);
- if (iter.next(found_file))
- {
- old_vfs_data_file = gDirUtilp->add(dir, found_file);
-
- size_t start_pos = found_file.find_last_of('.');
- if (start_pos != std::string::npos && start_pos > 0)
- {
- sscanf(found_file.substr(start_pos+1).c_str(), "%d", &old_salt);
- }
- LL_DEBUGS("AppCache") << "Default vfs data file not present, found: " << old_vfs_data_file << " Old salt: " << old_salt << LL_ENDL;
- }
- }
-
- old_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE) + llformat("%u", old_salt);
-
- stat_result = LLFile::stat(old_vfs_index_file, &s);
- if (stat_result)
- {
- // We've got a bad/missing index file, nukem!
- LL_WARNS("AppCache") << "Bad or missing vfx index file " << old_vfs_index_file << LL_ENDL;
- LL_WARNS("AppCache") << "Removing old vfs data file " << old_vfs_data_file << LL_ENDL;
- LLFile::remove(old_vfs_data_file);
- LLFile::remove(old_vfs_index_file);
-
- // Just in case, nuke any other old cache files in the directory.
- std::string dir;
- dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "");
-
- std::string mask;
- mask = VFS_DATA_FILE_BASE;
- mask += "*";
-
- gDirUtilp->deleteFilesInDir(dir, mask);
-
- mask = VFS_INDEX_FILE_BASE;
- mask += "*";
-
- gDirUtilp->deleteFilesInDir(dir, mask);
- }
-
- new_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_DATA_FILE_BASE) + llformat("%u", new_salt);
- new_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE) + llformat("%u", new_salt);
-
- static_vfs_data_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "static_data.db2");
- static_vfs_index_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "static_index.db2");
-
- if (resize_vfs)
- {
- LL_DEBUGS("AppCache") << "Removing old vfs and re-sizing" << LL_ENDL;
-
- LLFile::remove(old_vfs_data_file);
- LLFile::remove(old_vfs_index_file);
- }
- else if (old_salt != new_salt)
- {
- // move the vfs files to a new name before opening
- LL_DEBUGS("AppCache") << "Renaming " << old_vfs_data_file << " to " << new_vfs_data_file << LL_ENDL;
- LL_DEBUGS("AppCache") << "Renaming " << old_vfs_index_file << " to " << new_vfs_index_file << LL_ENDL;
- LLFile::rename(old_vfs_data_file, new_vfs_data_file);
- LLFile::rename(old_vfs_index_file, new_vfs_index_file);
- }
-
- // Startup the VFS...
- gSavedSettings.setU32("VFSSalt", new_salt);
-
- // Don't remove VFS after viewer crashes. If user has corrupt data, they can reinstall. JC
- gVFS = LLVFS::createLLVFS(new_vfs_index_file, new_vfs_data_file, false, vfs_size_u32, false);
- if (!gVFS)
- {
- return false;
- }
-
- gStaticVFS = LLVFS::createLLVFS(static_vfs_index_file, static_vfs_data_file, true, 0, false);
- if (!gStaticVFS)
- {
- return false;
- }
-
- BOOL success = gVFS->isValid() && gStaticVFS->isValid();
- if (!success)
- {
- return false;
- }
- else
- {
- LLVFile::initClass();
-
-#ifndef LL_RELEASE_FOR_DOWNLOAD
- if (gSavedSettings.getBOOL("DumpVFSCaches"))
- {
- dumpVFSCaches();
- }
-#endif
-
- return true;
- }
+ return true;
}
void LLAppViewer::addOnIdleCallback(const boost::function<void()>& cb)
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index 5332fe2deba5111e2a71cdcd248865b0cb5472e2..902b94d495219a34729fc7b3a85bfaa32dbbbe8d 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -1,4 +1,5 @@
/**
+ * @mainpage
* @mainpage
*
* This is the sources for the Second Life Viewer;
@@ -82,7 +83,7 @@ class LLAppViewer : public LLApp
virtual bool frame(); // Override for application body logic
// Application control
- void flushVFSIO(); // waits for vfs transfers to complete
+ void flushLFSIO(); // waits for lfs transfers to complete
void forceQuit(); // Puts the viewer into 'shutting down without error' mode.
void fastQuit(S32 error_code = 0); // Shuts down the viewer immediately after sending a logout message
void requestQuit(); // Request a quit. A kinder, gentler quit.
@@ -381,12 +382,6 @@ extern BOOL gRestoreGL;
extern bool gUseWireframe;
extern bool gInitialDeferredModeForWireframe;
-// VFS globals - gVFS is for general use
-// gStaticVFS is read-only and is shipped w/ the viewer
-// it has pre-cache data like the UI .TGAs
-class LLVFS;
-extern LLVFS *gStaticVFS;
-
extern LLMemoryInfo gSysMemory;
extern U64Bytes gMemoryAllocated;
diff --git a/indra/newview/llappviewerwin32.cpp b/indra/newview/llappviewerwin32.cpp
index 7c104ab690942f55afff3316e7188184fe0501e6..f2f1f38bfb69e7d46a2c11658413695fdb98c6b4 100644
--- a/indra/newview/llappviewerwin32.cpp
+++ b/indra/newview/llappviewerwin32.cpp
@@ -504,7 +504,7 @@ void LLAppViewerWin32::disableWinErrorReporting()
}
}
-const S32 MAX_CONSOLE_LINES = 500;
+const S32 MAX_CONSOLE_LINES = 7500;
// Only defined in newer SDKs than we currently use
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 4
diff --git a/indra/newview/llcompilequeue.cpp b/indra/newview/llcompilequeue.cpp
index 3b086c4cf5ab11a228b3c156056cccb2f432709a..4155dc76e6bd30016a9d11481cdd422bcba4c14a 100644
--- a/indra/newview/llcompilequeue.cpp
+++ b/indra/newview/llcompilequeue.cpp
@@ -53,7 +53,7 @@
#include "lldir.h"
#include "llnotificationsutil.h"
#include "llviewerstats.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "lluictrlfactory.h"
#include "lltrans.h"
@@ -117,7 +117,7 @@ namespace
}
// *NOTE$: A minor specialization of LLScriptAssetUpload, it does not require a buffer
-// (and does not save a buffer to the vFS) and it finds the compile queue window and
+// (and does not save a buffer to the cache) and it finds the compile queue window and
// displays a compiling message.
class LLQueuedScriptAssetUpload : public LLScriptAssetUpload
{
@@ -135,8 +135,8 @@ class LLQueuedScriptAssetUpload : public LLScriptAssetUpload
virtual LLSD prepareUpload()
{
/* *NOTE$: The parent class (LLScriptAssetUpload will attempt to save
- * the script buffer into to the VFS. Since the resource is already in
- * the VFS we don't want to do that. Just put a compiling message in
+ * the script buffer into to the cache. Since the resource is already in
+ * the cache we don't want to do that. Just put a compiling message in
* the window and move on
*/
LLFloaterCompileQueue* queue = LLFloaterReg::findTypedInstance<LLFloaterCompileQueue>("compile_queue", LLSD(mQueueId));
@@ -284,11 +284,11 @@ void LLFloaterCompileQueue::handleHTTPResponse(std::string pumpName, const LLSD
LLEventPumps::instance().post(pumpName, expresult);
}
-// *TODO: handleSCriptRetrieval is passed into the VFS via a legacy C function pointer
+// *TODO: handleSCriptRetrieval is passed into the cache via a legacy C function pointer
// future project would be to convert these to C++ callables (std::function<>) so that
// we can use bind and remove the userData parameter.
//
-void LLFloaterCompileQueue::handleScriptRetrieval(LLVFS *vfs, const LLUUID& assetId,
+void LLFloaterCompileQueue::handleScriptRetrieval(const LLUUID& assetId,
LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus)
{
LLSD result(LLSD::emptyMap());
diff --git a/indra/newview/llcompilequeue.h b/indra/newview/llcompilequeue.h
index 0ed3b62e10133a7d0c1b838a71461122dfc3e4d5..2d0886c3da64ee4c77907d464be7881845cab5d2 100644
--- a/indra/newview/llcompilequeue.h
+++ b/indra/newview/llcompilequeue.h
@@ -136,7 +136,7 @@ class LLFloaterCompileQueue final : public LLFloaterScriptQueue
//bool checkAssetId(const LLUUID &assetId);
static void handleHTTPResponse(std::string pumpName, const LLSD &expresult);
- static void handleScriptRetrieval(LLVFS *vfs, const LLUUID& assetId, LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus);
+ static void handleScriptRetrieval(const LLUUID& assetId, LLAssetType::EType type, void* userData, S32 status, LLExtStat extStatus);
private:
static void processExperienceIdResults(LLSD result, LLUUID parent);
diff --git a/indra/newview/llcontrolavatar.cpp b/indra/newview/llcontrolavatar.cpp
index 9c7c0414640c15127f8660f916f4de0098d80817..c1e322ddda27b3f4d5e8dedf59c0bda40d34f42d 100644
--- a/indra/newview/llcontrolavatar.cpp
+++ b/indra/newview/llcontrolavatar.cpp
@@ -78,6 +78,24 @@ void LLControlAvatar::initInstance()
mInitFlags |= 1<<4;
}
+const LLVOAvatar *LLControlAvatar::getAttachedAvatar() const
+{
+ if (mRootVolp && mRootVolp->isAttachment())
+ {
+ return mRootVolp->getAvatarAncestor();
+ }
+ return NULL;
+}
+
+LLVOAvatar *LLControlAvatar::getAttachedAvatar()
+{
+ if (mRootVolp && mRootVolp->isAttachment())
+ {
+ return mRootVolp->getAvatarAncestor();
+ }
+ return NULL;
+}
+
void LLControlAvatar::getNewConstraintFixups(LLVector3& new_pos_fixup, F32& new_scale_fixup) const
{
static const LLCachedControl<F32> max_legal_offset_cc(gSavedSettings, "AnimatedObjectsMaxLegalOffset", MAX_LEGAL_OFFSET);
@@ -164,7 +182,7 @@ void LLControlAvatar::matchVolumeTransform()
if (mRootVolp->isAttachment())
{
- LLVOAvatar *attached_av = mRootVolp->getAvatarAncestor();
+ LLVOAvatar *attached_av = getAttachedAvatar();
if (attached_av)
{
LLViewerJointAttachment *attach = attached_av->getTargetAttachmentPoint(mRootVolp);
@@ -359,7 +377,34 @@ void LLControlAvatar::idleUpdate(LLAgent &agent, const F64 &time)
}
}
-BOOL LLControlAvatar::updateCharacter(LLAgent &agent)
+bool LLControlAvatar::computeNeedsUpdate()
+{
+ computeUpdatePeriod();
+
+ // Animesh attachments are a special case. Should have the same update cadence as their attached parent avatar.
+ LLVOAvatar *attached_av = getAttachedAvatar();
+ if (attached_av)
+ {
+ // Have to run computeNeedsUpdate() for attached av in
+ // case it hasn't run updateCharacter() already this
+ // frame. Note this means that the attached av will
+ // run computeNeedsUpdate() multiple times per frame
+ // if it has animesh attachments. Results will be
+ // consistent except for the corner case of exceeding
+ // MAX_IMPOSTOR_INTERVAL in one call but not another,
+ // which should be rare.
+ attached_av->computeNeedsUpdate();
+ mNeedsImpostorUpdate = attached_av->mNeedsImpostorUpdate;
+ if (mNeedsImpostorUpdate)
+ {
+ mLastImpostorUpdateReason = 12;
+ }
+ return mNeedsImpostorUpdate;
+ }
+ return LLVOAvatar::computeNeedsUpdate();
+}
+
+bool LLControlAvatar::updateCharacter(LLAgent &agent)
{
return LLVOAvatar::updateCharacter(agent);
}
@@ -633,29 +678,23 @@ std::string LLControlAvatar::getFullname() const
// virtual
bool LLControlAvatar::shouldRenderRigged() const
{
- if (mRootVolp && mRootVolp->isAttachment())
- {
- LLVOAvatar *attached_av = mRootVolp->getAvatarAncestor();
- if (attached_av)
- {
- return attached_av->shouldRenderRigged();
- }
- }
+ const LLVOAvatar *attached_av = getAttachedAvatar();
+ if (attached_av)
+ {
+ return attached_av->shouldRenderRigged();
+ }
return true;
}
// virtual
BOOL LLControlAvatar::isImpostor()
{
- if (mRootVolp && mRootVolp->isAttachment())
- {
- // Attached animated objects should match state of their attached av.
- LLVOAvatar *attached_av = mRootVolp->getAvatarAncestor();
- if (attached_av)
- {
- return attached_av->isImpostor();
- }
- }
+ // Attached animated objects should match state of their attached av.
+ LLVOAvatar *attached_av = getAttachedAvatar();
+ if (attached_av)
+ {
+ return attached_av->isImpostor();
+ }
return LLVOAvatar::isImpostor();
}
diff --git a/indra/newview/llcontrolavatar.h b/indra/newview/llcontrolavatar.h
index eac25600ab784e2ec977294dbc69ba287509ff75..3afbf323f0f9d2444b808833a3546042afcc7465 100644
--- a/indra/newview/llcontrolavatar.h
+++ b/indra/newview/llcontrolavatar.h
@@ -40,6 +40,10 @@ class LLControlAvatar final :
virtual void initInstance(); // Called after construction to initialize the class.
virtual ~LLControlAvatar();
+ // If this is an attachment, return the avatar it is attached to. Otherwise NULL.
+ virtual const LLVOAvatar *getAttachedAvatar() const;
+ virtual LLVOAvatar *getAttachedAvatar();
+
void getNewConstraintFixups(LLVector3& new_pos_constraint, F32& new_scale_constraint) const;
void matchVolumeTransform();
void updateVolumeGeom();
@@ -53,7 +57,8 @@ class LLControlAvatar final :
void markForDeath();
virtual void idleUpdate(LLAgent &agent, const F64 &time);
- virtual BOOL updateCharacter(LLAgent &agent);
+ virtual bool computeNeedsUpdate();
+ virtual bool updateCharacter(LLAgent &agent);
void getAnimatedVolumes(std::vector<LLVOVolume*>& volumes);
void updateAnimations();
diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp
index da89311b8ecb441f4e9dfd670857317fb212fcf4..54de95d445ddf703247ec39ac1c3a9ff0a157fe4 100644
--- a/indra/newview/lldrawable.cpp
+++ b/indra/newview/lldrawable.cpp
@@ -1486,7 +1486,7 @@ void LLSpatialBridge::setVisible(LLCamera& camera_in, std::vector<LLDrawable*>*
LLVOAvatar* avatarp = (LLVOAvatar*) objparent;
if (avatarp->isVisible())
{
- impostor = objparent->isAvatar() && ((LLVOAvatar*) objparent)->isImpostor();
+ impostor = objparent->isAvatar() && !LLPipeline::sImpostorRender && ((LLVOAvatar*) objparent)->isImpostor();
loaded = objparent->isAvatar() && ((LLVOAvatar*) objparent)->isFullyLoaded();
}
else
@@ -1570,7 +1570,8 @@ void LLSpatialBridge::updateDistance(LLCamera& camera_in, bool force_update)
if (mDrawable->getVObj())
{
- if (mDrawable->getVObj()->isAttachment())
+ // Don't update if we are part of impostor, unles it's an impostor pass
+ if (!LLPipeline::sImpostorRender && mDrawable->getVObj()->isAttachment())
{
LLDrawable* parent = mDrawable->getParent();
if (parent && parent->getVObj())
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index c48ec6b6a347e8c561ae3d68e919f171e5e13c1f..362b873348d5e3387fc0bab4ce2b5154ed0b44c9 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -588,12 +588,12 @@ void LLDrawPoolAvatar::renderShadow(S32 pass)
{
return;
}
-
- BOOL impostor = avatarp->isImpostor();
- if (impostor
- && LLVOAvatar::AV_DO_NOT_RENDER != avatarp->getVisualMuteSettings()
- && LLVOAvatar::AV_ALWAYS_RENDER != avatarp->getVisualMuteSettings())
+ LLVOAvatar::AvatarOverallAppearance oa = avatarp->getOverallAppearance();
+ BOOL impostor = !LLPipeline::sImpostorRender && avatarp->isImpostor();
+ if (oa == LLVOAvatar::AOA_INVISIBLE ||
+ (impostor && oa == LLVOAvatar::AOA_JELLYDOLL))
{
+ // No shadows for jellydolled or invisible avs.
return;
}
@@ -1473,7 +1473,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
return;
}
- LLVOAvatar *avatarp;
+ LLVOAvatar *avatarp = NULL;
if (single_avatar)
{
@@ -1519,11 +1519,12 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
return;
}
- BOOL impostor = avatarp->isImpostor() && !single_avatar;
+ BOOL impostor = !LLPipeline::sImpostorRender && avatarp->isImpostor() && !single_avatar;
if (( avatarp->isInMuteList()
|| impostor
- || (LLVOAvatar::AV_DO_NOT_RENDER == avatarp->getVisualMuteSettings() && !avatarp->needsImpostorUpdate()) ) && pass != 0)
+ || (LLVOAvatar::AOA_NORMAL != avatarp->getOverallAppearance() && !avatarp->needsImpostorUpdate()) ) && pass != 0)
+// || (LLVOAvatar::AV_DO_NOT_RENDER == avatarp->getVisualMuteSettings() && !avatarp->needsImpostorUpdate()) ) && pass != 0)
{ //don't draw anything but the impostor for impostored avatars
return;
}
@@ -1533,6 +1534,13 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
return;
}
+ LLVOAvatar *attached_av = avatarp->getAttachedAvatar();
+ if (attached_av && LLVOAvatar::AOA_NORMAL != attached_av->getOverallAppearance())
+ {
+ // Animesh attachment of a jellydolled or invisible parent - don't show
+ return;
+ }
+
if (pass == 0)
{
if (!LLPipeline::sReflectionRender)
@@ -1540,7 +1548,8 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
LLVOAvatar::sNumVisibleAvatars++;
}
- if (impostor || (LLVOAvatar::AV_DO_NOT_RENDER == avatarp->getVisualMuteSettings() && !avatarp->needsImpostorUpdate()))
+// if (impostor || (LLVOAvatar::AV_DO_NOT_RENDER == avatarp->getVisualMuteSettings() && !avatarp->needsImpostorUpdate()))
+ if (impostor || (LLVOAvatar::AOA_NORMAL != avatarp->getOverallAppearance() && !avatarp->needsImpostorUpdate()))
{
if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && avatarp->mImpostor.isComplete())
{
diff --git a/indra/newview/llfilepicker.h b/indra/newview/llfilepicker.h
index be66a448b9d4bc2ed26e63fdc58681b3d05dfc87..4647ca949855f265a6194b8773318d13a6820c16 100644
--- a/indra/newview/llfilepicker.h
+++ b/indra/newview/llfilepicker.h
@@ -139,7 +139,7 @@ class LLFilePicker
S32 getFileCount() const { return (S32)mFiles.size(); }
- // See llvfs/lldir.h : getBaseFileName and getDirName to extract base or directory names
+ // see lldir.h : getBaseFileName and getDirName to extract base or directory names
// clear any lists of buffers or whatever, and make sure the file
// picker isn't locked.
diff --git a/indra/newview/llfloaterauction.cpp b/indra/newview/llfloaterauction.cpp
index 957b2e1e8ef008d21980b77b1b09bebc653b5865..9813156bf2b7b3c42a5919b9e2237e8d9595b629 100644
--- a/indra/newview/llfloaterauction.cpp
+++ b/indra/newview/llfloaterauction.cpp
@@ -32,8 +32,7 @@
#include "llimagej2c.h"
#include "llimagetga.h"
#include "llparcel.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "llwindow.h"
#include "message.h"
@@ -202,7 +201,9 @@ void LLFloaterAuction::onClickSnapshot(void* data)
LLPointer<LLImageTGA> tga = new LLImageTGA;
tga->encode(raw);
- LLVFile::writeFile(tga->getData(), tga->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_IMAGE_TGA);
+
+ LLFileSystem tga_file(self->mImageID, LLAssetType::AT_IMAGE_TGA, LLFileSystem::WRITE);
+ tga_file.write(tga->getData(), tga->getDataSize());
raw->biasedScaleToPowerOfTwo(LLViewerTexture::MAX_IMAGE_SIZE_DEFAULT);
@@ -210,7 +211,9 @@ void LLFloaterAuction::onClickSnapshot(void* data)
LLPointer<LLImageJ2C> j2c = new LLImageJ2C;
j2c->encode(raw, 0.0f);
- LLVFile::writeFile(j2c->getData(), j2c->getDataSize(), gVFS, self->mImageID, LLAssetType::AT_TEXTURE);
+
+ LLFileSystem j2c_file(self->mImageID, LLAssetType::AT_TEXTURE, LLFileSystem::WRITE);
+ j2c_file.write(j2c->getData(), j2c->getDataSize());
self->mImage = LLViewerTextureManager::getLocalTexture((LLImageRaw*)raw, FALSE);
gGL.getTexUnit(0)->bind(self->mImage);
diff --git a/indra/newview/llfloaterbvhpreview.cpp b/indra/newview/llfloaterbvhpreview.cpp
index d2e2e03c84ef61cd1e3f1f796dbb08d7cf5529b0..80a49b6731c6ef58d3de09ae4ab4fd9895b0ce3d 100644
--- a/indra/newview/llfloaterbvhpreview.cpp
+++ b/indra/newview/llfloaterbvhpreview.cpp
@@ -32,7 +32,7 @@
#include "lldatapacker.h"
#include "lldir.h"
#include "llnotificationsutil.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llapr.h"
#include "llstring.h"
@@ -997,10 +997,9 @@ void LLFloaterBvhPreview::onBtnOK(void* userdata)
LLDataPackerBinaryBuffer dp(buffer, file_size);
if (motionp->serialize(dp))
{
- LLVFile file(gVFS, motionp->getID(), LLAssetType::AT_ANIMATION, LLVFile::APPEND);
+ LLFileSystem file(motionp->getID(), LLAssetType::AT_ANIMATION, LLFileSystem::APPEND);
S32 size = dp.getCurrentSize();
- file.setMaxSize(size);
if (file.write((U8*)buffer, size))
{
std::string name = floaterp->getChild<LLUICtrl>("name_form")->getValue().asString();
diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp
index 318197e61d7f8ca476ada29196a71332f7314511..eda380c367f5a182e48b8d5e61e0e34f0ccb203d 100644
--- a/indra/newview/llfloatermodelpreview.cpp
+++ b/indra/newview/llfloatermodelpreview.cpp
@@ -59,6 +59,7 @@
#include "llspinctrl.h"
#include "lltabcontainer.h"
#include "lltrans.h"
+#include "llfilesystem.h"
#include "llcallbacklist.h"
#include "llviewertexteditor.h"
#include "llviewernetwork.h"
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 8104526f7edf07f8533c82cb63873a90ddaa2c26..10141fb12be84682de8cd8d0af91f4c0c6c8076b 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -1764,7 +1764,7 @@ void LLAvatarComplexityControls::setIndirectMaxNonImpostors()
{
U32 max_non_impostors = gSavedSettings.getU32("RenderAvatarMaxNonImpostors");
// for this one, we just need to make zero, which means off, the max value of the slider
- U32 indirect_max_non_impostors = (0 == max_non_impostors) ? LLVOAvatar::IMPOSTORS_OFF : max_non_impostors;
+ U32 indirect_max_non_impostors = (0 == max_non_impostors) ? LLVOAvatar::NON_IMPOSTORS_MAX_SLIDER : max_non_impostors;
gSavedSettings.setU32("IndirectMaxNonImpostors", indirect_max_non_impostors);
}
@@ -2266,7 +2266,7 @@ void LLFloaterPreferenceGraphicsAdvanced::updateMaxNonImpostors()
LLSliderCtrl* ctrl = getChild<LLSliderCtrl>("IndirectMaxNonImpostors",true);
U32 value = ctrl->getValue().asInteger();
- if (0 == value || LLVOAvatar::IMPOSTORS_OFF <= value)
+ if (0 == value || LLVOAvatar::NON_IMPOSTORS_MAX_SLIDER <= value)
{
value=0;
}
diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h
index e30c0931c109dfbde2a8ec79d95e3fcbeef4e3cf..73dfabdf9e0fca017fd6bb04056491a3f5f41697 100644
--- a/indra/newview/llfloaterpreference.h
+++ b/indra/newview/llfloaterpreference.h
@@ -108,7 +108,7 @@ class LLFloaterPreference final : public LLFloater, public LLAvatarPropertiesObs
void onBtnOK(const LLSD& userdata);
void onBtnCancel(const LLSD& userdata);
- void onClickClearCache(); // Clear viewer texture cache, vfs, and VO cache on next startup
+ void onClickClearCache(); // Clear viewer texture cache, file cache on next startup
void onClickBrowserClearCache(); // Clear web history and caches as well as viewer caches above
void onLanguageChange();
void onNotificationsChange(const std::string& OptionName);
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index 98091aa8ca0e2f3b1e19d8a90fdf1cbb1d610a24..db3c56f6a591a8fda4c09f2b738a5e8f461093d0 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -36,7 +36,7 @@
#include "llglheaders.h"
#include "llregionflags.h"
#include "llstl.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llxfermanager.h"
#include "indra_constants.h"
#include "message.h"
@@ -2235,10 +2235,9 @@ void LLPanelEstateCovenant::loadInvItem(LLInventoryItem *itemp)
}
// static
-void LLPanelEstateCovenant::onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void LLPanelEstateCovenant::onLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LL_INFOS() << "LLPanelEstateCovenant::onLoadComplete()" << LL_ENDL;
LLPanelEstateCovenant* panelp = (LLPanelEstateCovenant*)user_data;
@@ -2246,7 +2245,7 @@ void LLPanelEstateCovenant::onLoadComplete(LLVFS *vfs,
{
if(0 == status)
{
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 file_length = file.getSize();
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index 211043154403e1efb07bf67553e1c06b54a9c41e..cf38c0458c119f7dc67382d00fd435f5682e8276 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -55,7 +55,6 @@ class LLRadioGroup;
class LLSliderCtrl;
class LLSpinCtrl;
class LLTextBox;
-class LLVFS;
class LLPanelRegionGeneralInfo;
class LLPanelRegionDebugInfo;
@@ -357,8 +356,7 @@ class LLPanelEstateCovenant : public LLPanelRegionInfo
static bool confirmResetCovenantCallback(const LLSD& notification, const LLSD& response);
void sendChangeCovenantID(const LLUUID &asset_id);
void loadInvItem(LLInventoryItem *itemp);
- static void onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+ static void onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
diff --git a/indra/newview/llfloaterreporter.cpp b/indra/newview/llfloaterreporter.cpp
index bfc9b79e877e535e526ba1551399117ef417122b..dd2ab1ccd664afad55d024af36451e78c4b4c54e 100644
--- a/indra/newview/llfloaterreporter.cpp
+++ b/indra/newview/llfloaterreporter.cpp
@@ -44,8 +44,7 @@
#include "llnotificationsutil.h"
#include "llstring.h"
#include "llsys.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "mean_collision_data.h"
#include "message.h"
#include "v3math.h"
@@ -907,12 +906,9 @@ void LLFloaterReporter::takeScreenshot(bool use_prev_screenshot)
mResourceDatap->mAssetInfo.setName("screenshot_name");
mResourceDatap->mAssetInfo.setDescription("screenshot_descr");
- // store in VFS
- LLVFile::writeFile(upload_data->getData(),
- upload_data->getDataSize(),
- gVFS,
- mResourceDatap->mAssetInfo.mUuid,
- mResourceDatap->mAssetInfo.mType);
+ // store in cache
+ LLFileSystem j2c_file(mResourceDatap->mAssetInfo.mUuid, mResourceDatap->mAssetInfo.mType, LLFileSystem::WRITE);
+ j2c_file.write(upload_data->getData(), upload_data->getDataSize());
// store in the image list so it doesn't try to fetch from the server
LLPointer<LLViewerFetchedTexture> image_in_list =
diff --git a/indra/newview/llfloatertos.cpp b/indra/newview/llfloatertos.cpp
index bd403f68d7a650b42fbf16220ca970be7d8fbdca..1aeb727172e897e4a33604dc7b9c9da6c7e77e7d 100644
--- a/indra/newview/llfloatertos.cpp
+++ b/indra/newview/llfloatertos.cpp
@@ -40,7 +40,7 @@
#include "lltextbox.h"
#include "llui.h"
#include "lluictrlfactory.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "message.h"
#include "llstartup.h" // login_alert_done
#include "llcorehttputil.h"
diff --git a/indra/newview/llfloatertos.h b/indra/newview/llfloatertos.h
index 85033acf4d926effc1d607a535e06a65fa1f4ef4..7c2f0705b7f881f64323826e13987b12476b7528 100644
--- a/indra/newview/llfloatertos.h
+++ b/indra/newview/llfloatertos.h
@@ -36,7 +36,6 @@
class LLButton;
class LLRadioGroup;
-class LLVFS;
class LLTextEditor;
class LLUUID;
diff --git a/indra/newview/llgesturemgr.cpp b/indra/newview/llgesturemgr.cpp
index 46b90a2bfa9c19ed85f4332d8b69ed161aab5b27..0f772f712b2612f09cd76334439ec2d323c2455a 100644
--- a/indra/newview/llgesturemgr.cpp
+++ b/indra/newview/llgesturemgr.cpp
@@ -42,7 +42,7 @@
#include "llnotificationsutil.h"
#include "llstl.h"
#include "llstring.h" // todo: remove
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "message.h"
// newview
@@ -558,7 +558,7 @@ void LLGestureMgr::playGesture(LLMultiGesture* gesture)
LLGestureStepAnimation* anim_step = (LLGestureStepAnimation*)step;
const LLUUID& anim_id = anim_step->mAnimAssetID;
- // Don't request the animation if this step stops it or if it is already in Static VFS
+ // Don't request the animation if this step stops it or if it is already in the cache
if (!(anim_id.isNull()
|| anim_step->mFlags & ANIM_FLAG_STOP
|| gAssetStorage->hasLocalAsset(anim_id, LLAssetType::AT_ANIMATION)))
@@ -1051,10 +1051,9 @@ void LLGestureMgr::runStep(LLMultiGesture* gesture, LLGestureStep* step)
// static
-void LLGestureMgr::onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void LLGestureMgr::onLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LLLoadInfo* info = (LLLoadInfo*)user_data;
@@ -1069,7 +1068,7 @@ void LLGestureMgr::onLoadComplete(LLVFS *vfs,
if (0 == status)
{
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 size = file.getSize();
std::vector<char> buffer(size+1);
@@ -1172,8 +1171,7 @@ void LLGestureMgr::onLoadComplete(LLVFS *vfs,
}
// static
-void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+void LLGestureMgr::onAssetLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
@@ -1185,7 +1183,7 @@ void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
{
case LLAssetType::AT_ANIMATION:
{
- LLKeyframeMotion::onLoadComplete(vfs, asset_uuid, type, user_data, status, ext_status);
+ LLKeyframeMotion::onLoadComplete(asset_uuid, type, user_data, status, ext_status);
self.mLoadingAssets.erase(asset_uuid);
@@ -1193,7 +1191,7 @@ void LLGestureMgr::onAssetLoadComplete(LLVFS *vfs,
}
case LLAssetType::AT_SOUND:
{
- LLAudioEngine::assetCallback(vfs, asset_uuid, type, user_data, status, ext_status);
+ LLAudioEngine::assetCallback(asset_uuid, type, user_data, status, ext_status);
self.mLoadingAssets.erase(asset_uuid);
diff --git a/indra/newview/llgesturemgr.h b/indra/newview/llgesturemgr.h
index eec7970cd775c44c0f7bd09e8db9dbe9c5e665e3..4615c4a242241e5d354cdf16d83a79b92b053a9c 100644
--- a/indra/newview/llgesturemgr.h
+++ b/indra/newview/llgesturemgr.h
@@ -40,7 +40,6 @@ class LLMultiGesture;
class LLGestureListener;
class LLGestureStep;
class LLUUID;
-class LLVFS;
class LLGestureManagerObserver
{
@@ -154,15 +153,13 @@ class LLGestureMgr final : public LLSingleton<LLGestureMgr>, public LLInventoryF
void done();
// Used by loadGesture
- static void onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status);
+ static void onLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status);
// Used by playGesture to load an asset file
// required to play a gesture step
- static void onAssetLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+ static void onAssetLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
diff --git a/indra/newview/lllandmarklist.cpp b/indra/newview/lllandmarklist.cpp
index b4236c406b8b79ce85f2d7ecfcce2ee07c3d8430..2966ca1f109d5d90edc31b02601321de8864d5ba 100644
--- a/indra/newview/lllandmarklist.cpp
+++ b/indra/newview/lllandmarklist.cpp
@@ -33,7 +33,7 @@
#include "llappviewer.h"
#include "llagent.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llviewerstats.h"
// Globals
@@ -118,7 +118,6 @@ LLLandmark* LLLandmarkList::getAsset(const LLUUID& asset_uuid, loaded_callback_t
// static
void LLLandmarkList::processGetAssetReply(
- LLVFS *vfs,
const LLUUID& uuid,
LLAssetType::EType type,
void* user_data,
@@ -127,7 +126,7 @@ void LLLandmarkList::processGetAssetReply(
{
if( status == 0 )
{
- LLVFile file(vfs, uuid, type);
+ LLFileSystem file(uuid, type);
S32 file_length = file.getSize();
std::vector<char> buffer(file_length + 1);
diff --git a/indra/newview/lllandmarklist.h b/indra/newview/lllandmarklist.h
index 2e7bd2561013d67165f4a783c5322bd09a81db61..0e4859dbc9986e192ce0e1db1e84c85c6e0ff8fb 100644
--- a/indra/newview/lllandmarklist.h
+++ b/indra/newview/lllandmarklist.h
@@ -52,7 +52,6 @@ class LLLandmarkList
BOOL assetExists(const LLUUID& asset_uuid);
LLLandmark* getAsset(const LLUUID& asset_uuid, loaded_callback_t cb = NULL);
static void processGetAssetReply(
- LLVFS *vfs,
const LLUUID& uuid,
LLAssetType::EType type,
void* user_data,
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index ac41d87a5095020aae03ce89befda24bfadccf68..2f307b43ea7853182f18f9452dca4b2cbc17a596 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -49,7 +49,7 @@
#include "llsdutil_math.h"
#include "llsdserialize.h"
#include "llthread.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llviewercontrol.h"
#include "llviewerinventory.h"
#include "llviewermenufile.h"
@@ -295,8 +295,6 @@
// * Header parse failures come without much explanation. Elaborate.
// * Work queue for uploads? Any need for this or is the current scheme good
// enough?
-// * Various temp buffers used in VFS I/O might be allocated once or even
-// statically. Look for some wins here.
// * Move data structures holding mesh data used by main thread into main-
// thread-only access so that no locking is needed. May require duplication
// of some data so that worker thread has a minimal data set to guide
@@ -1340,8 +1338,8 @@ bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id, bool can_retry)
if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
{
- //check VFS for mesh skin info
- LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+ //check cache for mesh skin info
+ LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
U8* buffer = new(std::nothrow) U8[size];
@@ -1374,7 +1372,7 @@ bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id, bool can_retry)
delete[] buffer;
}
- //reading from VFS failed for whatever reason, fetch from sim
+ //reading from cache failed for whatever reason, fetch from sim
std::string http_url;
constructUrl(mesh_id, &http_url);
@@ -1453,8 +1451,8 @@ bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
{
- //check VFS for mesh skin info
- LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+ //check cache for mesh skin info
+ LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
U8* buffer = new(std::nothrow) U8[size];
@@ -1488,7 +1486,7 @@ bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
delete[] buffer;
}
- //reading from VFS failed for whatever reason, fetch from sim
+ //reading from cache failed for whatever reason, fetch from sim
std::string http_url;
constructUrl(mesh_id, &http_url);
@@ -1552,8 +1550,8 @@ bool LLMeshRepoThread::fetchMeshPhysicsShape(const LLUUID& mesh_id)
if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
{
- //check VFS for mesh physics shape info
- LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+ //check cache for mesh physics shape info
+ LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
LLMeshRepository::sCacheBytesRead += size;
@@ -1586,7 +1584,7 @@ bool LLMeshRepoThread::fetchMeshPhysicsShape(const LLUUID& mesh_id)
delete[] buffer;
}
- //reading from VFS failed for whatever reason, fetch from sim
+ //reading from cache failed for whatever reason, fetch from sim
std::string http_url;
constructUrl(mesh_id, &http_url);
@@ -1657,8 +1655,8 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params, bool c
++LLMeshRepository::sMeshRequestCount;
{
- //look for mesh in asset in vfs
- LLVFile file(gVFS, mesh_params.getSculptID(), LLAssetType::AT_MESH);
+ //look for mesh in asset in cache
+ LLFileSystem file(mesh_params.getSculptID(), LLAssetType::AT_MESH);
S32 size = file.getSize();
@@ -1672,7 +1670,7 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params, bool c
file.read(buffer, bytes);
if (headerReceived(mesh_params, buffer, bytes) == MESH_OK)
{
- // Found mesh in VFS cache
+ // Found mesh in cache
return true;
}
}
@@ -1741,8 +1739,8 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod,
if (version <= MAX_MESH_VERSION && offset >= 0 && size > 0)
{
- //check VFS for mesh asset
- LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH);
+ //check cache for mesh asset
+ LLFileSystem file(mesh_id, LLAssetType::AT_MESH);
if (file.getSize() >= offset+size)
{
U8* buffer = new(std::nothrow) U8[size];
@@ -1777,7 +1775,7 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod,
delete[] buffer;
}
- //reading from VFS failed for whatever reason, fetch from sim
+ //reading from cache failed for whatever reason, fetch from sim
std::string http_url;
constructUrl(mesh_id, &http_url);
@@ -3244,7 +3242,7 @@ void LLMeshHeaderHandler::processData(LLCore::BufferArray * /* body */, S32 /* b
}
else if (data && data_size > 0)
{
- // header was successfully retrieved from sim and parsed, cache in vfs
+ // header was successfully retrieved from sim and parsed and is in cache
S32 header_bytes = 0;
LLSD header;
@@ -3283,30 +3281,16 @@ void LLMeshHeaderHandler::processData(LLCore::BufferArray * /* body */, S32 /* b
// It's possible for the remote asset to have more data than is needed for the local cache
- // only allocate as much space in the VFS as is needed for the local cache
+ // only allocate as much space in the cache as is needed for the local cache
data_size = llmin(data_size, bytes);
- LLVFile file(gVFS, mesh_id, LLAssetType::AT_MESH, LLVFile::WRITE);
- if (file.getMaxSize() >= bytes || file.setMaxSize(bytes))
+ LLFileSystem file(mesh_id, LLAssetType::AT_MESH, LLFileSystem::WRITE);
+ if (file.getMaxSize() >= bytes)
{
LLMeshRepository::sCacheBytesWritten += data_size;
++LLMeshRepository::sCacheWrites;
file.write(data, data_size);
-
- // zero out the rest of the file
- U8 block[MESH_HEADER_SIZE] = {};
-
- while (bytes-file.tell() > sizeof(block))
- {
- file.write(block, sizeof(block));
- }
-
- S32 remaining = bytes-file.tell();
- if (remaining > 0)
- {
- file.write(block, remaining);
- }
}
}
else
@@ -3358,8 +3342,8 @@ void LLMeshLODHandler::processData(LLCore::BufferArray * /* body */, S32 /* body
EMeshProcessingResult result = gMeshRepo.mThread->lodReceived(mMeshParams, mLOD, data, data_size);
if (result == MESH_OK)
{
- // good fetch from sim, write to VFS for caching
- LLVFile file(gVFS, mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLVFile::WRITE);
+ // good fetch from sim, write to cache
+ LLFileSystem file(mMeshParams.getSculptID(), LLAssetType::AT_MESH, LLFileSystem::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
@@ -3421,8 +3405,8 @@ void LLMeshSkinInfoHandler::processData(LLCore::BufferArray * /* body */, S32 /*
&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
&& gMeshRepo.mThread->skinInfoReceived(mMeshID, data, data_size))
{
- // good fetch from sim, write to VFS for caching
- LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+ // good fetch from sim, write to cache
+ LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
@@ -3470,8 +3454,8 @@ void LLMeshDecompositionHandler::processData(LLCore::BufferArray * /* body */, S
&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
&& gMeshRepo.mThread->decompositionReceived(mMeshID, data, data_size))
{
- // good fetch from sim, write to VFS for caching
- LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+ // good fetch from sim, write to cache
+ LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
@@ -3517,8 +3501,8 @@ void LLMeshPhysicsShapeHandler::processData(LLCore::BufferArray * /* body */, S3
&& ((data != NULL) == (data_size > 0)) // if we have data but no size or have size but no data, something is wrong
&& gMeshRepo.mThread->physicsShapeReceived(mMeshID, data, data_size) == MESH_OK)
{
- // good fetch from sim, write to VFS for caching
- LLVFile file(gVFS, mMeshID, LLAssetType::AT_MESH, LLVFile::WRITE);
+ // good fetch from sim, write to cache for caching
+ LLFileSystem file(mMeshID, LLAssetType::AT_MESH, LLFileSystem::WRITE);
S32 offset = mOffset;
S32 size = mRequestedBytes;
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index 754907991ba7ce3572cc0f12720115e75a9a6515..df0aa5360ba0e6875e8f63cbde2a2aaa7c3c0872 100644
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -50,7 +50,6 @@
class LLVOVolume;
class LLMutex;
class LLCondition;
-class LLVFS;
class LLMeshRepository;
typedef enum e_mesh_processing_result_enum
diff --git a/indra/newview/lloutfitgallery.cpp b/indra/newview/lloutfitgallery.cpp
index e616cfe743b1b1d720d531562d72ac75403a584a..666a78eaee0263826065bd1999c4c1e184fb12ec 100644
--- a/indra/newview/lloutfitgallery.cpp
+++ b/indra/newview/lloutfitgallery.cpp
@@ -30,7 +30,7 @@
// llcommon
#include "llcommonutils.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llaccordionctrltab.h"
#include "llappearancemgr.h"
diff --git a/indra/newview/lloutfitgallery.h b/indra/newview/lloutfitgallery.h
index 6dd8a6298fedb36ff320e1c02fd5f5d8642d4f25..ce5c09013439def3932e36c44db14ddb753ebb68 100644
--- a/indra/newview/lloutfitgallery.h
+++ b/indra/newview/lloutfitgallery.h
@@ -38,7 +38,6 @@
#include <vector>
-class LLVFS;
class LLOutfitGallery;
class LLOutfitGalleryItem;
class LLOutfitListGearMenuBase;
diff --git a/indra/newview/llpostcard.cpp b/indra/newview/llpostcard.cpp
index d5775042c186bac9eddba6a122f70d1a4a846660..071fc31d27c161e8180980a0ef924333103fc085 100644
--- a/indra/newview/llpostcard.cpp
+++ b/indra/newview/llpostcard.cpp
@@ -28,8 +28,7 @@
#include "llpostcard.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "llviewerregion.h"
#include "message.h"
diff --git a/indra/newview/llpreviewgesture.cpp b/indra/newview/llpreviewgesture.cpp
index c2fbdc762ffa4f62c3d3ae225158daa39a664799..d847bd525f5b39bd53aad52e5f182414a505e70c 100644
--- a/indra/newview/llpreviewgesture.cpp
+++ b/indra/newview/llpreviewgesture.cpp
@@ -30,7 +30,7 @@
#include "llagent.h"
#include "llanimstatelabels.h"
#include "llanimationstates.h"
-#include "llappviewer.h" // gVFS
+#include "llappviewer.h"
#include "llcheckboxctrl.h"
#include "llcombobox.h"
#include "lldatapacker.h"
@@ -47,7 +47,7 @@
#include "llradiogroup.h"
#include "llresmgr.h"
#include "lltrans.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llviewerstats.h"
@@ -849,10 +849,9 @@ void LLPreviewGesture::loadAsset()
// static
-void LLPreviewGesture::onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void LLPreviewGesture::onLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LLUUID* item_idp = (LLUUID*)user_data;
@@ -861,7 +860,7 @@ void LLPreviewGesture::onLoadComplete(LLVFS *vfs,
{
if (0 == status)
{
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 size = file.getSize();
std::vector<char> buffer(size+1);
@@ -1148,10 +1147,9 @@ void LLPreviewGesture::saveIfNeeded()
tid.generate();
assetId = tid.makeAssetID(gAgent.getSecureSessionID());
- LLVFile file(gVFS, assetId, LLAssetType::AT_GESTURE, LLVFile::APPEND);
+ LLFileSystem file(assetId, LLAssetType::AT_GESTURE, LLFileSystem::APPEND);
S32 size = dp.getCurrentSize();
- file.setMaxSize(size);
file.write((U8*)buffer, size);
LLLineEditor* descEditor = getChild<LLLineEditor>("desc");
diff --git a/indra/newview/llpreviewgesture.h b/indra/newview/llpreviewgesture.h
index 82b10d9b4cd6ad177ac57e42c04ff7684dbe214c..23b21589ad916f8e63c02c66a25ee1cdeccba3a6 100644
--- a/indra/newview/llpreviewgesture.h
+++ b/indra/newview/llpreviewgesture.h
@@ -39,7 +39,6 @@ class LLScrollListCtrl;
class LLScrollListItem;
class LLButton;
class LLRadioGroup;
-class LLVFS;
class LLPreviewGesture final : public LLPreview
{
@@ -80,8 +79,7 @@ class LLPreviewGesture final : public LLPreview
void loadAsset();
- static void onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+ static void onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
diff --git a/indra/newview/llpreviewnotecard.cpp b/indra/newview/llpreviewnotecard.cpp
index 9c0921deb329e148fa2088e8f776a48fe92372eb..32932ea793382fc60d20be341f0d27c955b81d3e 100644
--- a/indra/newview/llpreviewnotecard.cpp
+++ b/indra/newview/llpreviewnotecard.cpp
@@ -52,7 +52,7 @@
#include "llselectmgr.h"
#include "lltrans.h"
#include "llviewertexteditor.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llviewerinventory.h"
#include "llviewerobject.h"
#include "llviewerobjectlist.h"
@@ -357,8 +357,7 @@ void LLPreviewNotecard::loadAsset()
}
// static
-void LLPreviewNotecard::onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+void LLPreviewNotecard::onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
@@ -369,7 +368,7 @@ void LLPreviewNotecard::onLoadComplete(LLVFS *vfs,
{
if(0 == status)
{
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 file_length = file.getSize();
@@ -484,7 +483,7 @@ void LLPreviewNotecard::finishInventoryUpload(LLUUID itemId, LLUUID newAssetId,
LLPreviewNotecard* nc = LLFloaterReg::findTypedInstance<LLPreviewNotecard>("preview_notecard", LLSD(itemId));
if (nc)
{
- // *HACK: we have to delete the asset in the VFS so
+ // *HACK: we have to delete the asset in the cache so
// that the viewer will redownload it. This is only
// really necessary if the asset had to be modified by
// the uploader, so this can be optimized away in some
@@ -492,7 +491,7 @@ void LLPreviewNotecard::finishInventoryUpload(LLUUID itemId, LLUUID newAssetId,
// script actually changed the asset.
if (nc->hasEmbeddedInventory())
{
- gVFS->removeFile(newAssetId, LLAssetType::AT_NOTECARD);
+ LLFileSystem::removeFile(newAssetId, LLAssetType::AT_NOTECARD);
}
if (newItemId.isNull())
{
@@ -517,7 +516,7 @@ void LLPreviewNotecard::finishTaskUpload(LLUUID itemId, LLUUID newAssetId, LLUUI
{
if (nc->hasEmbeddedInventory())
{
- gVFS->removeFile(newAssetId, LLAssetType::AT_NOTECARD);
+ LLFileSystem::removeFile(newAssetId, LLAssetType::AT_NOTECARD);
}
nc->setAssetId(newAssetId);
nc->refreshFromInventory();
@@ -596,14 +595,13 @@ bool LLPreviewNotecard::saveIfNeeded(LLInventoryItem* copyitem, bool sync)
tid.generate();
asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
- LLVFile file(gVFS, asset_id, LLAssetType::AT_NOTECARD, LLVFile::APPEND);
+ LLFileSystem file(asset_id, LLAssetType::AT_NOTECARD, LLFileSystem::APPEND);
LLSaveNotecardInfo* info = new LLSaveNotecardInfo(this, mItemUUID, mObjectUUID,
tid, copyitem);
S32 size = buffer.length() + 1;
- file.setMaxSize(size);
file.write((U8*)buffer.c_str(), size);
gAssetStorage->storeAssetData(tid, LLAssetType::AT_NOTECARD,
diff --git a/indra/newview/llpreviewnotecard.h b/indra/newview/llpreviewnotecard.h
index 47b7234612446d9e934940fde5181d37bb6554e3..634db75e8b26f617deda3382f078244fda89e275 100644
--- a/indra/newview/llpreviewnotecard.h
+++ b/indra/newview/llpreviewnotecard.h
@@ -99,8 +99,7 @@ class LLPreviewNotecard final : public LLPreview
/*virtual*/ void onBackupTimer();
// [/SL:KB]
- static void onLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+ static void onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp
index 27e8e6c302b59682f6c70c5259c182b371702f42..7b296f435fbb956d45013c943caf92a5e4811497 100644
--- a/indra/newview/llpreviewscript.cpp
+++ b/indra/newview/llpreviewscript.cpp
@@ -54,7 +54,7 @@
#include "llsdserialize.h"
#include "llslider.h"
#include "lltooldraganddrop.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llagent.h"
#include "llmenugl.h"
@@ -1770,8 +1770,11 @@ void LLPreviewLSL::saveIfNeeded(bool sync /*= true*/)
{
std::string buffer(mScriptEd->mEditor->getText());
+ LLUUID old_asset_id = inv_item->getAssetUUID().isNull() ? mScriptEd->getAssetID() : inv_item->getAssetUUID();
+
LLResourceUploadInfo::ptr_t uploadInfo(std::make_shared<LLScriptAssetUpload>(mItemUUID, buffer,
- [](LLUUID itemId, LLUUID, LLUUID, LLSD response) {
+ [old_asset_id](LLUUID itemId, LLUUID, LLUUID, LLSD response) {
+ LLFileSystem::removeFile(old_asset_id, LLAssetType::AT_LSL_TEXT);
LLPreviewLSL::finishedLSLUpload(itemId, response);
}));
@@ -1781,8 +1784,8 @@ void LLPreviewLSL::saveIfNeeded(bool sync /*= true*/)
}
// static
-void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void LLPreviewLSL::onLoadComplete(const LLUUID& asset_uuid, LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LL_DEBUGS() << "LLPreviewLSL::onLoadComplete: got uuid " << asset_uuid
<< LL_ENDL;
@@ -1792,7 +1795,7 @@ void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAsset
{
if(0 == status)
{
- LLVFile file(vfs, asset_uuid, type);
+ LLFileSystem file(asset_uuid, type);
S32 file_length = file.getSize();
std::vector<char> buffer(file_length+1);
@@ -1819,6 +1822,7 @@ void LLPreviewLSL::onLoadComplete( LLVFS *vfs, const LLUUID& asset_uuid, LLAsset
}
preview->mScriptEd->setScriptName(script_name);
preview->mScriptEd->setEnableEditing(is_modifiable);
+ preview->mScriptEd->setAssetID(asset_uuid);
preview->mAssetStatus = PREVIEW_ASSET_LOADED;
// [SL:KB] - Patch: Build-ScriptRecover | Checked: 2011-11-23 (Catznip-3.2)
@@ -2081,7 +2085,7 @@ void LLLiveLSLEditor::loadAsset()
}
// static
-void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
+void LLLiveLSLEditor::onLoadComplete(const LLUUID& asset_id,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
@@ -2095,9 +2099,10 @@ void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
{
if( LL_ERR_NOERR == status )
{
- instance->loadScriptText(vfs, asset_id, type);
+ instance->loadScriptText(asset_id, type);
instance->mScriptEd->setEnableEditing(TRUE);
instance->mAssetStatus = PREVIEW_ASSET_LOADED;
+ instance->mScriptEd->setAssetID(asset_id);
// [SL:KB] - Patch: Build-ScriptRecover | Checked: 2011-11-23 (Catznip-3.2)
// Start the timer which will perform regular backup saves
@@ -2129,9 +2134,9 @@ void LLLiveLSLEditor::onLoadComplete(LLVFS *vfs, const LLUUID& asset_id,
delete floater_key;
}
-void LLLiveLSLEditor::loadScriptText(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type)
+void LLLiveLSLEditor::loadScriptText(const LLUUID &uuid, LLAssetType::EType type)
{
- LLVFile file(vfs, uuid, type);
+ LLFileSystem file(uuid, type);
S32 file_length = file.getSize();
std::vector<char> buffer(file_length + 1);
file.read((U8*)&buffer[0], file_length);
@@ -2304,6 +2309,7 @@ void LLLiveLSLEditor::finishLSLUpload(LLUUID itemId, LLUUID taskId, LLUUID newAs
if (preview)
{
preview->mItem->setAssetUUID(newAssetId);
+ preview->mScriptEd->setAssetID(newAssetId);
// Bytecode save completed
if (response["compiled"])
@@ -2382,12 +2388,14 @@ void LLLiveLSLEditor::saveIfNeeded(bool sync /*= true*/)
if (!url.empty())
{
std::string buffer(mScriptEd->mEditor->getText());
+ LLUUID old_asset_id = mScriptEd->getAssetID();
LLResourceUploadInfo::ptr_t uploadInfo(std::make_shared<LLScriptAssetUpload>(mObjectUUID, mItemUUID,
monoChecked() ? LLScriptAssetUpload::MONO : LLScriptAssetUpload::LSL2,
isRunning, mScriptEd->getAssociatedExperience(), buffer,
- [isRunning](LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response) {
- LLLiveLSLEditor::finishLSLUpload(itemId, taskId, newAssetId, response, isRunning);
+ [isRunning, old_asset_id](LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response) {
+ LLFileSystem::removeFile(old_asset_id, LLAssetType::AT_LSL_TEXT);
+ LLLiveLSLEditor::finishLSLUpload(itemId, taskId, newAssetId, response, isRunning);
}));
LLViewerAssetUpload::EnqueueInventoryUpload(url, uploadInfo);
diff --git a/indra/newview/llpreviewscript.h b/indra/newview/llpreviewscript.h
index 561a286bef6f533147a5b3c1458467dda283dc47..254b617da2ac7a740615d018db4db5ed2dd30ceb 100644
--- a/indra/newview/llpreviewscript.h
+++ b/indra/newview/llpreviewscript.h
@@ -48,7 +48,6 @@ struct LLEntryAndEdCore;
class LLMenuBarGL;
//class LLFloaterScriptSearch;
class LLKeywordToken;
-class LLVFS;
class LLViewerInventoryItem;
class LLScriptEdContainer;
class LLFloaterGotoLine;
@@ -143,6 +142,9 @@ class LLScriptEdCore final : public LLPanel
void setItemRemoved(bool script_removed){mScriptRemoved = script_removed;};
+ void setAssetID( const LLUUID& asset_id){ mAssetID = asset_id; };
+ LLUUID getAssetID() { return mAssetID; }
+
private:
void onBtnDynamicHelp();
void onBtnUndoChanges();
@@ -191,6 +193,7 @@ class LLScriptEdCore final : public LLPanel
LLUUID mAssociatedExperience;
BOOL mScriptRemoved;
BOOL mSaveDialogShown;
+ LLUUID mAssetID;
LLScriptEdContainer* mContainer; // parent view
@@ -245,7 +248,7 @@ class LLPreviewLSL final : public LLScriptEdContainer
static void onLoad(void* userdata);
static void onSave(void* userdata, BOOL close_after_save);
- static void onLoadComplete(LLVFS *vfs, const LLUUID& uuid,
+ static void onLoadComplete(const LLUUID& uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
@@ -310,13 +313,13 @@ class LLLiveLSLEditor final : public LLScriptEdContainer
static void onLoad(void* userdata);
static void onSave(void* userdata, BOOL close_after_save);
- static void onLoadComplete(LLVFS *vfs, const LLUUID& asset_uuid,
+ static void onLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
static void onRunningCheckboxClicked(LLUICtrl*, void* userdata);
static void onReset(void* userdata);
- void loadScriptText(LLVFS *vfs, const LLUUID &uuid, LLAssetType::EType type);
+ void loadScriptText(const LLUUID &uuid, LLAssetType::EType type);
static void onErrorList(LLUICtrl*, void* user_data);
diff --git a/indra/newview/llsettingsvo.cpp b/indra/newview/llsettingsvo.cpp
index 748eac2a3e0d582450392fb85fc18d15f7145f2e..8be43cfa08bba6c0928253a9f56e025cbedd4401 100644
--- a/indra/newview/llsettingsvo.cpp
+++ b/indra/newview/llsettingsvo.cpp
@@ -57,7 +57,7 @@
#include "llinventorymodel.h"
#include "llassetstorage.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "lldrawpoolwater.h"
#include <boost/algorithm/string/replace.hpp>
@@ -292,18 +292,18 @@ void LLSettingsVOBase::onTaskAssetUploadComplete(LLUUID itemId, LLUUID taskId, L
void LLSettingsVOBase::getSettingsAsset(const LLUUID &assetId, LLSettingsVOBase::asset_download_fn callback)
{
gAssetStorage->getAssetData(assetId, LLAssetType::AT_SETTINGS,
- [callback](LLVFS *vfs, const LLUUID &asset_id, LLAssetType::EType, void *, S32 status, LLExtStat ext_status)
- { onAssetDownloadComplete(vfs, asset_id, status, ext_status, callback); },
+ [callback](const LLUUID &asset_id, LLAssetType::EType, void *, S32 status, LLExtStat ext_status)
+ { onAssetDownloadComplete(asset_id, status, ext_status, callback); },
nullptr, true);
}
-void LLSettingsVOBase::onAssetDownloadComplete(LLVFS *vfs, const LLUUID &asset_id, S32 status, LLExtStat ext_status, LLSettingsVOBase::asset_download_fn callback)
+void LLSettingsVOBase::onAssetDownloadComplete(const LLUUID &asset_id, S32 status, LLExtStat ext_status, LLSettingsVOBase::asset_download_fn callback)
{
LLSettingsBase::ptr_t settings;
if (!status)
{
- LLVFile file(vfs, asset_id, LLAssetType::AT_SETTINGS, LLVFile::READ);
+ LLFileSystem file(asset_id, LLAssetType::AT_SETTINGS, LLFileSystem::READ);
S32 size = file.getSize();
std::string buffer(size + 1, '\0');
diff --git a/indra/newview/llsettingsvo.h b/indra/newview/llsettingsvo.h
index 9a067d9d41ebcb64593ce2512a3d7896bc6d9065..d15b0a0e8f5374ec6410730b6366c04a9800bfcf 100644
--- a/indra/newview/llsettingsvo.h
+++ b/indra/newview/llsettingsvo.h
@@ -38,7 +38,6 @@
#include "llextendedstatus.h"
#include <boost/signals2.hpp>
-class LLVFS;
class LLInventoryItem;
class LLGLSLShader;
@@ -81,7 +80,7 @@ class LLSettingsVOBase : public LLSettingsBase
static void onAgentAssetUploadComplete(LLUUID itemId, LLUUID newAssetId, LLUUID newItemId, LLSD response, LLSettingsBase::ptr_t psettings, inventory_result_fn callback);
static void onTaskAssetUploadComplete(LLUUID itemId, LLUUID taskId, LLUUID newAssetId, LLSD response, LLSettingsBase::ptr_t psettings, inventory_result_fn callback);
- static void onAssetDownloadComplete(LLVFS *vfs, const LLUUID &asset_id, S32 status, LLExtStat ext_status, asset_download_fn callback);
+ static void onAssetDownloadComplete(const LLUUID &asset_id, S32 status, LLExtStat ext_status, asset_download_fn callback);
};
//=========================================================================
diff --git a/indra/newview/llsnapshotlivepreview.cpp b/indra/newview/llsnapshotlivepreview.cpp
index 54e6d9c1e6b4e77ad6c5a56f81fbb63d275c49fb..1417216865680b353d32d92796a2549adcd7c12c 100644
--- a/indra/newview/llsnapshotlivepreview.cpp
+++ b/indra/newview/llsnapshotlivepreview.cpp
@@ -31,6 +31,7 @@
#include "llagentbenefits.h"
#include "llagentcamera.h"
#include "llagentui.h"
+#include "llfilesystem.h"
#include "llcombobox.h"
#include "llfloaterperms.h"
#include "llfloaterreg.h"
@@ -51,8 +52,6 @@
#include "llviewercontrol.h"
#include "llviewermenufile.h" // upload_new_resource()
#include "llviewerstats.h"
-#include "llvfile.h"
-#include "llvfs.h"
#include "llwindow.h"
#include "llworld.h"
#include <boost/filesystem.hpp>
@@ -1013,7 +1012,8 @@ void LLSnapshotLivePreview::saveTexture(BOOL outfit_snapshot, std::string name)
if (formatted->encode(scaled, 0.0f))
{
- LLVFile::writeFile(formatted->getData(), formatted->getDataSize(), gVFS, new_asset_id, LLAssetType::AT_TEXTURE);
+ LLFileSystem fmt_file(new_asset_id, LLAssetType::AT_TEXTURE, LLFileSystem::WRITE);
+ fmt_file.write(formatted->getData(), formatted->getDataSize());
std::string pos_string;
LLAgentUI::buildLocationString(pos_string, LLAgentUI::LOCATION_FORMAT_FULL);
std::string who_took_it;
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 198747b69a0947b932c95cb9b5ac4588c5c18a7d..5fb23c97e2cc9288a952b5df5176224fa05c702c 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -82,7 +82,6 @@
#include "llversioninfo.h"
#include "llviewercontrol.h"
#include "llviewerhelp.h"
-#include "llvfs.h"
#include "llxorcipher.h" // saved password, MAC address
#include "llwindow.h"
#include "message.h"
@@ -274,7 +273,7 @@ bool login_alert_status(const LLSD& notification, const LLSD& response);
void login_packet_failed(void**, S32 result);
void use_circuit_callback(void**, S32 result);
void register_viewer_callbacks(LLMessageSystem* msg);
-void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32);
+void asset_callback_nothing(const LLUUID&, LLAssetType::EType, void*, S32);
bool callback_choose_gender(const LLSD& notification, const LLSD& response);
void init_start_screen(S32 location_id);
void release_start_screen();
@@ -589,7 +588,7 @@ bool idle_startup()
// start the xfer system. by default, choke the downloads
// a lot...
const S32 VIEWER_MAX_XFER = 3;
- start_xfer_manager(gVFS);
+ start_xfer_manager();
gXferManager->setMaxIncomingXfers(VIEWER_MAX_XFER);
F32 xfer_throttle_bps = gSavedSettings.getF32("XferThrottle");
if (xfer_throttle_bps > 1.f)
@@ -597,7 +596,7 @@ bool idle_startup()
gXferManager->setUseAckThrottling(TRUE);
gXferManager->setAckThrottleBPS(xfer_throttle_bps);
}
- gAssetStorage = new LLViewerAssetStorage(msg, gXferManager, gVFS, gStaticVFS);
+ gAssetStorage = new LLViewerAssetStorage(msg, gXferManager);
F32 dropPercent = gSavedSettings.getF32("PacketDropPercentage");
@@ -1046,13 +1045,6 @@ bool idle_startup()
gViewerWindow->revealIntroPanel();
- // Poke the VFS, which could potentially block for a while if
- // Windows XP is acting up
- set_startup_status(0.07f, LLTrans::getString("LoginVerifyingCache"), LLStringUtil::null);
- display_startup();
-
- gVFS->pokeFiles();
-
LLStartUp::setStartupState( STATE_LOGIN_AUTH_INIT );
return FALSE;
@@ -2638,7 +2630,7 @@ void register_viewer_callbacks(LLMessageSystem* msg)
msg->setHandlerFuncFast(_PREHASH_FeatureDisabled, process_feature_disabled_message);
}
-void asset_callback_nothing(LLVFS*, const LLUUID&, LLAssetType::EType, void*, S32)
+void asset_callback_nothing(const LLUUID&, LLAssetType::EType, void*, S32)
{
// nothing
}
diff --git a/indra/newview/lltexturecache.cpp b/indra/newview/lltexturecache.cpp
index 6130e91faf5b748d89d0c5f17f490651993f246e..9e71129cb0d7e6a9819728b3eec972fbe1917920 100644
--- a/indra/newview/lltexturecache.cpp
+++ b/indra/newview/lltexturecache.cpp
@@ -55,6 +55,7 @@ const S32 TEXTURE_FAST_CACHE_ENTRY_OVERHEAD = sizeof(S32) * 4; //w, h, c, level
const S32 TEXTURE_FAST_CACHE_DATA_SIZE = 16 * 16 * 4;
const S32 TEXTURE_FAST_CACHE_ENTRY_SIZE = TEXTURE_FAST_CACHE_DATA_SIZE + TEXTURE_FAST_CACHE_ENTRY_OVERHEAD;
const F32 TEXTURE_LAZY_PURGE_TIME_LIMIT = .004f; // 4ms. Would be better to autoadjust, but there is a major cache rework in progress.
+const F32 TEXTURE_PRUNING_MAX_TIME = 15.f;
class LLTextureCacheWorker : public LLWorkerClass
{
@@ -1557,7 +1558,6 @@ void LLTextureCache::readHeaderCache()
if (num_entries - empty_entries > sCacheMaxEntries)
{
// Special case: cache size was reduced, need to remove entries
- // Note: After we prune entries, we will call this again and create the LRU
U32 entries_to_purge = (num_entries - empty_entries) - sCacheMaxEntries;
LL_INFOS() << "Texture Cache Entries: " << num_entries << " Max: " << sCacheMaxEntries << " Empty: " << empty_entries << " Purging: " << entries_to_purge << LL_ENDL;
// We can exit the following loop with the given condition, since if we'd reach the end of the lru set we'd have:
@@ -1570,7 +1570,7 @@ void LLTextureCache::readHeaderCache()
++iter;
}
}
- else
+
{
S32 lru_entries = (S32)((F32)sCacheMaxEntries * TEXTURE_CACHE_LRU_SIZE);
for (std::set<lru_data_t>::iterator iter = lru.begin(); iter != lru.end(); ++iter)
@@ -1584,30 +1584,19 @@ void LLTextureCache::readHeaderCache()
if (purge_list.size() > 0)
{
+ LLTimer timer;
for (std::set<U32>::iterator iter = purge_list.begin(); iter != purge_list.end(); ++iter)
{
std::string tex_filename = getTextureFileName(entries[*iter].mID);
removeEntry((S32)*iter, entries[*iter], tex_filename);
- }
- // If we removed any entries, we need to rebuild the entries list,
- // write the header, and call this again
- std::vector<Entry> new_entries;
- for (U32 i=0; i<num_entries; i++)
- {
- const Entry& entry = entries[i];
- if (entry.mImageSize > 0)
+
+ //make sure that pruning entries doesn't take too much time
+ if (timer.getElapsedTimeF32() > TEXTURE_PRUNING_MAX_TIME)
{
- new_entries.push_back(entry);
+ break;
}
}
- mFreeList.clear(); // recreating list, no longer valid.
- llassert_always(new_entries.size() <= sCacheMaxEntries);
- mHeaderEntriesInfo.mEntries = new_entries.size();
- writeEntriesHeader();
- writeEntriesAndClose(new_entries);
- mHeaderMutex.unlock(); // unlock the mutex before calling again
- readHeaderCache(); // repeat with new entries file
- mHeaderMutex.lock();
+ writeEntriesAndClose(entries);
}
else
{
@@ -1730,7 +1719,7 @@ void LLTextureCache::purgeTexturesLazy(F32 time_limit_sec)
}
S64 cache_size = mTexturesSizeTotal;
- S64 purged_cache_size = (sCacheMaxTexturesSize * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
+ S64 purged_cache_size = (llmax(cache_size, sCacheMaxTexturesSize) * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
for (time_idx_set_t::iterator iter = time_idx_set.begin();
iter != time_idx_set.end(); ++iter)
{
@@ -1826,21 +1815,26 @@ void LLTextureCache::purgeTextures(bool validate)
}
S64 cache_size = mTexturesSizeTotal;
- S64 purged_cache_size = (sCacheMaxTexturesSize * (S64)((1.f-TEXTURE_CACHE_PURGE_AMOUNT)*100)) / 100;
+ S64 purged_cache_size = (llmax(cache_size, sCacheMaxTexturesSize) * (S64)((1.f - TEXTURE_CACHE_PURGE_AMOUNT) * 100)) / 100;
S32 purge_count = 0;
for (time_idx_set_t::iterator iter = time_idx_set.begin();
iter != time_idx_set.end(); ++iter)
{
S32 idx = iter->second;
bool purge_entry = false;
- if (validate)
+
+ if (cache_size >= purged_cache_size)
+ {
+ purge_entry = true;
+ }
+ else if (validate)
{
// make sure file exists and is the correct size
U32 uuididx = entries[idx].mID.mData[0];
if (uuididx == validate_idx)
{
- std::string filename = getTextureFileName(entries[idx].mID);
- LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mBodySize << LL_ENDL;
+ std::string filename = getTextureFileName(entries[idx].mID);
+ LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mBodySize << LL_ENDL;
// mHeaderAPRFilePoolp because this is under header mutex in main thread
S32 bodysize = LLAPRFile::size(filename, mHeaderAPRFilePoolp);
if (bodysize != entries[idx].mBodySize)
@@ -1850,10 +1844,6 @@ void LLTextureCache::purgeTextures(bool validate)
}
}
}
- else if (cache_size >= purged_cache_size)
- {
- purge_entry = true;
- }
else
{
break;
diff --git a/indra/newview/llviewerassetstorage.cpp b/indra/newview/llviewerassetstorage.cpp
index d0beead91348232af6f9902e056d2c308fcc168e..5af87d0732991b3ebe976d4afc05cc64099caf22 100644
--- a/indra/newview/llviewerassetstorage.cpp
+++ b/indra/newview/llviewerassetstorage.cpp
@@ -28,8 +28,7 @@
#include "llviewerassetstorage.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "message.h"
#include "llagent.h"
@@ -104,10 +103,8 @@ class LLViewerAssetRequest : public LLAssetRequest
///----------------------------------------------------------------------------
// Unused?
-LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs,
- const LLHost &upstream_host)
- : LLAssetStorage(msg, xfer, vfs, static_vfs, upstream_host),
+LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host)
+ : LLAssetStorage(msg, xfer, upstream_host),
mAssetCoroCount(0),
mCountRequests(0),
mCountStarted(0),
@@ -119,10 +116,8 @@ LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *
LLCoprocedureManager::instance().createPool(VIEWER_ASSET_STORAGE_CORO_POOL);
}
-
-LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs)
- : LLAssetStorage(msg, xfer, vfs, static_vfs),
+LLViewerAssetStorage::LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer)
+ : LLAssetStorage(msg, xfer),
mAssetCoroCount(0),
mCountRequests(0),
mCountStarted(0),
@@ -163,13 +158,13 @@ void LLViewerAssetStorage::storeAssetData(
if (mUpstreamHost.isOk())
{
- if (mVFS->getExists(asset_id, asset_type))
+ if (LLFileSystem::getExists(asset_id, asset_type))
{
// Pack data into this packet if we can fit it.
U8 buffer[MTUBYTES];
buffer[0] = 0;
- LLVFile vfile(mVFS, asset_id, asset_type, LLVFile::READ);
+ LLFileSystem vfile(asset_id, asset_type, LLFileSystem::READ);
S32 asset_size = vfile.getSize();
LLAssetRequest *req = new LLAssetRequest(asset_id, asset_type);
@@ -178,22 +173,20 @@ void LLViewerAssetStorage::storeAssetData(
if (asset_size < 1)
{
- // This can happen if there's a bug in our code or if the VFS has been corrupted.
- LL_WARNS("AssetStorage") << "LLViewerAssetStorage::storeAssetData() Data _should_ already be in the VFS, but it's not! " << asset_id << LL_ENDL;
- // LLAssetStorage metric: Zero size VFS
- reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
+ // This can happen if there's a bug in our code or if the cache has been corrupted.
+ LL_WARNS("AssetStorage") << "LLViewerAssetStorage::storeAssetData() Data _should_ already be in the cache, but it's not! " << asset_id << LL_ENDL;
delete req;
if (callback)
{
- callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::VFS_CORRUPT);
+ callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_FAILED, LLExtStat::CACHE_CORRUPT);
}
return;
}
else
{
// LLAssetStorage metric: Successful Request
- S32 size = mVFS->getSize(asset_id, asset_type);
+ S32 size = LLFileSystem::getFileSize(asset_id, asset_type);
const char *message = "Added to upload queue";
reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, size, MR_OKAY, __FILE__, __LINE__, message );
@@ -207,7 +200,7 @@ void LLViewerAssetStorage::storeAssetData(
}
}
- // Read the data from the VFS if it'll fit in this packet.
+ // Read the data from the cache if it'll fit in this packet.
if (asset_size + 100 < MTUBYTES)
{
BOOL res = vfile.read(buffer, asset_size); /* Flawfinder: ignore */
@@ -220,14 +213,11 @@ void LLViewerAssetStorage::storeAssetData(
}
else
{
- LL_WARNS("AssetStorage") << "Probable corruption in VFS file, aborting store asset data" << LL_ENDL;
-
- // LLAssetStorage metric: VFS corrupt - bogus size
- reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, asset_size, MR_VFS_CORRUPTION, __FILE__, __LINE__, "VFS corruption" );
+ LL_WARNS("AssetStorage") << "Probable corruption in cache file, aborting store asset data" << LL_ENDL;
if (callback)
{
- callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::VFS_CORRUPT);
+ callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::CACHE_CORRUPT);
}
return;
}
@@ -250,8 +240,7 @@ void LLViewerAssetStorage::storeAssetData(
else
{
LL_WARNS("AssetStorage") << "AssetStorage: attempt to upload non-existent vfile " << asset_id << ":" << LLAssetType::lookup(asset_type) << LL_ENDL;
- // LLAssetStorage metric: Zero size VFS
- reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (VFS - can't tell which)" );
+ reportMetric( asset_id, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_ZERO_SIZE, __FILE__, __LINE__, "The file didn't exist or was zero length (cache - can't tell which)" );
if (callback)
{
callback(asset_id, user_data, LL_ERR_ASSET_REQUEST_NONEXISTENT_FILE, LLExtStat::NONEXISTENT_FILE);
@@ -284,7 +273,6 @@ void LLViewerAssetStorage::storeAssetData(
if(filename.empty())
{
// LLAssetStorage metric: no filename
- reportMetric( LLUUID::null, asset_type, LLStringUtil::null, LLUUID::null, 0, MR_VFS_CORRUPTION, __FILE__, __LINE__, "Filename missing" );
LL_ERRS() << "No filename specified" << LL_ENDL;
return;
}
@@ -311,9 +299,7 @@ void LLViewerAssetStorage::storeAssetData(
legacy->mUpCallback = callback;
legacy->mUserData = user_data;
- LLVFile file(mVFS, asset_id, asset_type, LLVFile::WRITE);
-
- file.setMaxSize(size);
+ LLFileSystem file(asset_id, asset_type, LLFileSystem::WRITE);
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
@@ -556,21 +542,20 @@ void LLViewerAssetStorage::assetRequestCoro(
// case.
LLUUID temp_id;
temp_id.generate();
- LLVFile vf(gAssetStorage->mVFS, temp_id, atype, LLVFile::WRITE);
- vf.setMaxSize(size);
+ LLFileSystem vf(temp_id, atype, LLFileSystem::WRITE);
req->mBytesFetched = size;
if (!vf.write(raw.data(),size))
{
// TODO asset-http: handle error
LL_WARNS("ViewerAsset") << "Failure in vf.write()" << LL_ENDL;
result_code = LL_ERR_ASSET_REQUEST_FAILED;
- ext_status = LLExtStat::VFS_CORRUPT;
+ ext_status = LLExtStat::CACHE_CORRUPT;
}
else if (!vf.rename(uuid, atype))
{
LL_WARNS("ViewerAsset") << "rename failed" << LL_ENDL;
result_code = LL_ERR_ASSET_REQUEST_FAILED;
- ext_status = LLExtStat::VFS_CORRUPT;
+ ext_status = LLExtStat::CACHE_CORRUPT;
}
else
{
diff --git a/indra/newview/llviewerassetstorage.h b/indra/newview/llviewerassetstorage.h
index ef01d179b7bac20179ba983c0e3823d10fdf82fe..972c89de34bb8405d3ea742f51382c5cc9dbe375 100644
--- a/indra/newview/llviewerassetstorage.h
+++ b/indra/newview/llviewerassetstorage.h
@@ -30,18 +30,16 @@
#include "llassetstorage.h"
#include "llcorehttputil.h"
-class LLVFile;
+class LLFileSystem;
class LLViewerAssetRequest;
class LLViewerAssetStorage : public LLAssetStorage
{
public:
- LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs, const LLHost &upstream_host);
+ LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer, const LLHost &upstream_host);
- LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
- LLVFS *vfs, LLVFS *static_vfs);
+ LLViewerAssetStorage(LLMessageSystem *msg, LLXferManager *xfer);
~LLViewerAssetStorage();
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index 02a5c5c628f21cb81f492c26e0d61c7a51b11a85..2b748c8c8a516fcf3c5e63f9e8e3fec64c1487ae 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -45,7 +45,7 @@
#include "llviewerassetupload.h"
#include "llappviewer.h"
#include "llviewerstats.h"
-#include "llvfile.h"
+#include "llfilesystem.h"
#include "llgesturemgr.h"
#include "llpreviewnotecard.h"
#include "llpreviewgesture.h"
@@ -467,15 +467,13 @@ LLSD LLNewFileResourceUploadInfo::exportTempFile()
setAssetType(assetType);
- // copy this file into the vfs for upload
+ // copy this file into the cache for upload
S32 file_size;
LLAPRFile infile;
infile.open(filename, LL_APR_RB, NULL, &file_size);
if (infile.getFileHandle())
{
- LLVFile file(gVFS, getAssetId(), assetType, LLVFile::WRITE);
-
- file.setMaxSize(file_size);
+ LLFileSystem file(getAssetId(), assetType, LLFileSystem::WRITE);
const S32 buf_size = 65536;
U8 copy_buf[buf_size];
@@ -507,7 +505,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID itemId, LLAssetType:
mContents(buffer),
mInvnFinishFn(finish),
mTaskFinishFn(nullptr),
- mStoredToVFS(false)
+ mStoredToCache(false)
{
setItemId(itemId);
setAssetType(assetType);
@@ -521,7 +519,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID itemId, LLPointer<LL
mContents(),
mInvnFinishFn(finish),
mTaskFinishFn(nullptr),
- mStoredToVFS(false)
+ mStoredToCache(false)
{
setItemId(itemId);
@@ -555,7 +553,7 @@ LLBufferedAssetUploadInfo::LLBufferedAssetUploadInfo(LLUUID taskId, LLUUID itemI
mContents(buffer),
mInvnFinishFn(nullptr),
mTaskFinishFn(finish),
- mStoredToVFS(false)
+ mStoredToCache(false)
{
setItemId(itemId);
setAssetType(assetType);
@@ -566,13 +564,12 @@ LLSD LLBufferedAssetUploadInfo::prepareUpload()
if (getAssetId().isNull())
generateNewAssetId();
- LLVFile file(gVFS, getAssetId(), getAssetType(), LLVFile::APPEND);
+ LLFileSystem file(getAssetId(), getAssetType(), LLFileSystem::APPEND);
S32 size = mContents.length() + 1;
- file.setMaxSize(size);
file.write((U8*)mContents.c_str(), size);
- mStoredToVFS = true;
+ mStoredToCache = true;
return LLSD().with("success", LLSD::Boolean(true));
}
@@ -595,10 +592,10 @@ LLUUID LLBufferedAssetUploadInfo::finishUpload(LLSD &result)
LLUUID newAssetId = result["new_asset"].asUUID();
LLUUID itemId = getItemId();
- if (mStoredToVFS)
+ if (mStoredToCache)
{
LLAssetType::EType assetType(getAssetType());
- gVFS->renameFile(getAssetId(), assetType, newAssetId, assetType);
+ LLFileSystem::renameFile(getAssetId(), assetType, newAssetId, assetType);
}
if (mTaskUpload)
diff --git a/indra/newview/llviewerassetupload.h b/indra/newview/llviewerassetupload.h
index 3887be1a91741ae833e8ce571b55fdf147fbbe8e..cb6aac2bcd4b43721ea0f77e37f28ccbd6b482bd 100644
--- a/indra/newview/llviewerassetupload.h
+++ b/indra/newview/llviewerassetupload.h
@@ -206,7 +206,7 @@ class LLBufferedAssetUploadInfo : public LLResourceUploadInfo
std::string mContents;
invnUploadFinish_f mInvnFinishFn;
taskUploadFinish_f mTaskFinishFn;
- bool mStoredToVFS;
+ bool mStoredToCache;
};
//-------------------------------------------------------------------------
diff --git a/indra/newview/llviewermedia_streamingaudio.cpp b/indra/newview/llviewermedia_streamingaudio.cpp
index 3ccf3070ab181a919417c9ae9b4acd3ca28bf408..d3e24aece5f707734503dac9e76a1771504a2065 100644
--- a/indra/newview/llviewermedia_streamingaudio.cpp
+++ b/indra/newview/llviewermedia_streamingaudio.cpp
@@ -33,10 +33,8 @@
#include "llviewermedia_streamingaudio.h"
#include "llmimetypes.h"
-#include "llvfs.h"
#include "lldir.h"
-
LLStreamingAudio_MediaPlugins::LLStreamingAudio_MediaPlugins() :
mMediaPlugin(NULL),
mGain(1.0)
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 84e15a73aa135e062e1e524e40bdeae93ec9b50c..bac4844953f2161237f486ced2642ab7da503ac7 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -3280,6 +3280,7 @@ class LLObjectMute : public view_listener_t
if (avatar)
{
avatar->mNeedsImpostorUpdate = TRUE;
+ avatar->mLastImpostorUpdateReason = 9;
id = avatar->getID();
// [RLVa:KB] - Checked: RLVa-1.0.0
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index 0db1826f390e4be933167d447f9a17dad1fb8b4b..d8665e661b5306966b8595a13c6d9b4ea9cc5b24 100644
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -54,8 +54,6 @@
#include "llviewercontrol.h" // gSavedSettings
#include "llviewertexturelist.h"
#include "lluictrlfactory.h"
-#include "llvfile.h"
-#include "llvfs.h"
#include "llviewerinventory.h"
#include "llviewermenu.h" // gMenuHolder
#include "llviewerparcelmgr.h"
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index 05316d5e1fb75ebcfb6a9bbc6977bc46b9db4d0a..6c75b8515ba69e80c57edecb5a6dcb53700d8344 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -44,8 +44,7 @@
#include "llteleportflags.h"
#include "lltoastnotifypanel.h"
#include "lltransactionflags.h"
-#include "llvfile.h"
-#include "llvfs.h"
+#include "llfilesystem.h"
#include "llxfermanager.h"
#include "mean_collision_data.h"
@@ -7296,16 +7295,15 @@ void process_covenant_reply(LLMessageSystem* msg, void**)
}
}
-void onCovenantLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status)
+void onCovenantLoadComplete(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status)
{
LL_DEBUGS("Messaging") << "onCovenantLoadComplete()" << LL_ENDL;
std::string covenant_text;
if(0 == status)
{
- LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
+ LLFileSystem file(asset_uuid, type, LLFileSystem::READ);
S32 file_length = file.getSize();
diff --git a/indra/newview/llviewermessage.h b/indra/newview/llviewermessage.h
index 78829a6a568151f7a9c3da0cda5f122ddaa1b5f9..1e5a69ae138f3b07422a5585fc60e517f144041a 100644
--- a/indra/newview/llviewermessage.h
+++ b/indra/newview/llviewermessage.h
@@ -47,7 +47,6 @@ class LLInventoryObject;
class LLInventoryItem;
class LLMeanCollisionData;
class LLMessageSystem;
-class LLVFS;
class LLViewerObject;
class LLViewerRegion;
@@ -189,8 +188,7 @@ void process_script_dialog(LLMessageSystem* msg, void**);
void process_load_url(LLMessageSystem* msg, void**);
void process_script_teleport_request(LLMessageSystem* msg, void**);
void process_covenant_reply(LLMessageSystem* msg, void**);
-void onCovenantLoadComplete(LLVFS *vfs,
- const LLUUID& asset_uuid,
+void onCovenantLoadComplete(const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
diff --git a/indra/newview/llviewerpartsource.cpp b/indra/newview/llviewerpartsource.cpp
index 661ceba7261d6e8b1a7e63a1c79e42c5570a44da..606e91c7f1ff59581c100fb9cceeeae106c6789d 100644
--- a/indra/newview/llviewerpartsource.cpp
+++ b/indra/newview/llviewerpartsource.cpp
@@ -136,7 +136,7 @@ void LLViewerPartSourceScript::update(const F32 dt)
{
mOwnerAvatarp = find_avatar(mOwnerUUID);
}
- if (mOwnerAvatarp.notNull() && LLVOAvatar::AV_DO_NOT_RENDER == mOwnerAvatarp->getVisualMuteSettings())
+ if (mOwnerAvatarp.notNull() && LLVOAvatar::AOA_NORMAL != mOwnerAvatarp->getOverallAppearance())
{
return;
}
diff --git a/indra/newview/llviewerprecompiledheaders.h b/indra/newview/llviewerprecompiledheaders.h
index bbbacce8fa4e46d5a5974eeb9afd6caf5c0b4e5c..e378c2448ace1b7e2c2795efd47b49d435ad31a0 100644
--- a/indra/newview/llviewerprecompiledheaders.h
+++ b/indra/newview/llviewerprecompiledheaders.h
@@ -101,7 +101,6 @@
#include "v4math.h"
#include "xform.h"
-// Library includes from llvfs
#include "lldir.h"
// Library includes from llmessage project
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index d3a01c99bcf0e44d5310bf465491db7776abe62b..a7430c391d33dad4decd852b48847a1926771dd5 100644
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -33,7 +33,6 @@
#include "llfloaterreg.h"
#include "llmemory.h"
#include "lltimer.h"
-#include "llvfile.h"
#include "llappviewer.h"
@@ -145,7 +144,6 @@ LLTrace::SampleStatHandle<> FPS_SAMPLE("fpssample"),
VISIBLE_AVATARS("visibleavatars", "Visible Avatars"),
SHADER_OBJECTS("shaderobjects", "Object Shaders"),
DRAW_DISTANCE("drawdistance", "Draw Distance"),
- PENDING_VFS_OPERATIONS("vfspendingoperations"),
WINDOW_WIDTH("windowwidth", "Window width"),
WINDOW_HEIGHT("windowheight", "Window height");
@@ -385,7 +383,6 @@ void update_statistics()
F64Bits layer_bits = gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits();
add(LLStatViewer::LAYERS_NETWORK_DATA_RECEIVED, layer_bits);
add(LLStatViewer::OBJECT_NETWORK_DATA_RECEIVED, gObjectData);
- sample(LLStatViewer::PENDING_VFS_OPERATIONS, LLVFile::getVFSThread()->getPending());
add(LLStatViewer::ASSET_UDP_DATA_RECEIVED, F64Bits(gTransferManager.getTransferBitsIn(LLTCT_ASSET)));
gTransferManager.resetTransferBitsIn(LLTCT_ASSET);
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index 243ae4d9b2e2b661ca91bd4377a50f8b212715c8..445330c1fbbd14a2a51aa22609f596d290a1f9e4 100644
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -186,7 +186,6 @@ extern LLTrace::SampleStatHandle<> FPS_SAMPLE,
VISIBLE_AVATARS,
SHADER_OBJECTS,
DRAW_DISTANCE,
- PENDING_VFS_OPERATIONS,
WINDOW_WIDTH,
WINDOW_HEIGHT;
diff --git a/indra/newview/llviewertexlayer.cpp b/indra/newview/llviewertexlayer.cpp
index e21d62d7d050c29a8189e2d818e59b3b100467f5..7b7c12a4c7af03e067973d1e28871adc5991cbe4 100644
--- a/indra/newview/llviewertexlayer.cpp
+++ b/indra/newview/llviewertexlayer.cpp
@@ -31,8 +31,6 @@
#include "llagent.h"
#include "llimagej2c.h"
#include "llnotificationsutil.h"
-#include "llvfile.h"
-#include "llvfs.h"
#include "llviewerregion.h"
#include "llglslshader.h"
#include "llvoavatarself.h"
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 7e4572d26cda3bcff165fc50ee0cd17f2d86975c..0dbe0521675898d7e961705bfca8c9f7bfe3ce6d 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -39,8 +39,6 @@
#include "llimagej2c.h"
#include "llimagetga.h"
#include "llstl.h"
-#include "llvfile.h"
-#include "llvfs.h"
#include "message.h"
#include "lltimer.h"
diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h
index 9482450b63e2e41e25a31449a7d0e3882a228b15..5b24944fe7154a8166e1b1da5fbd0416b0c05edf 100644
--- a/indra/newview/llviewertexture.h
+++ b/indra/newview/llviewertexture.h
@@ -54,7 +54,7 @@ class LLTexturePipelineTester ;
typedef void (*loaded_callback_func)( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata );
-class LLVFile;
+class LLFileSystem;
class LLMessageSystem;
class LLViewerMediaImpl ;
class LLVOVolume ;
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index 4af980e24a08aba7f75d772eef6cd6c437eff5a2..8ffd45ce25d796dd19cfa1cd86792f7034f5d806 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -41,9 +41,7 @@
#include "llsdserialize.h"
#include "llsys.h"
-#include "llvfs.h"
-#include "llvfile.h"
-#include "llvfsthread.h"
+#include "llfilesystem.h"
#include "llxmltree.h"
#include "message.h"
diff --git a/indra/newview/llviewerwearable.cpp b/indra/newview/llviewerwearable.cpp
index 16c74d8df4f1001ddff02e67419643777c210f3a..e8c63c6f057c6f0520659d4faea9cb2e63475f47 100644
--- a/indra/newview/llviewerwearable.cpp
+++ b/indra/newview/llviewerwearable.cpp
@@ -107,7 +107,6 @@ LLWearable::EImportResult LLViewerWearable::importStream( std::istream& input_st
// Shouldn't really log the asset id for security reasons, but
// we need it in this case.
LL_WARNS() << "Bad Wearable asset header: " << mAssetID << LL_ENDL;
- //gVFS->dumpMap();
return result;
}
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 32538a14743bd752eaf7111a520258bf6d4b213e..3785b99ef1116244b033c6acd4dd22c27fb4ff68 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -214,6 +214,8 @@ enum ERenderName
RENDER_NAME_FADE
};
+#define JELLYDOLLS_SHOULD_IMPOSTOR
+
//-----------------------------------------------------------------------------
// Callback data
//-----------------------------------------------------------------------------
@@ -581,7 +583,8 @@ class LLPelvisFixMotion final :
// Static Data
//-----------------------------------------------------------------------------
S32 LLVOAvatar::sFreezeCounter = 0;
-U32 LLVOAvatar::sMaxNonImpostors = 12; // overridden based on graphics setting
+U32 LLVOAvatar::sMaxNonImpostors = 12; // Set from RenderAvatarMaxNonImpostors
+bool LLVOAvatar::sLimitNonImpostors = false; // True unless RenderAvatarMaxNonImpostors is 0 (unlimited)
F32 LLVOAvatar::sRenderDistance = 256.f;
S32 LLVOAvatar::sNumVisibleAvatars = 0;
S32 LLVOAvatar::sNumLODChangesThisFrame = 0;
@@ -608,7 +611,6 @@ BOOL LLVOAvatar::sShowFootPlane = FALSE;
BOOL LLVOAvatar::sVisibleInFirstPerson = FALSE;
F32 LLVOAvatar::sLODFactor = 1.f;
F32 LLVOAvatar::sPhysicsLODFactor = 1.f;
-bool LLVOAvatar::sUseImpostors = false; // overwridden by RenderAvatarMaxNonImpostors
BOOL LLVOAvatar::sJointDebug = FALSE;
F32 LLVOAvatar::sUnbakedTime = 0.f;
F32 LLVOAvatar::sUnbakedUpdateTime = 0.f;
@@ -641,6 +643,7 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
mMeshValid(FALSE),
mVisible(FALSE),
mLastImpostorUpdateFrameTime(0.f),
+ mLastImpostorUpdateReason(0),
mWindFreq(0.f),
mRipplePhase( 0.f ),
mBelowWater(FALSE),
@@ -663,6 +666,7 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
mNeedsSkin(FALSE),
mLastSkinTime(0.f),
mUpdatePeriod(1),
+ mOverallAppearance(AOA_INVISIBLE),
mVisualComplexityStale(true),
mVisuallyMuteSetting(AV_RENDER_NORMALLY),
mMutedAVColor(LLColor4::white /* used for "uninitialize" */),
@@ -709,6 +713,7 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
setAnimationData("Speed", &mSpeed);
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 0;
mNeedsAnimUpdate = TRUE;
mNeedsExtentUpdate = true;
@@ -764,8 +769,8 @@ std::string LLVOAvatar::avString() const
}
else
{
- std::string viz_string = LLVOAvatar::rezStatusToString(getRezzedStatus());
- return " Avatar '" + getFullname() + "' " + viz_string + " ";
+ std::string viz_string = LLVOAvatar::rezStatusToString(getRezzedStatus());
+ return " Avatar '" + getFullname() + "' " + viz_string + " ";
}
}
@@ -1078,6 +1083,7 @@ void LLVOAvatar::resetImpostors()
LLVOAvatar* avatar = static_cast<LLVOAvatar*>(character);
avatar->mImpostor.release();
avatar->mNeedsImpostorUpdate = TRUE;
+ avatar->mLastImpostorUpdateReason = 1;
}
}
@@ -1136,7 +1142,6 @@ void LLVOAvatar::initInstance()
//-------------------------------------------------------------------------
if (LLCharacter::sInstances.size() == 1)
{
- LLKeyframeMotion::setVFS(gStaticVFS);
registerMotion( ANIM_AGENT_DO_NOT_DISTURB, LLNullMotion::create );
registerMotion( ANIM_AGENT_CROUCH, LLKeyframeStandMotion::create );
registerMotion( ANIM_AGENT_CROUCHWALK, LLKeyframeWalkMotion::create );
@@ -1321,55 +1326,68 @@ void LLVOAvatar::calculateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
LL_RECORD_BLOCK_TIME(FTM_AVATAR_EXTENT_UPDATE);
static const LLCachedControl<S32> box_detail(gSavedSettings, "AvatarBoundingBoxComplexity");
+ if (getOverallAppearance() != AOA_NORMAL)
+ {
+ if (isControlAvatar())
+ {
+ // Animated objects don't show system avatar but do need to include rigged meshes in their bounding box.
+ box_detail = 3;
+ }
+ else
+ {
+ // Jellydolled avatars ignore attachments, etc, use only system avatar.
+ box_detail = 1;
+ }
+ }
// FIXME the update_min_max function used below assumes there is a
// known starting point, but in general there isn't. Ideally the
// box update logic should be modified to handle the no-point-yet
// case. For most models, starting with the pelvis is safe though.
LLVector3 zero_pos;
- LLVector4a pos;
+ LLVector4a pos;
if (dist_vec(zero_pos, mPelvisp->getWorldPosition())<0.001)
{
// Don't use pelvis until av initialized
- pos.load3(getRenderPosition().mV);
+ pos.load3(getRenderPosition().mV);
}
else
{
pos.load3(mPelvisp->getWorldPosition().mV);
}
- newMin = pos;
- newMax = pos;
+ newMin = pos;
+ newMax = pos;
- //stretch bounding box by joint positions. Doing this for
- //control avs, where the polymeshes aren't maintained or
- //displayed, can give inaccurate boxes due to joints stuck at (0,0,0).
- if ((box_detail >= 1) && !isControlAvatar())
+ if (box_detail>=1 && !isControlAvatar())
{
+ //stretch bounding box by joint positions. Doing this for
+ //control avs, where the polymeshes aren't maintained or
+ //displayed, can give inaccurate boxes due to joints stuck at (0,0,0).
for (const auto &polymesh_pair : mPolyMeshes)
{
LLPolyMesh *mesh = polymesh_pair.second;
for (S32 joint_num = 0; joint_num < mesh->mJointRenderData.size(); joint_num++)
{
LLVector4a trans;
- trans.load3(mesh->mJointRenderData[joint_num]->mWorldMatrix->getTranslation().mV);
+ trans.load3( mesh->mJointRenderData[joint_num]->mWorldMatrix->getTranslation().mV);
update_min_max(newMin, newMax, trans);
}
}
}
- // Pad bounding box for starting joint, plus polymesh if
- // applicable. Subsequent calcs should be accurate enough to not
- // need padding.
- LLVector4a padding(0.25);
- newMin.sub(padding);
- newMax.add(padding);
+ // Pad bounding box for starting joint, plus polymesh if
+ // applicable. Subsequent calcs should be accurate enough to not
+ // need padding.
+ LLVector4a padding(0.25);
+ newMin.sub(padding);
+ newMax.add(padding);
- // stretch bounding box by static attachments
+ //stretch bounding box by static attachments
if (box_detail >= 2)
{
float max_attachment_span = get_default_max_prim_scale() * 5.0f;
-
+
for (const auto& attach_pair : mAttachmentPoints)
{
LLViewerJointAttachment* attachment = attach_pair.second;
@@ -1409,19 +1427,19 @@ void LLVOAvatar::calculateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
if (bridge)
{
const LLVector4a* ext = bridge->getSpatialExtents();
- LLVector4a distance;
+ LLVector4a distance;
distance.setSub(ext[1], ext[0]);
LLVector4a max_span(max_attachment_span);
S32 lt = distance.lessThan(max_span).getGatheredBits() & 0x7;
-
+
// Only add the prim to spatial extents calculations if it isn't a megaprim.
- // max_attachment_span calculated at the start of the function
- // (currently 5 times our max prim size)
+ // max_attachment_span calculated at the start of the function
+ // (currently 5 times our max prim size)
if (lt == 0x7)
{
- update_min_max(newMin, newMax, ext[0]);
- update_min_max(newMin, newMax, ext[1]);
+ update_min_max(newMin,newMax,ext[0]);
+ update_min_max(newMin,newMax,ext[1]);
}
}
}
@@ -1434,7 +1452,7 @@ void LLVOAvatar::calculateSpatialExtents(LLVector4a& newMin, LLVector4a& newMax)
// Stretch bounding box by rigged mesh joint boxes
if (box_detail>=3)
{
- updateRiggingInfo();
+ updateRiggingInfo();
for (S32 joint_num = 0; joint_num < LL_CHARACTER_MAX_ANIMATED_JOINTS; joint_num++)
{
LLJoint *joint = getJoint(joint_num);
@@ -1998,6 +2016,38 @@ void LLVOAvatar::resetVisualParams()
}
}
+void LLVOAvatar::applyDefaultParams()
+{
+ // These are params from avs with newly created copies of shape,
+ // skin, hair, eyes, plus gender set as noted. Run arche_tool.py
+ // to get params from some other xml appearance dump.
+ std::map<S32, U8> male_params = {
+ {1,33}, {2,61}, {4,85}, {5,23}, {6,58}, {7,127}, {8,63}, {10,85}, {11,63}, {12,42}, {13,0}, {14,85}, {15,63}, {16,36}, {17,85}, {18,95}, {19,153}, {20,63}, {21,34}, {22,0}, {23,63}, {24,109}, {25,88}, {27,132}, {31,63}, {33,136}, {34,81}, {35,85}, {36,103}, {37,136}, {38,127}, {80,255}, {93,203}, {98,0}, {99,0}, {105,127}, {108,0}, {110,0}, {111,127}, {112,0}, {113,0}, {114,127}, {115,0}, {116,0}, {117,0}, {119,127}, {130,114}, {131,127}, {132,99}, {133,63}, {134,127}, {135,140}, {136,127}, {137,127}, {140,0}, {141,0}, {142,0}, {143,191}, {150,0}, {155,104}, {157,0}, {162,0}, {163,0}, {165,0}, {166,0}, {167,0}, {168,0}, {169,0}, {177,0}, {181,145}, {182,216}, {183,133}, {184,0}, {185,127}, {192,0}, {193,127}, {196,170}, {198,0}, {503,0}, {505,127}, {506,127}, {507,109}, {508,85}, {513,127}, {514,127}, {515,63}, {517,85}, {518,42}, {603,100}, {604,216}, {605,214}, {606,204}, {607,204}, {608,204}, {609,51}, {616,25}, {617,89}, {619,76}, {624,204}, {625,0}, {629,127}, {637,0}, {638,0}, {646,144}, {647,85}, {649,127}, {650,132}, {652,127}, {653,85}, {654,0}, {656,127}, {659,127}, {662,127}, {663,127}, {664,127}, {665,127}, {674,59}, {675,127}, {676,85}, {678,127}, {682,127}, {683,106}, {684,47}, {685,79}, {690,127}, {692,127}, {693,204}, {700,63}, {701,0}, {702,0}, {703,0}, {704,0}, {705,127}, {706,127}, {707,0}, {708,0}, {709,0}, {710,0}, {711,127}, {712,0}, {713,159}, {714,0}, {715,0}, {750,178}, {752,127}, {753,36}, {754,85}, {755,131}, {756,127}, {757,127}, {758,127}, {759,153}, {760,95}, {762,0}, {763,140}, {764,74}, {765,27}, {769,127}, {773,127}, {775,0}, {779,214}, {780,204}, {781,198}, {785,0}, {789,0}, {795,63}, {796,30}, {799,127}, {800,226}, {801,255}, {802,198}, {803,255}, {804,255}, {805,255}, {806,255}, {807,255}, {808,255}, {812,255}, {813,255}, {814,255}, {815,204}, {816,0}, {817,255}, {818,255}, {819,255}, {820,255}, {821,255}, {822,255}, {823,255}, {824,255}, {825,255}, {826,255}, {827,255}, {828,0}, {829,255}, {830,255}, {834,255}, {835,255}, {836,255}, {840,0}, {841,127}, {842,127}, {844,255}, {848,25}, {858,100}, {859,255}, {860,255}, {861,255}, {862,255}, {863,84}, {868,0}, {869,0}, {877,0}, {879,51}, {880,132}, {921,255}, {922,255}, {923,255}, {10000,0}, {10001,0}, {10002,25}, {10003,0}, {10004,25}, {10005,23}, {10006,51}, {10007,0}, {10008,25}, {10009,23}, {10010,51}, {10011,0}, {10012,0}, {10013,25}, {10014,0}, {10015,25}, {10016,23}, {10017,51}, {10018,0}, {10019,0}, {10020,25}, {10021,0}, {10022,25}, {10023,23}, {10024,51}, {10025,0}, {10026,25}, {10027,23}, {10028,51}, {10029,0}, {10030,25}, {10031,23}, {10032,51}, {11000,1}, {11001,127}
+ };
+ std::map<S32, U8> female_params = {
+ {1,33}, {2,61}, {4,85}, {5,23}, {6,58}, {7,127}, {8,63}, {10,85}, {11,63}, {12,42}, {13,0}, {14,85}, {15,63}, {16,36}, {17,85}, {18,95}, {19,153}, {20,63}, {21,34}, {22,0}, {23,63}, {24,109}, {25,88}, {27,132}, {31,63}, {33,136}, {34,81}, {35,85}, {36,103}, {37,136}, {38,127}, {80,0}, {93,203}, {98,0}, {99,0}, {105,127}, {108,0}, {110,0}, {111,127}, {112,0}, {113,0}, {114,127}, {115,0}, {116,0}, {117,0}, {119,127}, {130,114}, {131,127}, {132,99}, {133,63}, {134,127}, {135,140}, {136,127}, {137,127}, {140,0}, {141,0}, {142,0}, {143,191}, {150,0}, {155,104}, {157,0}, {162,0}, {163,0}, {165,0}, {166,0}, {167,0}, {168,0}, {169,0}, {177,0}, {181,145}, {182,216}, {183,133}, {184,0}, {185,127}, {192,0}, {193,127}, {196,170}, {198,0}, {503,0}, {505,127}, {506,127}, {507,109}, {508,85}, {513,127}, {514,127}, {515,63}, {517,85}, {518,42}, {603,100}, {604,216}, {605,214}, {606,204}, {607,204}, {608,204}, {609,51}, {616,25}, {617,89}, {619,76}, {624,204}, {625,0}, {629,127}, {637,0}, {638,0}, {646,144}, {647,85}, {649,127}, {650,132}, {652,127}, {653,85}, {654,0}, {656,127}, {659,127}, {662,127}, {663,127}, {664,127}, {665,127}, {674,59}, {675,127}, {676,85}, {678,127}, {682,127}, {683,106}, {684,47}, {685,79}, {690,127}, {692,127}, {693,204}, {700,63}, {701,0}, {702,0}, {703,0}, {704,0}, {705,127}, {706,127}, {707,0}, {708,0}, {709,0}, {710,0}, {711,127}, {712,0}, {713,159}, {714,0}, {715,0}, {750,178}, {752,127}, {753,36}, {754,85}, {755,131}, {756,127}, {757,127}, {758,127}, {759,153}, {760,95}, {762,0}, {763,140}, {764,74}, {765,27}, {769,127}, {773,127}, {775,0}, {779,214}, {780,204}, {781,198}, {785,0}, {789,0}, {795,63}, {796,30}, {799,127}, {800,226}, {801,255}, {802,198}, {803,255}, {804,255}, {805,255}, {806,255}, {807,255}, {808,255}, {812,255}, {813,255}, {814,255}, {815,204}, {816,0}, {817,255}, {818,255}, {819,255}, {820,255}, {821,255}, {822,255}, {823,255}, {824,255}, {825,255}, {826,255}, {827,255}, {828,0}, {829,255}, {830,255}, {834,255}, {835,255}, {836,255}, {840,0}, {841,127}, {842,127}, {844,255}, {848,25}, {858,100}, {859,255}, {860,255}, {861,255}, {862,255}, {863,84}, {868,0}, {869,0}, {877,0}, {879,51}, {880,132}, {921,255}, {922,255}, {923,255}, {10000,0}, {10001,0}, {10002,25}, {10003,0}, {10004,25}, {10005,23}, {10006,51}, {10007,0}, {10008,25}, {10009,23}, {10010,51}, {10011,0}, {10012,0}, {10013,25}, {10014,0}, {10015,25}, {10016,23}, {10017,51}, {10018,0}, {10019,0}, {10020,25}, {10021,0}, {10022,25}, {10023,23}, {10024,51}, {10025,0}, {10026,25}, {10027,23}, {10028,51}, {10029,0}, {10030,25}, {10031,23}, {10032,51}, {11000,1}, {11001,127}
+ };
+ std::map<S32, U8> *params = NULL;
+ if (getSex() == SEX_MALE)
+ params = &male_params;
+ else
+ params = &female_params;
+
+ for( auto it = params->begin(); it != params->end(); ++it)
+ {
+ LLVisualParam* param = getVisualParam(it->first);
+ if( !param )
+ {
+ // invalid id
+ break;
+ }
+
+ U8 value = it->second;
+ F32 newWeight = U8_to_F32(value, param->getMinWeight(), param->getMaxWeight());
+ param->setWeight(newWeight);
+ }
+}
+
//-----------------------------------------------------------------------------
// resetSkeleton()
//-----------------------------------------------------------------------------
@@ -2060,15 +2110,30 @@ void LLVOAvatar::resetSkeleton(bool reset_animations)
}
// Reset tweakable params to preserved state
- if (mLastProcessedAppearance)
- {
- bool slam_params = true;
- applyParsedAppearanceMessage(*mLastProcessedAppearance, slam_params);
- }
+ if (getOverallAppearance() == AOA_NORMAL)
+ {
+ if (mLastProcessedAppearance)
+ {
+ bool slam_params = true;
+ applyParsedAppearanceMessage(*mLastProcessedAppearance, slam_params);
+ }
+ }
+ else
+ {
+ // Stripped down approximation of
+ // applyParsedAppearanceMessage, but with alternative default
+ // (jellydoll) params
+ setCompositeUpdatesEnabled( FALSE );
+ gPipeline.markGLRebuild(this);
+ applyDefaultParams();
+ setCompositeUpdatesEnabled( TRUE );
+ updateMeshTextures();
+ updateMeshVisibility();
+ }
updateVisualParams();
// Restore attachment pos overrides
- updateAttachmentOverrides();
+ updateAttachmentOverrides();
// Animations
if (reset_animations)
@@ -2701,7 +2766,7 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
BOOL visible = isVisible() || mNeedsAnimUpdate;
// update attachments positions
- if (detailed_update || !sUseImpostors)
+ if (detailed_update)
{
LL_RECORD_BLOCK_TIME(FTM_ATTACHMENT_UPDATE);
auto& selectMgr = LLSelectMgr::instance();
@@ -2757,6 +2822,7 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
if (angle_diff > F_PI/512.f*distance*mUpdatePeriod)
{
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 2;
}
}
@@ -2768,6 +2834,7 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
if (dist_diff/mImpostorDistance > 0.1f)
{
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 3;
}
else
{
@@ -2780,6 +2847,7 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
if (diff.getLength3().getF32() > 0.05f)
{
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 4;
}
else
{
@@ -2787,6 +2855,7 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
if (diff.getLength3().getF32() > 0.05f)
{
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 5;
}
}
}
@@ -2795,13 +2864,13 @@ void LLVOAvatar::idleUpdateMisc(bool detailed_update)
if (mDrawable.notNull())
{
- mDrawable->movePartition();
+ mDrawable->movePartition();
- //force a move if sitting on an active object
- if (getParent() && ((LLViewerObject*) getParent())->mDrawable->isActive())
- {
- gPipeline.markMoved(mDrawable, TRUE);
- }
+ //force a move if sitting on an active object
+ if (getParent() && ((LLViewerObject*) getParent())->mDrawable->isActive())
+ {
+ gPipeline.markMoved(mDrawable, TRUE);
+ }
}
}
@@ -3599,8 +3668,13 @@ bool LLVOAvatar::isVisuallyMuted()
muted = false;
}
else if (mVisuallyMuteSetting == AV_DO_NOT_RENDER)
- { // Always want to see this AV as an impostor
+ {
+#ifdef JELLYDOLLS_SHOULD_IMPOSTOR
muted = true;
+ // Always want to see this AV as an impostor
+#else
+ muted = false;
+#endif
}
else if (isInMuteList())
{
@@ -3612,7 +3686,7 @@ bool LLVOAvatar::isVisuallyMuted()
muted = true;
}
// [/RLVa:KB]
- else
+ else
{
muted = isTooComplex();
}
@@ -3726,9 +3800,14 @@ void LLVOAvatar::updateAppearanceMessageDebugText()
if (hover_offset[2] != 0.0)
{
debug_line += llformat(" hov_z: %.3f", hover_offset[2]);
- debug_line += llformat(" %s", (isSitting() ? "S" : "T"));
+ debug_line += llformat(" %s", (isSitting() ? "S" : "T"));
debug_line += llformat("%s", (isMotionActive(ANIM_AGENT_SIT_GROUND_CONSTRAINED) ? "G" : "-"));
}
+ if (mInAir)
+ {
+ debug_line += " A";
+
+ }
LLVector3 ankle_right_pos_agent = mFootRightp->getWorldPosition();
LLVector3 normal;
@@ -3741,9 +3820,38 @@ void LLVOAvatar::updateAppearanceMessageDebugText()
LLVector3 pelvis_pos = mPelvisp->getPosition();
debug_line += llformat(" rp %.3f pp %.3f", root_pos[2], pelvis_pos[2]);
- S32 is_visible = (S32) isVisible();
- S32 is_m_visible = (S32) mVisible;
- debug_line += llformat(" v %d/%d", is_visible, is_m_visible);
+ const LLVector3& scale = getScale();
+ debug_line += llformat(" scale-z %.3f", scale[2]);
+ S32 is_visible = (S32) isVisible();
+ S32 is_m_visible = (S32) mVisible;
+ debug_line += llformat(" v %d/%d", is_visible, is_m_visible);
+
+ AvatarOverallAppearance aoa = getOverallAppearance();
+ if (aoa == AOA_NORMAL)
+ {
+ debug_line += " N";
+ }
+ else if (aoa == AOA_JELLYDOLL)
+ {
+ debug_line += " J";
+ }
+ else
+ {
+ debug_line += " I";
+ }
+
+ if (mMeshValid)
+ {
+ debug_line += "m";
+ }
+ else
+ {
+ debug_line += "-";
+ }
+ if (isImpostor())
+ {
+ debug_line += " Imp" + llformat("%d[%d]:%.1f", mUpdatePeriod, mLastImpostorUpdateReason, ((F32)(gFrameTimeSeconds-mLastImpostorUpdateFrameTime)));
+ }
addDebugText(debug_line);
}
@@ -3783,11 +3891,11 @@ LLViewerInventoryItem* recursiveGetObjectInventoryItem(LLViewerObject *vobj, LLU
void LLVOAvatar::updateAnimationDebugText()
{
- for (LLMotion* motionp : mMotionController.getActiveMotions())
+ for (LLMotion* motionp : mMotionController.getActiveMotions())
+ {
+ if (motionp->getMinPixelArea() < getPixelArea())
{
- if (motionp->getMinPixelArea() < getPixelArea())
- {
- std::string output;
+ std::string output;
std::string motion_name = motionp->getName();
if (motion_name.empty())
{
@@ -3804,73 +3912,74 @@ void LLVOAvatar::updateAnimationDebugText()
}
}
if (motion_name.empty())
+ {
+ std::string name;
+ if (gAgent.isGodlikeWithoutAdminMenuFakery() || isSelf())
{
- std::string name;
- if (gAgent.isGodlikeWithoutAdminMenuFakery() || isSelf())
+ name = motionp->getID().asString();
+ LLVOAvatar::AnimSourceIterator anim_it = mAnimationSources.begin();
+ for (; anim_it != mAnimationSources.end(); ++anim_it)
{
- name = motionp->getID().asString();
- LLVOAvatar::AnimSourceIterator anim_it = mAnimationSources.begin();
- for (; anim_it != mAnimationSources.end(); ++anim_it)
+ if (anim_it->second == motionp->getID())
{
- if (anim_it->second == motionp->getID())
+ LLViewerObject* object = gObjectList.findObject(anim_it->first);
+ if (!object)
{
- LLViewerObject* object = gObjectList.findObject(anim_it->first);
- if (!object)
+ break;
+ }
+ if (object->isAvatar())
+ {
+ if (mMotionController.mIsSelf)
+ {
+ // Searching inventory by asset id is really long
+ // so just mark as inventory
+ // Also item is likely to be named by LLPreviewAnim
+ name += "(inventory)";
+ }
+ }
+ else
+ {
+ LLViewerInventoryItem* item = NULL;
+ if (!object->isInventoryDirty())
+ {
+ item = object->getInventoryItemByAsset(motionp->getID());
+ }
+ if (item)
{
- break;
+ name = item->getName();
}
- if (object->isAvatar())
+ else if (object->isAttachment())
{
- if (mMotionController.mIsSelf)
- {
- // Searching inventory by asset id is really long
- // so just mark as inventory
- // Also item is likely to be named by LLPreviewAnim
- name += "(inventory)";
- }
+ name += "(att:" + getAttachmentItemName() + ")";
}
else
{
- LLViewerInventoryItem* item = NULL;
- if (!object->isInventoryDirty())
- {
- item = object->getInventoryItemByAsset(motionp->getID());
- }
- if (item)
- {
- name = item->getName();
- }
- else if (object->isAttachment())
- {
- name += "(" + getAttachmentItemName() + ")";
- }
- else
- {
- // in-world object, name or content unknown
- name += "(in-world)";
- }
+ // in-world object, name or content unknown
+ name += "(in-world)";
}
- break;
}
+ break;
}
}
- else
- {
- name = LLUUID::null.asString();
- }
- output = llformat("%s - %d",
- name.c_str(),
- (U32)motionp->getPriority());
}
else
{
- output = llformat("%s - %d",
- motion_name.c_str(),
- (U32)motionp->getPriority());
+ name = LLUUID::null.asString();
}
- addDebugText(output);
+ motion_name = name;
+ }
+ std::string motion_tag = "";
+ if (mPlayingAnimations.find(motionp->getID()) != mPlayingAnimations.end())
+ {
+ motion_tag = "*";
}
+ output = llformat("%s%s - %d",
+ motion_name.c_str(),
+ motion_tag.c_str(),
+ (U32)motionp->getPriority());
+ addDebugText(output);
}
+ }
}
void LLVOAvatar::updateDebugText()
@@ -4001,7 +4110,14 @@ void LLVOAvatar::updateFootstepSounds()
// computeUpdatePeriod()
// Factored out from updateCharacter()
// Set new value for mUpdatePeriod based on distance and various other factors.
-//------------------------------------------------------------------------
+//
+// Note 10-2020: it turns out that none of these update period
+// calculations have been having any effect, because
+// mNeedsImpostorUpdate was not being set in updateCharacter(). So
+// it's really open to question whether we want to enable time based updates, and if
+// so, at what rate. Leaving the rates as given would lead to
+// drastically more frequent impostor updates than we've been doing all these years.
+// ------------------------------------------------------------------------
void LLVOAvatar::computeUpdatePeriod()
{
bool visually_muted = isVisuallyMuted();
@@ -4009,7 +4125,7 @@ void LLVOAvatar::computeUpdatePeriod()
&& isVisible()
&& (!isSelf() || visually_muted)
&& !isUIAvatar()
- && sUseImpostors
+ && (sLimitNonImpostors || visually_muted)
&& !mNeedsAnimUpdate
&& !sFreezeCounter)
{
@@ -4017,11 +4133,14 @@ void LLVOAvatar::computeUpdatePeriod()
LLVector4a size;
size.setSub(ext[1],ext[0]);
F32 mag = size.getLength3().getF32()*0.5f;
+
+ const S32 UPDATE_RATE_SLOW = 64;
+ const S32 UPDATE_RATE_MED = 48;
+ const S32 UPDATE_RATE_FAST = 32;
- F32 impostor_area = 256.f*512.f*(8.125f - LLVOAvatar::sLODFactor*8.f);
if (visually_muted)
- { // visually muted avatars update at 16 hz
- mUpdatePeriod = 16;
+ { // visually muted avatars update at lowest rate
+ mUpdatePeriod = UPDATE_RATE_SLOW;
}
else if (! shouldImpostor()
|| mDrawable->mDistanceWRTCamera < 1.f + mag)
@@ -4030,34 +4149,29 @@ void LLVOAvatar::computeUpdatePeriod()
// impostor camera near clip plane
mUpdatePeriod = 1;
}
- else if ( shouldImpostor(4) )
+ else if ( shouldImpostor(4.0) )
{ //background avatars are REALLY slow updating impostors
- mUpdatePeriod = 16;
+ mUpdatePeriod = UPDATE_RATE_SLOW;
}
else if (mLastRezzedStatus <= 0)
{
// Don't update cloud avatars too often
- mUpdatePeriod = 8;
+ mUpdatePeriod = UPDATE_RATE_SLOW;
}
- else if ( shouldImpostor(3) )
+ else if ( shouldImpostor(3.0) )
{ //back 25% of max visible avatars are slow updating impostors
- mUpdatePeriod = 8;
- }
- else if (mImpostorPixelArea <= impostor_area)
- { // stuff in between gets an update period based on pixel area
- mUpdatePeriod = llclamp((S32) sqrtf(impostor_area*4.f/mImpostorPixelArea), 2, 8);
+ mUpdatePeriod = UPDATE_RATE_MED;
}
- else
+ else
{
//nearby avatars, update the impostors more frequently.
- mUpdatePeriod = 4;
+ mUpdatePeriod = UPDATE_RATE_FAST;
}
}
else
{
mUpdatePeriod = 1;
}
-
}
//------------------------------------------------------------------------
@@ -4328,7 +4442,33 @@ void LLVOAvatar::updateRootPositionAndRotation(LLAgent& agent, F32 speed, bool w
if (!isSitting() && !was_sit_ground_constrained)
{
root_pos += LLVector3d(getHoverOffset());
- }
+ if (getOverallAppearance() == AOA_JELLYDOLL)
+ {
+ F32 offz = -0.5 * (getScale()[VZ] - mBodySize.mV[VZ]);
+ root_pos[2] += offz;
+ // if (!isSelf() && !isControlAvatar())
+ // {
+ // LL_DEBUGS("Avatar") << "av " << getFullname()
+ // << " frame " << LLFrameTimer::getFrameCount()
+ // << " root adjust offz " << offz
+ // << " scalez " << getScale()[VZ]
+ // << " bsz " << mBodySize.mV[VZ]
+ // << LL_ENDL;
+ // }
+ }
+ }
+ // if (!isSelf() && !isControlAvatar())
+ // {
+ // LL_DEBUGS("Avatar") << "av " << getFullname() << " aoa " << (S32) getOverallAppearance()
+ // << " frame " << LLFrameTimer::getFrameCount()
+ // << " scalez " << getScale()[VZ]
+ // << " bsz " << mBodySize.mV[VZ]
+ // << " root pos " << root_pos[2]
+ // << " curr rootz " << mRoot->getPosition()[2]
+ // << " pp-z " << mPelvisp->getPosition()[2]
+ // << " renderpos " << getRenderPosition()
+ // << LL_ENDL;
+ // }
if (isControlAvatar())
{
@@ -4338,6 +4478,14 @@ void LLVOAvatar::updateRootPositionAndRotation(LLAgent& agent, F32 speed, bool w
else
{
LLVector3 newPosition = gAgent.getPosAgentFromGlobal(root_pos);
+ // if (!isSelf() && !isControlAvatar())
+ // {
+ // LL_DEBUGS("Avatar") << "av " << getFullname()
+ // << " frame " << LLFrameTimer::getFrameCount()
+ // << " newPosition " << newPosition
+ // << " renderpos " << getRenderPosition()
+ // << LL_ENDL;
+ // }
if (newPosition != mRoot->getXform()->getWorldPosition())
{
mRoot->touch();
@@ -4368,6 +4516,37 @@ void LLVOAvatar::updateRootPositionAndRotation(LLAgent& agent, F32 speed, bool w
}
//------------------------------------------------------------------------
+// LLVOAvatar::computeNeedsUpdate()
+//
+// Most of the logic here is to figure out when to periodically update impostors.
+// Non-impostors have mUpdatePeriod == 1 and will need update every frame.
+//------------------------------------------------------------------------
+bool LLVOAvatar::computeNeedsUpdate()
+{
+ const F32 MAX_IMPOSTOR_INTERVAL = 4.0f;
+ computeUpdatePeriod();
+
+ bool needs_update_by_frame_count = ((LLDrawable::getCurrentFrame()+mID.mData[0])%mUpdatePeriod == 0);
+
+ bool needs_update_by_max_time = ((gFrameTimeSeconds-mLastImpostorUpdateFrameTime)> MAX_IMPOSTOR_INTERVAL);
+ bool needs_update = needs_update_by_frame_count || needs_update_by_max_time;
+
+ if (needs_update && !isSelf())
+ {
+ if (needs_update_by_max_time)
+ {
+ mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 11;
+ }
+ else
+ {
+ //mNeedsImpostorUpdate = TRUE;
+ //mLastImpostorUpdateReason = 10;
+ }
+ }
+ return needs_update;
+}
+
// updateCharacter()
//
// This is called for all avatars, so there are 4 possible situations:
@@ -4390,7 +4569,7 @@ void LLVOAvatar::updateRootPositionAndRotation(LLAgent& agent, F32 speed, bool w
// simulator.
//
//------------------------------------------------------------------------
-BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
+bool LLVOAvatar::updateCharacter(LLAgent &agent)
{
updateDebugText();
@@ -4403,6 +4582,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
#ifdef SHOW_DEBUG
bool is_control_avatar = isControlAvatar(); // capture state to simplify tracing
bool is_attachment = false;
+
if (is_control_avatar)
{
LLControlAvatar *cav = static_cast<LLControlAvatar*>(this);
@@ -4423,11 +4603,11 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
//--------------------------------------------------------------------
// The rest should only be done occasionally for far away avatars.
- // Set mUpdatePeriod and visible based on distance and other criteria.
+ // Set mUpdatePeriod and visible based on distance and other criteria,
+ // and flag for impostor update if needed.
//--------------------------------------------------------------------
- computeUpdatePeriod();
- bool needs_update = (LLDrawable::getCurrentFrame()+mID.mData[0])%mUpdatePeriod == 0;
-
+ bool needs_update = computeNeedsUpdate();
+
//--------------------------------------------------------------------
// Early out if does not need update and not self
// don't early out for your own avatar, as we rely on your animations playing reliably
@@ -4440,6 +4620,12 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
return FALSE;
}
+ //--------------------------------------------------------------------
+ // Handle transitions between regular rendering, jellydoll, or invisible.
+ // Can trigger skeleton reset or animation changes
+ //--------------------------------------------------------------------
+ updateOverallAppearance();
+
//--------------------------------------------------------------------
// change animation time quanta based on avatar render load
//--------------------------------------------------------------------
@@ -4523,8 +4709,8 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
if (visible)
{
- // System avatar mesh vertices need to be reskinned.
- mNeedsSkin = TRUE;
+ // System avatar mesh vertices need to be reskinned.
+ mNeedsSkin = TRUE;
}
return visible;
@@ -4968,7 +5154,8 @@ U32 LLVOAvatar::renderSkinned()
}
if (!isSelf() || gAgent.needsRenderHead() || LLPipeline::sShadowRender)
{
- if (isTextureVisible(TEX_HEAD_BAKED) || isUIAvatar())
+
+ if (isTextureVisible(TEX_HEAD_BAKED) || (getOverallAppearance() == AOA_JELLYDOLL && !isControlAvatar()) || isUIAvatar())
{
LLViewerJoint* head_mesh = getViewerJoint(MESH_ID_HEAD);
if (head_mesh)
@@ -4978,7 +5165,7 @@ U32 LLVOAvatar::renderSkinned()
first_pass = FALSE;
}
}
- if (isTextureVisible(TEX_UPPER_BAKED) || isUIAvatar())
+ if (isTextureVisible(TEX_UPPER_BAKED) || (getOverallAppearance() == AOA_JELLYDOLL && !isControlAvatar()) || isUIAvatar())
{
LLViewerJoint* upper_mesh = getViewerJoint(MESH_ID_UPPER_BODY);
if (upper_mesh)
@@ -4988,7 +5175,7 @@ U32 LLVOAvatar::renderSkinned()
first_pass = FALSE;
}
- if (isTextureVisible(TEX_LOWER_BAKED) || isUIAvatar())
+ if (isTextureVisible(TEX_LOWER_BAKED) || (getOverallAppearance() == AOA_JELLYDOLL && !isControlAvatar()) || isUIAvatar())
{
LLViewerJoint* lower_mesh = getViewerJoint(MESH_ID_LOWER_BODY);
if (lower_mesh)
@@ -5045,7 +5232,7 @@ U32 LLVOAvatar::renderTransparent(BOOL first_pass)
}
first_pass = FALSE;
}
- if (isTextureVisible(TEX_HAIR_BAKED))
+ if (isTextureVisible(TEX_HAIR_BAKED) && (getOverallAppearance() != AOA_JELLYDOLL))
{
LLViewerJoint* hair_mesh = getViewerJoint(MESH_ID_HAIR);
if (hair_mesh)
@@ -5093,7 +5280,7 @@ U32 LLVOAvatar::renderRigid()
gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f);
}
- if (isTextureVisible(TEX_EYES_BAKED) || isUIAvatar())
+ if (isTextureVisible(TEX_EYES_BAKED) || (getOverallAppearance() == AOA_JELLYDOLL && !isControlAvatar()) || isUIAvatar())
{
LLViewerJoint* eyeball_left = getViewerJoint(MESH_ID_EYEBALL_LEFT);
LLViewerJoint* eyeball_right = getViewerJoint(MESH_ID_EYEBALL_RIGHT);
@@ -5722,8 +5909,8 @@ void LLVOAvatar::processAnimationStateChanges()
stopMotion(ANIM_AGENT_TARGET);
if (mEnableDefaultMotions)
{
- startMotion(ANIM_AGENT_BODY_NOISE);
- }
+ startMotion(ANIM_AGENT_BODY_NOISE);
+ }
}
// clear all current animations
@@ -5743,23 +5930,32 @@ void LLVOAvatar::processAnimationStateChanges()
}
}
+ // if jellydolled, shelve all playing animations
+ if (getOverallAppearance() != AOA_NORMAL)
+ {
+ mPlayingAnimations.clear();
+ }
+
// start up all new anims
- for (auto anim_it = mSignaledAnimations.begin(); anim_it != mSignaledAnimations.end();)
+ if (getOverallAppearance() == AOA_NORMAL)
{
- AnimIterator found_anim = mPlayingAnimations.find(anim_it->first);
-
- // signaled but not playing, or different sequence id, start motion
- if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second)
+ for (auto anim_it = mSignaledAnimations.begin(); anim_it != mSignaledAnimations.end();)
{
- if (processSingleAnimationStateChange(anim_it->first, TRUE))
+ AnimIterator found_anim = mPlayingAnimations.find(anim_it->first);
+
+ // signaled but not playing, or different sequence id, start motion
+ if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second)
{
- mPlayingAnimations[anim_it->first] = anim_it->second;
- ++anim_it;
- continue;
+ if (processSingleAnimationStateChange(anim_it->first, TRUE))
+ {
+ mPlayingAnimations[anim_it->first] = anim_it->second;
+ ++anim_it;
+ continue;
+ }
}
- }
- ++anim_it;
+ ++anim_it;
+ }
}
// clear source information for animations which have been stopped
@@ -6355,6 +6551,11 @@ void LLVOAvatar::addAttachmentOverridesForObject(LLViewerObject *vo, std::set<LL
return;
}
+ if (getOverallAppearance() != AOA_NORMAL)
+ {
+ return;
+ }
+
#ifdef SHOW_DEBUG
LLScopedContextString str("addAttachmentOverridesForObject " + getFullname());
@@ -7766,9 +7967,15 @@ void LLVOAvatar::onGlobalColorChanged(const LLTexGlobalColor* global_color)
}
// virtual
+// Do rigged mesh attachments display with this av?
bool LLVOAvatar::shouldRenderRigged() const
{
- return true;
+ if (getOverallAppearance() == AOA_NORMAL)
+ {
+ return true;
+ }
+ // TBD - render for AOA_JELLYDOLL?
+ return false;
}
// FIXME: We have an mVisible member, set in updateVisibility(), but this
@@ -8056,12 +8263,14 @@ BOOL LLVOAvatar::processFullyLoadedChange(bool loading)
}
// did our loading state "change" from last call?
- // runway - why are we updating every 30 calls even if nothing has changed?
+ // FIXME runway - why are we updating every 30 calls even if nothing has changed?
+ // This causes updateLOD() to run every 30 frames, among other things.
const S32 UPDATE_RATE = 30;
BOOL changed =
((mFullyLoaded != mPreviousFullyLoaded) || // if the value is different from the previous call
(!mFullyLoadedInitialized) || // if we've never been called before
(mFullyLoadedFrameCounter % UPDATE_RATE == 0)); // every now and then issue a change
+ BOOL fully_loaded_changed = (mFullyLoaded != mPreviousFullyLoaded);
mPreviousFullyLoaded = mFullyLoaded;
mFullyLoadedInitialized = TRUE;
@@ -8072,7 +8281,13 @@ BOOL LLVOAvatar::processFullyLoadedChange(bool loading)
// to know about outfit switching
LLAvatarRenderNotifier::getInstance()->updateNotificationState();
}
-
+
+ if (fully_loaded_changed && !isSelf() && mFullyLoaded && isImpostor())
+ {
+ // Fix for jellydoll initially invisible
+ mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 6;
+ }
return changed;
}
@@ -8147,40 +8362,20 @@ void LLVOAvatar::updateMeshVisibility()
bool bake_flag[BAKED_NUM_INDICES];
memset(bake_flag, 0, BAKED_NUM_INDICES*sizeof(bool));
- for (const auto& attach_pair : mAttachmentPoints)
+ if (getOverallAppearance() == AOA_NORMAL)
{
- LLViewerJointAttachment* attachment = attach_pair.second;
- if (attachment)
+ for (const auto& attach_pair : mAttachmentPoints)
{
- for (LLViewerObject* objectp : attachment->mAttachedObjects)
+ LLViewerJointAttachment* attachment = attach_pair.second;
+ if (attachment)
{
- if (objectp)
- {
- for (int face_index = 0; face_index < objectp->getNumTEs(); face_index++)
- {
- LLTextureEntry* tex_entry = objectp->getTE(face_index);
- bake_flag[BAKED_HEAD] |= (tex_entry->getID() == IMG_USE_BAKED_HEAD);
- bake_flag[BAKED_EYES] |= (tex_entry->getID() == IMG_USE_BAKED_EYES);
- bake_flag[BAKED_HAIR] |= (tex_entry->getID() == IMG_USE_BAKED_HAIR);
- bake_flag[BAKED_LOWER] |= (tex_entry->getID() == IMG_USE_BAKED_LOWER);
- bake_flag[BAKED_UPPER] |= (tex_entry->getID() == IMG_USE_BAKED_UPPER);
- bake_flag[BAKED_SKIRT] |= (tex_entry->getID() == IMG_USE_BAKED_SKIRT);
- bake_flag[BAKED_LEFT_ARM] |= (tex_entry->getID() == IMG_USE_BAKED_LEFTARM);
- bake_flag[BAKED_LEFT_LEG] |= (tex_entry->getID() == IMG_USE_BAKED_LEFTLEG);
- bake_flag[BAKED_AUX1] |= (tex_entry->getID() == IMG_USE_BAKED_AUX1);
- bake_flag[BAKED_AUX2] |= (tex_entry->getID() == IMG_USE_BAKED_AUX2);
- bake_flag[BAKED_AUX3] |= (tex_entry->getID() == IMG_USE_BAKED_AUX3);
- }
- }
-
- LLViewerObject::const_child_list_t& child_list = objectp->getChildren();
- for (LLViewerObject* objectchild : child_list)
+ for (LLViewerObject* objectp : attachment->mAttachedObjects)
{
- if (objectchild)
+ if (objectp)
{
- for (int face_index = 0; face_index < objectchild->getNumTEs(); face_index++)
+ for (int face_index = 0; face_index < objectp->getNumTEs(); face_index++)
{
- LLTextureEntry* tex_entry = objectchild->getTE(face_index);
+ LLTextureEntry* tex_entry = objectp->getTE(face_index);
bake_flag[BAKED_HEAD] |= (tex_entry->getID() == IMG_USE_BAKED_HEAD);
bake_flag[BAKED_EYES] |= (tex_entry->getID() == IMG_USE_BAKED_EYES);
bake_flag[BAKED_HAIR] |= (tex_entry->getID() == IMG_USE_BAKED_HAIR);
@@ -8194,6 +8389,29 @@ void LLVOAvatar::updateMeshVisibility()
bake_flag[BAKED_AUX3] |= (tex_entry->getID() == IMG_USE_BAKED_AUX3);
}
}
+
+ LLViewerObject::const_child_list_t& child_list = objectp->getChildren();
+ for (LLViewerObject* objectchild : child_list)
+ {
+ if (objectchild)
+ {
+ for (int face_index = 0; face_index < objectchild->getNumTEs(); face_index++)
+ {
+ LLTextureEntry* tex_entry = objectchild->getTE(face_index);
+ bake_flag[BAKED_HEAD] |= (tex_entry->getID() == IMG_USE_BAKED_HEAD);
+ bake_flag[BAKED_EYES] |= (tex_entry->getID() == IMG_USE_BAKED_EYES);
+ bake_flag[BAKED_HAIR] |= (tex_entry->getID() == IMG_USE_BAKED_HAIR);
+ bake_flag[BAKED_LOWER] |= (tex_entry->getID() == IMG_USE_BAKED_LOWER);
+ bake_flag[BAKED_UPPER] |= (tex_entry->getID() == IMG_USE_BAKED_UPPER);
+ bake_flag[BAKED_SKIRT] |= (tex_entry->getID() == IMG_USE_BAKED_SKIRT);
+ bake_flag[BAKED_LEFT_ARM] |= (tex_entry->getID() == IMG_USE_BAKED_LEFTARM);
+ bake_flag[BAKED_LEFT_LEG] |= (tex_entry->getID() == IMG_USE_BAKED_LEFTLEG);
+ bake_flag[BAKED_AUX1] |= (tex_entry->getID() == IMG_USE_BAKED_AUX1);
+ bake_flag[BAKED_AUX2] |= (tex_entry->getID() == IMG_USE_BAKED_AUX2);
+ bake_flag[BAKED_AUX3] |= (tex_entry->getID() == IMG_USE_BAKED_AUX3);
+ }
+ }
+ }
}
}
}
@@ -9084,7 +9302,11 @@ void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys )
mLastProcessedAppearance = contents;
bool slam_params = false;
- applyParsedAppearanceMessage(*contents, slam_params);
+ applyParsedAppearanceMessage(*contents, slam_params);
+ if (getOverallAppearance() != AOA_NORMAL)
+ {
+ resetSkeleton(false);
+ }
}
void LLVOAvatar::applyParsedAppearanceMessage(LLAppearanceMessageContents& contents, bool slam_params)
@@ -9979,7 +10201,7 @@ BOOL LLVOAvatar::updateLOD()
return FALSE;
}
- if (isImpostor() && 0 != mDrawable->getNumFaces() && mDrawable->getFace(0)->hasGeometry())
+ if (!LLPipeline::sImpostorRender && isImpostor() && 0 != mDrawable->getNumFaces() && mDrawable->getFace(0)->hasGeometry())
{
return TRUE;
}
@@ -10170,10 +10392,10 @@ void LLVOAvatar::updateImpostors()
for (LLCharacter* character : instances_copy)
{
LLVOAvatar* avatar = static_cast<LLVOAvatar*>(character);
- if (!avatar->isDead() && avatar->isVisible()
- && (
- (avatar->isImpostor() || LLVOAvatar::AV_DO_NOT_RENDER == avatar->getVisualMuteSettings()) && avatar->needsImpostorUpdate())
- )
+ if (!avatar->isDead()
+ && avatar->isVisible()
+ && avatar->isImpostor()
+ && avatar->needsImpostorUpdate())
{
avatar->calcMutedAVColor();
gPipeline.generateImpostor(avatar);
@@ -10186,12 +10408,20 @@ void LLVOAvatar::updateImpostors()
// virtual
BOOL LLVOAvatar::isImpostor()
{
- return sUseImpostors && (isVisuallyMuted() || (mUpdatePeriod >= IMPOSTOR_PERIOD)) ? TRUE : FALSE;
+ return isVisuallyMuted() || (sLimitNonImpostors && (mUpdatePeriod > 1));
}
-BOOL LLVOAvatar::shouldImpostor(const U32 rank_factor) const
+BOOL LLVOAvatar::shouldImpostor(const F32 rank_factor)
{
- return (!isSelf() && sUseImpostors && mVisibilityRank > (sMaxNonImpostors * rank_factor));
+ if (isSelf())
+ {
+ return false;
+ }
+ if (isVisuallyMuted())
+ {
+ return true;
+ }
+ return sLimitNonImpostors && (mVisibilityRank > sMaxNonImpostors * rank_factor);
}
BOOL LLVOAvatar::needsImpostorUpdate() const
@@ -10236,7 +10466,7 @@ void LLVOAvatar::getImpostorValues(LLVector4a* extents, LLVector3& angle, F32& d
}
// static
-const U32 LLVOAvatar::IMPOSTORS_OFF = 66; /* Must equal the maximum allowed the RenderAvatarMaxNonImpostors
+const U32 LLVOAvatar::NON_IMPOSTORS_MAX_SLIDER = 66; /* Must equal the maximum allowed the RenderAvatarMaxNonImpostors
* slider in panel_preferences_graphics1.xml */
// static
@@ -10244,10 +10474,10 @@ void LLVOAvatar::updateImpostorRendering(U32 newMaxNonImpostorsValue)
{
#if SHOW_DEBUG
U32 oldmax = sMaxNonImpostors;
- bool oldflg = sUseImpostors;
+ bool oldflg = sLimitNonImpostors;
#endif
- if (IMPOSTORS_OFF <= newMaxNonImpostorsValue)
+ if (NON_IMPOSTORS_MAX_SLIDER <= newMaxNonImpostorsValue)
{
sMaxNonImpostors = 0;
}
@@ -10255,14 +10485,14 @@ void LLVOAvatar::updateImpostorRendering(U32 newMaxNonImpostorsValue)
{
sMaxNonImpostors = newMaxNonImpostorsValue;
}
- // the sUseImpostors flag depends on whether or not sMaxNonImpostors is set to the no-limit value (0)
- sUseImpostors = (0 != sMaxNonImpostors);
+ // the sLimitNonImpostors flag depends on whether or not sMaxNonImpostors is set to the no-limit value (0)
+ sLimitNonImpostors = (0 != sMaxNonImpostors);
#if SHOW_DEBUG
- if ( oldflg != sUseImpostors )
+ if ( oldflg != sLimitNonImpostors )
{
LL_DEBUGS("AvatarRender")
<< "was " << (oldflg ? "use" : "don't use" ) << " impostors (max " << oldmax << "); "
- << "now " << (sUseImpostors ? "use" : "don't use" ) << " impostors (max " << sMaxNonImpostors << "); "
+ << "now " << (sLimitNonImpostors ? "use" : "don't use" ) << " impostors (max " << sMaxNonImpostors << "); "
<< LL_ENDL;
}
#endif
@@ -10652,10 +10882,178 @@ void LLVOAvatar::setVisualMuteSettings(VisualMuteSettings set)
{
mVisuallyMuteSetting = set;
mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 7;
LLRenderMuteList::getInstance()->saveVisualMuteSetting(getID(), S32(set));
}
+
+void LLVOAvatar::setOverallAppearanceNormal()
+{
+ if (isControlAvatar())
+ return;
+
+ LLVector3 pelvis_pos = getJoint("mPelvis")->getPosition();
+ resetSkeleton(false);
+ getJoint("mPelvis")->setPosition(pelvis_pos);
+
+ for (auto it = mJellyAnims.begin(); it != mJellyAnims.end(); ++it)
+ {
+ bool is_playing = (mPlayingAnimations.find(*it) != mPlayingAnimations.end());
+ LL_DEBUGS("Avatar") << "jelly anim " << *it << " " << is_playing << LL_ENDL;
+ if (!is_playing)
+ {
+ // Anim was not requested for this av by sim, but may be playing locally
+ stopMotion(*it);
+ }
+ }
+ mJellyAnims.clear();
+
+ processAnimationStateChanges();
+}
+
+void LLVOAvatar::setOverallAppearanceJellyDoll()
+{
+ if (isControlAvatar())
+ return;
+
+ // stop current animations
+ {
+ for ( LLVOAvatar::AnimIterator anim_it= mPlayingAnimations.begin();
+ anim_it != mPlayingAnimations.end();
+ ++anim_it)
+ {
+ {
+ stopMotion(anim_it->first, TRUE);
+ }
+ }
+ }
+ processAnimationStateChanges();
+
+ // Start any needed anims for jellydoll
+ updateOverallAppearanceAnimations();
+
+ LLVector3 pelvis_pos = getJoint("mPelvis")->getPosition();
+ resetSkeleton(false);
+ getJoint("mPelvis")->setPosition(pelvis_pos);
+
+}
+
+void LLVOAvatar::setOverallAppearanceInvisible()
+{
+}
+
+void LLVOAvatar::updateOverallAppearance()
+{
+ AvatarOverallAppearance new_overall = getOverallAppearance();
+ if (new_overall != mOverallAppearance)
+ {
+ switch (new_overall)
+ {
+ case AOA_NORMAL:
+ setOverallAppearanceNormal();
+ break;
+ case AOA_JELLYDOLL:
+ setOverallAppearanceJellyDoll();
+ break;
+ case AOA_INVISIBLE:
+ setOverallAppearanceInvisible();
+ break;
+ }
+ mOverallAppearance = new_overall;
+ if (!isSelf())
+ {
+ mNeedsImpostorUpdate = TRUE;
+ mLastImpostorUpdateReason = 8;
+ }
+ updateMeshVisibility();
+ }
+
+ // This needs to be done even if overall appearance has not
+ // changed, since sit/stand status can be different.
+ updateOverallAppearanceAnimations();
+}
+
+void LLVOAvatar::updateOverallAppearanceAnimations()
+{
+ if (isControlAvatar())
+ return;
+
+ if (getOverallAppearance() == AOA_JELLYDOLL)
+ {
+ LLUUID motion_id;
+ if (isSitting() && getParent()) // sitting on object
+ {
+ motion_id = ANIM_AGENT_SIT_FEMALE;
+ }
+ else if (isSitting()) // sitting on ground
+ {
+ motion_id = ANIM_AGENT_SIT_GROUND_CONSTRAINED;
+ }
+ else // standing
+ {
+ motion_id = ANIM_AGENT_STAND;
+ }
+ if (mJellyAnims.find(motion_id) == mJellyAnims.end())
+ {
+ for (auto it = mJellyAnims.begin(); it != mJellyAnims.end(); ++it)
+ {
+ bool is_playing = (mPlayingAnimations.find(*it) != mPlayingAnimations.end());
+ LL_DEBUGS("Avatar") << "jelly anim " << *it << " " << is_playing << LL_ENDL;
+ if (!is_playing)
+ {
+ // Anim was not requested for this av by sim, but may be playing locally
+ stopMotion(*it, TRUE);
+ }
+ }
+ mJellyAnims.clear();
+
+ startMotion(motion_id);
+ mJellyAnims.insert(motion_id);
+
+ processAnimationStateChanges();
+ }
+ }
+}
+
+// Based on isVisuallyMuted(), but has 3 possible results.
+LLVOAvatar::AvatarOverallAppearance LLVOAvatar::getOverallAppearance() const
+{
+ AvatarOverallAppearance result = AOA_NORMAL;
+
+ // Priority order (highest priority first)
+ // * own avatar is always drawn normally
+ // * if on the "always draw normally" list, draw them normally
+ // * if on the "always visually mute" list, show as jellydoll
+ // * if explicitly muted (blocked), show as invisible
+ // * check against the render cost and attachment limits - if too complex, show as jellydoll
+ if (isSelf())
+ {
+ result = AOA_NORMAL;
+ }
+ else // !isSelf()
+ {
+ if (isInMuteList())
+ {
+ result = AOA_INVISIBLE;
+ }
+ else if (mVisuallyMuteSetting == AV_ALWAYS_RENDER)
+ {
+ result = AOA_NORMAL;
+ }
+ else if (mVisuallyMuteSetting == AV_DO_NOT_RENDER)
+ { // Always want to see this AV as an impostor
+ result = AOA_JELLYDOLL;
+ }
+ else if (isTooComplex())
+ {
+ result = AOA_JELLYDOLL;
+ }
+ }
+
+ return result;
+}
+
void LLVOAvatar::calcMutedAVColor()
{
LLColor4 new_color(mMutedAVColor);
@@ -10674,8 +11072,8 @@ void LLVOAvatar::calcMutedAVColor()
{
// [/RLVa:KB]
// explicitly not-rendered avatars are light grey
- new_color = LLColor4::grey3;
- change_msg = " not rendered: color is grey3";
+ new_color = LLColor4::grey4;
+ change_msg = " not rendered: color is grey4";
// [RLVa:KB] - Checked: RLVa-2.2 (@setcam_avdist)
}
// [/RLVa:KB]
@@ -10691,29 +11089,34 @@ void LLVOAvatar::calcMutedAVColor()
new_color = LLColor4::white;
change_msg = " simple imposter ";
}
+#ifdef COLORIZE_JELLYDOLLS
// else if ( mMutedAVColor == LLColor4::white || mMutedAVColor == LLColor4::grey3 || mMutedAVColor == LLColor4::grey4 )
// [RLVa:KB] - Checked: RLVa-2.2 (@setcam_avdist)
else if ( mMutedAVColor == LLColor4::white || mMutedAVColor == LLColor4::grey3 || mMutedAVColor == LLColor4::grey4 || mMutedAVColor == LLColor4::silhouette)
// [/RLVa:KB]
- {
+ {
// select a color based on the first byte of the agents uuid so any muted agent is always the same color
F32 color_value = (F32) (av_id.mData[0]);
F32 spectrum = (color_value / 256.f); // spectrum is between 0 and 1.f
- // Array of colors. These are arranged so only one RGB color changes between each step,
+ // Array of colors. These are arranged so only one RGB color changes between each step,
// and it loops back to red so there is an even distribution. It is not a heat map
- const S32 NUM_SPECTRUM_COLORS = 7;
+ const S32 NUM_SPECTRUM_COLORS = 7;
static LLColor4 * spectrum_color[NUM_SPECTRUM_COLORS] = { &LLColor4::red, &LLColor4::magenta, &LLColor4::blue, &LLColor4::cyan, &LLColor4::green, &LLColor4::yellow, &LLColor4::red };
-
- spectrum = spectrum * (NUM_SPECTRUM_COLORS - 1); // Scale to range of number of colors
- S32 spectrum_index_1 = floor(spectrum); // Desired color will be after this index
- S32 spectrum_index_2 = spectrum_index_1 + 1; // and before this index (inclusive)
+
+ spectrum = spectrum * (NUM_SPECTRUM_COLORS - 1); // Scale to range of number of colors
+ S32 spectrum_index_1 = floor(spectrum); // Desired color will be after this index
+ S32 spectrum_index_2 = spectrum_index_1 + 1; // and before this index (inclusive)
F32 fractBetween = spectrum - (F32)(spectrum_index_1); // distance between the two indexes (0-1)
-
- new_color = lerp(*spectrum_color[spectrum_index_1], *spectrum_color[spectrum_index_2], fractBetween);
- new_color.normalize();
- new_color *= 0.28f; // Tone it down
+ new_color = lerp(*spectrum_color[spectrum_index_1], *spectrum_color[spectrum_index_2], fractBetween);
+ new_color.normalize();
+ new_color *= 0.28f; // Tone it down
+ }
+#endif
+ else
+ {
+ new_color = LLColor4::grey4;
change_msg = " over limit color ";
}
diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index 43a39c7f90706a8fe82e4380566a2c9bfbf93b86..33a3c2180ca148a9caa6210edea23765c1d5e338 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -91,6 +91,7 @@ class LLVOAvatar :
public:
friend class LLVOAvatarSelf;
+ friend class LLAvatarCheckImpostorMode;
/********************************************************************************
** **
@@ -131,6 +132,7 @@ class LLVOAvatar :
public:
/*virtual*/ void updateGL();
/*virtual*/ LLVOAvatar* asAvatar();
+
virtual U32 processUpdateMessage(LLMessageSystem *mesgsys,
void **user_data,
U32 block_num,
@@ -252,6 +254,11 @@ class LLVOAvatar :
virtual bool isControlAvatar() const { return mIsControlAvatar; } // True if this avatar is a control av (no associated user)
virtual bool isUIAvatar() const { return mIsUIAvatar; } // True if this avatar is a supplemental av used in some UI views (no associated user)
+ // If this is an attachment, return the avatar it is attached to. Otherwise NULL.
+ virtual const LLVOAvatar *getAttachedAvatar() const { return NULL; }
+ virtual LLVOAvatar *getAttachedAvatar() { return NULL; }
+
+
private: //aligned members
LL_ALIGN_16(LLVector4a mImpostorExtents[2]);
@@ -262,7 +269,8 @@ class LLVOAvatar :
void updateAppearanceMessageDebugText();
void updateAnimationDebugText();
virtual void updateDebugText();
- virtual BOOL updateCharacter(LLAgent &agent);
+ virtual bool computeNeedsUpdate();
+ virtual bool updateCharacter(LLAgent &agent);
void updateFootstepSounds();
void computeUpdatePeriod();
void updateOrientation(LLAgent &agent, F32 speed, F32 delta_time);
@@ -314,12 +322,12 @@ class LLVOAvatar :
public:
static S32 sRenderName;
static BOOL sRenderGroupTitles;
- static const U32 IMPOSTORS_OFF; /* Must equal the maximum allowed the RenderAvatarMaxNonImpostors
- * slider in panel_preferences_graphics1.xml */
- static U32 sMaxNonImpostors; //(affected by control "RenderAvatarMaxNonImpostors")
- static F32 sRenderDistance; //distance at which avatars will render.
+ static const U32 NON_IMPOSTORS_MAX_SLIDER; /* Must equal the maximum allowed the RenderAvatarMaxNonImpostors
+ * slider in panel_preferences_graphics1.xml */
+ static U32 sMaxNonImpostors; // affected by control "RenderAvatarMaxNonImpostors"
+ static bool sLimitNonImpostors; // use impostors for far away avatars
+ static F32 sRenderDistance; // distance at which avatars will render.
static BOOL sShowAnimationDebug; // show animation debug info
- static bool sUseImpostors; //use impostors for far away avatars
static BOOL sShowFootPlane; // show foot collision plane reported by server
static BOOL sShowCollisionVolumes; // show skeletal collision volumes
static BOOL sVisibleInFirstPerson;
@@ -407,6 +415,7 @@ class LLVOAvatar :
void initAttachmentPoints(bool ignore_hud_joints = false);
/*virtual*/ void buildCharacter();
void resetVisualParams();
+ void applyDefaultParams();
void resetSkeleton(bool reset_animations);
LLVector3 mCurRootToHeadOffset;
@@ -434,6 +443,9 @@ class LLVOAvatar :
// [/RLVa:KB]
void forceUpdateVisualMuteSettings();
+ // Visual Mute Setting is an input. Does not necessarily determine
+ // what the avatar looks like, because it interacts with other
+ // settings like muting, complexity threshold. Should be private or protected.
enum VisualMuteSettings
{
AV_RENDER_NORMALLY = 0,
@@ -441,11 +453,39 @@ class LLVOAvatar :
AV_ALWAYS_RENDER = 2
};
void setVisualMuteSettings(VisualMuteSettings set);
-// [RLVa:KB] - Checked: RLVa-2.2 (@setcam_avdist)
+
+protected:
+ // If you think you need to access this outside LLVOAvatar, you probably want getOverallAppearance()
+ // [RLVa:KB] - Checked: RLVa-2.2 (@setcam_avdist)
VisualMuteSettings getVisualMuteSettings() { return (!isRlvSilhouette()) ? mVisuallyMuteSetting : AV_DO_NOT_RENDER; };
// [/RLVa:KB]
// VisualMuteSettings getVisualMuteSettings() { return mVisuallyMuteSetting; };
+public:
+
+ // Overall Appearance is an output. Depending on whether the
+ // avatar is blocked/muted, whether it exceeds the complexity
+ // threshold, etc, avatar will want to be displayed in one of
+ // these ways. Rendering code that wants to know how to display an
+ // avatar should be looking at this value, NOT the visual mute
+ // settings
+ enum AvatarOverallAppearance
+ {
+ AOA_NORMAL,
+ AOA_JELLYDOLL,
+ AOA_INVISIBLE
+ };
+
+ AvatarOverallAppearance getOverallAppearance() const;
+ void setOverallAppearanceNormal();
+ void setOverallAppearanceJellyDoll();
+ void setOverallAppearanceInvisible();
+
+ void updateOverallAppearance();
+ void updateOverallAppearanceAnimations();
+
+ std::set<LLUUID> mJellyAnims;
+
U32 renderRigid();
U32 renderSkinned();
F32 getLastSkinTime() { return mLastSkinTime; }
@@ -458,7 +498,8 @@ class LLVOAvatar :
static void restoreGL();
S32 mSpecialRenderMode; // special lighting
- private:
+private:
+ AvatarOverallAppearance mOverallAppearance;
F32 mAttachmentSurfaceArea; //estimated surface area of attachments
U32 mAttachmentVisibleTriangleCount;
F32 mAttachmentEstTriangleCount;
@@ -534,7 +575,7 @@ class LLVOAvatar :
//--------------------------------------------------------------------
public:
virtual BOOL isImpostor();
- BOOL shouldImpostor(const U32 rank_factor = 1) const;
+ BOOL shouldImpostor(const F32 rank_factor = 1.0);
BOOL needsImpostorUpdate() const;
const LLVector3& getImpostorOffset() const;
const LLVector2& getImpostorDim() const;
@@ -545,6 +586,7 @@ class LLVOAvatar :
static void updateImpostors();
LLRenderTarget mImpostor;
BOOL mNeedsImpostorUpdate;
+ S32 mLastImpostorUpdateReason;
F32SecondsImplicit mLastImpostorUpdateFrameTime;
const LLVector3* getLastAnimExtents() const { return mLastAnimExtents; }
void setNeedsExtentUpdate(bool val) { mNeedsExtentUpdate = val; }
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index 878041fb67ed691a8b66e5439b3ed3fd035393de..7557e34c2d972e7d95e3cbaae1a1303df9e120ae 100644
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -689,7 +689,7 @@ LLVOAvatarSelf::~LLVOAvatarSelf()
*********************************************************************************/
// virtual
-BOOL LLVOAvatarSelf::updateCharacter(LLAgent &agent)
+bool LLVOAvatarSelf::updateCharacter(LLAgent &agent)
{
// update screen joint size
if (mScreenp)
diff --git a/indra/newview/llvoavatarself.h b/indra/newview/llvoavatarself.h
index 4d01a685dcc934787b6db5f99e3e4a7e6c0ee63c..4436e511fb42b94cc89e1433f1c536c605b17b8f 100644
--- a/indra/newview/llvoavatarself.h
+++ b/indra/newview/llvoavatarself.h
@@ -116,7 +116,7 @@ class LLVOAvatarSelf final :
// Updates
//--------------------------------------------------------------------
public:
- /*virtual*/ BOOL updateCharacter(LLAgent &agent);
+ /*virtual*/ bool updateCharacter(LLAgent &agent);
/*virtual*/ void idleUpdateTractorBeam();
bool checkStuckAppearance();
diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index 3b83ceefda22ec7d6b551a584312d7b3e357ee58..8296e2f74a883f753c539bdd4995acaf410472f2 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -223,10 +223,9 @@ class LLVOVolume final : public LLViewerObject
void updateSculptTexture();
void setIndexInTex(U32 ch, S32 index) { mIndexInTex[ch] = index ;}
void sculpt();
- static void rebuildMeshAssetCallback(LLVFS *vfs,
- const LLUUID& asset_uuid,
- LLAssetType::EType type,
- void* user_data, S32 status, LLExtStat ext_status);
+ static void rebuildMeshAssetCallback(const LLUUID& asset_uuid,
+ LLAssetType::EType type,
+ void* user_data, S32 status, LLExtStat ext_status);
void updateRelativeXform(bool force_identity = false);
/*virtual*/ BOOL updateGeometry(LLDrawable *drawable);
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index be1078c09c354ce9b225a689c61a2d5402e956c1..2938b81fd8d8e02a0701993ff4d9d56517f4ece4 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -3092,9 +3092,10 @@ void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera)
if (vobj) // this test may not be needed, see above
{
LLVOAvatar* av = vobj->asAvatar();
- if (av && (av->isImpostor()
- || av->isInMuteList()
- || (LLVOAvatar::AV_DO_NOT_RENDER == av->getVisualMuteSettings() && !av->needsImpostorUpdate()) ))
+ if (av &&
+ ((!sImpostorRender && av->isImpostor()) //ignore impostor flag during impostor pass
+ || av->isInMuteList()
+ || (LLVOAvatar::AOA_JELLYDOLL == av->getOverallAppearance() && !av->needsImpostorUpdate()) ))
{
return;
}
@@ -10927,7 +10928,6 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
{
LL_RECORD_BLOCK_TIME(FTM_IMPOSTOR_MARK_VISIBLE);
markVisible(avatar->mDrawable, viewer_camera);
- LLVOAvatar::sUseImpostors = false; // @TODO ???
for (const auto& attach_pair : avatar->mAttachmentPoints)
{
@@ -11166,7 +11166,6 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
avatar->setImpostorDim(tdim);
- LLVOAvatar::sUseImpostors = (0 != LLVOAvatar::sMaxNonImpostors);
sUseOcclusion = occlusion;
sReflectionRender = false;
sImpostorRender = false;
diff --git a/indra/newview/skins/default/xui/da/floater_stats.xml b/indra/newview/skins/default/xui/da/floater_stats.xml
index fe3fa9626ee83ad65cde2b5aed8985f93b3b4170..d07f9e48cad658e86166c6a33bd8498aec8f205e 100644
--- a/indra/newview/skins/default/xui/da/floater_stats.xml
+++ b/indra/newview/skins/default/xui/da/floater_stats.xml
@@ -32,7 +32,6 @@
<stat_bar label="Layers" name="layerskbitstat"/>
<stat_bar label="Actual In" name="actualinkbitstat"/>
<stat_bar label="Actual Out" name="actualoutkbitstat"/>
- <stat_bar label="VFS Pending Ops" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/da/strings.xml b/indra/newview/skins/default/xui/da/strings.xml
index ec6ba4800d50b47c5825ba76c913dbcac90eb151..814305c1bc230461d41b52da57f31687bd244be6 100644
--- a/indra/newview/skins/default/xui/da/strings.xml
+++ b/indra/newview/skins/default/xui/da/strings.xml
@@ -22,9 +22,6 @@
<string name="StartupInitializingTextureCache">
Initialiserer tekstur cache...
</string>
- <string name="StartupInitializingVFS">
- Initialiserer VFS...
- </string>
<string name="ProgressRestoring">
Gendanner...
</string>
diff --git a/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
index dff462a5947ea9b78fdcef46689610e5a7c156f5..a3749f1cfae9b6277db7464f77b36a8d7d5ce672 100644
--- a/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/de/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Ebenen" name="layersdatareceived"/>
<stat_bar label="Tatsächlicher Eingang" name="messagedatain"/>
<stat_bar label="Tatsächlicher Ausgang" name="messagedataout"/>
- <stat_bar label="Ausstehende Vorgänge im VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/de/floater_stats.xml b/indra/newview/skins/default/xui/de/floater_stats.xml
index 4e6f56cd94e579e987dcfac9a5928c049d3ba4b2..1838c2081a2145a702d9ff6d2731e8fead47301b 100644
--- a/indra/newview/skins/default/xui/de/floater_stats.xml
+++ b/indra/newview/skins/default/xui/de/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Ebenen" name="layersdatareceived"/>
<stat_bar label="Tatsächlicher Eingang" name="messagedatain"/>
<stat_bar label="Tatsächlicher Ausgang" name="messagedataout"/>
- <stat_bar label="Ausstehende Vorgänge im VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/de/strings.xml b/indra/newview/skins/default/xui/de/strings.xml
index 4762e262bd5f782b9e163bb55eff87b756bea592..9b7b91ceb96432deba278f00213a1dedb62ab2ca 100644
--- a/indra/newview/skins/default/xui/de/strings.xml
+++ b/indra/newview/skins/default/xui/de/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
Textur-Cache wird initialisiert...
</string>
- <string name="StartupInitializingVFS">
- VFS wird initialisiert...
- </string>
<string name="StartupRequireDriverUpdate">
Grafikinitialisierung fehlgeschlagen. Bitte aktualisieren Sie Ihren Grafiktreiber.
</string>
@@ -73,7 +70,6 @@ LOD-Faktor: [LOD_FACTOR]
Darstellungsqualität: [RENDER_QUALITY]
Erweitertes Beleuchtungsmodell: [GPU_SHADERS]
Texturspeicher: [TEXTURE_MEMORY] MB
-Erstellungszeit VFS (Cache): [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
HiDPI-Anzeigemodus: [HIDPI]
diff --git a/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
index 62cce3a1e377c76c2b6c03fcb4e659d0738e1a2b..35d43854879a82c409e54951c3d7ab8392f78458 100644
--- a/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/en/floater_scene_load_stats.xml
@@ -206,12 +206,6 @@
bar_max="1024.f"
tick_spacing="128.f"
precision="1"
- show_bar="false"/>
- <stat_bar name="vfspendingoperations"
- label="VFS Pending Operations"
- orientation="horizontal"
- stat="vfspendingoperations"
- unit_label=" Ops."
show_bar="false"/>
</stat_view>
</stat_view>
diff --git a/indra/newview/skins/default/xui/en/floater_stats.xml b/indra/newview/skins/default/xui/en/floater_stats.xml
index e4f735740b7c15b836ae79bf7d00cf6078f26e10..f9d44b2c6931d6d7592c3af5cda4cf620787b4c4 100644
--- a/indra/newview/skins/default/xui/en/floater_stats.xml
+++ b/indra/newview/skins/default/xui/en/floater_stats.xml
@@ -198,10 +198,6 @@
stat="messagedataout"
decimal_digits="1"
show_history="false"/>
- <stat_bar name="vfspendingoperations"
- label="VFS Pending Operations"
- stat="vfspendingoperations"
- unit_label="Ops."/>
</stat_view>
</stat_view>
diff --git a/indra/newview/skins/default/xui/en/strings.xml b/indra/newview/skins/default/xui/en/strings.xml
index 595e4ff4bda96bed39a7a957b36dc9bc49f05f03..30ab0427d62411f337bc5043d04dbb4d221794c8 100644
--- a/indra/newview/skins/default/xui/en/strings.xml
+++ b/indra/newview/skins/default/xui/en/strings.xml
@@ -17,7 +17,6 @@
<string name="StartupLoading">Loading [APP_NAME]...</string>
<string name="StartupClearingCache">Clearing cache...</string>
<string name="StartupInitializingTextureCache">Initializing texture cache...</string>
- <string name="StartupInitializingVFS">Initializing VFS...</string>
<string name="StartupRequireDriverUpdate">Graphics initialization failed. Please update your graphics driver!</string>
<!-- about dialog/support string-->
@@ -61,9 +60,9 @@ LOD factor: [LOD_FACTOR]
Render quality: [RENDER_QUALITY]
Advanced Lighting Model: [GPU_SHADERS]
Texture memory: [TEXTURE_MEMORY]MB
-VFS (cache) creation time: [VFS_TIME]
+Disk cache: [DISK_CACHE_INFO]
</string>
- <string name="AboutOSXHiDPI">
+ <string name="AboutOSXHiDPI">
HiDPI display mode: [HIDPI]
</string>
<string name="AboutLibs">
diff --git a/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
index f625d5257c1e157186514549072123e10aaa28d1..cfc5e524b5ae1c9569bf85a35b41b8c452e51ab9 100644
--- a/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/es/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Capas" name="layersdatareceived"/>
<stat_bar label="Entrando ahora" name="messagedatain"/>
<stat_bar label="Saliendo ahora" name="messagedataout"/>
- <stat_bar label="Operaciones VFS pendientes" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulador" name="sim">
diff --git a/indra/newview/skins/default/xui/es/floater_stats.xml b/indra/newview/skins/default/xui/es/floater_stats.xml
index d1c5e867dba453d0c5184187898385f1ae554428..0aec786f2515c3ef55d8af25d79998748b19bd45 100644
--- a/indra/newview/skins/default/xui/es/floater_stats.xml
+++ b/indra/newview/skins/default/xui/es/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Capas" name="layersdatareceived"/>
<stat_bar label="Entrando ahora" name="messagedatain"/>
<stat_bar label="Saliendo ahora" name="messagedataout"/>
- <stat_bar label="Operaciones VFS pendientes" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulador" name="sim">
diff --git a/indra/newview/skins/default/xui/es/strings.xml b/indra/newview/skins/default/xui/es/strings.xml
index 15b5713b8834586c79304595e951eaa75d885e7c..2609bda072b2fe6de6afe090a5794c3ec3b1a02d 100644
--- a/indra/newview/skins/default/xui/es/strings.xml
+++ b/indra/newview/skins/default/xui/es/strings.xml
@@ -22,9 +22,6 @@
<string name="StartupInitializingTextureCache">
Iniciando la caché de las texturas...
</string>
- <string name="StartupInitializingVFS">
- Iniciando VFS...
- </string>
<string name="StartupRequireDriverUpdate">
Error de inicialización de gráficos. Actualiza tu controlador de gráficos.
</string>
@@ -65,7 +62,6 @@ Factor LOD: [LOD_FACTOR]
Calidad de renderización: [RENDER_QUALITY]
Modelo de iluminación avanzado: [GPU_SHADERS]
Memoria de textura: [TEXTURE_MEMORY]MB
-VFS (cache) hora de creación: [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
Modo de visualización HiDPi: [HIDPI]
diff --git a/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
index 62830054bf18d19a209c615f4be12bb9bbf78b24..3889b13f0c4fb615ff2d0dd4a2fd9cd672cd0eb9 100644
--- a/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/fr/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Couches" name="layersdatareceived"/>
<stat_bar label="Arrivés" name="messagedatain"/>
<stat_bar label="Sortis" name="messagedataout"/>
- <stat_bar label="Opérations VFS en attente" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulateur" name="sim">
diff --git a/indra/newview/skins/default/xui/fr/floater_stats.xml b/indra/newview/skins/default/xui/fr/floater_stats.xml
index fae17e360854b63211ce1b2b88cfcc62818cf6b3..d0f7f4293973fe02f07e3ff5efcd04f7f937cbe9 100644
--- a/indra/newview/skins/default/xui/fr/floater_stats.xml
+++ b/indra/newview/skins/default/xui/fr/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Couches" name="layersdatareceived"/>
<stat_bar label="Arrivés" name="messagedatain"/>
<stat_bar label="Sortis" name="messagedataout"/>
- <stat_bar label="Opérations VFS en attente" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulateur" name="sim">
diff --git a/indra/newview/skins/default/xui/fr/strings.xml b/indra/newview/skins/default/xui/fr/strings.xml
index 6f6b74626f75213cf122ee94300f7ef27a2174b7..3aec0dd794c5ac813d637e787742e5b299ab4821 100644
--- a/indra/newview/skins/default/xui/fr/strings.xml
+++ b/indra/newview/skins/default/xui/fr/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
Initialisation du cache des textures...
</string>
- <string name="StartupInitializingVFS">
- Initialisation VFS...
- </string>
<string name="StartupRequireDriverUpdate">
Échec d'initialisation des graphiques. Veuillez mettre votre pilote graphique à jour.
</string>
@@ -74,7 +71,6 @@ Facteur LOD (niveau de détail) : [LOD_FACTOR]
Qualité de rendu : [RENDER_QUALITY]
Modèle d’éclairage avancé : [GPU_SHADERS]
Mémoire textures : [TEXTURE_MEMORY] Mo
-Heure de création VFS (cache) : [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
Mode d'affichage HiDPI : [HIDPI]
diff --git a/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
index ca18812eb7198df6236e7a7d5f1a9e27cdffbe60..efceb052984421fdc7a94c0989438f19e3cf6d4f 100644
--- a/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/it/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Livelli" name="layersdatareceived"/>
<stat_bar label="Effettivi in ingresso" name="messagedatain"/>
<stat_bar label="Effettivi in uscita" name="messagedataout"/>
- <stat_bar label="Operazioni VFS in sospeso" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulatore" name="sim">
diff --git a/indra/newview/skins/default/xui/it/floater_stats.xml b/indra/newview/skins/default/xui/it/floater_stats.xml
index 7ef13aa37fe2ad2dd76bc7b84516b21a6cdbdf5e..6434c3b66b04a690f9eefebf23aaed5506839bca 100644
--- a/indra/newview/skins/default/xui/it/floater_stats.xml
+++ b/indra/newview/skins/default/xui/it/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Livelli" name="layersdatareceived"/>
<stat_bar label="Effettivi in ingresso" name="messagedatain"/>
<stat_bar label="Effettivi in uscita" name="messagedataout"/>
- <stat_bar label="Operazioni VFS in sospeso" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulatore" name="sim">
diff --git a/indra/newview/skins/default/xui/it/strings.xml b/indra/newview/skins/default/xui/it/strings.xml
index a5b3615ba0aa2691bbae14f752550b4ac7413de3..75b238c783cadcc55078afc21fc67f56bab1d30c 100644
--- a/indra/newview/skins/default/xui/it/strings.xml
+++ b/indra/newview/skins/default/xui/it/strings.xml
@@ -28,9 +28,6 @@
<string name="StartupInitializingTextureCache">
Inizializzazione della cache texture...
</string>
- <string name="StartupInitializingVFS">
- Inizializzazione VFS...
- </string>
<string name="StartupRequireDriverUpdate">
Inizializzazione grafica non riuscita. Aggiorna il driver della scheda grafica!
</string>
@@ -71,7 +68,6 @@ Fattore livello di dettaglio: [LOD_FACTOR]
Qualità di rendering: [RENDER_QUALITY]
Modello illuminazione avanzato: [GPU_SHADERS]
Memoria texture: [TEXTURE_MEMORY]MB
-Data/ora creazione VFS (cache): [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
Modalità display HiDPI: [HIDPI]
diff --git a/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
index f6edce026f08544a357e3cba35703c2cf8566e83..f348ce3c4dec7f913f83d146b5e787d6b2360492 100644
--- a/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/ja/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="レイヤー" name="layersdatareceived"/>
<stat_bar label="実際ã®å—ä¿¡" name="messagedatain"/>
<stat_bar label="実際ã®é€ä¿¡" name="messagedataout"/>
- <stat_bar label="VFS ä¿ç•™ä¸ã®æ“作" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="シミュレーター" name="sim">
diff --git a/indra/newview/skins/default/xui/ja/floater_stats.xml b/indra/newview/skins/default/xui/ja/floater_stats.xml
index 3bc343639bc1a9430b44c2c82f6c4c241bdbcebf..1da0e5ebc971981d59dcbd2e06c57056327841ab 100644
--- a/indra/newview/skins/default/xui/ja/floater_stats.xml
+++ b/indra/newview/skins/default/xui/ja/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="レイヤー" name="layersdatareceived"/>
<stat_bar label="実際ã®å—ä¿¡" name="messagedatain"/>
<stat_bar label="実際ã®é€ä¿¡" name="messagedataout"/>
- <stat_bar label="VFS ä¿ç•™ä¸ã®æ“作" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="シミュレーター" name="sim">
diff --git a/indra/newview/skins/default/xui/ja/strings.xml b/indra/newview/skins/default/xui/ja/strings.xml
index 10a2e811199c4c4285d6a6b59c57b61c6bf05ad5..fc7d0627838a311eb61c38232fe51cb0110b79d7 100644
--- a/indra/newview/skins/default/xui/ja/strings.xml
+++ b/indra/newview/skins/default/xui/ja/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
テクスãƒãƒ£ã‚ャッシュをåˆæœŸåŒ–ä¸ã§ã™...
</string>
- <string name="StartupInitializingVFS">
- VFS ã‚’åˆæœŸåŒ–ä¸ã§ã™...
- </string>
<string name="StartupRequireDriverUpdate">
グラフィックをåˆæœŸåŒ–ã§ãã¾ã›ã‚“ã§ã—ãŸã€‚グラフィックドライãƒã‚’æ›´æ–°ã—ã¦ãã ã•ã„。
</string>
@@ -74,7 +71,6 @@ LOD ä¿‚æ•°: [LOD_FACTOR]
æç”»ã®è³ª: [RENDER_QUALITY]
高度ãªãƒ©ã‚¤ãƒ†ã‚£ãƒ³ã‚°ãƒ¢ãƒ‡ãƒ«: [GPU_SHADERS]
テクスãƒãƒ£ãƒ¡ãƒ¢ãƒª: [TEXTURE_MEMORY]MB
-VFS（ã‚ャッシュ）作æˆæ™‚é–“: [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
HiDPI 表示モード: [HIDPI]
diff --git a/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
index 6fdc7e19f664509e36d092d2d18fd9c07db33566..8f5d0c5c70d8d89e124e8c7a5392e5a47eec2ff3 100644
--- a/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/pl/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar name="layersdatareceived" label="Warstwy" />
<stat_bar name="messagedatain" label="Aktualna il. wchodzÄ…ca" />
<stat_bar name="messagedataout" label="Aktualna il. wychodzÄ…ca" />
- <stat_bar name="vfspendingoperations" label="Operacje oczekujÄ…ce VFS" unit_label=" op." />
</stat_view>
</stat_view>
<stat_view name="sim" label="Symulator">
diff --git a/indra/newview/skins/default/xui/pl/floater_stats.xml b/indra/newview/skins/default/xui/pl/floater_stats.xml
index 5dd7d19babb515a83ae7e1e2430e96e776bad8f7..21e37717c26c8c0117773fd9fe8f6955891244a6 100644
--- a/indra/newview/skins/default/xui/pl/floater_stats.xml
+++ b/indra/newview/skins/default/xui/pl/floater_stats.xml
@@ -55,7 +55,6 @@
<stat_bar label="Warstwy" name="layersdatareceived" />
<stat_bar label="Aktualna il. wchodzÄ…ca" name="messagedatain" />
<stat_bar label="Aktualna il. wychodzÄ…ca" name="messagedataout" />
- <stat_bar label="Operacje oczekujÄ…ce VFS" name="vfspendingoperations" />
</stat_view>
</stat_view>
<stat_view label="Symulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pl/strings.xml b/indra/newview/skins/default/xui/pl/strings.xml
index 91fea234d2a1ffd2a8810c7ae63fe28be7ee6b5e..cf033df3c9c2933b7c7e4d4a3864995f12c69fe5 100644
--- a/indra/newview/skins/default/xui/pl/strings.xml
+++ b/indra/newview/skins/default/xui/pl/strings.xml
@@ -15,9 +15,6 @@
<string name="StartupInitializingTextureCache">
Inicjowanie bufora danych tekstur...
</string>
- <string name="StartupInitializingVFS">
- Inicjowanie wirtualnego systemu plików...
- </string>
<string name="StartupRequireDriverUpdate">
Nie można zainicjować grafiki. Zaktualizuj sterowniki!
</string>
diff --git a/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
index 027e1ef3116db5182059ee73f540f61a8314d1df..dbaab1d7820bc122c60dba0aba34ab2dbd9add5e 100644
--- a/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/pt/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Layers" name="layersdatareceived"/>
<stat_bar label="Actual In" name="messagedatain"/>
<stat_bar label="Actual Out" name="messagedataout"/>
- <stat_bar label="Operações pendentes do VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pt/floater_stats.xml b/indra/newview/skins/default/xui/pt/floater_stats.xml
index f41fe17778cc883fec84b88ed81d8e6aade17f89..32539842684a112181e85af14d1c2772fa40439b 100644
--- a/indra/newview/skins/default/xui/pt/floater_stats.xml
+++ b/indra/newview/skins/default/xui/pt/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Layers" name="layersdatareceived"/>
<stat_bar label="Actual In" name="messagedatain"/>
<stat_bar label="Actual Out" name="messagedataout"/>
- <stat_bar label="Operações pendentes do VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simulator" name="sim">
diff --git a/indra/newview/skins/default/xui/pt/strings.xml b/indra/newview/skins/default/xui/pt/strings.xml
index 20cad7c3bbdde23294243dc81da337dba7513cef..8da8e0a4b528f79d52427696935e79fa5482bee4 100644
--- a/indra/newview/skins/default/xui/pt/strings.xml
+++ b/indra/newview/skins/default/xui/pt/strings.xml
@@ -22,9 +22,6 @@
<string name="StartupInitializingTextureCache">
Iniciando cache de texturas...
</string>
- <string name="StartupInitializingVFS">
- Iniciando VFS...
- </string>
<string name="StartupRequireDriverUpdate">
Falha na inicialização dos gráficos. Atualize seu driver gráfico!
</string>
@@ -65,7 +62,6 @@ LOD fator: [LOD_FACTOR]
Qualidade de renderização: [RENDER_QUALITY]
Modelo avançado de luzes: [GPU_SHADERS]
Memória de textura: [TEXTURE_MEMORY]MB
-VFS (cache) tempo de criação: [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
HiDPI modo de exibição: [HIDPI]
diff --git a/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
index a101e62627791015994208432c07ae0a45520d54..c4f432023cc19bc843258b57956f4c5546326cb6 100644
--- a/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/ru/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Слои" name="layersdatareceived"/>
<stat_bar label="ДейÑтвительный ввод" name="messagedatain"/>
<stat_bar label="ДейÑтвительный вывод" name="messagedataout"/>
- <stat_bar label="Ожидающие операции VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="СимулÑтор" name="sim">
diff --git a/indra/newview/skins/default/xui/ru/floater_stats.xml b/indra/newview/skins/default/xui/ru/floater_stats.xml
index 10e9f5a7f49b1b0ef04aa76c1f8c89cccbb8c317..a7d26029c254abe5ad764351c7f757610f93ecec 100644
--- a/indra/newview/skins/default/xui/ru/floater_stats.xml
+++ b/indra/newview/skins/default/xui/ru/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Слои" name="layersdatareceived"/>
<stat_bar label="ДейÑтвительный ввод" name="messagedatain"/>
<stat_bar label="ДейÑтвительный вывод" name="messagedataout"/>
- <stat_bar label="Ожидающие операции VFS" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="СимулÑтор" name="sim">
diff --git a/indra/newview/skins/default/xui/ru/strings.xml b/indra/newview/skins/default/xui/ru/strings.xml
index 98cf52f2d2bf8d23700c472a50f2814eee0ca730..171653fa02c0f65a3a3eb7a4d64f516fd04bfe99 100644
--- a/indra/newview/skins/default/xui/ru/strings.xml
+++ b/indra/newview/skins/default/xui/ru/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
Ð˜Ð½Ð¸Ñ†Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ†Ð¸Ñ ÐºÑша текÑтур...
</string>
- <string name="StartupInitializingVFS">
- Ð˜Ð½Ð¸Ñ†Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ†Ð¸Ñ Ð²Ð¸Ñ€Ñ‚ÑƒÐ°Ð»ÑŒÐ½Ð¾Ð¹ файловой ÑиÑтемы...
- </string>
<string name="StartupRequireDriverUpdate">
Ошибка инициализации графики. Обновите графичеÑкий драйвер!
</string>
@@ -74,7 +71,6 @@ SLURL: <nolink>[SLURL]</nolink>
КачеÑтво визуализации: [RENDER_QUALITY]
РаÑÑˆÐ¸Ñ€ÐµÐ½Ð½Ð°Ñ Ð¼Ð¾Ð´ÐµÐ»ÑŒ оÑвещениÑ: [GPU_SHADERS]
ПамÑÑ‚ÑŒ текÑтур: [TEXTURE_MEMORY] МБ
-Ð’Ñ€ÐµÐ¼Ñ ÑÐ¾Ð·Ð´Ð°Ð½Ð¸Ñ VFS (кÑш): [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
Режим Ð¾Ñ‚Ð¾Ð±Ñ€Ð°Ð¶ÐµÐ½Ð¸Ñ HiDPI: [HIDPI]
diff --git a/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
index ae0a94595dd4234805b0fc36635d1a492c25c1ac..7d5f4adb02490ca8da96e46a85c45073d80d58f7 100644
--- a/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/tr/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="Katmanlar" name="layersdatareceived"/>
<stat_bar label="Gerçekte Gelen" name="messagedatain"/>
<stat_bar label="Gerçekte Giden" name="messagedataout"/>
- <stat_bar label="VFS Bekleyen Ä°ÅŸlemler" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simülatör" name="sim">
diff --git a/indra/newview/skins/default/xui/tr/floater_stats.xml b/indra/newview/skins/default/xui/tr/floater_stats.xml
index 1ae42ad3829b2fab6774f0df8546a0cc4b1716d3..bd36d4916f5fc135e8941e88f8f27d7fce8b9b87 100644
--- a/indra/newview/skins/default/xui/tr/floater_stats.xml
+++ b/indra/newview/skins/default/xui/tr/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="Katmanlar" name="layersdatareceived"/>
<stat_bar label="Gerçekte Gelen" name="messagedatain"/>
<stat_bar label="Gerçekte Giden" name="messagedataout"/>
- <stat_bar label="VFS Bekleyen Ä°ÅŸlemler" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="Simülatör" name="sim">
diff --git a/indra/newview/skins/default/xui/tr/strings.xml b/indra/newview/skins/default/xui/tr/strings.xml
index 3f1a964e4f2f22a5fc768875929d99c4108b467a..b054b0e1b2511fe7a34aa38211e80b3f30c16251 100644
--- a/indra/newview/skins/default/xui/tr/strings.xml
+++ b/indra/newview/skins/default/xui/tr/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
Doku önbelleği başlatılıyor...
</string>
- <string name="StartupInitializingVFS">
- VFS Başlatılıyor...
- </string>
<string name="StartupRequireDriverUpdate">
Grafik başlatma başarılamadı. Lütfen grafik sürücünüzü güncelleştirin!
</string>
@@ -74,7 +71,6 @@ LOD faktörü: [LOD_FACTOR]
Ä°ÅŸleme kalitesi: [RENDER_QUALITY]
Gelişmiş Aydınlatma Modeli: [GPU_SHADERS]
Doku belleÄŸi: [TEXTURE_MEMORY]MB
-VFS (önbellek) oluşturma saati: [VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
HiDPI görüntü modu: [HIDPI]
diff --git a/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml b/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
index 1a5c20abeb954ee0da413720cc53c72411ffebad..20344e299fa37d5d8bf0467d7b5231a15e449fc7 100644
--- a/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
+++ b/indra/newview/skins/default/xui/zh/floater_scene_load_stats.xml
@@ -29,7 +29,6 @@
<stat_bar label="層次" name="layersdatareceived"/>
<stat_bar label="實入" name="messagedatain"/>
<stat_bar label="實出" name="messagedataout"/>
- <stat_bar label="VFS 待行作æ¥" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="模擬器" name="sim">
diff --git a/indra/newview/skins/default/xui/zh/floater_stats.xml b/indra/newview/skins/default/xui/zh/floater_stats.xml
index f06eb5e78f3b4fed52140b1947ed8f793d835d7c..e233ece52730f53b0d6bd3bf6af4ca21c8a14290 100644
--- a/indra/newview/skins/default/xui/zh/floater_stats.xml
+++ b/indra/newview/skins/default/xui/zh/floater_stats.xml
@@ -56,7 +56,6 @@
<stat_bar label="層次" name="layersdatareceived"/>
<stat_bar label="實入" name="messagedatain"/>
<stat_bar label="實出" name="messagedataout"/>
- <stat_bar label="VFS 待行作æ¥" name="vfspendingoperations"/>
</stat_view>
</stat_view>
<stat_view label="模擬器" name="sim">
diff --git a/indra/newview/skins/default/xui/zh/strings.xml b/indra/newview/skins/default/xui/zh/strings.xml
index 572b79816babdc64bf63f884356000fd55d8860c..554ff151f8be142103be7baaad74942b1aa0f81f 100644
--- a/indra/newview/skins/default/xui/zh/strings.xml
+++ b/indra/newview/skins/default/xui/zh/strings.xml
@@ -31,9 +31,6 @@
<string name="StartupInitializingTextureCache">
æ£åœ¨åˆå§‹åŒ–æ質快å–...
</string>
- <string name="StartupInitializingVFS">
- VFS åˆå§‹åŒ–ä¸...
- </string>
<string name="StartupRequireDriverUpdate">
顯åƒåˆå§‹åŒ–失敗。 è«‹æ›´æ–°ä½ çš„é¡¯åƒå¡é©…動程å¼ï¼
</string>
@@ -74,7 +71,6 @@
呈åƒå“質：[RENDER_QUALITY]
進階照明模型：[GPU_SHADERS]
æ質記憶體：[TEXTURE_MEMORY]MB
-VFS（快å–）建立時間：[VFS_TIME]
</string>
<string name="AboutOSXHiDPI">
HiDPI顯示模å¼ï¼š[HIDPI]
diff --git a/indra/newview/viewer_manifest.py b/indra/newview/viewer_manifest.py
index f75183785945dcf74c4fc2d2d11f16fcff983790..e6a62f9dae54d479302f945e7fdb7d193e7bfba2 100755
--- a/indra/newview/viewer_manifest.py
+++ b/indra/newview/viewer_manifest.py
@@ -69,7 +69,6 @@ def construct(self):
self.exclude("logcontrol-dev.xml")
self.path("*.ini")
self.path("*.xml")
- self.path("*.db2")
# include the entire shaders directory recursively
self.path("shaders")
diff --git a/indra/test/CMakeLists.txt b/indra/test/CMakeLists.txt
index 0e615bf85e3e487087cf193afc60b7829d8b345e..a24a9db0fd8e45c4a8f8f42dbc21bd0a3bf23c16 100644
--- a/indra/test/CMakeLists.txt
+++ b/indra/test/CMakeLists.txt
@@ -8,12 +8,11 @@ include(LLCoreHttp)
include(LLInventory)
include(LLMath)
include(LLMessage)
-include(LLVFS)
+include(LLFileSystem)
include(LLXML)
include(Linking)
include(Tut)
include(LLAddBuildTest)
-
include_directories(
${LLCOMMON_INCLUDE_DIRS}
${LLCOREHTTP_INCLUDE_DIRS}
@@ -21,7 +20,7 @@ include_directories(
${LLMATH_INCLUDE_DIRS}
${LLMESSAGE_INCLUDE_DIRS}
${LLINVENTORY_INCLUDE_DIRS}
- ${LLVFS_INCLUDE_DIRS}
+ ${LLFILESYSTEM_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}
${TUT_INCLUDE_DIR}
@@ -86,7 +85,7 @@ target_link_libraries(lltest
${LLINVENTORY_LIBRARIES}
${LLMESSAGE_LIBRARIES}
${LLMATH_LIBRARIES}
- ${LLVFS_LIBRARIES}
+ ${LLFILESYSTEM_LIBRARIES}
${LLXML_LIBRARIES}
${LSCRIPT_LIBRARIES}
${LLCOMMON_LIBRARIES}
diff --git a/scripts/content_tools/arche_tool.py b/scripts/content_tools/arche_tool.py
index 23c96fc64ef40b605dbeb19a3dc9a09434986e3d..f99d7be39ad7be65dfb47bce1223bcfee26e425f 100644
--- a/scripts/content_tools/arche_tool.py
+++ b/scripts/content_tools/arche_tool.py
@@ -79,15 +79,32 @@ def compare_trees(file_trees):
print "Summary:"
print summary
-
+def dump_appearance_params(tree):
+ vals = []
+ for e in tree.getroot().iter():
+ if e.tag == "param":
+ g = int(e.get("group"))
+ if g in [0,3]:
+ vals.append("{" + e.get("id") + "," +e.get("u8") + "}")
+ #print e.get("id"), e.get("name"), e.get("group"), e.get("u8")
+ if len(vals)==253:
+ print ", ".join(vals)
+
+
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="compare avatar XML archetype files")
parser.add_argument("--verbose", help="verbose flag", action="store_true")
+ parser.add_argument("--compare", help="compare flag", action="store_true")
+ parser.add_argument("--appearance_params", help="compare flag", action="store_true")
parser.add_argument("files", nargs="+", help="name of one or more archtype files")
args = parser.parse_args()
print "files",args.files
file_trees = [etree.parse(filename) for filename in args.files]
- compare_trees(file_trees)
+ print args
+ if args.compare:
+ compare_trees(file_trees)
+ if args.appearance_params:
+ dump_appearance_params(file_trees[0])