282 lines
9.8 KiB
C++
282 lines
9.8 KiB
C++
/**
|
|
* @file llworldmipmap.cpp
|
|
* @brief Data storage for the S3 mipmap of the entire world.
|
|
*
|
|
* $LicenseInfo:firstyear=2003&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 "llviewerprecompiledheaders.h"
|
|
|
|
#include "llworldmipmap.h"
|
|
#include "llviewercontrol.h" // LLControlGroup
|
|
|
|
#include "llviewertexturelist.h"
|
|
#include "math.h" // log()
|
|
|
|
// <FS:CR> HG maps
|
|
#include "lfsimfeaturehandler.h"
|
|
#ifdef OPENSIM
|
|
#include "llviewernetwork.h"
|
|
#include "llagent.h"
|
|
#endif // OPENSIM
|
|
// </FS:CR>
|
|
|
|
// Turn this on to output tile stats in the standard output
|
|
#define DEBUG_TILES_STAT 0
|
|
|
|
LLWorldMipmap::LLWorldMipmap() :
|
|
mCurrentLevel(0)
|
|
{
|
|
}
|
|
|
|
LLWorldMipmap::~LLWorldMipmap()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
// Delete all sublevel maps and clean them
|
|
void LLWorldMipmap::reset()
|
|
{
|
|
for (int level = 0; level < MAP_LEVELS; level++)
|
|
{
|
|
mWorldObjectsMipMap[level].clear();
|
|
}
|
|
}
|
|
|
|
// This method should be called before each use of the mipmap (typically, before each draw), so that to let
|
|
// the boost level of unused tiles to drop to 0 (BOOST_NONE).
|
|
// Tiles that are accessed have had their boost level pushed to BOOST_MAP_VISIBLE so we can identify them.
|
|
// The result of this strategy is that if a tile is not used during 2 consecutive loops, its boost level drops to 0.
|
|
void LLWorldMipmap::equalizeBoostLevels()
|
|
{
|
|
#if DEBUG_TILES_STAT
|
|
S32 nb_missing = 0;
|
|
S32 nb_tiles = 0;
|
|
S32 nb_visible = 0;
|
|
#endif // DEBUG_TILES_STAT
|
|
// For each level
|
|
for (S32 level = 0; level < MAP_LEVELS; level++)
|
|
{
|
|
sublevel_tiles_t& level_mipmap = mWorldObjectsMipMap[level];
|
|
// For each tile
|
|
for (sublevel_tiles_t::iterator iter = level_mipmap.begin(); iter != level_mipmap.end(); iter++)
|
|
{
|
|
LLPointer<LLViewerFetchedTexture> img = iter->second;
|
|
S32 current_boost_level = img->getBoostLevel();
|
|
if (current_boost_level == LLGLTexture::BOOST_MAP_VISIBLE)
|
|
{
|
|
// If level was BOOST_MAP_VISIBLE, the tile has been used in the last draw so keep it high
|
|
img->setBoostLevel(LLGLTexture::BOOST_MAP);
|
|
}
|
|
else
|
|
{
|
|
// If level was BOOST_MAP only (or anything else...), the tile wasn't used in the last draw
|
|
// so we drop its boost level to BOOST_NONE.
|
|
img->setBoostLevel(LLGLTexture::BOOST_NONE);
|
|
}
|
|
#if DEBUG_TILES_STAT
|
|
// Increment some stats if compile option on
|
|
nb_tiles++;
|
|
if (current_boost_level == LLGLTexture::BOOST_MAP_VISIBLE)
|
|
{
|
|
nb_visible++;
|
|
}
|
|
if (img->isMissingAsset())
|
|
{
|
|
nb_missing++;
|
|
}
|
|
#endif // DEBUG_TILES_STAT
|
|
}
|
|
}
|
|
#if DEBUG_TILES_STAT
|
|
LL_INFOS("WorldMap") << "LLWorldMipmap tile stats : total requested = " << nb_tiles << ", visible = " << nb_visible << ", missing = " << nb_missing << LL_ENDL;
|
|
#endif // DEBUG_TILES_STAT
|
|
}
|
|
|
|
// This method should be used when the mipmap is not actively used for a while, e.g., the map UI is hidden
|
|
void LLWorldMipmap::dropBoostLevels()
|
|
{
|
|
// For each level
|
|
for (S32 level = 0; level < MAP_LEVELS; level++)
|
|
{
|
|
sublevel_tiles_t& level_mipmap = mWorldObjectsMipMap[level];
|
|
// For each tile
|
|
for (sublevel_tiles_t::iterator iter = level_mipmap.begin(); iter != level_mipmap.end(); iter++)
|
|
{
|
|
LLPointer<LLViewerFetchedTexture> img = iter->second;
|
|
img->setBoostLevel(LLGLTexture::BOOST_NONE);
|
|
}
|
|
}
|
|
}
|
|
|
|
LLPointer<LLViewerFetchedTexture> LLWorldMipmap::getObjectsTile(U32 grid_x, U32 grid_y, S32 level, bool load)
|
|
{
|
|
// Check the input data
|
|
llassert(level <= MAP_LEVELS);
|
|
llassert(level >= 1);
|
|
|
|
// If the *loading* level changed, cleared the new level from "missed" tiles
|
|
// so that we get a chance to reload them
|
|
if (load && (level != mCurrentLevel))
|
|
{
|
|
cleanMissedTilesFromLevel(level);
|
|
mCurrentLevel = level;
|
|
}
|
|
|
|
// Build the region handle
|
|
U64 handle = convertGridToHandle(grid_x, grid_y);
|
|
|
|
// Check if the image is around already
|
|
sublevel_tiles_t& level_mipmap = mWorldObjectsMipMap[level-1];
|
|
sublevel_tiles_t::iterator found = level_mipmap.find(handle);
|
|
|
|
// If not there and load on, go load it
|
|
if (found == level_mipmap.end())
|
|
{
|
|
if (load)
|
|
{
|
|
// Load it
|
|
LLPointer<LLViewerFetchedTexture> img = loadObjectsTile(grid_x, grid_y, level);
|
|
// Insert the image in the map
|
|
level_mipmap.insert(sublevel_tiles_t::value_type( handle, img ));
|
|
// Find the element again in the map (it's there now...)
|
|
found = level_mipmap.find(handle);
|
|
}
|
|
else
|
|
{
|
|
// Return with NULL if not found and we're not trying to load
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
// Get the image pointer and check if this asset is missing
|
|
LLPointer<LLViewerFetchedTexture> img = found->second;
|
|
if (img->isMissingAsset())
|
|
{
|
|
// Return NULL if asset missing
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
// Boost the tile level so to mark it's in use *if* load on
|
|
if (load)
|
|
{
|
|
img->setBoostLevel(LLGLTexture::BOOST_MAP_VISIBLE);
|
|
}
|
|
return img;
|
|
}
|
|
}
|
|
|
|
LLPointer<LLViewerFetchedTexture> LLWorldMipmap::loadObjectsTile(U32 grid_x, U32 grid_y, S32 level)
|
|
{
|
|
// Get the grid coordinates
|
|
// <FS:CR> HG Maps
|
|
//std::string imageurl = gSavedSettings.getString("CurrentMapServerURL") + llformat("map-%d-%d-%d-objects.jpg", level, grid_x, grid_y);
|
|
std::string imageurl = LFSimFeatureHandler::instance().mapServerURL() + llformat("map-%d-%d-%d-objects.jpg", level, grid_x, grid_y);
|
|
// </FS:CR>
|
|
|
|
// DO NOT COMMIT!! DEBUG ONLY!!!
|
|
// Use a local jpeg for every tile to test map speed without S3 access
|
|
//imageurl = "file://C:\\Develop\\mapserver-distribute-3\\indra\\build-vc80\\mapserver\\relwithdebinfo\\regions\\00995\\01001\\region-995-1001-prims.jpg";
|
|
// END DEBUG
|
|
//LL_INFOS("WorldMap") << "LLWorldMipmap::loadObjectsTile(), URL = " << imageurl << LL_ENDL;
|
|
|
|
LLPointer<LLViewerFetchedTexture> img = LLViewerTextureManager::getFetchedTextureFromUrl(imageurl, FTT_MAP_TILE, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
|
|
//LL_INFOS("MAPURL") << "fetching map tile from " << imageurl << LL_ENDL;
|
|
|
|
img->setBoostLevel(LLGLTexture::BOOST_MAP);
|
|
|
|
// Return the smart pointer
|
|
return img;
|
|
}
|
|
|
|
// This method is used to clean up a level from tiles marked as "missing".
|
|
// The idea is to allow tiles that have been improperly marked missing to be reloaded when retraversing the level again.
|
|
// When zooming in and out rapidly, some tiles are never properly loaded and, eventually marked missing.
|
|
// This creates "blue" areas in a subresolution that never got a chance to reload if we don't clean up the level.
|
|
void LLWorldMipmap::cleanMissedTilesFromLevel(S32 level)
|
|
{
|
|
// Check the input data
|
|
llassert(level <= MAP_LEVELS);
|
|
llassert(level >= 0);
|
|
|
|
// This happens when the object is first initialized
|
|
if (level == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Iterate through the subresolution level and suppress the tiles that are marked as missing
|
|
// Note: erasing in a map while iterating through it is bug prone. Using a postfix increment is mandatory here.
|
|
sublevel_tiles_t& level_mipmap = mWorldObjectsMipMap[level-1];
|
|
sublevel_tiles_t::iterator it = level_mipmap.begin();
|
|
while (it != level_mipmap.end())
|
|
{
|
|
LLPointer<LLViewerFetchedTexture> img = it->second;
|
|
if (img->isMissingAsset())
|
|
{
|
|
level_mipmap.erase(it++);
|
|
}
|
|
else
|
|
{
|
|
++it;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// static methods
|
|
// Compute the level in the world mipmap (between 1 and MAP_LEVELS, as in the URL) given the scale (size of a sim in screen pixels)
|
|
S32 LLWorldMipmap::scaleToLevel(F32 scale)
|
|
{
|
|
// If scale really small, picks up the higest level there is (lowest resolution)
|
|
if (scale <= F32_MIN)
|
|
return MAP_LEVELS;
|
|
// Compute the power of two resolution level knowing the base level
|
|
S32 level = llfloor((log(REGION_WIDTH_METERS/scale)/log(2.0f)) + 1.0f);
|
|
// Check bounds and return the value
|
|
if (level > MAP_LEVELS)
|
|
return MAP_LEVELS;
|
|
else if (level < 1)
|
|
return 1;
|
|
else
|
|
return level;
|
|
}
|
|
|
|
// Convert world coordinates to mipmap grid coordinates at a given level (between 1 and MAP_LEVELS)
|
|
void LLWorldMipmap::globalToMipmap(F64 global_x, F64 global_y, S32 level, U32* grid_x, U32* grid_y)
|
|
{
|
|
// Check the input data
|
|
llassert(level <= MAP_LEVELS);
|
|
llassert(level >= 1);
|
|
|
|
// Convert world coordinates into grid coordinates
|
|
*grid_x = lltrunc(global_x/REGION_WIDTH_METERS);
|
|
*grid_y = lltrunc(global_y/REGION_WIDTH_METERS);
|
|
// Compute the valid grid coordinates at that level of the mipmap
|
|
S32 regions_in_tile = 1 << (level - 1);
|
|
*grid_x = *grid_x - (*grid_x % regions_in_tile);
|
|
*grid_y = *grid_y - (*grid_y % regions_in_tile);
|
|
}
|
|
|
|
|