/*virtual*/ void completed(U32 status, const std::string& reason, const LLSD& content) { slmGetTimer.stop(); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET status: " << status << llendl; llinfos << " SLM GET reason: " << reason << llendl; llinfos << " SLM GET content: " << content.asString() << llendl; llinfos << " SLM GET timer: " << slmGetTimer.getElapsedTimeF32() << llendl; } if ((status == MarketplaceErrorCodes::IMPORT_AUTHENTICATION_ERROR) || (status == MarketplaceErrorCodes::IMPORT_JOB_TIMEOUT)) { if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET clearing marketplace cookie due to authentication failure or timeout (" << status << " / " << reason << ")." << llendl; } sMarketplaceCookie.clear(); } sImportInProgress = (status == MarketplaceErrorCodes::IMPORT_PROCESSING); sImportGetPending = false; sImportResultStatus = status; sImportResults = content; }
/*virtual*/ void completed(U32 status, const std::string& reason, const LLSD& content) { slmGetTimer.stop(); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET status: " << status << llendl; llinfos << " SLM GET reason: " << reason << llendl; llinfos << " SLM GET content: " << content.asString() << llendl; llinfos << " SLM GET timer: " << slmGetTimer.getElapsedTimeF32() << llendl; } // MAINT-2452 : Do not clear the cookie on IMPORT_DONE_WITH_ERRORS if ((status >= MarketplaceErrorCodes::IMPORT_BAD_REQUEST) && (status != MarketplaceErrorCodes::IMPORT_DONE_WITH_ERRORS)) { if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET clearing marketplace cookie due to client or server error (" << status << " / " << reason << ")." << llendl; } sMarketplaceCookie.clear(); } else if (gSavedSettings.getBOOL("InventoryOutboxLogging") && (status == MarketplaceErrorCodes::IMPORT_DONE_WITH_ERRORS)) { llinfos << " SLM GET : Got IMPORT_DONE_WITH_ERRORS, marketplace cookie not cleared." << llendl; } sImportInProgress = (status == MarketplaceErrorCodes::IMPORT_PROCESSING); sImportGetPending = false; sImportResultStatus = status; sImportResults = content; }
S32 LLQueuedThread::updateQueue(U32 max_time_ms) { F64 max_time = (F64)max_time_ms * .001; LLTimer timer; S32 pending = 1; // Frame Update if (mThreaded) { pending = getPending(); if(pending > 0) { unpause(); } } else { while (pending > 0) { pending = processNextRequest(); if (max_time && timer.getElapsedTimeF64() > max_time) break; } } return pending; }
/*virtual*/ void completed(U32 status, const std::string& reason, const LLSD& content) { slmGetTimer.stop(); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET status: " << status << llendl; llinfos << " SLM GET reason: " << reason << llendl; llinfos << " SLM GET content: " << content.asString() << llendl; llinfos << " SLM GET timer: " << slmGetTimer.getElapsedTimeF32() << llendl; } // MAINT-2452 : Do not clear the cookie on IMPORT_DONE_WITH_ERRORS : Happens when trying to import objects with wrong permissions // ACME-1221 : Do not clear the cookie on IMPORT_NOT_FOUND : Happens for newly created Merchant accounts that are initially empty if ((status >= MarketplaceErrorCodes::IMPORT_BAD_REQUEST) && (status != MarketplaceErrorCodes::IMPORT_DONE_WITH_ERRORS) && (status != MarketplaceErrorCodes::IMPORT_NOT_FOUND)) { if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET clearing marketplace cookie due to client or server error (" << status << " / " << reason << ")." << llendl; } sMarketplaceCookie.clear(); } else if (gSavedSettings.getBOOL("InventoryOutboxLogging") && (status >= MarketplaceErrorCodes::IMPORT_BAD_REQUEST)) { llinfos << " SLM GET : Got error status = " << status << ", but marketplace cookie not cleared." << llendl; } sImportInProgress = (status == MarketplaceErrorCodes::IMPORT_PROCESSING); sImportGetPending = false; sImportResultStatus = status; sImportResults = content; }
void object::test<5>() { set_test_name("bad type"); LLSD request; request["uri"] = uri; request["method"] = "getdict"; request["reply"] = "reply"; (void)request["params"]; // Set up a timeout filter so we don't spin forever waiting. LLEventTimeout watchdog; // Connect the timeout filter to the reply pump. LLTempBoundListener temp( pumps.obtain("reply"). listen("watchdog", boost::bind(&LLEventTimeout::post, boost::ref(watchdog), _1))); // Now connect our target listener to the timeout filter. watchdog.listen("captureReply", boost::bind(&data::captureReply, this, _1)); // Kick off the request... reply.clear(); pumps.obtain("LLXMLRPCTransaction").post(request); // Set the timer F32 timeout(10); watchdog.eventAfter(timeout, LLSD().insert("timeout", 0)); // and pump "mainloop" until we get something, whether from // LLXMLRPCListener or from the watchdog filter. LLTimer timer; F32 start = timer.getElapsedTimeF32(); LLEventPump& mainloop(pumps.obtain("mainloop")); while (reply.isUndefined()) { mainloop.post(LLSD()); } ensure("timeout works", (timer.getElapsedTimeF32() - start) < (timeout + 1)); ensure_equals(reply["status"].asString(), "BadType"); ensure_contains("bad type", reply["responses"]["nested_dict"].asString(), "bad XMLRPC type"); }
bool LLUpdaterServiceImpl::onMainLoop(LLSD const & event) { if(mTimer.getStarted() && mTimer.hasExpired()) { stopTimer(); // Check for failed install. if(LLFile::isfile(ll_install_failed_marker_path())) { int requiredValue = 0; { llifstream stream(ll_install_failed_marker_path()); stream >> requiredValue; if(stream.fail()) requiredValue = 0; } // TODO: notify the user. llinfos << "found marker " << ll_install_failed_marker_path() << llendl; llinfos << "last install attempt failed" << llendl; LLFile::remove(ll_install_failed_marker_path()); LLSD event; event["type"] = LLSD(LLUpdaterService::INSTALL_ERROR); event["required"] = LLSD(requiredValue); LLEventPumps::instance().obtain(LLUpdaterService::pumpName()).post(event); setState(LLUpdaterService::TERMINAL); } else {
void LLUpdaterServiceImpl::restartTimer(unsigned int seconds) { LL_INFOS("UpdaterService") << "will check for update again in " << seconds << " seconds" << LL_ENDL; mTimer.start(); mTimer.setTimerExpirySec((F32)seconds); LLEventPumps::instance().obtain("mainloop").listen( sListenerName, boost::bind(&LLUpdaterServiceImpl::onMainLoop, this, _1)); }
bool LLUpdaterServiceImpl::onMainLoop(LLSD const & event) { if(mTimer.getStarted() && mTimer.hasExpired()) { stopTimer(); // Check for failed install. if(LLFile::isfile(ll_install_failed_marker_path())) { LL_DEBUGS("UpdaterService") << "found marker " << ll_install_failed_marker_path() << LL_ENDL; int requiredValue = 0; { llifstream stream(ll_install_failed_marker_path().c_str()); stream >> requiredValue; if(stream.fail()) { requiredValue = 0; } } // TODO: notify the user. LL_WARNS("UpdaterService") << "last install attempt failed" << LL_ENDL;; LLFile::remove(ll_install_failed_marker_path()); LLSD event; event["type"] = LLSD(LLUpdaterService::INSTALL_ERROR); event["required"] = LLSD(requiredValue); LLEventPumps::instance().obtain(LLUpdaterService::pumpName()).post(event); setState(LLUpdaterService::TERMINAL); } //<FS:TM> 3.6.4 check this, commented out to compile //else //{ // std::string query_url = LLGridManager::getInstance()->getUpdateServiceURL(); // if ( !query_url.empty() ) // { // mUpdateChecker.checkVersion(query_url, mChannel, mVersion, // mPlatform, mPlatformVersion, mUniqueId, // mWillingToTest); // setState(LLUpdaterService::CHECKING_FOR_UPDATE); // } // else // { // LL_WARNS("UpdaterService") // << "No updater service defined for grid '" << LLGridManager::getInstance()->getGrid() // << "' will check again in " << mCheckPeriod << " seconds" // << LL_ENDL; // // Because the grid can be changed after the viewer is started (when the first check takes place) // // but before the user logs in, the next check may be on a different grid, so set the retry timer // // even though this check did not happen. The default time is once an hour, and if we're not // // doing the check anyway the performance impact is completely insignificant. // restartTimer(mCheckPeriod); // } //} }
F32 pump_loop(LLPumpIO* pump, F32 seconds) { LLTimer timer; timer.setTimerExpirySec(seconds); while(!timer.hasExpired()) { LLFrameTimer::updateFrameTime(); pump->pump(); pump->callback(); } return timer.getElapsedTimeF32(); }
//static void LLMarketplaceInventoryImporter::update() { if (instanceExists()) { static LLTimer update_timer; if (update_timer.hasExpired()) { LLMarketplaceInventoryImporter::instance().updateImport(); //static LLCachedControl<F32> MARKET_IMPORTER_UPDATE_FREQUENCY("MarketImporterUpdateFreq", 1.0f); update_timer.setTimerExpirySec(MARKET_IMPORTER_UPDATE_FREQUENCY); } } }
bool LLTrackingData::haveTrackingInfo() { LLViewerObject* object = gObjectList.findObject(mAvatarID); if(object && !object->isDead()) { mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY); mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY); mAgentGone.setTimerExpirySec(OFFLINE_SECONDS); mHaveInfo = true; return true; } if(mHaveCoarseInfo && !mCoarseLocationTimer.checkExpirationAndReset(COARSE_FREQUENCY)) { // if we reach here, then we have a 'recent' coarse update mUpdateTimer.setTimerExpirySec(FIND_FREQUENCY); mAgentGone.setTimerExpirySec(OFFLINE_SECONDS); return true; } if(mUpdateTimer.checkExpirationAndReset(FIND_FREQUENCY)) { LLAvatarTracker::instance().findAgent(); mHaveCoarseInfo = false; } if(mAgentGone.checkExpirationAndReset(OFFLINE_SECONDS)) { mHaveInfo = false; mHaveCoarseInfo = false; } return mHaveInfo; }
void LLWLParamSet::updateCloudScrolling(void) { static LLTimer s_cloud_timer; F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64(); if(getEnableCloudScrollX()) { mCloudScrollXOffset += F32(delta_t * (getCloudScrollX() - 10.f) / 100.f); } if(getEnableCloudScrollY()) { mCloudScrollYOffset += F32(delta_t * (getCloudScrollY() - 10.f) / 100.f); } }
bool pollStatus() { if (!hasSessionCookie()) { return false; } sImportGetPending = true; std::string url = getInventoryImportURL(); url += sImportId.asString(); // Make the headers for the post AIHTTPHeaders headers; headers.addHeader("Accept", "*/*"); headers.addHeader("Cookie", sMarketplaceCookie); headers.addHeader("Content-Type", "application/llsd+xml"); headers.addHeader("User-Agent", LLViewerMedia::getCurrentUserAgent()); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET: " << url << llendl; } slmGetTimer.start(); LLHTTPClient::get(url, new LLImportGetResponder(), headers); return true; }
bool establishMarketplaceSessionCookie() { if (hasSessionCookie()) { return false; } sImportInProgress = true; sImportGetPending = true; std::string url = getInventoryImportURL(); AIHTTPHeaders headers = LLViewerMedia::getHeaders(); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM GET: establishMarketplaceSessionCookie, LLHTTPClient::get, url = " << url << llendl; llinfos << " SLM GET: headers " << llendl; llinfos << headers << llendl; } slmGetTimer.start(); LLHTTPClient::get(url, new LLImportGetResponder(), headers); return true; }
void LLProgressBar::draw() { static LLTimer timer; F32 alpha = getDrawContext().mAlpha; LLColor4 image_bar_color = mColorBackground.get(); image_bar_color.setAlpha(alpha); mImageBar->draw(getLocalRect(), image_bar_color); alpha *= 0.5f + 0.5f*0.5f*(1.f + (F32)sin(3.f*timer.getElapsedTimeF32())); LLColor4 bar_color = mColorBar.get(); bar_color.mV[VALPHA] *= alpha; // modulate alpha LLRect progress_rect = getLocalRect(); progress_rect.mRight = llround(getRect().getWidth() * (mPercentDone / 100.f)); mImageFill->draw(progress_rect, bar_color); }
namespace etw { HMODULE hETW; tpLogFrame pLogFrame; tpLogStartTask pLogStartTask; tpLogEndTask pLogEndTask; tpLogTickTask pLogTickTask; LLTimer etwFrameTimer; void init() { pLogFrame = NULL; pLogStartTask = NULL; pLogEndTask = NULL; pLogTickTask = NULL; // This is okay for now. We'll only need that for measuring under well defined circumstances. // Maybe create an installer for this one day (very low prio) that copies and registers the provider. hETW = ::LoadLibrary( L"c:\\xperf\\fs_etw.dll" ); if( hETW ) { tpInitialize pInitialize = reinterpret_cast< tpInitialize>( ::GetProcAddress( hETW, "initialize" ) ); if( pInitialize && (*pInitialize)() ) { pLogFrame = reinterpret_cast< tpLogFrame >( ::GetProcAddress( hETW, "log_beginFrame" ) ); pLogStartTask = reinterpret_cast< tpLogStartTask >( ::GetProcAddress( hETW, "log_startTask" ) ); pLogEndTask = reinterpret_cast< tpLogEndTask >( ::GetProcAddress( hETW, "log_endTask" ) ); pLogTickTask = reinterpret_cast< tpLogTickTask >( ::GetProcAddress( hETW, "log_tickTask" ) ); etwFrameTimer.reset(); } } } }
bool triggerImport() { if (!hasSessionCookie()) { return false; } sImportId = LLSD::emptyMap(); sImportInProgress = true; sImportPostPending = true; sImportResultStatus = MarketplaceErrorCodes::IMPORT_PROCESSING; sImportResults = LLSD::emptyMap(); std::string url = getInventoryImportURL(); // Make the headers for the post AIHTTPHeaders headers; headers.addHeader("Accept", "*/*"); headers.addHeader("Connection", "Keep-Alive"); headers.addHeader("Cookie", sMarketplaceCookie); headers.addHeader("Content-Type", "application/xml"); headers.addHeader("User-Agent", LLViewerMedia::getCurrentUserAgent()); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM POST: " << url << llendl; } slmPostTimer.start(); LLHTTPClient::post(url, LLSD(), new LLImportPostResponder(), headers); return true; }
// This experimental mode sends chat messages into SL on a back channel for LSL scripts // to intercept with a listen() event. This is experimental and not sustainable for // a production feature ... many avatars using this would flood the chat system and // hurt server performance. Depending on how useful this proves to be, a better // mechanism should be designed to stream data from the viewer into SL scripts. void LLLMImpl::modeStreamDataToSL(Leap::HandList & hands) { S32 numHands = hands.count(); if (numHands == 1 && mChatMsgTimer.checkExpirationAndReset(LLLEAP_CHAT_MSG_INTERVAL)) { // Get the first (and only) hand Leap::Hand hand = hands[0]; Leap::Vector palm_pos = hand.palmPosition(); Leap::Vector palm_normal = hand.palmNormal(); F32 ball_radius = (F32) hand.sphereRadius(); Leap::Vector ball_center = hand.sphereCenter(); // Chat message looks like "/2343 LM1,<palm pos>,<palm normal>,<sphere center>,<sphere radius>" LLVector3 vec; std::stringstream status_chat_msg; status_chat_msg << "/2343 LM,"; status_chat_msg << "<" << palm_pos.x << "," << palm_pos.y << "," << palm_pos.z << ">,"; status_chat_msg << "<" << palm_normal.x << "," << palm_normal.y << "," << palm_normal.z << ">,"; status_chat_msg << "<" << ball_center.x << "," << ball_center.y << "," << ball_center.z << ">," << ball_radius; FSNearbyChat::instance().sendChatFromViewer(status_chat_msg.str(), CHAT_TYPE_SHOUT, FALSE); } }
void LLTrackingData::setTrackedCoarseLocation(const LLVector3d& global_pos) { mCoarseLocationTimer.setTimerExpirySec(COARSE_FREQUENCY); mGlobalPositionEstimate = global_pos; mHaveInfo = true; mHaveCoarseInfo = true; }
void timeDelay(LLCoros::self& self, LLPanelMarketplaceOutbox* outboxPanel) { waitForEventOn(self, "mainloop"); LLTimer delayTimer; delayTimer.reset(); delayTimer.setTimerExpirySec(5.0f); while (!delayTimer.hasExpired()) { waitForEventOn(self, "mainloop"); } outboxPanel->onSyncComplete(); gTimeDelayDebugFunc = ""; }
// This is the SLPlugin process. // This is not part of a DSO. // // This function is called by SLPlugin to send a message (originating from // SLPlugin itself) to the loaded DSO. It calls LLPluginInstance::sendMessage. void LLPluginProcessChild::sendMessageToPlugin(const LLPluginMessage &message) { if (mInstance) { std::string buffer = message.generate(); LL_DEBUGS("Plugin") << "Sending to plugin: " << buffer << LL_ENDL; LLTimer elapsed; mInstance->sendMessage(buffer); mCPUElapsed += elapsed.getElapsedTimeF64(); } else { LL_WARNS("Plugin") << "mInstance == NULL" << LL_ENDL; } }
void runThePump(float timeout = 100.0f) { LLTimer timer; timer.setTimerExpirySec(timeout); while(!mSawCompleted && !mSawCompletedHeader && !timer.hasExpired()) { if (mServerPump) { mServerPump->pump(); mServerPump->callback(); } if (mClientPump) { mClientPump->pump(); mClientPump->callback(); } } }
void LLTextureCache::purgeTextureFilesTimeSliced(BOOL force_all) { LLMutexLock lock(&mHeaderMutex); F32 delay_between_passes = 1.0f; // seconds F32 max_time_per_pass = 0.1f; // seconds if (!force_all && mTimeLastFileDelete.getElapsedTimeF32() <= delay_between_passes) { return; } LLTimer timer; S32 howmany = 0; if (mFilesToDelete.size() > 0) { llinfos << "TEXTURE CACHE: " << mFilesToDelete.size() << " files scheduled for deletion" << llendl; } for (LLTextureCache::filename_list_t::iterator iter = mFilesToDelete.begin(); iter!=mFilesToDelete.end(); ) { LLTextureCache::filename_list_t::iterator iter2 = iter++; ll_apr_file_remove(*iter2, NULL); mFilesToDelete.erase(iter2); howmany++; if (!force_all && timer.getElapsedTimeF32() > max_time_per_pass) { break; } } if (!mFilesToDelete.empty()) { llinfos << "TEXTURE CACHE: "<< howmany << " files deleted (" << mFilesToDelete.size() << " files left for next pass)" << llendl; } mTimeLastFileDelete.reset(); }
void LLProgressBar::draw() { static LLTimer timer; LLUIImagePtr shadow_imagep = LLUI::getUIImage("rounded_square_soft.tga"); LLUIImagePtr bar_fg_imagep = LLUI::getUIImage("progressbar_fill.tga"); LLUIImagePtr bar_bg_imagep = LLUI::getUIImage("progressbar_track.tga"); LLUIImagePtr bar_imagep = LLUI::getUIImage("rounded_square.tga"); LLColor4 background_color = LLUI::sColorsGroup->getColor("LoginProgressBarBgColor"); bar_bg_imagep->draw(getLocalRect(), background_color); F32 alpha = 0.5f + 0.5f*0.5f*(1.f + (F32)sin(3.f*timer.getElapsedTimeF32())); LLColor4 bar_color = LLUI::sColorsGroup->getColor("LoginProgressBarFgColor"); bar_color.mV[3] = alpha; LLRect progress_rect = getLocalRect(); progress_rect.mRight = llround(getRect().getWidth() * (mPercentDone / 100.f)); bar_fg_imagep->draw(progress_rect); }
void LLVertexBuffer::clientCopy(F64 max_time) { if (!sDeleteList.empty()) { size_t num = sDeleteList.size(); glDeleteBuffersARB(sDeleteList.size(), (GLuint*) &(sDeleteList[0])); sDeleteList.clear(); sGLCount -= num; } if (sEnableVBOs) { LLTimer timer; BOOL reset = TRUE; buffer_list_t::iterator iter = sLockedList.begin(); while(iter != sLockedList.end()) { LLVertexBuffer* buffer = *iter; if (buffer->isLocked() && buffer->useVBOs()) { buffer->setBuffer(0); } ++iter; if (reset) { reset = FALSE; timer.reset(); //skip first copy (don't count pipeline stall) } else { if (timer.getElapsedTimeF64() > max_time) { break; } } } sLockedList.erase(sLockedList.begin(), iter); } }
void LLTrackingData::agentFound(const LLUUID& prey, const LLVector3d& estimated_global_pos) { if(prey != mAvatarID) { llwarns << "LLTrackingData::agentFound() - found " << prey << " but looking for " << mAvatarID << llendl; } mHaveInfo = true; mAgentGone.setTimerExpirySec(OFFLINE_SECONDS); mGlobalPositionEstimate = estimated_global_pos; }
/*virtual*/ void completed(U32 status, const std::string& reason, const LLSD& content) { slmPostTimer.stop(); if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM POST status: " << status << llendl; llinfos << " SLM POST reason: " << reason << llendl; llinfos << " SLM POST content: " << content.asString() << llendl; llinfos << " SLM POST timer: " << slmPostTimer.getElapsedTimeF32() << llendl; } // MAINT-2301 : we determined we can safely ignore that error in that context if (status == MarketplaceErrorCodes::IMPORT_JOB_TIMEOUT) { if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM POST : Ignoring time out status and treating it as success" << llendl; } status = MarketplaceErrorCodes::IMPORT_DONE; } if (status >= MarketplaceErrorCodes::IMPORT_BAD_REQUEST) { if (gSavedSettings.getBOOL("InventoryOutboxLogging")) { llinfos << " SLM POST clearing marketplace cookie due to client or server error" << llendl; } sMarketplaceCookie.clear(); } sImportInProgress = (status == MarketplaceErrorCodes::IMPORT_DONE); sImportPostPending = false; sImportResultStatus = status; sImportId = content; }
// This mode tries to detect simple hand motion and either triggers an avatar gesture or // sends a chat message into SL in response. It is very rough, hard-coded for detecting // a hand wave (a SL gesture) or the wiggling-thumb gun trigger (a chat message sent to a // special version of the popgun). void LLLMImpl::modeGestureDetection1(Leap::HandList & hands) { static S32 trigger_direction = -1; S32 numHands = hands.count(); if (numHands == 1) { // Get the first hand Leap::Hand hand = hands[0]; // Check if the hand has any fingers Leap::FingerList finger_list = hand.fingers(); S32 num_fingers = finger_list.count(); static S32 last_num_fingers = 0; if (num_fingers == 1) { // One finger ... possibly reset the Leap::Finger finger = finger_list[0]; Leap::Vector finger_dir = finger.direction(); // Negative Z is into the screen - check that it's the largest component S32 abs_z_dir = llabs(finger_dir.z); if (finger_dir.z < -0.5 && abs_z_dir > llabs(finger_dir.x) && abs_z_dir > llabs(finger_dir.y)) { Leap::Vector finger_pos = finger.tipPosition(); Leap::Vector finger_vel = finger.tipVelocity(); LL_INFOS("LeapMotion") << "finger direction is " << finger_dir.x << ", " << finger_dir.y << ", " << finger_dir.z << ", position " << finger_pos.x << ", " << finger_pos.y << ", " << finger_pos.z << ", velocity " << finger_vel.x << ", " << finger_vel.y << ", " << finger_vel.z << LL_ENDL; } if (trigger_direction != -1) { LL_INFOS("LeapMotion") << "Reset trigger_direction - one finger" << LL_ENDL; trigger_direction = -1; } } else if (num_fingers == 2) { Leap::Finger barrel_finger = finger_list[0]; Leap::Vector barrel_finger_dir = barrel_finger.direction(); // Negative Z is into the screen - check that it's the largest component F32 abs_z_dir = llabs(barrel_finger_dir.z); if (barrel_finger_dir.z < -0.5f && abs_z_dir > llabs(barrel_finger_dir.x) && abs_z_dir > llabs(barrel_finger_dir.y)) { Leap::Finger thumb_finger = finger_list[1]; Leap::Vector thumb_finger_dir = thumb_finger.direction(); Leap::Vector thumb_finger_pos = thumb_finger.tipPosition(); Leap::Vector thumb_finger_vel = thumb_finger.tipVelocity(); if ((thumb_finger_dir.x < barrel_finger_dir.x) ) { // Trigger gunfire if (trigger_direction < 0 && // Haven't fired thumb_finger_vel.x > 50.f && // Moving into screen thumb_finger_vel.z < -50.f && mChatMsgTimer.checkExpirationAndReset(LLLEAP_CHAT_MSG_INTERVAL)) { // Chat message looks like "/2343 LM2 gunfire" std::string gesture_chat_msg("/2343 LM2 gunfire"); //LLNearbyChatBar::sendChatFromViewer(gesture_chat_msg, CHAT_TYPE_SHOUT, FALSE); trigger_direction = 1; LL_INFOS("LeapMotion") << "Sent gunfire chat" << LL_ENDL; } else if (trigger_direction > 0 && // Have fired, need to pull thumb back thumb_finger_vel.x < -50.f && thumb_finger_vel.z > 50.f) // Moving out of screen { trigger_direction = -1; LL_INFOS("LeapMotion") << "Reset trigger_direction" << LL_ENDL; } } } else if (trigger_direction != -1) { LL_INFOS("LeapMotion") << "Reset trigger_direction - hand pos" << LL_ENDL; trigger_direction = -1; } } else if (num_fingers == 5 && num_fingers == last_num_fingers) { if (mGestureTimer.checkExpirationAndReset(LLLEAP_GESTURE_INTERVAL)) { // figure out a gesture to trigger std::string gestureString("/overhere"); LLGestureMgr::instance().triggerAndReviseString( gestureString ); } } last_num_fingers = num_fingers; } }
// This controller mode is used to fly the avatar, going up, down, forward and turning. void LLLMImpl::modeFlyingControlTest(Leap::HandList & hands) { static S32 sLMFlyingHysteresis = 0; S32 numHands = hands.count(); BOOL agent_is_flying = gAgent.getFlying(); if (numHands == 0 && agent_is_flying && sLMFlyingHysteresis > 0) { sLMFlyingHysteresis--; if (sLMFlyingHysteresis == 0) { LL_INFOS("LeapMotion") << "LM stop flying - look ma, no hands!" << LL_ENDL; gAgent.setFlying(FALSE); } } else if (numHands == 1) { // Get the first hand Leap::Hand hand = hands[0]; // Check if the hand has any fingers Leap::FingerList finger_list = hand.fingers(); S32 num_fingers = finger_list.count(); Leap::Vector palm_pos = hand.palmPosition(); Leap::Vector palm_normal = hand.palmNormal(); F32 ball_radius = (F32) hand.sphereRadius(); Leap::Vector ball_center = hand.sphereCenter(); // Number of fingers controls flying on / off if (num_fingers == 0 && // To do - add hysteresis or data smoothing? agent_is_flying) { if (sLMFlyingHysteresis > 0) { sLMFlyingHysteresis--; } else { LL_INFOS("LeapMotion") << "LM stop flying" << LL_ENDL; gAgent.setFlying(FALSE); } } else if (num_fingers > 2 && !agent_is_flying) { LL_INFOS("LeapMotion") << "LM start flying" << LL_ENDL; gAgent.setFlying(TRUE); sLMFlyingHysteresis = 5; } // Radius of ball controls forward motion if (agent_is_flying) { if (ball_radius > 110.f) { // Open hand, move fast gAgent.setControlFlags(AGENT_CONTROL_AT_POS | AGENT_CONTROL_FAST_AT); } else if (ball_radius > 85.f) { // Partially open, move slow gAgent.setControlFlags(AGENT_CONTROL_AT_POS); } else { // Closed - stop gAgent.clearControlFlags(AGENT_CONTROL_AT_POS); } // Height of palm controls moving up and down if (palm_pos.y > 260.f) { // Go up fast gAgent.setControlFlags(AGENT_CONTROL_UP_POS | AGENT_CONTROL_FAST_UP); } else if (palm_pos.y > 200.f) { // Go up gAgent.setControlFlags(AGENT_CONTROL_UP_POS); } else if (palm_pos.y < 60.f) { // Go down fast gAgent.setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_NEG); } else if (palm_pos.y < 120.f) { // Go down gAgent.setControlFlags(AGENT_CONTROL_UP_NEG); } else { // Clear up / down gAgent.clearControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_POS | AGENT_CONTROL_UP_NEG); } // Palm normal going left / right controls direction if (mYawTimer.checkExpirationAndReset(LLLEAP_YAW_INTERVAL)) { if (palm_normal.x > 0.4f) { // Go left fast gAgent.moveYaw(1.f); } else if (palm_normal.x < -0.4f) { // Go right fast gAgent.moveYaw(-1.f); } } } // end flying controls } }
void LLViewerImageList::decodeAllImages(F32 max_time) { LLTimer timer; if(gNoRender) return; // Update texture stats and priorities std::vector<LLPointer<LLViewerImage> > image_list; for (image_priority_list_t::iterator iter = mImageList.begin(); iter != mImageList.end(); ) { LLViewerImage* imagep = *iter++; image_list.push_back(imagep); imagep->mInImageList = FALSE; } mImageList.clear(); for (std::vector<LLPointer<LLViewerImage> >::iterator iter = image_list.begin(); iter != image_list.end(); ++iter) { LLViewerImage* imagep = *iter; imagep->processTextureStats(); F32 decode_priority = imagep->calcDecodePriority(); imagep->setDecodePriority(decode_priority); mImageList.insert(imagep); imagep->mInImageList = TRUE; } image_list.clear(); // Update fetch (decode) for (image_priority_list_t::iterator iter = mImageList.begin(); iter != mImageList.end(); ) { LLViewerImage* imagep = *iter++; imagep->updateFetch(); } // Run threads S32 fetch_pending = 0; while (1) { LLAppViewer::instance()->getTextureCache()->update(1); // unpauses the texture cache thread LLAppViewer::instance()->getImageDecodeThread()->update(1); // unpauses the image thread fetch_pending = LLAppViewer::instance()->getTextureFetch()->update(1); // unpauses the texture fetch thread if (fetch_pending == 0 || timer.getElapsedTimeF32() > max_time) { break; } } // Update fetch again for (image_priority_list_t::iterator iter = mImageList.begin(); iter != mImageList.end(); ) { LLViewerImage* imagep = *iter++; imagep->updateFetch(); } max_time -= timer.getElapsedTimeF32(); max_time = llmax(max_time, .001f); F32 create_time = updateImagesCreateTextures(max_time); LL_DEBUGS("ViewerImages") << "decodeAllImages() took " << timer.getElapsedTimeF32() << " seconds. " << " fetch_pending " << fetch_pending << " create_time " << create_time << LL_ENDL; }