/** * @file lllandmark.cpp * @brief Landmark asset class * * $LicenseInfo:firstyear=2002&license=viewergpl$ * * Copyright (c) 2002-2009, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at * http://secondlifegrid.net/programs/open_source/licensing/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/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 char* cur = buffer; S32 chars_read = 0; S32 count = 0; U32 version = 0; // read version count = sscanf( cur, "Landmark version %u\n%n", &version, &chars_read ); if(count != 1) { goto error; } if(version == 1) { LLVector3d pos; cur += chars_read; // read position count = sscanf( cur, "position %lf %lf %lf\n%n", pos.mdV+VX, pos.mdV+VY, pos.mdV+VZ, &chars_read ); if( count != 3 ) { goto error; } cur += chars_read; // llinfos << "Landmark read: " << pos << llendl; return new LLLandmark(pos); } else if(version == 2) { // *NOTE: Changing the buffer size will require changing the // scanf call below. char region_id_str[MAX_STRING]; /* Flawfinder: ignore */ LLVector3 pos; cur += chars_read; count = sscanf( /* Flawfinder: ignore */ cur, "region_id %254s\n%n", region_id_str, &chars_read); if(count != 1) goto error; cur += chars_read; count = sscanf(cur, "local_pos %f %f %f\n%n", pos.mV+VX, pos.mV+VY, pos.mV+VZ, &chars_read); if(count != 3) goto error; cur += chars_read; LLLandmark* lm = new LLLandmark; lm->mRegionID.set(region_id_str); lm->mRegionPos = pos; return lm; } error: llinfos << "Bad Landmark Asset: bad _DATA_ block." << llendl; return NULL; } // 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. lldebugs << "requestRegionHandle: null" << llendl; if(callback) { const U64 U64_ZERO = 0; callback(region_id, U64_ZERO); } } else { if(region_id == mLocalRegion.first) { lldebugs << "requestRegionHandle: local" << llendl; if(callback) { callback(region_id, mLocalRegion.second); } } else { region_map_t::iterator it = mRegions.find(region_id); if(it == mRegions.end()) { lldebugs << "requestRegionHandle: upstream" << llendl; if(callback) { region_callback_map_t::value_type vt(region_id, callback); sRegionCallbackMap.insert(vt); } lldebugs << "Landmark requesting information about: " << region_id << llendl; 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. lldebugs << "requestRegionHandle: ready" << llendl; 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); lldebugs << "Landmark got reply for region: " << region_id << " " << grid_x << "," << grid_y << llendl; #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; } } }