Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LLFrameTimer review and resulting changes.

Browse Source 
This makes the class API a bit more sane, although
only a bit, because I had to leave it working with
possibly new code merged in from LL: the API can't
really change. I also removed some unused code.

While reviewing how LLFrameTimer worked however,
I did find a few instances where things where broken:

* sFrameDeltaTime wasn't correctly updated (more
  than once per frame and therefore erratic). This
  only influenced scrolling speed, but still.
* While dragging an inventory item, the scroll
  arrows of a tab container didn't work
  (LLTabContainer::handleDragAndDrop).
* Map zoom interpolation was broken (it interpolated
  between A and B, but used the already updated
  interpolation for A the next frame...
  (added mCurZoomValInterpolationStart).
This commit is contained in:
Aleric Inglewood
2011-08-01 21:00:27 +02:00
committed by Siana Gearz
parent 7a739f4915
commit dfa10281ea
19 changed files with 189 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
indra/llcommon/llapp.cpp
View File

@@ -249,15 +249,6 @@ LLSD LLApp::getOptionData(OptionPriority level)
return mOptions[level];
}
void LLApp::stepFrame()
{
LLFrameTimer::updateFrameTime();
LLFrameTimer::updateFrameCount();
LLEventTimer::updateClass();
mRunner.run();
}
void LLApp::setupErrorHandling()
{
// Error handling is done by starting up an error handling thread, which just sleeps and

19
indra/llcommon/llapp.h
View File

@@ -236,17 +236,6 @@ public:
pid_t fork();
#endif
/**
* @brief Get a reference to the application runner
*
* Please use the runner with caution. Since the Runner usage
* pattern is not yet clear, this method just gives access to it
* to add and remove runnables.
* @return Returns the application runner. Do not save the
* pointer past the caller's stack frame.
*/
LLRunner& getRunner() { return mRunner; }
public:
typedef std::map<std::string, std::string> string_map;
string_map mOptionMap; // Contains all command-line options and arguments in a map
@@ -264,11 +253,6 @@ protected:
static LLAppChildCallback sDefaultChildCallback;
#endif
/**
* @brief This method is called once a frame to do once a frame tasks.
*/
void stepFrame();
/**
* @ brief This method is called once as soon as logging is initialized.
*/
@@ -289,9 +273,6 @@ private:
// Default application threads
LLErrorThread* mThreadErrorp; // Waits for app to go to status ERROR, then runs the error callback
// This is the application level runnable scheduler.
LLRunner mRunner;
/** @name Runtime option implementation */
//@{

100
indra/llcommon/llframetimer.cpp
View File

@@ -4,6 +4,7 @@
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
* Copyright (c) 2011, Aleric Inglewood.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
@@ -35,48 +36,55 @@
#include "llframetimer.h"
// Local constants.
static F64 const USEC_PER_SECOND = 1000000.0;
static F64 const USEC_TO_SEC_F64 = 0.000001;
// Static members
//LLTimer LLFrameTimer::sInternalTimer;
U64 LLFrameTimer::sStartTotalTime = totalTime();
F64 LLFrameTimer::sFrameTime = 0.0;
U64 LLFrameTimer::sTotalTime = 0;
F64 LLFrameTimer::sTotalSeconds = 0.0;
S32 LLFrameTimer::sFrameCount = 0;
U64 LLFrameTimer::sFrameDeltaTime = 0;
const F64 USEC_PER_SECOND = 1000000.0;
const F64 USEC_TO_SEC_F64 = 0.000001;
U64 const LLFrameTimer::sStartTotalTime = totalTime(); // Application start in microseconds since epoch.
U64 LLFrameTimer::sTotalTime = LLFrameTimer::sStartTotalTime; // Current time in microseconds since epoch, updated at least once per frame.
F64 LLFrameTimer::sTotalSeconds = // Current time in seconds since epoch, updated together with LLFrameTimer::sTotalTime.
U64_to_F64(LLFrameTimer::sTotalTime) * USEC_TO_SEC_F64;
F64 LLFrameTimer::sFrameTime = 0.0; // Current time in seconds since application start, updated together with LLFrameTimer::sTotalTime.
// Updated exactly once per frame:
S32 LLFrameTimer::sFrameCount = 0; // Current frame number (number of frames since application start).
U64 LLFrameTimer::sPrevTotalTime = LLFrameTimer::sStartTotalTime; // Previous (frame) time in microseconds since epoch, updated once per frame.
U64 LLFrameTimer::sFrameDeltaTime = 0; // Microseconds between last two calls to LLFrameTimer::updateFrameTimeAndCount.
// static
void LLFrameTimer::updateFrameTime()
{
U64 total_time = totalTime();
sFrameDeltaTime = total_time - sTotalTime;
sTotalTime = total_time;
sTotalTime = totalTime();
sTotalSeconds = U64_to_F64(sTotalTime) * USEC_TO_SEC_F64;
sFrameTime = U64_to_F64(sTotalTime - sStartTotalTime) * USEC_TO_SEC_F64;
}
void LLFrameTimer::start()
// static
void LLFrameTimer::updateFrameTimeAndCount()
{
reset();
mStarted = TRUE;
updateFrameTime();
sFrameDeltaTime = sTotalTime - sPrevTotalTime;
sPrevTotalTime = sTotalTime;
++sFrameCount;
}
void LLFrameTimer::reset(F32 expiration)
{
llassert(!mPaused);
mStartTime = sFrameTime;
mExpiry = sFrameTime + expiration;
}
void LLFrameTimer::start(F32 expiration)
{
reset(expiration);
mRunning = true; // Start, if not already started.
}
void LLFrameTimer::stop()
{
mStarted = FALSE;
}
void LLFrameTimer::reset()
{
mStartTime = sFrameTime;
mExpiry = sFrameTime;
}
void LLFrameTimer::resetWithExpiry(F32 expiration)
{
reset();
setTimerExpirySec(expiration);
llassert(!mPaused);
mRunning = false;
}
// Don't combine pause/unpause with start/stop
@@ -89,25 +97,31 @@ void LLFrameTimer::resetWithExpiry(F32 expiration)
// Note: elapsed would also be valid with no unpause() call (= time run until pause() called)
void LLFrameTimer::pause()
{
if (mStarted)
mStartTime = sFrameTime - mStartTime; // save dtime
mStarted = FALSE;
if (!mPaused)
{
mStartTime = sFrameTime - mStartTime; // Abuse mStartTime to store the elapsed time so far.
}
mPaused = true;
}
void LLFrameTimer::unpause()
{
if (!mStarted)
mStartTime = sFrameTime - mStartTime; // restore dtime
mStarted = TRUE;
if (mPaused)
{
mStartTime = sFrameTime - mStartTime; // Set mStartTime consistent with the elapsed time so far.
}
mPaused = false;
}
void LLFrameTimer::setTimerExpirySec(F32 expiration)
{
mExpiry = expiration + mStartTime;
llassert(!mPaused);
mExpiry = mStartTime + expiration;
}
void LLFrameTimer::setExpiryAt(F64 seconds_since_epoch)
{
llassert(!mPaused);
mStartTime = sFrameTime;
mExpiry = seconds_since_epoch - (USEC_TO_SEC_F64 * sStartTotalTime);
}
@@ -119,20 +133,14 @@ F64 LLFrameTimer::expiresAt() const
return expires_at;
}
BOOL LLFrameTimer::checkExpirationAndReset(F32 expiration)
bool LLFrameTimer::checkExpirationAndReset(F32 expiration)
{
//llinfos << "LLFrameTimer::checkExpirationAndReset()" << llendl;
//llinfos << " mStartTime:" << mStartTime << llendl;
//llinfos << " sFrameTime:" << sFrameTime << llendl;
//llinfos << " mExpiry: " << mExpiry << llendl;
if(hasExpired())
if (hasExpired())
{
reset();
setTimerExpirySec(expiration);
return TRUE;
reset(expiration);
return true;
}
return FALSE;
return false;
}
// static

95
indra/llcommon/llframetimer.h
View File

@@ -6,6 +6,7 @@
* $LicenseInfo:firstyear=2002&license=viewergpl$
*
* Copyright (c) 2002-2009, Linden Research, Inc.
* Copyright (c) 2011, Aleric Inglewood.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
@@ -37,7 +38,7 @@
/**
* *NOTE: Because of limitations on linux which we do not really have
* time to explore, the total time is derived from the frame time
* and is recsynchronized on every frame.
* and is resynchronized on every frame.
*/
#include "lltimer.h"
@@ -46,61 +47,64 @@
class LL_COMMON_API LLFrameTimer
{
public:
LLFrameTimer() : mStartTime( sFrameTime ), mExpiry(0), mStarted(TRUE) {}
// Create an LLFrameTimer and start it. After creation it is running and in the state expired (hasExpired will return true).
LLFrameTimer(void) : mStartTime(sFrameTime), mExpiry(0), mRunning(true), mPaused(false) { }
// Return the number of seconds since the start of this
// application instance.
// Return the number of seconds since the start of the application.
static F64 getElapsedSeconds()
{
// Loses msec precision after ~4.5 hours...
return sFrameTime;
}
// Return a low precision usec since epoch
// Return a low precision usec since epoch.
static U64 getTotalTime()
{
return sTotalTime ? sTotalTime : totalTime();
llassert(sTotalTime);
return sTotalTime;
}
// Return a low precision seconds since epoch
// Return a low precision seconds since epoch.
static F64 getTotalSeconds()
{
return sTotalSeconds;
}
// Call this method once per frame to update the current frame time. This is actually called
// at some other times as well
// Call this method once per frame to update the current frame time.
// This is actually called at some other times as well.
static void updateFrameTime();
// Call this method once, and only once, per frame to update the current frame count.
static void updateFrameCount() { sFrameCount++; }
// Call this method once, and only once, per frame to update the current frame count and sFrameDeltaTime.
static void updateFrameTimeAndCount();
static U32 getFrameCount() { return sFrameCount; }
// Return current frame number (the number of frames since application start).
static U32 getFrameCount() { return sFrameCount; }
static F32 getFrameDeltaTimeF32();
// Return duration of last frame in seconds.
static F32 getFrameDeltaTimeF32();
// Return seconds since the current frame started
static F32 getCurrentFrameTime();
static F32 getCurrentFrameTime();
// MANIPULATORS
void start();
void stop();
void reset();
void resetWithExpiry(F32 expiration);
void pause();
void unpause();
void reset(F32 expiration = 0.f); // Same as start() but leaves mRunning off when called after stop().
void start(F32 expiration = 0.f); // Reset and (re)start with expiration.
void stop(); // Stop running.
void pause(); // Mark elapsed time so far.
void unpause(); // Move 'start' time in order to decrement time between pause and unpause from ElapsedTime.
void setTimerExpirySec(F32 expiration);
void setExpiryAt(F64 seconds_since_epoch);
BOOL checkExpirationAndReset(F32 expiration);
F32 getElapsedTimeAndResetF32() { F32 t = F32(sFrameTime - mStartTime); reset(); return t; }
void setAge(const F64 age) { mStartTime = sFrameTime - age; }
bool checkExpirationAndReset(F32 expiration); // Returns true when expired. Only resets if expired.
F32 getElapsedTimeAndResetF32() { F32 t = getElapsedTimeF32(); reset(); return t; }
void setAge(const F64 age) { llassert(!mPaused); mStartTime = sFrameTime - age; }
// ACCESSORS
BOOL hasExpired() const { return (sFrameTime >= mExpiry); }
F32 getTimeToExpireF32() const { return (F32)(mExpiry - sFrameTime); }
F32 getElapsedTimeF32() const { return mStarted ? (F32)(sFrameTime - mStartTime) : (F32)mStartTime; }
BOOL getStarted() const { return mStarted; }
bool hasExpired() const { return sFrameTime >= mExpiry; }
F32 getElapsedTimeF32() const { llassert(mRunning); return mPaused ? (F32)mStartTime : (F32)(sFrameTime - mStartTime); }
bool getStarted() const { return mRunning; }
// return the seconds since epoch when this timer will expire.
F64 expiresAt() const;
@@ -114,45 +118,52 @@ protected:
// Aplication constants
//
// Start time of opp in usec since epoch
static U64 sStartTotalTime;
// Application start in microseconds since epoch.
static U64 const sStartTotalTime;
//
// Data updated per frame
//
// Seconds since application start
// Current time in seconds since application start, updated together with sTotalTime.
static F64 sFrameTime;
// Time that has elapsed since last call to updateFrameTime()
// Microseconds between last two calls to updateFrameTimeAndCount (time between last two frames).
static U64 sFrameDeltaTime;
// Total microseconds since epoch.
// Current time in microseconds since epoch, updated at least once per frame.
static U64 sTotalTime;
// Seconds since epoch.
// Previous (frame) time in microseconds since epoch, updated once per frame.
static U64 sPrevTotalTime;
// Current time in seconds since epoch, updated together with sTotalTime.
static F64 sTotalSeconds;
// Total number of frames elapsed in application
// Current frame number (number of frames since application start).
static S32 sFrameCount;
//
// Member data
//
// Number of seconds after application start when this timer was
// started. Set equal to sFrameTime when reset.
// When not paused (mPaused is false): number of seconds since application start,
// otherwise this value is equal to the accumulated run time (ElapsedTime).
// Set equal to sFrameTime when reset.
F64 mStartTime;
// Timer expires this many seconds after application start time.
// Timer expires when sFrameTime reaches this value (in seconds since application start).
F64 mExpiry;
// Useful bit of state usually associated with timers, but does
// not affect actual functionality
BOOL mStarted;
// True when running, merely a boolean return by getStarted(). The timer always runs.
bool mRunning;
// True when accumulating ElapsedTime. If false mStartTime has a different meaning
// and really unpause() should be called before anything else.
bool mPaused;
};
// Glue code for Havok (or anything else that doesn't want the full .h files)
extern F32 getCurrentFrameTime();
extern F32 getCurrentFrameTime();
#endif // LL_LLFRAMETIMER_H

4
indra/llmessage/llpumpio.cpp
View File

@@ -1147,9 +1147,7 @@ void LLPumpIO::LLChainInfo::setTimeoutSeconds(F32 timeout)
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
if(timeout > 0.0f)
{
mTimer.start();
mTimer.reset();
mTimer.setTimerExpirySec(timeout);
mTimer.start(timeout);
}
else
{

3
indra/llui/llalertdialog.cpp
View File

@@ -349,8 +349,7 @@ bool LLAlertDialog::show()
if(mDefaultOption >= 0)
{
// delay before enabling default button
mDefaultBtnTimer.start();
mDefaultBtnTimer.setTimerExpirySec(DEFAULT_BUTTON_DELAY);
mDefaultBtnTimer.start(DEFAULT_BUTTON_DELAY);
}
// attach to floater if necessary

3
indra/llui/lllineeditor.cpp
View File

@@ -858,8 +858,7 @@ BOOL LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
if (mScrollTimer.hasExpired())
{
S32 increment = llround(mScrollTimer.getElapsedTimeF32() / AUTO_SCROLL_TIME);
mScrollTimer.reset();
mScrollTimer.setTimerExpirySec(AUTO_SCROLL_TIME);
mScrollTimer.reset(AUTO_SCROLL_TIME);
if( (x < mMinHPixels) && (mScrollHPos > 0 ) )
{
// Scroll to the left

80
indra/llui/lltabcontainer.cpp
View File

@@ -630,49 +630,59 @@ LLXMLNodePtr LLTabContainer::getXML(bool save_children) const
// virtual
BOOL LLTabContainer::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, EDragAndDropType type, void* cargo_data, EAcceptance *accept, std::string &tooltip)
{
BOOL has_scroll_arrows = (getMaxScrollPos() > 0);
bool const has_scroll_arrows = (getMaxScrollPos() > 0);
if( mDragAndDropDelayTimer.getElapsedTimeF32() > SCROLL_DELAY_TIME )
LLButton* button = NULL;
if (has_scroll_arrows)
{
if (has_scroll_arrows)
// We're dragging an inventory item. Check if we're hovering over scroll arrows of this tab container.
if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
{
if (mJumpPrevArrowBtn && mJumpPrevArrowBtn->getRect().pointInRect(x, y))
button = mJumpPrevArrowBtn;
}
else if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
{
button = mJumpNextArrowBtn;
}
else if (mPrevArrowBtn->getRect().pointInRect(x, y))
{
button = mPrevArrowBtn;
}
else if (mNextArrowBtn->getRect().pointInRect(x, y))
{
button = mNextArrowBtn;
}
if (button)
{
if (mDragAndDropDelayTimer.getStarted() && mDragAndDropDelayTimer.hasExpired())
{
S32 local_x = x - mJumpPrevArrowBtn->getRect().mLeft;
S32 local_y = y - mJumpPrevArrowBtn->getRect().mBottom;
mJumpPrevArrowBtn->handleHover(local_x, local_y, mask);
// We've been hovering (another) SCROLL_DELAY_TIME seconds. Emulate a button press.
button->onCommit();
// Reset the timer.
mDragAndDropDelayTimer.start(SCROLL_DELAY_TIME);
}
if (mJumpNextArrowBtn && mJumpNextArrowBtn->getRect().pointInRect(x, y))
else if (!mDragAndDropDelayTimer.getStarted())
{
S32 local_x = x - mJumpNextArrowBtn->getRect().mLeft;
S32 local_y = y - mJumpNextArrowBtn->getRect().mBottom;
mJumpNextArrowBtn->handleHover(local_x, local_y, mask);
}
if (mPrevArrowBtn->getRect().pointInRect(x, y))
{
S32 local_x = x - mPrevArrowBtn->getRect().mLeft;
S32 local_y = y - mPrevArrowBtn->getRect().mBottom;
mPrevArrowBtn->handleHover(local_x, local_y, mask);
}
else if (mNextArrowBtn->getRect().pointInRect(x, y))
{
S32 local_x = x - mNextArrowBtn->getRect().mLeft;
S32 local_y = y - mNextArrowBtn->getRect().mBottom;
mNextArrowBtn->handleHover(local_x, local_y, mask);
// We just entered the arrow. Start the timer.
mDragAndDropDelayTimer.start(SCROLL_DELAY_TIME);
}
}
for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
else
{
LLTabTuple* tuple = *iter;
tuple->mButton->setVisible( TRUE );
S32 local_x = x - tuple->mButton->getRect().mLeft;
S32 local_y = y - tuple->mButton->getRect().mBottom;
if (tuple->mButton->pointInView(local_x, local_y) && tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
{
tuple->mButton->onCommit();
mDragAndDropDelayTimer.stop();
}
// We're not on an arrow or just left it. Stop the time (in case it was running).
mDragAndDropDelayTimer.stop();
}
}
for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
{
LLTabTuple* tuple = *iter;
tuple->mButton->setVisible( TRUE );
S32 local_x = x - tuple->mButton->getRect().mLeft;
S32 local_y = y - tuple->mButton->getRect().mBottom;
if (tuple->mButton->pointInView(local_x, local_y) && tuple->mButton->getEnabled() && !tuple->mTabPanel->getVisible())
{
tuple->mButton->onCommit();
}
}
@@ -1849,5 +1859,3 @@ void LLTabContainer::commitHoveredButton(S32 x, S32 y)
}
}

2
indra/llvfs/llpidlock.cpp
View File

@@ -167,7 +167,7 @@ bool LLPidLockFile::requestLock(LLNameTable<void *> *name_table, bool autosave,
if (!mWaiting) //Not presently waiting to save. Queue up.
{
mTimer.resetWithExpiry(timeout);
mTimer.reset(timeout);
mWaiting=TRUE;
}

3
indra/newview/llappviewer.cpp
View File

@@ -3545,8 +3545,7 @@ void LLAppViewer::idle()
// Update frame timers
static LLTimer idle_timer;
LLFrameTimer::updateFrameTime();
LLFrameTimer::updateFrameCount();
LLFrameTimer::updateFrameTimeAndCount();
LLEventTimer::updateClass();
LLCriticalDamp::updateInterpolants();
LLMortician::updateClass();

10
indra/newview/llfloateractivespeakers.cpp
View File

@@ -91,7 +91,7 @@ LLSpeaker::LLSpeaker(const LLUUID& id, const std::string& name, const ESpeakerTy
gVoiceClient->setUserVolume(id, LLMuteList::getInstance()->getSavedResidentVolume(id));
mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
mActivityTimer.reset(SPEAKER_TIMEOUT);
}
@@ -1021,7 +1021,7 @@ LLPointer<LLSpeaker> LLSpeakerMgr::setSpeaker(const LLUUID& id, const std::strin
{
// keep highest priority status (lowest value) instead of overriding current value
speakerp->mStatus = llmin(speakerp->mStatus, status);
speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
speakerp->mActivityTimer.reset(SPEAKER_TIMEOUT);
// RN: due to a weird behavior where IMs from attached objects come from the wearer's agent_id
// we need to override speakers that we think are objects when we find out they are really
// residents
@@ -1329,7 +1329,7 @@ void LLIMSpeakerMgr::updateSpeakers(const LLSD& update)
{
speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL;
speakerp->mDotColor = INACTIVE_COLOR;
speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
speakerp->mActivityTimer.reset(SPEAKER_TIMEOUT);
}
else if (agent_data["transition"].asString() == "ENTER")
{
@@ -1377,7 +1377,7 @@ void LLIMSpeakerMgr::updateSpeakers(const LLSD& update)
{
speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL;
speakerp->mDotColor = INACTIVE_COLOR;
speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
speakerp->mActivityTimer.reset(SPEAKER_TIMEOUT);
}
else if ( agent_transition == "ENTER")
{
@@ -1476,7 +1476,7 @@ void LLLocalSpeakerMgr::updateSpeakerList()
{
speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL;
speakerp->mDotColor = INACTIVE_COLOR;
speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT);
speakerp->mActivityTimer.reset(SPEAKER_TIMEOUT);
}
}
}

6
indra/newview/llfloatersnapshot.cpp
View File

@@ -229,7 +229,6 @@ LLSnapshotLivePreview::LLSnapshotLivePreview (const LLRect& rect) :
mSnapshotBufferType(LLViewerWindow::SNAPSHOT_TYPE_COLOR)
{
setSnapshotQuality(gSavedSettings.getS32("SnapshotQuality"));
mSnapshotDelayTimer.setTimerExpirySec(0.0f);
mSnapshotDelayTimer.start();
// gIdleCallbacks.addFunction( &LLSnapshotLivePreview::onIdle, (void*)this );
sList.insert(this);
@@ -350,8 +349,7 @@ void LLSnapshotLivePreview::updateSnapshot(BOOL new_snapshot, BOOL new_thumbnail
mShineAnimTimer.stop();
if (new_snapshot)
{
mSnapshotDelayTimer.start();
mSnapshotDelayTimer.setTimerExpirySec(delay);
mSnapshotDelayTimer.start(delay);
}
if(new_thumbnail)
{
@@ -754,7 +752,7 @@ BOOL LLSnapshotLivePreview::onIdle( void* snapshot_preview )
// see if it's time yet to snap the shot and bomb out otherwise.
previewp->mSnapshotActive =
(previewp->mSnapshotDelayTimer.getStarted() && previewp->mSnapshotDelayTimer.hasExpired())
(previewp->mSnapshotDelayTimer.getStarted() && previewp->mSnapshotDelayTimer.hasExpired())
&& !LLToolCamera::getInstance()->hasMouseCapture(); // don't take snapshots while ALT-zoom active
if ( ! previewp->mSnapshotActive)
{

19
indra/newview/llfloaterworldmap.cpp
View File

@@ -502,17 +502,26 @@ void LLFloaterWorldMap::draw()
getDragHandle()->setMouseOpaque(TRUE);
//RN: snaps to zoom value because interpolation caused jitter in the text rendering
if (!mZoomTimer.getStarted() && mCurZoomVal != (F32)childGetValue("zoom slider").asReal())
F32 interp = 1.f;
if (!mZoomTimer.getStarted())
{
mZoomTimer.start();
mCurZoomValInterpolationStart = mCurZoomVal;
if (mCurZoomVal < (F32)childGetValue("zoom slider").asReal())
{
mZoomTimer.start();
}
}
F32 interp = mZoomTimer.getElapsedTimeF32() / MAP_ZOOM_TIME;
if (interp > 1.f)
if (mZoomTimer.getStarted())
{
interp = mZoomTimer.getElapsedTimeF32() / MAP_ZOOM_TIME;
}
if (interp >= 1.f)
{
interp = 1.f;
mZoomTimer.stop();
}
mCurZoomVal = lerp(mCurZoomVal, (F32)childGetValue("zoom slider").asReal(), interp);
// Interpolate between mCurZoomValInterpolationStart and "zoom slider".
mCurZoomVal = lerp(mCurZoomValInterpolationStart, (F32)childGetValue("zoom slider").asReal(), interp);
F32 map_scale = 256.f*pow(2.f, mCurZoomVal);
LLWorldMapView::setScale( map_scale );

1
indra/newview/llfloaterworldmap.h
View File

@@ -164,6 +164,7 @@ protected:
// Sets sMapScale, in pixels per region
F32 mCurZoomVal;
F32 mCurZoomValInterpolationStart; // Used during mZoomTimer interpolation.
LLFrameTimer mZoomTimer;
LLDynamicArray<LLUUID> mLandmarkAssetIDList;

3
indra/newview/llpanelmediahud.cpp
View File

@@ -396,9 +396,8 @@ void LLPanelMediaHUD::updateShape()
}
}
// If we need to start fading the UI (and we have not already started)
else if(! mFadeTimer.getStarted())
else if (!mFadeTimer.getStarted())
{
mFadeTimer.reset();
mFadeTimer.start();
}
}

3
indra/newview/llpreviewtexture.cpp
View File

@@ -446,8 +446,7 @@ void LLPreviewTexture::onFileLoadedForSave(BOOL success,
}
else
{
self->mSavedFileTimer.reset();
self->mSavedFileTimer.setTimerExpirySec( SECONDS_TO_SHOW_FILE_SAVED_MSG );
self->mSavedFileTimer.reset(SECONDS_TO_SHOW_FILE_SAVED_MSG);
}
self->mSaveFileName.clear();

6
indra/newview/llstatusbar.cpp
View File

@@ -683,8 +683,7 @@ void LLStatusBar::setBalance(S32 balance)
if( balance != mBalance )
{
mBalanceTimer->reset();
mBalanceTimer->setTimerExpirySec( ICON_TIMER_EXPIRY );
mBalanceTimer->reset(ICON_TIMER_EXPIRY);
mBalance = balance;
}
}
@@ -728,8 +727,7 @@ void LLStatusBar::setHealth(S32 health)
}
}
mHealthTimer->reset();
mHealthTimer->setTimerExpirySec( ICON_TIMER_EXPIRY );
mHealthTimer->reset(ICON_TIMER_EXPIRY);
}
mHealth = health;

12
indra/newview/llviewerinventory.cpp
View File

@@ -390,7 +390,7 @@ LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& uuid,
mVersion(LLViewerInventoryCategory::VERSION_UNKNOWN),
mDescendentCount(LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)
{
mDescendentsRequested.reset();
mDescendentsRequested.stop();
}
LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& owner_id) :
@@ -398,7 +398,7 @@ LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& owner_id) :
mVersion(LLViewerInventoryCategory::VERSION_UNKNOWN),
mDescendentCount(LLViewerInventoryCategory::DESCENDENT_COUNT_UNKNOWN)
{
mDescendentsRequested.reset();
mDescendentsRequested.stop();
}
LLViewerInventoryCategory::LLViewerInventoryCategory(const LLViewerInventoryCategory* other)
@@ -489,12 +489,12 @@ bool LLViewerInventoryCategory::fetchDescendents()
// <edit>
if((mUUID == gSystemFolderRoot) || (gInventory.isObjectDescendentOf(mUUID, gSystemFolderRoot))) return false;
// </edit>
if((VERSION_UNKNOWN == mVersion)
&& mDescendentsRequested.hasExpired()) //Expired check prevents multiple downloads.
if (VERSION_UNKNOWN == mVersion &&
(!mDescendentsRequested.getStarted() ||
mDescendentsRequested.hasExpired())) // Expired check prevents multiple downloads.
{
const F32 FETCH_TIMER_EXPIRY = 10.0f;
mDescendentsRequested.reset();
mDescendentsRequested.setTimerExpirySec(FETCH_TIMER_EXPIRY);
mDescendentsRequested.start(FETCH_TIMER_EXPIRY);
// bitfield
// 1 = by date

2
indra/newview/llvoavatar.cpp
View File

@@ -3964,7 +3964,7 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
}
//idle text
std::string idle_string;
if(!mIsSelf && mIdleTimer.getElapsedTimeF32() > 120 && gSavedSettings.getBOOL("AscentShowIdleTime"))
if(!mIsSelf && mIdleTimer.getElapsedTimeF32() > 120.f && gSavedSettings.getBOOL("AscentShowIdleTime"))
{
idle_string = getIdleTime();
}