/**
* @file lllandmark.cpp
* @brief Landmark asset class
*
* $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 "lllandmark.h"
#include <errno.h>
#include "message.h"
#include "llregionhandle.h"
std::pair<LLUUID, U64> LLLandmark::mLocalRegion;
LLLandmark::region_map_t LLLandmark::mRegions;
LLLandmark::region_callback_map_t LLLandmark::sRegionCallbackMap;
LLLandmark::LLLandmark() :
mGlobalPositionKnown(false)
{
}
LLLandmark::LLLandmark(const LLVector3d& pos) :
mGlobalPositionKnown(true),
mGlobalPos( pos )
{
}
bool LLLandmark::getGlobalPos(LLVector3d& pos)
{
if(mGlobalPositionKnown)
{
pos = mGlobalPos;
}
else if(mRegionID.notNull())
{
F32 g_x = -1.0;
F32 g_y = -1.0;
if(mRegionID == mLocalRegion.first)
{
from_region_handle(mLocalRegion.second, &g_x, &g_y);
}
else
{
region_map_t::iterator it = mRegions.find(mRegionID);
if(it != mRegions.end())
{
from_region_handle((*it).second.mRegionHandle, &g_x, &g_y);
}
}
if((g_x > 0.f) && (g_y > 0.f))
{
pos.mdV[0] = g_x + mRegionPos.mV[0];
pos.mdV[1] = g_y + mRegionPos.mV[1];
pos.mdV[2] = mRegionPos.mV[2];
setGlobalPos(pos);
}
}
return mGlobalPositionKnown;
}
void LLLandmark::setGlobalPos(const LLVector3d& pos)
{
mGlobalPos = pos;
mGlobalPositionKnown = true;
}
bool LLLandmark::getRegionID(LLUUID& region_id)
{
if(mRegionID.notNull())
{
region_id = mRegionID;
return true;
}
return false;
}
LLVector3 LLLandmark::getRegionPos() const
{
return mRegionPos;
}
// static
LLLandmark* LLLandmark::constructFromString(const char *buffer, const S32 buffer_size)
{
S32 chars_read = 0;
S32 chars_read_total = 0;
S32 count = 0;
U32 version = 0;
bool bad_block = false;
LLLandmark* result = NULL;
// read version
count = sscanf( buffer, "Landmark version %u\n%n", &version, &chars_read );
chars_read_total += chars_read;
if (count != 1
|| chars_read_total >= buffer_size)
{
bad_block = true;
}
if (!bad_block)
{
switch (version)
{
case 1:
{
LLVector3d pos;
// read position
count = sscanf(buffer + chars_read_total, "position %lf %lf %lf\n%n", pos.mdV + VX, pos.mdV + VY, pos.mdV + VZ, &chars_read);
if (count != 3)
{
bad_block = true;
}
else
{
LL_DEBUGS("Landmark") << "Landmark read: " << pos << LL_ENDL;
result = new LLLandmark(pos);
}
break;
}
case 2:
{
// *NOTE: Changing the buffer size will require changing the
// scanf call below.
char region_id_str[MAX_STRING];
LLVector3 pos;
LLUUID region_id;
count = sscanf( buffer + chars_read_total,
"region_id %254s\n%n",
region_id_str,
&chars_read);
chars_read_total += chars_read;
if (count != 1
|| chars_read_total >= buffer_size
|| !LLUUID::validate(region_id_str))
{
bad_block = true;
}
if (!bad_block)
{
region_id.set(region_id_str);
if (region_id.isNull())
{
bad_block = true;
}
}
if (!bad_block)
{
count = sscanf(buffer + chars_read_total, "local_pos %f %f %f\n%n", pos.mV + VX, pos.mV + VY, pos.mV + VZ, &chars_read);
if (count != 3)
{
bad_block = true;
}
else
{
result = new LLLandmark;
result->mRegionID = region_id;
result->mRegionPos = pos;
}
}
break;
}
default:
{
LL_INFOS("Landmark") << "Encountered Unknown landmark version " << version << LL_ENDL;
break;
}
}
}
if (bad_block)
{
LL_INFOS("Landmark") << "Bad Landmark Asset: bad _DATA_ block." << LL_ENDL;
}
return result;
}
// static
void LLLandmark::registerCallbacks(LLMessageSystem* msg)
{
msg->setHandlerFunc("RegionIDAndHandleReply", &processRegionIDAndHandle);
}
// static
void LLLandmark::requestRegionHandle(
LLMessageSystem* msg,
const LLHost& upstream_host,
const LLUUID& region_id,
region_handle_callback_t callback)
{
if(region_id.isNull())
{
// don't bother with checking - it's 0.
LL_DEBUGS("Landmark") << "requestRegionHandle: null" << LL_ENDL;
if(callback)
{
const U64 U64_ZERO = 0;
callback(region_id, U64_ZERO);
}
}
else
{
if(region_id == mLocalRegion.first)
{
LL_DEBUGS("Landmark") << "requestRegionHandle: local" << LL_ENDL;
if(callback)
{
callback(region_id, mLocalRegion.second);
}
}
else
{
region_map_t::iterator it = mRegions.find(region_id);
if(it == mRegions.end())
{
LL_DEBUGS("Landmark") << "requestRegionHandle: upstream" << LL_ENDL;
if(callback)
{
region_callback_map_t::value_type vt(region_id, callback);
sRegionCallbackMap.insert(vt);
}
LL_DEBUGS("Landmark") << "Landmark requesting information about: "
<< region_id << LL_ENDL;
msg->newMessage("RegionHandleRequest");
msg->nextBlock("RequestBlock");
msg->addUUID("RegionID", region_id);
msg->sendReliable(upstream_host);
}
else if(callback)
{
// we have the answer locally - just call the callack.
LL_DEBUGS("Landmark") << "requestRegionHandle: ready" << LL_ENDL;
callback(region_id, (*it).second.mRegionHandle);
}
}
}
// As good a place as any to expire old entries.
expireOldEntries();
}
// static
void LLLandmark::setRegionHandle(const LLUUID& region_id, U64 region_handle)
{
mLocalRegion.first = region_id;
mLocalRegion.second = region_handle;
}
// static
void LLLandmark::processRegionIDAndHandle(LLMessageSystem* msg, void**)
{
LLUUID region_id;
msg->getUUID("ReplyBlock", "RegionID", region_id);
mRegions.erase(region_id);
CacheInfo info;
const F32 CACHE_EXPIRY_SECONDS = 60.0f * 10.0f; // ten minutes
info.mTimer.setTimerExpirySec(CACHE_EXPIRY_SECONDS);
msg->getU64("ReplyBlock", "RegionHandle", info.mRegionHandle);
region_map_t::value_type vt(region_id, info);
mRegions.insert(vt);
#if LL_DEBUG
U32 grid_x, grid_y;
grid_from_region_handle(info.mRegionHandle, &grid_x, &grid_y);
LL_DEBUGS() << "Landmark got reply for region: " << region_id << " "
<< grid_x << "," << grid_y << LL_ENDL;
#endif
// make all the callbacks here.
region_callback_map_t::iterator it;
while((it = sRegionCallbackMap.find(region_id)) != sRegionCallbackMap.end())
{
(*it).second(region_id, info.mRegionHandle);
sRegionCallbackMap.erase(it);
}
}
// static
void LLLandmark::expireOldEntries()
{
for(region_map_t::iterator it = mRegions.begin(); it != mRegions.end(); )
{
if((*it).second.mTimer.hasExpired())
{
mRegions.erase(it++);
}
else
{
++it;
}
}
}