diff --git a/doc/contributions.txt b/doc/contributions.txt
index 99a0e7ad9ee3e879e5e2d2af687bab9d32fc0eb4..4201d6149dadb7c3eadded39bebae425b6bc0ce5 100644
--- a/doc/contributions.txt
+++ b/doc/contributions.txt
@@ -53,6 +53,7 @@ Alissa Sabre
VWR-7153
VWR-7168
VWR-7087
+ VWR-7086
Angus Boyd
VWR-592
Argent Stonecutter
@@ -146,6 +147,7 @@ Ginko Bayliss
VWR-4
Grazer Kline
VWR-1092
+ VWR-2113
Gudmund Shepherd
VWR-1594
Hamncheese Omlet
@@ -363,6 +365,8 @@ Tharax Ferraris
Thraxis Epsilon
SVC-371
VWR-383
+Wilton Lundquist
+ VWR-7682
Whoops Babii
VWR-631
VWR-1640
diff --git a/indra/llcharacter/llcharacter.cpp b/indra/llcharacter/llcharacter.cpp
index 033ac16274890b1bcfc0577503041bddc0d08fc5..1d5947c9ef6c7e007a12f05970d0255c1dc45c22 100644
--- a/indra/llcharacter/llcharacter.cpp
+++ b/indra/llcharacter/llcharacter.cpp
@@ -103,11 +103,11 @@ LLJoint *LLCharacter::getJoint( const std::string &name )
}
//-----------------------------------------------------------------------------
-// addMotion()
+// registerMotion()
//-----------------------------------------------------------------------------
-BOOL LLCharacter::addMotion( const LLUUID& id, LLMotionConstructor create )
+BOOL LLCharacter::registerMotion( const LLUUID& id, LLMotionConstructor create )
{
- return mMotionController.addMotion(id, create);
+ return mMotionController.registerMotion(id, create);
}
//-----------------------------------------------------------------------------
@@ -119,7 +119,16 @@ void LLCharacter::removeMotion( const LLUUID& id )
}
//-----------------------------------------------------------------------------
-// getMotion()
+// findMotion()
+//-----------------------------------------------------------------------------
+LLMotion* LLCharacter::findMotion( const LLUUID &id )
+{
+ return mMotionController.findMotion( id );
+}
+
+//-----------------------------------------------------------------------------
+// createMotion()
+// NOTE: Always assign the result to a LLPointer!
//-----------------------------------------------------------------------------
LLMotion* LLCharacter::createMotion( const LLUUID &id )
{
@@ -168,26 +177,24 @@ void LLCharacter::requestStopMotion( LLMotion* motion)
//-----------------------------------------------------------------------------
-// updateMotion()
+// updateMotions()
//-----------------------------------------------------------------------------
-void LLCharacter::updateMotion(BOOL force_update)
+void LLCharacter::updateMotions(e_update_t update_type)
{
- // unpause if we're forcing an update or
- // number of outstanding pause requests has dropped
- // to the initial one
- if (mMotionController.isPaused() &&
- (force_update || mPauseRequest->getNumRefs() == 1))
+ LLFastTimer t(LLFastTimer::FTM_UPDATE_ANIMATION);
+ if (update_type == HIDDEN_UPDATE)
{
- mMotionController.unpause();
+ mMotionController.updateMotionsMinimal();
}
-
- mMotionController.updateMotion();
-
- // pause once again, after forced update, if there are outstanding
- // pause requests
- if (force_update && mPauseRequest->getNumRefs() > 1)
+ else
{
- mMotionController.pause();
+ // unpause if the number of outstanding pause requests has dropped to the initial one
+ if (mMotionController.isPaused() && mPauseRequest->getNumRefs() == 1)
+ {
+ mMotionController.unpauseAllMotions();
+ }
+ bool force_update = (update_type == FORCE_UPDATE);
+ mMotionController.updateMotions(force_update);
}
}
@@ -499,7 +506,7 @@ void LLCharacter::updateVisualParams()
LLAnimPauseRequest LLCharacter::requestPause()
{
- mMotionController.pause();
+ mMotionController.pauseAllMotions();
return mPauseRequest;
}
diff --git a/indra/llcharacter/llcharacter.h b/indra/llcharacter/llcharacter.h
index 2c0451d46c192f47933dbe35f9bbbd693d883fbc..4fd135721ba335bd88738321acefa2b3d5d5cbb3 100644
--- a/indra/llcharacter/llcharacter.h
+++ b/indra/llcharacter/llcharacter.h
@@ -137,13 +137,16 @@ class LLCharacter
//-------------------------------------------------------------------------
// registers a motion with the character
// returns true if successfull
- BOOL addMotion( const LLUUID& id, LLMotionConstructor create );
+ BOOL registerMotion( const LLUUID& id, LLMotionConstructor create );
void removeMotion( const LLUUID& id );
- // returns an instance of a registered motion
+ // returns an instance of a registered motion, creating one if necessary
LLMotion* createMotion( const LLUUID &id );
+ // returns an existing instance of a registered motion
+ LLMotion* findMotion( const LLUUID &id );
+
// start a motion
// returns true if successful, false if an error occurred
virtual BOOL startMotion( const LLUUID& id, F32 start_offset = 0.f);
@@ -161,12 +164,16 @@ class LLCharacter
virtual void requestStopMotion( LLMotion* motion );
// periodic update function, steps the motion controller
- void updateMotion(BOOL force_update = FALSE);
+ enum e_update_t { NORMAL_UPDATE, HIDDEN_UPDATE, FORCE_UPDATE };
+ void updateMotions(e_update_t update_type);
LLAnimPauseRequest requestPause();
BOOL areAnimationsPaused() { return mMotionController.isPaused(); }
void setAnimTimeFactor(F32 factor) { mMotionController.setTimeFactor(factor); }
void setTimeStep(F32 time_step) { mMotionController.setTimeStep(time_step); }
+
+ LLMotionController& getMotionController() { return mMotionController; }
+
// Releases all motion instances which should result in
// no cached references to character joint data. This is
// useful if a character wants to rebuild it's skeleton.
diff --git a/indra/llcharacter/llkeyframemotion.cpp b/indra/llcharacter/llkeyframemotion.cpp
index d9e8407d44daa61565f867ddeee2ddc4cd000c0e..710cd44a6faa8261b956d3c63ee45f525f731d1a 100644
--- a/indra/llcharacter/llkeyframemotion.cpp
+++ b/indra/llcharacter/llkeyframemotion.cpp
@@ -1986,9 +1986,8 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
LLCharacter* character = *char_iter;
- // create an instance of this motion (it may or may not already exist)
- LLKeyframeMotion* motionp = (LLKeyframeMotion*) character->createMotion(asset_uuid);
-
+ // look for an existing instance of this motion
+ LLKeyframeMotion* motionp = (LLKeyframeMotion*) character->findMotion(asset_uuid);
if (motionp)
{
if (0 == status)
@@ -2017,7 +2016,7 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
motionp->mAssetStatus = ASSET_FETCH_FAILED;
}
- delete []buffer;
+ delete[] buffer;
}
else
{
@@ -2027,8 +2026,7 @@ void LLKeyframeMotion::onLoadComplete(LLVFS *vfs,
}
else
{
- // motionp is NULL
- llwarns << "Failed to createMotion() for asset UUID " << asset_uuid << llendl;
+ llwarns << "No existing motion for asset data. UUID: " << asset_uuid << llendl;
}
}
diff --git a/indra/llcharacter/llkeyframemotionparam.cpp b/indra/llcharacter/llkeyframemotionparam.cpp
index 513b7688ceab518d03ba343ac67a19659dc2c668..ea88e18367c298135073c49edba5e7218c9413c9 100644
--- a/indra/llcharacter/llkeyframemotionparam.cpp
+++ b/indra/llcharacter/llkeyframemotionparam.cpp
@@ -76,7 +76,7 @@ LLKeyframeMotionParam::~LLKeyframeMotionParam()
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
- delete paramMotion.first; // note - deletes the structure; ParameterizedMotion pair remains intact
+ delete paramMotion.mMotion;
}
motionList.clear();
}
@@ -102,32 +102,32 @@ LLMotion::LLMotionInitStatus LLKeyframeMotionParam::onInitialize(LLCharacter *ch
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
+ LLMotion* motion = paramMotion.mMotion;
+ motion->onInitialize(character);
- paramMotion.first->onInitialize(character);
-
- if (paramMotion.first->getDuration() > mEaseInDuration)
+ if (motion->getDuration() > mEaseInDuration)
{
- mEaseInDuration = paramMotion.first->getEaseInDuration();
+ mEaseInDuration = motion->getEaseInDuration();
}
- if (paramMotion.first->getEaseOutDuration() > mEaseOutDuration)
+ if (motion->getEaseOutDuration() > mEaseOutDuration)
{
- mEaseOutDuration = paramMotion.first->getEaseOutDuration();
+ mEaseOutDuration = motion->getEaseOutDuration();
}
- if (paramMotion.first->getDuration() > mDuration)
+ if (motion->getDuration() > mDuration)
{
- mDuration = paramMotion.first->getDuration();
+ mDuration = motion->getDuration();
}
- if (paramMotion.first->getPriority() > mPriority)
+ if (motion->getPriority() > mPriority)
{
- mPriority = paramMotion.first->getPriority();
+ mPriority = motion->getPriority();
}
- LLPose *pose = paramMotion.first->getPose();
+ LLPose *pose = motion->getPose();
- mPoseBlender.addMotion(paramMotion.first);
+ mPoseBlender.addMotion(motion);
for (LLJointState *jsp = pose->getFirstJointState(); jsp; jsp = pose->getNextJointState())
{
LLPose *blendedPose = mPoseBlender.getBlendedPose();
@@ -151,7 +151,7 @@ BOOL LLKeyframeMotionParam::onActivate()
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
- paramMotion.first->activate();
+ paramMotion.mMotion->activate(mActivationTimestamp);
}
}
return TRUE;
@@ -173,8 +173,8 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
-// llinfos << "Weight for pose " << paramMotion.first->getName() << " is " << paramMotion.first->getPose()->getWeight() << llendl;
- paramMotion.first->getPose()->setWeight(0.f);
+// llinfos << "Weight for pose " << paramMotion.mMotion->getName() << " is " << paramMotion.mMotion->getPose()->getWeight() << llendl;
+ paramMotion.mMotion->getPose()->setWeight(0.f);
}
}
@@ -190,6 +190,7 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
continue;
}
+ // DANGER! Do not modify mParameterizedMotions while using these pointers!
const ParameterizedMotion* firstMotion = NULL;
const ParameterizedMotion* secondMotion = NULL;
@@ -197,9 +198,9 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
- paramMotion.first->onUpdate(time, joint_mask);
+ paramMotion.mMotion->onUpdate(time, joint_mask);
- F32 distToParam = paramMotion.second - *paramValue;
+ F32 distToParam = paramMotion.mParam - *paramValue;
if ( distToParam <= 0.f)
{
@@ -227,12 +228,12 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
LLPose *secondPose;
if (firstMotion)
- firstPose = firstMotion->first->getPose();
+ firstPose = firstMotion->mMotion->getPose();
else
firstPose = NULL;
if (secondMotion)
- secondPose = secondMotion->first->getPose();
+ secondPose = secondMotion->mMotion->getPose();
else
secondPose = NULL;
@@ -243,7 +244,7 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
{
firstPose->setWeight(weightFactor);
}
- else if (firstMotion->second == secondMotion->second)
+ else if (firstMotion->mParam == secondMotion->mParam)
{
firstPose->setWeight(0.5f * weightFactor);
secondPose->setWeight(0.5f * weightFactor);
@@ -251,8 +252,8 @@ BOOL LLKeyframeMotionParam::onUpdate(F32 time, U8* joint_mask)
else
{
F32 first_weight = 1.f -
- ((llclamp(*paramValue - firstMotion->second, 0.f, (secondMotion->second - firstMotion->second))) /
- (secondMotion->second - firstMotion->second));
+ ((llclamp(*paramValue - firstMotion->mParam, 0.f, (secondMotion->mParam - firstMotion->mParam))) /
+ (secondMotion->mParam - firstMotion->mParam));
first_weight = llclamp(first_weight, 0.f, 1.f);
F32 second_weight = 1.f - first_weight;
@@ -290,7 +291,7 @@ void LLKeyframeMotionParam::onDeactivate()
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
- paramMotion.first->onDeactivate();
+ paramMotion.mMotion->onDeactivate();
}
}
}
@@ -328,9 +329,9 @@ void LLKeyframeMotionParam::setDefaultKeyframeMotion(char *name)
for (motion_list_t::iterator iter2 = motionList.begin(); iter2 != motionList.end(); ++iter2)
{
const ParameterizedMotion& paramMotion = *iter2;
- if (paramMotion.first->getName() == name)
+ if (paramMotion.mMotion->getName() == name)
{
- mDefaultKeyframeMotion = paramMotion.first;
+ mDefaultKeyframeMotion = paramMotion.mMotion;
}
}
}
diff --git a/indra/llcharacter/llkeyframemotionparam.h b/indra/llcharacter/llkeyframemotionparam.h
index 305207eb0918ac25e22d580542360cfb04341ffa..c8104d2b382328e658c26623feb087d81df94dd8 100644
--- a/indra/llcharacter/llkeyframemotionparam.h
+++ b/indra/llcharacter/llkeyframemotionparam.h
@@ -126,7 +126,12 @@ class LLKeyframeMotionParam :
//-------------------------------------------------------------------------
// new functions defined by this subclass
//-------------------------------------------------------------------------
- typedef std::pair<LLMotion*, F32> ParameterizedMotion;
+ struct ParameterizedMotion
+ {
+ ParameterizedMotion(LLMotion* motion, F32 param) : mMotion(motion), mParam(param) {}
+ LLMotion* mMotion;
+ F32 mParam;
+ };
// add a motion and associated parameter triplet
BOOL addKeyframeMotion(char *name, const LLUUID &id, char *param, F32 value);
@@ -134,8 +139,6 @@ class LLKeyframeMotionParam :
// set default motion for LOD and retrieving blend constants
void setDefaultKeyframeMotion(char *);
- static BOOL sortFunc(ParameterizedMotion *new_motion, ParameterizedMotion *tested_motion);
-
BOOL loadMotions();
protected:
@@ -147,10 +150,10 @@ class LLKeyframeMotionParam :
{
bool operator() (const ParameterizedMotion& a, const ParameterizedMotion& b) const
{
- if (a.second != b.second)
- return (a.second < b.second);
+ if (a.mParam != b.mParam)
+ return (a.mParam < b.mParam);
else
- return a.first < b.first;
+ return a.mMotion < b.mMotion;
}
};
diff --git a/indra/llcharacter/llmotion.cpp b/indra/llcharacter/llmotion.cpp
index 9123ebfcbd80f351e3b5a0444ca7c6578e804e77..369e516482678544e8919a5c991e80e46f12ef36 100644
--- a/indra/llcharacter/llmotion.cpp
+++ b/indra/llcharacter/llmotion.cpp
@@ -127,6 +127,13 @@ void LLMotion::setDeactivateCallback( void (*cb)(void *), void* userdata )
mDeactivateCallbackUserData = userdata;
}
+//virtual
+void LLMotion::setStopTime(F32 time)
+{
+ mStopTimestamp = time;
+ mStopped = TRUE;
+}
+
BOOL LLMotion::isBlending()
{
return mPose.getWeight() < 1.f;
@@ -135,8 +142,9 @@ BOOL LLMotion::isBlending()
//-----------------------------------------------------------------------------
// activate()
//-----------------------------------------------------------------------------
-void LLMotion::activate()
+void LLMotion::activate(F32 time)
{
+ mActivationTimestamp = time;
mStopped = FALSE;
mActive = TRUE;
onActivate();
@@ -150,7 +158,12 @@ void LLMotion::deactivate()
mActive = FALSE;
mPose.setWeight(0.f);
- if (mDeactivateCallback) (*mDeactivateCallback)(mDeactivateCallbackUserData);
+ if (mDeactivateCallback)
+ {
+ (*mDeactivateCallback)(mDeactivateCallbackUserData);
+ mDeactivateCallback = NULL; // only call callback once
+ mDeactivateCallbackUserData = NULL;
+ }
onDeactivate();
}
diff --git a/indra/llcharacter/llmotion.h b/indra/llcharacter/llmotion.h
index 7669920339bc3e1407ce917de15395f402e169e6..50090e65e4855a104a8818a508d65166656ca89b 100644
--- a/indra/llcharacter/llmotion.h
+++ b/indra/llcharacter/llmotion.h
@@ -48,6 +48,8 @@ class LLCharacter;
//-----------------------------------------------------------------------------
class LLMotion
{
+ friend class LLMotionController;
+
public:
enum LLMotionBlendType
{
@@ -73,10 +75,6 @@ class LLMotion
// functions to support MotionController and MotionRegistry
//-------------------------------------------------------------------------
- // static constructor
- // all subclasses must implement such a function and register it
- static LLMotion *create(const LLUUID &id) { return NULL; }
-
// get the name of this instance
const std::string &getName() const { return mName; }
@@ -96,7 +94,7 @@ class LLMotion
F32 getStopTime() const { return mStopTimestamp; }
- virtual void setStopTime(F32 time) { mStopTimestamp = time; mStopped = TRUE; }
+ virtual void setStopTime(F32 time);
BOOL isStopped() const { return mStopped; }
@@ -104,12 +102,18 @@ class LLMotion
BOOL isBlending();
- void activate();
-
+ // Activation functions.
+ // It is OK for other classes to activate a motion,
+ // but only the controller can deactivate it.
+ // Thus, if mActive == TRUE, the motion *may* be on the controllers active list,
+ // but if mActive == FALSE, the motion is gauranteed not to be on the active list.
+protected:
+ // Used by LLMotionController only
void deactivate();
-
BOOL isActive() { return mActive; }
-
+public:
+ void activate(F32 time);
+
public:
//-------------------------------------------------------------------------
// animation callbacks to be implemented by subclasses
@@ -170,14 +174,13 @@ class LLMotion
BOOL mStopped; // motion has been stopped;
BOOL mActive; // motion is on active list (can be stopped or not stopped)
-public:
//-------------------------------------------------------------------------
// these are set implicitly by the motion controller and
// may be referenced (read only) in the above handlers.
//-------------------------------------------------------------------------
std::string mName; // instance name assigned by motion controller
LLUUID mID;
-
+
F32 mActivationTimestamp; // time when motion was activated
F32 mStopTimestamp; // time when motion was told to stop
F32 mSendStopTimestamp; // time when simulator should be told to stop this motion
diff --git a/indra/llcharacter/llmotioncontroller.cpp b/indra/llcharacter/llmotioncontroller.cpp
index 5bcae5e63584d90f2e442e0307b0e056ccebee24..3cb4da4e3ae9781f75dfab8a29f39be4d47e3c31 100644
--- a/indra/llcharacter/llmotioncontroller.cpp
+++ b/indra/llcharacter/llmotioncontroller.cpp
@@ -34,6 +34,8 @@
//-----------------------------------------------------------------------------
#include "linden_common.h"
+#include "llmemtype.h"
+
#include "llmotioncontroller.h"
#include "llkeyframemotion.h"
#include "llmath.h"
@@ -49,32 +51,6 @@ const U32 MAX_MOTION_INSTANCES = 32;
//-----------------------------------------------------------------------------
LLMotionRegistry LLMotionController::sRegistry;
-//-----------------------------------------------------------------------------
-// LLMotionTableEntry()
-//-----------------------------------------------------------------------------
-LLMotionTableEntry::LLMotionTableEntry()
-{
- mConstructor = NULL;
- mID.setNull();
-}
-
-LLMotionTableEntry::LLMotionTableEntry(LLMotionConstructor constructor, const LLUUID& id)
- : mConstructor(constructor), mID(id)
-{
-
-}
-
-//-----------------------------------------------------------------------------
-// create()
-//-----------------------------------------------------------------------------
-LLMotion* LLMotionTableEntry::create(const LLUUID &id)
-{
- LLMotion* motionp = mConstructor(id);
-
- return motionp;
-}
-
-
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// LLMotionRegistry class
@@ -85,7 +61,7 @@ LLMotion* LLMotionTableEntry::create(const LLUUID &id)
// LLMotionRegistry()
// Class Constructor
//-----------------------------------------------------------------------------
-LLMotionRegistry::LLMotionRegistry() : mMotionTable(LLMotionTableEntry::uuidEq, LLMotionTableEntry())
+LLMotionRegistry::LLMotionRegistry()
{
}
@@ -97,19 +73,19 @@ LLMotionRegistry::LLMotionRegistry() : mMotionTable(LLMotionTableEntry::uuidEq,
//-----------------------------------------------------------------------------
LLMotionRegistry::~LLMotionRegistry()
{
- mMotionTable.removeAll();
+ mMotionTable.clear();
}
//-----------------------------------------------------------------------------
// addMotion()
//-----------------------------------------------------------------------------
-BOOL LLMotionRegistry::addMotion( const LLUUID& id, LLMotionConstructor constructor )
+BOOL LLMotionRegistry::registerMotion( const LLUUID& id, LLMotionConstructor constructor )
{
-// llinfos << "Registering motion: " << name << llendl;
- if (!mMotionTable.check(id))
+ // llinfos << "Registering motion: " << name << llendl;
+ if (!is_in_map(mMotionTable, id))
{
- mMotionTable.set(id, LLMotionTableEntry(constructor, id));
+ mMotionTable[id] = constructor;
return TRUE;
}
@@ -121,7 +97,7 @@ BOOL LLMotionRegistry::addMotion( const LLUUID& id, LLMotionConstructor construc
//-----------------------------------------------------------------------------
void LLMotionRegistry::markBad( const LLUUID& id )
{
- mMotionTable.set(id, LLMotionTableEntry());
+ mMotionTable[id] = LLMotionConstructor(NULL);
}
//-----------------------------------------------------------------------------
@@ -129,17 +105,17 @@ void LLMotionRegistry::markBad( const LLUUID& id )
//-----------------------------------------------------------------------------
LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
{
- LLMotionTableEntry motion_entry = mMotionTable.get(id);
+ LLMotionConstructor constructor = get_if_there(mMotionTable, id, LLMotionConstructor(NULL));
LLMotion* motion = NULL;
- if ( motion_entry.getID().isNull() )
+ if ( constructor == NULL )
{
// *FIX: need to replace with a better default scheme. RN
motion = LLKeyframeMotion::create(id);
}
else
{
- motion = motion_entry.create(id);
+ motion = constructor(id);
}
return motion;
@@ -158,8 +134,8 @@ LLMotion *LLMotionRegistry::createMotion( const LLUUID &id )
LLMotionController::LLMotionController()
: mTimeFactor(1.f),
mCharacter(NULL),
- mTime(0.f),
- mTimeOffset(0.f),
+ mAnimTime(0.f),
+ mPrevTimerElapsed(0.f),
mLastTime(0.0f),
mHasRunOnce(FALSE),
mPaused(FALSE),
@@ -180,6 +156,15 @@ LLMotionController::~LLMotionController()
deleteAllMotions();
}
+void LLMotionController::incMotionCounts(S32& num_motions, S32& num_loading_motions, S32& num_loaded_motions, S32& num_active_motions, S32& num_deprecated_motions)
+{
+ num_motions += mAllMotions.size();
+ num_loading_motions += mLoadingMotions.size();
+ num_loaded_motions += mLoadedMotions.size();
+ num_active_motions += mActiveMotions.size();
+ num_deprecated_motions += mDeprecatedMotions.size();
+}
+
//-----------------------------------------------------------------------------
// deleteAllMotions()
//-----------------------------------------------------------------------------
@@ -194,24 +179,38 @@ void LLMotionController::deleteAllMotions()
}
//-----------------------------------------------------------------------------
-// addLoadedMotion()
+// purgeExcessMotion()
//-----------------------------------------------------------------------------
-void LLMotionController::addLoadedMotion(LLMotion* motionp)
+void LLMotionController::purgeExcessMotions()
{
- std::set<LLUUID> motions_to_kill;
+ if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
+ {
+ // clean up deprecated motions
+ for (motion_set_t::iterator deprecated_motion_it = mDeprecatedMotions.begin();
+ deprecated_motion_it != mDeprecatedMotions.end(); )
+ {
+ motion_set_t::iterator cur_iter = deprecated_motion_it++;
+ LLMotion* cur_motionp = *cur_iter;
+ if (!isMotionActive(cur_motionp))
+ {
+ // Motion is deprecated so we know it's not cannonical,
+ // we can safely remove the instance
+ removeMotionInstance(cur_motionp); // modifies mDeprecatedMotions
+ mDeprecatedMotions.erase(cur_iter);
+ }
+ }
+ }
- // gather all inactive, loaded motions
+ std::set<LLUUID> motions_to_kill;
if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
{
// too many motions active this frame, kill all blenders
mPoseBlender.clearBlenders();
-
- for (motion_list_t::iterator loaded_motion_it = mLoadedMotions.begin();
- loaded_motion_it != mLoadedMotions.end();
- ++loaded_motion_it)
+ for (motion_set_t::iterator loaded_motion_it = mLoadedMotions.begin();
+ loaded_motion_it != mLoadedMotions.end();
+ ++loaded_motion_it)
{
LLMotion* cur_motionp = *loaded_motion_it;
-
// motion isn't playing, delete it
if (!isMotionActive(cur_motionp))
{
@@ -219,7 +218,7 @@ void LLMotionController::addLoadedMotion(LLMotion* motionp)
}
}
}
-
+
// clean up all inactive, loaded motions
for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin();
motion_it != motions_to_kill.end();
@@ -235,8 +234,28 @@ void LLMotionController::addLoadedMotion(LLMotion* motionp)
}
}
- // add new motion to loaded list
- mLoadedMotions.push_back(motionp);
+ if (mLoadedMotions.size() > 2*MAX_MOTION_INSTANCES)
+ {
+ LL_WARNS_ONCE("Animation") << "> " << 2*MAX_MOTION_INSTANCES << " Loaded Motions" << llendl;
+ }
+}
+
+//-----------------------------------------------------------------------------
+// deactivateStoppedMotions()
+//-----------------------------------------------------------------------------
+void LLMotionController::deactivateStoppedMotions()
+{
+ // Since we're hidden, deactivate any stopped motions.
+ for (motion_list_t::iterator iter = mActiveMotions.begin();
+ iter != mActiveMotions.end(); )
+ {
+ motion_list_t::iterator curiter = iter++;
+ LLMotion* motionp = *curiter;
+ if (motionp->isStopped())
+ {
+ deactivateMotionInstance(motionp);
+ }
+ }
}
//-----------------------------------------------------------------------------
@@ -253,9 +272,10 @@ void LLMotionController::setTimeStep(F32 step)
iter != mActiveMotions.end(); ++iter)
{
LLMotion* motionp = *iter;
- motionp->mActivationTimestamp = (F32)llfloor(motionp->mActivationTimestamp / step) * step;
+ F32 activation_time = motionp->mActivationTimestamp;
+ motionp->mActivationTimestamp = (F32)(llfloor(activation_time / step)) * step;
BOOL stopped = motionp->isStopped();
- motionp->setStopTime((F32)llfloor(motionp->getStopTime() / step) * step);
+ motionp->setStopTime((F32)(llfloor(motionp->getStopTime() / step)) * step);
motionp->setStopped(stopped);
motionp->mSendStopTimestamp = (F32)llfloor(motionp->mSendStopTimestamp / step) * step;
}
@@ -267,7 +287,6 @@ void LLMotionController::setTimeStep(F32 step)
//-----------------------------------------------------------------------------
void LLMotionController::setTimeFactor(F32 time_factor)
{
- mTimeOffset += mTimer.getElapsedTimeAndResetF32() * mTimeFactor;
mTimeFactor = time_factor;
}
@@ -281,11 +300,11 @@ void LLMotionController::setCharacter(LLCharacter *character)
//-----------------------------------------------------------------------------
-// addMotion()
+// registerMotion()
//-----------------------------------------------------------------------------
-BOOL LLMotionController::addMotion( const LLUUID& id, LLMotionConstructor constructor )
+BOOL LLMotionController::registerMotion( const LLUUID& id, LLMotionConstructor constructor )
{
- return sRegistry.addMotion(id, constructor);
+ return sRegistry.registerMotion(id, constructor);
}
//-----------------------------------------------------------------------------
@@ -294,10 +313,8 @@ BOOL LLMotionController::addMotion( const LLUUID& id, LLMotionConstructor constr
void LLMotionController::removeMotion( const LLUUID& id)
{
LLMotion* motionp = findMotion(id);
-
- removeMotionInstance(motionp);
-
mAllMotions.erase(id);
+ removeMotionInstance(motionp);
}
// removes instance of a motion from all runtime structures, but does
@@ -307,10 +324,11 @@ void LLMotionController::removeMotionInstance(LLMotion* motionp)
{
if (motionp)
{
- stopMotionInstance(motionp, TRUE);
-
+ llassert(findMotion(motionp->getID()) != motionp);
+ if (motionp->isActive())
+ motionp->deactivate();
mLoadingMotions.erase(motionp);
- mLoadedMotions.remove(motionp);
+ mLoadedMotions.erase(motionp);
mActiveMotions.remove(motionp);
delete motionp;
}
@@ -321,6 +339,7 @@ void LLMotionController::removeMotionInstance(LLMotion* motionp)
//-----------------------------------------------------------------------------
LLMotion* LLMotionController::createMotion( const LLUUID &id )
{
+ LLMemType mt(LLMemType::MTYPE_ANIMATION);
// do we have an instance of this motion for this character?
LLMotion *motion = findMotion(id);
@@ -354,8 +373,8 @@ LLMotion* LLMotionController::createMotion( const LLUUID &id )
mLoadingMotions.insert(motion);
break;
case LLMotion::STATUS_SUCCESS:
- // add motion to our list
- addLoadedMotion(motion);
+ // add motion to our list
+ mLoadedMotions.insert(motion);
break;
default:
llerrs << "Invalid initialization status" << llendl;
@@ -378,6 +397,7 @@ BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
// motion that is stopping will be allowed to stop but
// replaced by a new instance of that motion
if (motion
+ && !mPaused
&& motion->canDeprecate()
&& motion->getFadeWeight() > 0.01f // not LOD-ed out
&& (motion->isBlending() || motion->getStopTime() != 0.f))
@@ -404,7 +424,7 @@ BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
}
// llinfos << "Starting motion " << name << llendl;
- return activateMotionInstance(motion, mTime - start_offset);
+ return activateMotionInstance(motion, mAnimTime - start_offset);
}
@@ -415,7 +435,6 @@ BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate
{
// if already inactive, return false
LLMotion *motion = findMotion(id);
-
return stopMotionInstance(motion, stop_immediate);
}
@@ -429,12 +448,7 @@ BOOL LLMotionController::stopMotionInstance(LLMotion* motion, BOOL stop_immediat
// If on active list, stop it
if (isMotionActive(motion) && !motion->isStopped())
{
- // when using timesteps, set stop time to last frame's time, otherwise grab current timer value
- // *FIX: should investigate this inconsistency...hints of obscure bugs
-
- F32 stop_time = (mTimeStep != 0.f || mPaused) ? (mTime) : mTimeOffset + (mTimer.getElapsedTimeF32() * mTimeFactor);
- motion->setStopTime(stop_time);
-
+ motion->setStopTime(mAnimTime);
if (stop_immediate)
{
deactivateMotionInstance(motion);
@@ -450,7 +464,6 @@ BOOL LLMotionController::stopMotionInstance(LLMotion* motion, BOOL stop_immediat
return FALSE;
}
-
//-----------------------------------------------------------------------------
// updateRegularMotions()
//-----------------------------------------------------------------------------
@@ -476,6 +489,59 @@ void LLMotionController::resetJointSignatures()
memset(&mJointSignature[1][0], 0, sizeof(U8) * LL_CHARACTER_MAX_JOINTS);
}
+//-----------------------------------------------------------------------------
+// updateIdleMotion()
+// minimal updates for active motions
+//-----------------------------------------------------------------------------
+void LLMotionController::updateIdleMotion(LLMotion* motionp)
+{
+ if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
+ {
+ deactivateMotionInstance(motionp);
+ }
+ else if (motionp->isStopped() && mAnimTime > motionp->getStopTime())
+ {
+ // is this the first iteration in the ease out phase?
+ if (mLastTime <= motionp->getStopTime())
+ {
+ // store residual weight for this motion
+ motionp->mResidualWeight = motionp->getPose()->getWeight();
+ }
+ }
+ else if (mAnimTime > motionp->mSendStopTimestamp)
+ {
+ // notify character of timed stop event on first iteration past sendstoptimestamp
+ // this will only be called when an animation stops itself (runs out of time)
+ if (mLastTime <= motionp->mSendStopTimestamp)
+ {
+ mCharacter->requestStopMotion( motionp );
+ stopMotionInstance(motionp, FALSE);
+ }
+ }
+ else if (mAnimTime >= motionp->mActivationTimestamp)
+ {
+ if (mLastTime < motionp->mActivationTimestamp)
+ {
+ motionp->mResidualWeight = motionp->getPose()->getWeight();
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+// updateIdleActiveMotions()
+// Call this instead of updateMotionsByType for hidden avatars
+//-----------------------------------------------------------------------------
+void LLMotionController::updateIdleActiveMotions()
+{
+ for (motion_list_t::iterator iter = mActiveMotions.begin();
+ iter != mActiveMotions.end(); )
+ {
+ motion_list_t::iterator curiter = iter++;
+ LLMotion* motionp = *curiter;
+ updateIdleMotion(motionp);
+ }
+}
+
//-----------------------------------------------------------------------------
// updateMotionsByType()
//-----------------------------------------------------------------------------
@@ -531,36 +597,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
if (!update_motion)
{
- if (motionp->isStopped() && mTime > motionp->getStopTime() + motionp->getEaseOutDuration())
- {
- deactivateMotionInstance(motionp);
- }
- else if (motionp->isStopped() && mTime > motionp->getStopTime())
- {
- // is this the first iteration in the ease out phase?
- if (mLastTime <= motionp->getStopTime())
- {
- // store residual weight for this motion
- motionp->mResidualWeight = motionp->getPose()->getWeight();
- }
- }
- else if (mTime > motionp->mSendStopTimestamp)
- {
- // notify character of timed stop event on first iteration past sendstoptimestamp
- // this will only be called when an animation stops itself (runs out of time)
- if (mLastTime <= motionp->mSendStopTimestamp)
- {
- mCharacter->requestStopMotion( motionp );
- stopMotionInstance(motionp, FALSE);
- }
- }
- else if (mTime >= motionp->mActivationTimestamp)
- {
- if (mLastTime < motionp->mActivationTimestamp)
- {
- motionp->mResidualWeight = motionp->getPose()->getWeight();
- }
- }
+ updateIdleMotion(motionp);
continue;
}
@@ -572,7 +609,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
motionp->fadeOut();
//should we notify the simulator that this motion should be stopped (check even if skipped by LOD logic)
- if (mTime > motionp->mSendStopTimestamp)
+ if (mAnimTime > motionp->mSendStopTimestamp)
{
// notify character of timed stop event on first iteration past sendstoptimestamp
// this will only be called when an animation stops itself (runs out of time)
@@ -585,7 +622,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
if (motionp->getFadeWeight() < 0.01f)
{
- if (motionp->isStopped() && mTime > motionp->getStopTime() + motionp->getEaseOutDuration())
+ if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
{
posep->setWeight(0.f);
deactivateMotionInstance(motionp);
@@ -601,7 +638,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
//**********************
// MOTION INACTIVE
//**********************
- if (motionp->isStopped() && mTime > motionp->getStopTime() + motionp->getEaseOutDuration())
+ if (motionp->isStopped() && mAnimTime > motionp->getStopTime() + motionp->getEaseOutDuration())
{
// this motion has gone on too long, deactivate it
// did we have a chance to stop it?
@@ -623,7 +660,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
//**********************
// MOTION EASE OUT
//**********************
- else if (motionp->isStopped() && mTime > motionp->getStopTime())
+ else if (motionp->isStopped() && mAnimTime > motionp->getStopTime())
{
// is this the first iteration in the ease out phase?
if (mLastTime <= motionp->getStopTime())
@@ -638,22 +675,22 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
}
else
{
- posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight * cubic_step(1.f - ((mTime - motionp->getStopTime()) / motionp->getEaseOutDuration())));
+ posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight * cubic_step(1.f - ((mAnimTime - motionp->getStopTime()) / motionp->getEaseOutDuration())));
}
// perform motion update
- update_result = motionp->onUpdate(mTime - motionp->mActivationTimestamp, last_joint_signature);
+ update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
}
//**********************
// MOTION ACTIVE
//**********************
- else if (mTime > motionp->mActivationTimestamp + motionp->getEaseInDuration())
+ else if (mAnimTime > motionp->mActivationTimestamp + motionp->getEaseInDuration())
{
posep->setWeight(motionp->getFadeWeight());
//should we notify the simulator that this motion should be stopped?
- if (mTime > motionp->mSendStopTimestamp)
+ if (mAnimTime > motionp->mSendStopTimestamp)
{
// notify character of timed stop event on first iteration past sendstoptimestamp
// this will only be called when an animation stops itself (runs out of time)
@@ -665,13 +702,13 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
}
// perform motion update
- update_result = motionp->onUpdate(mTime - motionp->mActivationTimestamp, last_joint_signature);
+ update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
}
//**********************
// MOTION EASE IN
//**********************
- else if (mTime >= motionp->mActivationTimestamp)
+ else if (mAnimTime >= motionp->mActivationTimestamp)
{
if (mLastTime < motionp->mActivationTimestamp)
{
@@ -684,10 +721,10 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
else
{
// perform motion update
- posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight + (1.f - motionp->mResidualWeight) * cubic_step((mTime - motionp->mActivationTimestamp) / motionp->getEaseInDuration()));
+ posep->setWeight(motionp->getFadeWeight() * motionp->mResidualWeight + (1.f - motionp->mResidualWeight) * cubic_step((mAnimTime - motionp->mActivationTimestamp) / motionp->getEaseInDuration()));
}
// perform motion update
- update_result = motionp->onUpdate(mTime - motionp->mActivationTimestamp, last_joint_signature);
+ update_result = motionp->onUpdate(mAnimTime - motionp->mActivationTimestamp, last_joint_signature);
}
else
{
@@ -698,7 +735,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
// allow motions to deactivate themselves
if (!update_result)
{
- if (!motionp->isStopped() || motionp->getStopTime() > mTime)
+ if (!motionp->isStopped() || motionp->getStopTime() > mAnimTime)
{
// animation has stopped itself due to internal logic
// propagate this to the network
@@ -714,18 +751,68 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
}
}
+//-----------------------------------------------------------------------------
+// updateLoadingMotions()
+//-----------------------------------------------------------------------------
+void LLMotionController::updateLoadingMotions()
+{
+ // query pending motions for completion
+ for (motion_set_t::iterator iter = mLoadingMotions.begin();
+ iter != mLoadingMotions.end(); )
+ {
+ motion_set_t::iterator curiter = iter++;
+ LLMotion* motionp = *curiter;
+ if( !motionp)
+ {
+ continue; // maybe shouldn't happen but i've seen it -MG
+ }
+ LLMotion::LLMotionInitStatus status = motionp->onInitialize(mCharacter);
+ if (status == LLMotion::STATUS_SUCCESS)
+ {
+ mLoadingMotions.erase(curiter);
+ // add motion to our loaded motion list
+ mLoadedMotions.insert(motionp);
+ // this motion should be playing
+ if (!motionp->isStopped())
+ {
+ activateMotionInstance(motionp, mAnimTime);
+ }
+ }
+ else if (status == LLMotion::STATUS_FAILURE)
+ {
+ llinfos << "Motion " << motionp->getID() << " init failed." << llendl;
+ sRegistry.markBad(motionp->getID());
+ mLoadingMotions.erase(curiter);
+ mAllMotions.erase(motionp->getID());
+ delete motionp;
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+// call updateMotion() or updateMotionsMinimal() every frame
+//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// updateMotion()
//-----------------------------------------------------------------------------
-void LLMotionController::updateMotion()
+void LLMotionController::updateMotions(bool force_update)
{
BOOL use_quantum = (mTimeStep != 0.f);
+ // Always update mPrevTimerElapsed
+ F32 cur_time = mTimer.getElapsedTimeF32();
+ F32 delta_time = cur_time - mPrevTimerElapsed;
+ mPrevTimerElapsed = cur_time;
+ mLastTime = mAnimTime;
+
+ // Always cap the number of loaded motions
+ purgeExcessMotions();
+
// Update timing info for this time step.
if (!mPaused)
{
- F32 update_time = mTimeOffset + (mTimer.getElapsedTimeF32() * mTimeFactor);
+ F32 update_time = mAnimTime + delta_time * mTimeFactor;
if (use_quantum)
{
F32 time_interval = fmodf(update_time, mTimeStep);
@@ -741,7 +828,8 @@ void LLMotionController::updateMotion()
mPoseBlender.interpolate(interp - mLastInterp);
mLastInterp = interp;
}
-
+
+ updateLoadingMotions();
return;
}
@@ -750,53 +838,24 @@ void LLMotionController::updateMotion()
clearBlenders();
mTimeStepCount = quantum_count;
- mLastTime = mTime;
- mTime = (F32)quantum_count * mTimeStep;
+ mAnimTime = (F32)quantum_count * mTimeStep;
mLastInterp = 0.f;
}
else
{
- mLastTime = mTime;
- mTime = update_time;
+ mAnimTime = update_time;
}
}
- // query pending motions for completion
- for (motion_set_t::iterator iter = mLoadingMotions.begin();
- iter != mLoadingMotions.end(); )
- {
- motion_set_t::iterator curiter = iter++;
- LLMotion* motionp = *curiter;
- if( !motionp)
- {
- continue; // maybe shouldn't happen but i've seen it -MG
- }
- LLMotion::LLMotionInitStatus status = motionp->onInitialize(mCharacter);
- if (status == LLMotion::STATUS_SUCCESS)
- {
- mLoadingMotions.erase(curiter);
- // add motion to our loaded motion list
- addLoadedMotion(motionp);
- // this motion should be playing
- if (!motionp->isStopped())
- {
- activateMotionInstance(motionp, mTime);
- }
- }
- else if (status == LLMotion::STATUS_FAILURE)
- {
- llinfos << "Motion " << motionp->getID() << " init failed." << llendl;
- sRegistry.markBad(motionp->getID());
- mLoadingMotions.erase(curiter);
-
- mAllMotions.erase(motionp->getID());
- delete motionp;
- }
- }
+ updateLoadingMotions();
resetJointSignatures();
- if (!mPaused)
+ if (mPaused && !force_update)
+ {
+ updateIdleActiveMotions();
+ }
+ else
{
// update additive motions
updateAdditiveMotions();
@@ -819,6 +878,23 @@ void LLMotionController::updateMotion()
// llinfos << "Motion controller time " << motionTimer.getElapsedTimeF32() << llendl;
}
+//-----------------------------------------------------------------------------
+// updateMotionsMinimal()
+// minimal update (e.g. while hidden)
+//-----------------------------------------------------------------------------
+void LLMotionController::updateMotionsMinimal()
+{
+ // Always update mPrevTimerElapsed
+ mPrevTimerElapsed = mTimer.getElapsedTimeF32();
+
+ purgeExcessMotions();
+ updateLoadingMotions();
+ resetJointSignatures();
+
+ deactivateStoppedMotions();
+
+ mHasRunOnce = TRUE;
+}
//-----------------------------------------------------------------------------
// activateMotionInstance()
@@ -841,7 +917,6 @@ BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
}
motion->mResidualWeight = motion->getPose()->getWeight();
- motion->mActivationTimestamp = time;
// set stop time based on given duration and ease out time
if (motion->getDuration() != 0.f && !motion->getLoop())
@@ -862,13 +937,26 @@ BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
{
motion->mSendStopTimestamp = F32_MAX;
}
-
- mActiveMotions.remove(motion); // in case it is already in the active list
+
+ if (motion->isActive())
+ {
+ mActiveMotions.remove(motion);
+ }
mActiveMotions.push_front(motion);
- motion->activate();
+ motion->activate(time);
motion->onUpdate(0.f, mJointSignature[1]);
+ if (mAnimTime >= motion->mSendStopTimestamp)
+ {
+ motion->setStopTime(motion->mSendStopTimestamp);
+ if (motion->mResidualWeight == 0.0f)
+ {
+ // bit of a hack; if newly activating a motion while easing out, weight should = 1
+ motion->mResidualWeight = 1.f;
+ }
+ }
+
return TRUE;
}
@@ -925,9 +1013,17 @@ bool LLMotionController::isMotionLoading(LLMotion* motion)
//-----------------------------------------------------------------------------
// findMotion()
//-----------------------------------------------------------------------------
-LLMotion *LLMotionController::findMotion(const LLUUID& id)
+LLMotion* LLMotionController::findMotion(const LLUUID& id)
{
- return get_if_there<LLUUID, LLMotion*>(mAllMotions, id, NULL);
+ motion_map_t::iterator iter = mAllMotions.find(id);
+ if(iter == mAllMotions.end())
+ {
+ return NULL;
+ }
+ else
+ {
+ return iter->second;
+ }
}
//-----------------------------------------------------------------------------
@@ -935,16 +1031,12 @@ LLMotion *LLMotionController::findMotion(const LLUUID& id)
//-----------------------------------------------------------------------------
void LLMotionController::deactivateAllMotions()
{
- //They must all die, precious.
- for (std::map<LLUUID, LLMotion*>::iterator iter = mAllMotions.begin();
+ for (motion_map_t::iterator iter = mAllMotions.begin();
iter != mAllMotions.end(); iter++)
{
LLMotion* motionp = iter->second;
- if (motionp) motionp->deactivate();
+ deactivateMotionInstance(motionp);
}
-
- // delete all motion instances
- deleteAllMotions();
}
@@ -960,11 +1052,12 @@ void LLMotionController::flushAllMotions()
{
motion_list_t::iterator curiter = iter++;
LLMotion* motionp = *curiter;
- F32 dtime = mTime - motionp->mActivationTimestamp;
+ F32 dtime = mAnimTime - motionp->mActivationTimestamp;
active_motions.push_back(std::make_pair(motionp->getID(),dtime));
- motionp->deactivate();
+ motionp->deactivate(); // don't call deactivateMotionInstance() because we are going to reactivate it
}
-
+ mActiveMotions.clear();
+
// delete all motion instances
deleteAllMotions();
@@ -983,12 +1076,11 @@ void LLMotionController::flushAllMotions()
//-----------------------------------------------------------------------------
// pause()
//-----------------------------------------------------------------------------
-void LLMotionController::pause()
+void LLMotionController::pauseAllMotions()
{
if (!mPaused)
{
//llinfos << "Pausing animations..." << llendl;
- mPauseTime = mTimer.getElapsedTimeF32();
mPaused = TRUE;
}
@@ -997,13 +1089,11 @@ void LLMotionController::pause()
//-----------------------------------------------------------------------------
// unpause()
//-----------------------------------------------------------------------------
-void LLMotionController::unpause()
+void LLMotionController::unpauseAllMotions()
{
if (mPaused)
{
//llinfos << "Unpausing animations..." << llendl;
- mTimer.reset();
- mTimer.setAge(mPauseTime);
mPaused = FALSE;
}
}
diff --git a/indra/llcharacter/llmotioncontroller.h b/indra/llcharacter/llmotioncontroller.h
index c6749c5c369a4b8e5ea2cf8ee26f1748911ae0d4..4da6d8ac579337279b6f2617095748aba950a650 100644
--- a/indra/llcharacter/llmotioncontroller.h
+++ b/indra/llcharacter/llmotioncontroller.h
@@ -57,30 +57,6 @@ class LLCharacter;
//-----------------------------------------------------------------------------
typedef LLMotion*(*LLMotionConstructor)(const LLUUID &id);
-class LLMotionTableEntry
-{
-public:
- LLMotionTableEntry();
- LLMotionTableEntry(LLMotionConstructor constructor, const LLUUID& id);
- ~LLMotionTableEntry(){};
-
- LLMotion* create(const LLUUID& id);
- static BOOL uuidEq(const LLUUID &uuid, const LLMotionTableEntry &id_pair)
- {
- if (uuid == id_pair.mID)
- {
- return TRUE;
- }
- return FALSE;
- }
-
- const LLUUID& getID() { return mID; }
-
-protected:
- LLMotionConstructor mConstructor;
- LLUUID mID;
-};
-
class LLMotionRegistry
{
public:
@@ -92,7 +68,7 @@ class LLMotionRegistry
// adds motion classes to the registry
// returns true if successfull
- BOOL addMotion( const LLUUID& id, LLMotionConstructor create);
+ BOOL registerMotion( const LLUUID& id, LLMotionConstructor create);
// creates a new instance of a named motion
// returns NULL motion is not registered
@@ -103,7 +79,8 @@ class LLMotionRegistry
protected:
- LLUUIDHashMap<LLMotionTableEntry, 32> mMotionTable;
+ typedef std::map<LLUUID, LLMotionConstructor> motion_map_t;
+ motion_map_t mMotionTable;
};
//-----------------------------------------------------------------------------
@@ -130,7 +107,7 @@ class LLMotionController
// registers a motion with the controller
// (actually just forwards call to motion registry)
// returns true if successfull
- BOOL addMotion( const LLUUID& id, LLMotionConstructor create );
+ BOOL registerMotion( const LLUUID& id, LLMotionConstructor create );
// creates a motion from the registry
LLMotion *createMotion( const LLUUID &id );
@@ -151,11 +128,17 @@ class LLMotionController
// returns true if successful
BOOL stopMotionLocally( const LLUUID &id, BOOL stop_immediate );
+ // Move motions from loading to loaded
+ void updateLoadingMotions();
+
// update motions
// invokes the update handlers for each active motion
// activates sequenced motions
// deactivates terminated motions`
- void updateMotion();
+ void updateMotions(bool force_update = false);
+
+ // minimal update (e.g. while hidden)
+ void updateMotionsMinimal();
void clearBlenders() { mPoseBlender.clearBlenders(); }
@@ -167,8 +150,8 @@ class LLMotionController
void deactivateAllMotions();
// pause and continue all motions
- void pause();
- void unpause();
+ void pauseAllMotions();
+ void unpauseAllMotions();
BOOL isPaused() { return mPaused; }
void setTimeStep(F32 step);
@@ -178,6 +161,8 @@ class LLMotionController
motion_list_t& getActiveMotions() { return mActiveMotions; }
+ void incMotionCounts(S32& num_motions, S32& num_loading_motions, S32& num_loaded_motions, S32& num_active_motions, S32& num_deprecated_motions);
+
//protected:
bool isMotionActive( LLMotion *motion );
bool isMotionLoading( LLMotion *motion );
@@ -187,7 +172,6 @@ class LLMotionController
// internal operations act on motion instances directly
// as there can be duplicate motions per id during blending overlap
void deleteAllMotions();
- void addLoadedMotion(LLMotion *motion);
BOOL activateMotionInstance(LLMotion *motion, F32 time);
BOOL deactivateMotionInstance(LLMotion *motion);
void deprecateMotionInstance(LLMotion* motion);
@@ -197,6 +181,10 @@ class LLMotionController
void updateAdditiveMotions();
void resetJointSignatures();
void updateMotionsByType(LLMotion::LLMotionBlendType motion_type);
+ void updateIdleMotion(LLMotion* motionp);
+ void updateIdleActiveMotions();
+ void purgeExcessMotions();
+ void deactivateStoppedMotions();
protected:
F32 mTimeFactor;
@@ -210,20 +198,20 @@ class LLMotionController
// Animations are instantiated and immediately put in the mAllMotions map for their entire lifetime.
// If the animations depend on any asset data, the appropriate data is fetched from the data server,
// and the animation is put on the mLoadingMotions list.
-// Once an animations is loaded, it will be initialized and put on the mLoadedMotions deque.
+// Once an animations is loaded, it will be initialized and put on the mLoadedMotions list.
// Any animation that is currently playing also sits in the mActiveMotions list.
typedef std::map<LLUUID, LLMotion*> motion_map_t;
motion_map_t mAllMotions;
motion_set_t mLoadingMotions;
- motion_list_t mLoadedMotions;
+ motion_set_t mLoadedMotions;
motion_list_t mActiveMotions;
motion_set_t mDeprecatedMotions;
LLFrameTimer mTimer;
- F32 mTime;
- F32 mTimeOffset;
+ F32 mPrevTimerElapsed;
+ F32 mAnimTime;
F32 mLastTime;
BOOL mHasRunOnce;
BOOL mPaused;
diff --git a/indra/llcommon/llmemory.cpp b/indra/llcommon/llmemory.cpp
index 4ca6a1243554fa13eccf1d5580dab6637e8129f3..56879f4e73d47b0ede2b32ba74f6a5ed6eec3f09 100644
--- a/indra/llcommon/llmemory.cpp
+++ b/indra/llcommon/llmemory.cpp
@@ -36,12 +36,8 @@
# include <psapi.h>
#elif defined(LL_DARWIN)
# include <sys/types.h>
-# include <sys/sysctl.h>
# include <mach/task.h>
-# include <mach/vm_map.h>
# include <mach/mach_init.h>
-# include <mach/vm_region.h>
-# include <mach/mach_port.h>
#elif defined(LL_LINUX)
# include <unistd.h>
#endif
@@ -314,13 +310,18 @@ U64 getCurrentRSS()
#elif defined(LL_DARWIN)
-// This can cause bad stalls! Replace with fast version
-
-// static U32 getPageSize()
-// {
-// int ctl[2] = { CTL_HW, HW_PAGESIZE };
-// int page_size;
-// size_t size = sizeof(page_size);
+/*
+ The API used here is not capable of dealing with 64-bit memory sizes, but is available before 10.4.
+
+ Once we start requiring 10.4, we can use the updated API, which looks like this:
+
+ task_basic_info_64_data_t basicInfo;
+ mach_msg_type_number_t basicInfoCount = TASK_BASIC_INFO_64_COUNT;
+ if (task_info(mach_task_self(), TASK_BASIC_INFO_64, (task_info_t)&basicInfo, &basicInfoCount) == KERN_SUCCESS)
+
+ Of course, this doesn't gain us anything unless we start building the viewer as a 64-bit executable, since that's the only way
+ for our memory allocation to exceed 2^32.
+*/
// if (sysctl(ctl, 2, &page_size, &size, NULL, 0) == -1)
// {
@@ -333,58 +334,25 @@ U64 getCurrentRSS()
U64 getCurrentRSS()
{
- // Stalls!!!
-
-// task_t task = mach_task_self();
-// vm_address_t addr = VM_MIN_ADDRESS;
-// vm_size_t size = 0;
-// U64 residentPages = 0;
+ U64 residentSize = 0;
-// while (true)
-// {
-// mach_msg_type_number_t bcount = VM_REGION_BASIC_INFO_COUNT;
-// vm_region_basic_info binfo;
-// mach_port_t bobj;
-// kern_return_t ret;
-
-// addr += size;
-
-// ret = vm_region(task, &addr, &size, VM_REGION_BASIC_INFO,
-// (vm_region_info_t) &binfo, &bcount, &bobj);
-
-// if (ret != KERN_SUCCESS)
-// {
-// break;
-// }
-
-// if (bobj != MACH_PORT_NULL)
-// {
-// mach_port_deallocate(task, bobj);
-// }
-
-// mach_msg_type_number_t ecount = VM_REGION_EXTENDED_INFO_COUNT;
-// vm_region_extended_info einfo;
-// mach_port_t eobj;
-
-// ret = vm_region(task, &addr, &size, VM_REGION_EXTENDED_INFO,
-// (vm_region_info_t) &einfo, &ecount, &eobj);
-
-// if (ret != KERN_SUCCESS)
-// {
-// llwarns << "vm_region failed" << llendl;
-// return 0;
-// }
-
-// if (eobj != MACH_PORT_NULL)
-// {
-// mach_port_deallocate(task, eobj);
-// }
+ task_basic_info_data_t basicInfo;
+ mach_msg_type_number_t basicInfoCount = TASK_BASIC_INFO_COUNT;
+ if (task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&basicInfo, &basicInfoCount) == KERN_SUCCESS)
+ {
+ residentSize = basicInfo.resident_size;
-// residentPages += einfo.pages_resident;
-// }
+ // If we ever wanted it, the process virtual size is also available as:
+ // virtualSize = basicInfo.virtual_size;
+
+// llinfos << "resident size is " << residentSize << llendl;
+ }
+ else
+ {
+ llwarns << "task_info failed" << llendl;
+ }
-// return residentPages * getPageSize();
- return 0;
+ return residentSize;
}
#elif defined(LL_LINUX)
diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h
index 2cdb55eb19fcebc2947f3be086dc1bda7dcf6e4e..bed6c1dda5a595f70eaae564f4e6866ed652bfdb 100644
--- a/indra/llcommon/llversionviewer.h
+++ b/indra/llcommon/llversionviewer.h
@@ -34,7 +34,7 @@
const S32 LL_VERSION_MAJOR = 1;
const S32 LL_VERSION_MINOR = 20;
-const S32 LL_VERSION_PATCH = 9;
+const S32 LL_VERSION_PATCH = 11;
const S32 LL_VERSION_BUILD = 0;
const char * const LL_CHANNEL = "Second Life Release";
diff --git a/indra/llcommon/llworkerthread.cpp b/indra/llcommon/llworkerthread.cpp
index d828ed94689a14a042465cda3d80ef98aa026bfa..f3be5a26903a0f6f31638ebec3f5e716a88c4eae 100644
--- a/indra/llcommon/llworkerthread.cpp
+++ b/indra/llcommon/llworkerthread.cpp
@@ -36,6 +36,7 @@
#include "llframecallbackmanager.h"
#endif
+BOOL LLWorkerClass::sDeleteLock = FALSE ;
//============================================================================
// Run on MAIN thread
@@ -94,6 +95,7 @@ S32 LLWorkerThread::update(U32 max_time_ms)
{
(*iter)->abortWork(false);
}
+ LLWorkerClass::sDeleteLock = TRUE ;
for (std::vector<LLWorkerClass*>::iterator iter = delete_list.begin();
iter != delete_list.end(); ++iter)
{
@@ -107,6 +109,7 @@ S32 LLWorkerThread::update(U32 max_time_ms)
}
delete *iter;
}
+ LLWorkerClass::sDeleteLock = FALSE ;
// delete and aborted entries mean there's still work to do
res += delete_list.size() + abort_list.size();
return res;
diff --git a/indra/llcommon/llworkerthread.h b/indra/llcommon/llworkerthread.h
index be06bc2a58e510dd7cc3a3ebf0a8fa267b2ba1ff..793155308b56f9a80378a8c412f9326d9cfce887 100644
--- a/indra/llcommon/llworkerthread.h
+++ b/indra/llcommon/llworkerthread.h
@@ -118,6 +118,9 @@ class LLWorkerClass
{
friend class LLWorkerThread;
friend class LLWorkerThread::WorkRequest;
+
+public:
+ static BOOL sDeleteLock ;
public:
typedef LLWorkerThread::handle_t handle_t;
enum FLAGS
@@ -178,6 +181,7 @@ class LLWorkerClass
void setFlags(U32 flags) { mWorkFlags = mWorkFlags | flags; }
void clearFlags(U32 flags) { mWorkFlags = mWorkFlags & ~flags; }
U32 getFlags() { return mWorkFlags; }
+public:
bool getFlags(U32 flags) { return mWorkFlags & flags ? true : false; }
private:
diff --git a/indra/llcrashlogger/llcrashlogger.cpp b/indra/llcrashlogger/llcrashlogger.cpp
index 32dea6c707c4dab88406a4538ed5d04a47d3ce87..076149bcf41cc209eca0ff2cf28d4789dd96b13b 100755
--- a/indra/llcrashlogger/llcrashlogger.cpp
+++ b/indra/llcrashlogger/llcrashlogger.cpp
@@ -96,6 +96,33 @@ LLCrashLogger::~LLCrashLogger()
}
+// TRIM_SIZE must remain larger than LINE_SEARCH_SIZE.
+const int TRIM_SIZE = 128000;
+const int LINE_SEARCH_DIST = 500;
+const std::string SKIP_TEXT = "\n ...Skipping... \n";
+void trimSLLog(std::string& sllog)
+{
+ if(sllog.length() > TRIM_SIZE * 2)
+ {
+ std::string::iterator head = sllog.begin() + TRIM_SIZE;
+ std::string::iterator tail = sllog.begin() + sllog.length() - TRIM_SIZE;
+ std::string::iterator new_head = std::find(head, head - LINE_SEARCH_DIST, '\n');
+ if(new_head != head - LINE_SEARCH_DIST)
+ {
+ head = new_head;
+ }
+
+ std::string::iterator new_tail = std::find(tail, tail + LINE_SEARCH_DIST, '\n');
+ if(new_tail != tail + LINE_SEARCH_DIST)
+ {
+ tail = new_tail;
+ }
+
+ sllog.erase(head, tail);
+ sllog.insert(head, SKIP_TEXT.begin(), SKIP_TEXT.end());
+ }
+}
+
void LLCrashLogger::gatherFiles()
{
@@ -129,7 +156,15 @@ void LLCrashLogger::gatherFiles()
LLSDSerialize::fromXML(mDebugLog, debug_log_file);
mFileMap["SecondLifeLog"] = mDebugLog["SLLog"].asString();
mFileMap["SettingsXml"] = mDebugLog["SettingsFilename"].asString();
- LLCurl::setCAFile(mDebugLog["CAFilename"].asString());
+ if(mDebugLog.has("CAFilename"))
+ {
+ LLCurl::setCAFile(mDebugLog["CAFilename"].asString());
+ }
+ else
+ {
+ LLCurl::setCAFile(gDirUtilp->getCAFile());
+ }
+
llinfos << "Using log file from debug log " << mFileMap["SecondLifeLog"] << llendl;
llinfos << "Using settings file from debug log " << mFileMap["SettingsXml"] << llendl;
}
@@ -150,6 +185,17 @@ void LLCrashLogger::gatherFiles()
mCrashHost += mDebugLog["CurrentSimHost"].asString();
mCrashHost += ":12043/crash/report";
}
+ else if(mDebugLog.has("GridName"))
+ {
+ // This is a 'little' hacky, but its the best simple solution.
+ std::string grid_host = mDebugLog["GridName"].asString();
+ LLStringUtil::toLower(grid_host);
+
+ mCrashHost = "https://login.";
+ mCrashHost += grid_host;
+ mCrashHost += ".lindenlab.com:12043/crash/report";
+ }
+
// Use login servers as the alternate, since they are already load balanced and have a known name
mAltCrashHost = "https://login.agni.lindenlab.com:12043/crash/report";
@@ -169,7 +215,14 @@ void LLCrashLogger::gatherFiles()
}
std::stringstream s;
s << f.rdbuf();
- mCrashInfo[(*itr).first] = s.str();
+
+ std::string crash_info = s.str();
+ if(itr->first == "SecondLifeLog")
+ {
+ trimSLLog(crash_info);
+ }
+
+ mCrashInfo[(*itr).first] = crash_info;
}
}
diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp
index 66b84c9a08ca8af6d3f7e41d6aa150736fa78de2..1c8fb4234fb6b27fe424fc87addac2ad4811a353 100644
--- a/indra/llimage/llimage.cpp
+++ b/indra/llimage/llimage.cpp
@@ -842,8 +842,8 @@ void LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )
U8* temp_buffer = new U8[ temp_data_size ];
if (!temp_buffer)
{
- llerrs << "Out of memory in LLImageRaw::scale( S32 new_width, S32 new_height, BOOL scale_image_data )" << llendl;
- return;
+ llerrs << "Out of memory in LLImageRaw::scale: old (w, h, c) = (" << old_width << ", " << old_height << ", " << (S32)getComponents() <<
+ ") ; new (w, h, c) = (" << new_width << ", " << new_height << ", " << (S32)getComponents() << ")" << llendl;
}
memcpy(temp_buffer, getData(), temp_data_size); /* Flawfinder: ignore */
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index f020730d4a0ec943d4f4f86c6429d115de34ce45..1c9b4d96939951a9ad7f5ebd24dd3e3f1ffe6c63 100644
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -61,8 +61,6 @@ S32 LLImageGL::sCount = 0;
BOOL LLImageGL::sGlobalUseAnisotropic = FALSE;
F32 LLImageGL::sLastFrameTime = 0.f;
-BOOL LLImageGL::sRefCheck = TRUE ;
-
std::set<LLImageGL*> LLImageGL::sImageList;
//----------------------------------------------------------------------------
@@ -279,9 +277,7 @@ LLImageGL::LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps)
sImageList.insert(this);
sCount++;
- sRefCheck = FALSE ;
createGLTexture(0, imageraw);
- sRefCheck = TRUE ;
}
LLImageGL::~LLImageGL()
@@ -426,9 +422,7 @@ void LLImageGL::dump()
//----------------------------------------------------------------------------
BOOL LLImageGL::bindTextureInternal(const S32 stage) const
-{
- llassert_always(!sRefCheck || (getNumRefs() > 0 && getNumRefs() < 100000)) ;
-
+{
if (gGLManager.mIsDisabled)
{
llwarns << "Trying to bind a texture while GL is disabled!" << llendl;
diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h
index c5fe9b7299c4d68d4b2d80c0ee50f5a7a9a4a939..8aeecb3627849d374330ee6171ae41346260b73e 100644
--- a/indra/llrender/llimagegl.h
+++ b/indra/llrender/llimagegl.h
@@ -207,9 +207,6 @@ class LLImageGL : public LLRefCount
#else
BOOL getMissed() const { return FALSE; };
#endif
-
-private://paranoia error check
- static BOOL sRefCheck ;
};
#endif // LL_LLIMAGEGL_H
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 681c5ce5daee5261cfd1eb1fac243ccc0fd7dd3a..0bc5bc60de86bf918f780d5fe40aa72ed7d80f08 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -1107,11 +1107,15 @@ BOOL LLScrollListCtrl::selectItemRange( S32 first_index, S32 last_index )
BOOL success = FALSE;
S32 index = 0;
- for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); iter++)
+ for (item_list::iterator iter = mItemList.begin(); iter != mItemList.end(); )
{
LLScrollListItem *itemp = *iter;
-
- llassert_always(itemp) ;
+ if(!itemp)
+ {
+ iter = mItemList.erase(iter);
+ continue ;
+ }
+
if( index >= first_index && index <= last_index )
{
if( itemp->getEnabled() )
@@ -1125,6 +1129,7 @@ BOOL LLScrollListCtrl::selectItemRange( S32 first_index, S32 last_index )
deselectItem(itemp);
}
index++;
+ iter++ ;
}
if (mCommitOnSelectionChange)
diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp
index ccff4f3161e0fcf04352a2f676951c4b4d36295d..4a81ddd1fd2c7da1d0f7d617aa006babbfa81855 100644
--- a/indra/llwindow/llwindowwin32.cpp
+++ b/indra/llwindow/llwindowwin32.cpp
@@ -1343,9 +1343,6 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO
SetWindowLong(mWindowHandle, GWL_USERDATA, (U32)this);
show();
- //make sure multi sampling is disabled by default
- glDisable(GL_MULTISAMPLE_ARB);
-
//register joystick timer callback
SetTimer( mWindowHandle, 0, 1000 / 30, NULL ); // 30 fps timer
@@ -1368,7 +1365,9 @@ void LLWindowWin32::moveWindow( const LLCoordScreen& position, const LLCoordScre
// if the window was already maximized, MoveWindow seems to still set the maximized flag even if
// the window is smaller than maximized.
// So we're going to do a restore first (which is a ShowWindow call) (SL-44655).
- ShowWindow(mWindowHandle, SW_RESTORE);
+
+ // THIS CAUSES DEV-15484 and DEV-15949
+ //ShowWindow(mWindowHandle, SW_RESTORE);
// NOW we can call MoveWindow
MoveWindow(mWindowHandle, position.mX, position.mY, size.mX, size.mY, TRUE);
}
diff --git a/indra/lscript/lscript_compile/indra.l b/indra/lscript/lscript_compile/indra.l
index 5f649d1f8d905064bad4047726291e56f5fe095c..14f8acb5516aa07b1584f72be14c5d2c44375b1c 100644
--- a/indra/lscript/lscript_compile/indra.l
+++ b/indra/lscript/lscript_compile/indra.l
@@ -603,9 +603,10 @@ extern "C" { int yyerror(const char *fmt, ...); }
"CLICK_ACTION_OPEN_MEDIA" { count(); yylval.ival = CLICK_ACTION_OPEN_MEDIA; return(INTEGER_CONSTANT); }
"TEXTURE_BLANK" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "5748decc-f629-461c-9a36-a35a221fe21f"); return(STRING_CONSTANT); }
-"TEXTURE_DEFAULT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8b5fec65-8d8d-9dc5-cda8-8fdf2716e361"); return(STRING_CONSTANT); }
-"TEXTURE_PLYWOOD" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
-"TEXTURE_TRANSPARENT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "59facb66-4a72-40a2-815c-7d9b42c56f60"); return(STRING_CONSTANT); }
+"TEXTURE_DEFAULT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
+"TEXTURE_MEDIA" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8b5fec65-8d8d-9dc5-cda8-8fdf2716e361"); return(STRING_CONSTANT); }
+"TEXTURE_PLYWOOD" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
+"TEXTURE_TRANSPARENT" { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8dcd4a48-2d37-4909-9f78-f7a9eb4ef903"); return(STRING_CONSTANT); }
{L}({L}|{N})* { count(); yylval.sval = new char[strlen(yytext) + 1]; strcpy(yylval.sval, yytext); return(IDENTIFIER); }
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index eb04b430d777d755c8519e37edc28ea567597972..e185d96c98d9f4b948ad5032b62e7f96ca3f74c9 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -5797,17 +5797,6 @@
<key>Value</key>
<integer>1</integer>
</map>
- <key>RenderDynamicReflections</key>
- <map>
- <key>Comment</key>
- <string>Generate a dynamic cube map for reflections (objects reflect their environment, experimental).</string>
- <key>Persist</key>
- <integer>1</integer>
- <key>Type</key>
- <string>Boolean</string>
- <key>Value</key>
- <integer>0</integer>
- </map>
<key>RenderFSAASamples</key>
<map>
<key>Comment</key>
@@ -9961,11 +9950,11 @@
<key>Comment</key>
<string>Controls whether the thread watchdog timer is activated.</string>
<key>Persist</key>
- <integer>1</integer>
+ <integer>0</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
- <integer>1</integer>
+ <integer>0</integer>
</map>
<key>WaterEditPresets</key>
<map>
diff --git a/indra/newview/gpu_table.txt b/indra/newview/gpu_table.txt
index f0b0f0c514b9b1a231c5183915ec46e976f636cb..f038e0f64dec6e8381dbda2a9c340d8e4994cf81 100644
--- a/indra/newview/gpu_table.txt
+++ b/indra/newview/gpu_table.txt
@@ -186,6 +186,7 @@ NVIDIA GeForce Go 6700 .*NVIDIA.*GeForce Go 67.* 1 1
NVIDIA GeForce Go 6800 .*NVIDIA.*GeForce Go 68.* 1 1
NVIDIA GeForce Go 7200 .*NVIDIA.*GeForce Go 72.* 1 1
NVIDIA GeForce Go 7300 .*NVIDIA.*GeForce Go 73.* 1 1
+NVIDIA GeForce Go 7300 LE .*NVIDIA.*GeForce Go 73.*LE.* 0 1
NVIDIA GeForce Go 7400 .*NVIDIA.*GeForce Go 74.* 1 1
NVIDIA GeForce Go 7600 .*NVIDIA.*GeForce Go 76.* 2 1
NVIDIA GeForce Go 7700 .*NVIDIA.*GeForce Go 77.* 2 1
@@ -194,6 +195,7 @@ NVIDIA GeForce Go 7900 .*NVIDIA.*GeForce Go 79.* 2 1
NVIDIA GeForce Go 6 .*GeForce Go 6.* 1 1
NVIDIA GeForce PCX .*GeForce PCX.* 0 1
NVIDIA Generic .*NVIDIA.*Unknown.* 0 0
+NVIDIA NV34 .*NVIDIA.*NV34.* 0 1
NVIDIA NV43 .*NVIDIA.*NV43.* 1 1
NVIDIA MCP78 .*NVIDIA.*MCP78.* 1 1
NVIDIA Quadro2 .*Quadro2.* 0 1
diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 9d2ea7a1b72cc63a0fee9450b0edec3eadfd595f..e926e97f7688d80821c3c458b527a4c9fd5e372a 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -94,6 +94,7 @@
#include "llsky.h"
#include "llrendersphere.h"
#include "llstatusbar.h"
+#include "llstartup.h"
#include "llimview.h"
#include "lltool.h"
#include "lltoolfocus.h"
@@ -6432,7 +6433,6 @@ BOOL LLAgent::isWearingItem( const LLUUID& item_id )
return (getWearableFromWearableItem( item_id ) != NULL);
}
-
// static
void LLAgent::processAgentInitialWearablesUpdate( LLMessageSystem* mesgsys, void** user_data )
{
@@ -6471,8 +6471,12 @@ void LLAgent::processAgentInitialWearablesUpdate( LLMessageSystem* mesgsys, void
//avatar->createStandardWearables();
// no, deal with it by noting that we need to choose a
- // gender.
- gAgent.setGenderChosen(FALSE);
+ // gender, but only if an initial outfit load isn't happening.
+ // This whole check (num_wearables < 4) can probably be deleted. JC
+ if (gInitialOutfit.empty())
+ {
+ gAgent.setGenderChosen(FALSE);
+ }
return;
}
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 0c7a5e23aea4304bcdbbdf6b116cd0232123905f..c040dae469b94c9c842f29044a087fa8e57f845b 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -402,13 +402,13 @@ bool handleCrashSubmitBehaviorChanged(const LLSD& newvalue)
const S32 NEVER_SUBMIT_REPORT = 2;
if(cb == NEVER_SUBMIT_REPORT)
{
-// LLWatchdog::getInstance()->cleanup(); // SJB: cleaning up a running watchdog is unsafe
+// LLWatchdog::getInstance()->cleanup(); // SJB: cleaning up a running watchdog thread is unsafe
LLAppViewer::instance()->destroyMainloopTimeout();
}
else if(gSavedSettings.getBOOL("WatchdogEnabled") == TRUE)
{
-// LLWatchdog::getInstance()->init();
-// LLAppViewer::instance()->initMainloopTimeout("Mainloop Resume");
+ // Don't re-enable the watchdog when we change the setting; this may get called before it's started
+// LLWatchdog::getInstance()->init();
}
return true;
}
@@ -530,7 +530,7 @@ void LLAppViewer::initGridChoice()
std::string custom_server = gSavedSettings.getString("CustomServer");
LLViewerLogin::getInstance()->setGridChoice(custom_server);
}
- else if(server != 0)
+ else if(server != (S32)GRID_INFO_NONE)
{
LLViewerLogin::getInstance()->setGridChoice((EGridInfo)server);
}
@@ -1139,12 +1139,12 @@ bool LLAppViewer::cleanup()
llinfos << "Cleaning Up" << llendflush;
- LLKeyframeDataCache::clear();
-
// Must clean up texture references before viewer window is destroyed.
LLHUDObject::cleanupHUDObjects();
llinfos << "HUD Objects cleaned up" << llendflush;
+ LLKeyframeDataCache::clear();
+
// End TransferManager before deleting systems it depends on (Audio, VFS, AssetStorage)
#if 0 // this seems to get us stuck in an infinite loop...
gTransferManager.cleanup();
@@ -1321,7 +1321,7 @@ bool LLAppViewer::cleanup()
removeMarkerFile(); // Any crashes from here on we'll just have to ignore
- closeDebug();
+ writeDebugInfo();
// Let threads finish
LLTimer idleTimer;
@@ -1579,6 +1579,7 @@ bool LLAppViewer::initConfiguration()
// on these platform to help debug.
#ifndef LL_RELEASE_FOR_DOWNLOAD
gSavedSettings.setBOOL("WatchdogEnabled", FALSE);
+ gSavedSettings.setBOOL("QAMode", TRUE );
#endif
#ifndef LL_WINDOWS
@@ -1630,15 +1631,6 @@ bool LLAppViewer::initConfiguration()
// Do this *before* loading the settings file
LLAlertDialog::parseAlerts("alerts.xml", &gSavedSettings, TRUE);
-#if LL_DYNAMIC_FONT_DISCOVERY
- // Linux does *dynamic* font discovery which is preferable to
- // whatever got written-out into the config file last time. This
- // does remove the ability of the user to hand-define the fallbacks
- // though, so from a config-management point of view this is hacky.
- gSavedSettings.setString("FontSansSerifFallback",
- LLWindow::getFontListSans());
-#endif
-
// - read command line settings.
LLControlGroupCLP clp;
std::string cmd_line_config = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,
@@ -1683,6 +1675,15 @@ bool LLAppViewer::initConfiguration()
// - load overrides from user_settings
loadSettingsFromDirectory(LL_PATH_USER_SETTINGS);
+#if LL_DYNAMIC_FONT_DISCOVERY
+ // Linux does *dynamic* font discovery which is preferable to
+ // whatever got written-out into the config file last time. This
+ // does remove the ability of the user to hand-define the fallbacks
+ // though, so from a config-management point of view this is hacky.
+ gSavedSettings.setString("FontSansSerifFallback",
+ LLWindow::getFontListSans());
+#endif
+
// - apply command line settings
clp.notify();
@@ -2133,7 +2134,7 @@ bool LLAppViewer::initWindow()
return true;
}
-void LLAppViewer::closeDebug()
+void LLAppViewer::writeDebugInfo()
{
std::string debug_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"debug_info.log");
llinfos << "Opening debug file " << debug_filename << llendl;
@@ -2212,6 +2213,8 @@ void LLAppViewer::writeSystemInfo()
gDebugInfo["ClientInfo"]["PatchVersion"] = LL_VERSION_PATCH;
gDebugInfo["ClientInfo"]["BuildVersion"] = LL_VERSION_BUILD;
+ gDebugInfo["CAFilename"] = gDirUtilp->getCAFile();
+
gDebugInfo["CPUInfo"]["CPUString"] = gSysCPU.getCPUString();
gDebugInfo["CPUInfo"]["CPUFamily"] = gSysCPU.getFamily();
gDebugInfo["CPUInfo"]["CPUMhz"] = gSysCPU.getMhz();
@@ -2222,7 +2225,11 @@ void LLAppViewer::writeSystemInfo()
gDebugInfo["RAMInfo"]["Physical"] = (LLSD::Integer)(gSysMemory.getPhysicalMemoryKB());
gDebugInfo["RAMInfo"]["Allocated"] = (LLSD::Integer)(gMemoryAllocated>>10); // MB -> KB
gDebugInfo["OSInfo"] = getOSInfo().getOSStringSimple();
-
+
+ // The user is not logged on yet, but record the current grid choice login url
+ // which may have been the intended grid. This can b
+ gDebugInfo["GridName"] = LLViewerLogin::getInstance()->getGridLabel();
+
// *FIX:Mani - move this ddown in llappviewerwin32
#ifdef LL_WINDOWS
DWORD thread_id = GetCurrentThreadId();
@@ -2246,6 +2253,8 @@ void LLAppViewer::writeSystemInfo()
LL_INFOS("SystemInfo") << "Memory info:\n" << gSysMemory << LL_ENDL;
LL_INFOS("SystemInfo") << "OS: " << getOSInfo().getOSStringSimple() << LL_ENDL;
LL_INFOS("SystemInfo") << "OS info: " << getOSInfo() << LL_ENDL;
+
+ writeDebugInfo(); // Save out debug_info.log early, in case of crash.
}
void LLAppViewer::handleSyncViewerCrash()
@@ -2259,9 +2268,6 @@ void LLAppViewer::handleViewerCrash()
{
llinfos << "Handle viewer crash entry." << llendl;
- // Make sure the watchdog gets turned off...
-// LLWatchdog::getInstance()->cleanup(); // SJB: This causes the Watchdog to hang for an extra 20-40s?!
-
LLAppViewer* pApp = LLAppViewer::instance();
if (pApp->beingDebugged())
{
@@ -2277,6 +2283,9 @@ void LLAppViewer::handleViewerCrash()
}
pApp->mReportedCrash = TRUE;
+ // Make sure the watchdog gets turned off...
+// pApp->destroyMainloopTimeout(); // SJB: Bah. This causes the crash handler to hang, not sure why.
+
//We already do this in writeSystemInfo(), but we do it again here to make /sure/ we have a version
//to check against no matter what
gDebugInfo["ClientInfo"]["Name"] = gSavedSettings.getString("VersionChannelName");
@@ -2365,7 +2374,7 @@ void LLAppViewer::handleViewerCrash()
LLWorld::getInstance()->getInfo(gDebugInfo);
// Close the debug file
- pApp->closeDebug();
+ pApp->writeDebugInfo();
LLError::logToFile("");
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index 228f6e4bafc15994a1729a48d54d53a486f93ccb..4bafca25a48e7ea9bc1461465e2d29a4df716d7e 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -70,7 +70,7 @@ class LLAppViewer : public LLApp
bool quitRequested() { return mQuitRequested; }
bool logoutRequestSent() { return mLogoutRequestSent; }
- void closeDebug();
+ void writeDebugInfo();
const LLOSInfo& getOSInfo() const { return mSysOSInfo; }
diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp
index a03adfa3388a5f75fbf13b7fac9ed3b3fd29b01f..6f5dc1d3e777723c2dcc37586c417a70daa4c042 100644
--- a/indra/newview/lldrawable.cpp
+++ b/indra/newview/lldrawable.cpp
@@ -122,7 +122,11 @@ void LLDrawable::destroy()
sNumZombieDrawables--;
}
- LLFace::sDeleteLock = mFaces.size() ;
+ if (LLSpatialGroup::sNoDelete)
+ {
+ llerrs << "Illegal deletion of LLDrawable!" << llendl;
+ }
+
std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());
mFaces.clear();
@@ -185,7 +189,6 @@ void LLDrawable::cleanupReferences()
{
LLFastTimer t(LLFastTimer::FTM_PIPELINE);
- LLFace::sDeleteLock = mFaces.size() ;
std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());
mFaces.clear();
@@ -279,7 +282,6 @@ void LLDrawable::setNumFaces(const S32 newFaces, LLFacePool *poolp, LLViewerImag
}
else if (newFaces < (S32)mFaces.size())
{
- LLFace::sDeleteLock = (S32)mFaces.size() - newFaces ;
std::for_each(mFaces.begin() + newFaces, mFaces.end(), DeletePointer());
mFaces.erase(mFaces.begin() + newFaces, mFaces.end());
}
@@ -303,7 +305,6 @@ void LLDrawable::setNumFacesFast(const S32 newFaces, LLFacePool *poolp, LLViewer
}
else if (newFaces < (S32)mFaces.size())
{
- LLFace::sDeleteLock = (S32)mFaces.size() - newFaces ;
std::for_each(mFaces.begin() + newFaces, mFaces.end(), DeletePointer());
mFaces.erase(mFaces.begin() + newFaces, mFaces.end());
}
@@ -338,12 +339,8 @@ void LLDrawable::deleteFaces(S32 offset, S32 count)
face_list_t::iterator face_begin = mFaces.begin() + offset;
face_list_t::iterator face_end = face_begin + count;
- S32 end = (S32)mFaces.size() ;
- LLFace::sDeleteLock = count ;
std::for_each(face_begin, face_end, DeletePointer());
mFaces.erase(face_begin, face_end);
-
- llassert_always(mFaces.size() == end - count) ;
}
void LLDrawable::update()
@@ -521,7 +518,7 @@ F32 LLDrawable::updateXform(BOOL undamped)
}
if ((mCurrentScale != target_scale) ||
- (!isRoot() && (dist_squared >= MIN_INTERPOLATE_DISTANCE_SQUARED*camdist2)))
+ (!isRoot() && (dist_squared >= MIN_INTERPOLATE_DISTANCE_SQUARED) || !mVObjp->getAngularVelocity().isExactlyZero()))
{ //child prim moving or scale change requires immediate rebuild
gPipeline.markRebuild(this, LLDrawable::REBUILD_POSITION, TRUE);
}
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 5cc4e37c97571c9883dced8a29aa8d74445a8f7d..fe2c2041ae42ef2a93361a46ac8b030b2ae61ae3 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -230,7 +230,6 @@ void LLDrawPoolAlpha::renderGroupAlpha(LLSpatialGroup* group, U32 type, U32 mask
if (texture && params.mTexture.notNull())
{
- llassert_always(gGL.getTexUnit(0)) ;
gGL.getTexUnit(0)->activate();
params.mTexture->bind();
params.mTexture->addTextureStats(params.mVSize);
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index f1d88aa54ac49624c4e47b20f5bdbf512c0a95e9..04a7cfd8a0fb08533f35008aab6f82ffae40951f 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -452,7 +452,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
return;
}
- if (single_avatar && avatarp->mSpecialRenderMode >= 2) // 2=image preview, 3=morph view
+ if (single_avatar && avatarp->mSpecialRenderMode >= 1) // 1=anim preview, 2=image preview, 3=morph view
{
gPipeline.enableLightsAvatarEdit(LLColor4(.5f, .5f, .5f, 1.f));
}
diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 1784fccf1f0b267a5b7cada1421548c66f92a9cd..56dc61c1a36570af9017a52d93aec7844c125923 100644
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -556,30 +556,7 @@ void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL
for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)
{
LLDrawInfo& params = **k;
- if (LLPipeline::sDynamicReflections)
- {
- if (params.mReflectionMap.notNull())
- {
- params.mReflectionMap->bind();
- }
- else
- {
- if (params.mModelMatrix)
- {
- sCubeMap = gPipeline.findReflectionMap(params.mModelMatrix->getTranslation());
- }
-
- if (sCubeMap)
- {
- sCubeMap->bind();
- }
- else if (gSky.mVOSkyp->getCubeMap())
- {
- gSky.mVOSkyp->getCubeMap()->bind();
- }
- }
- }
-
+
applyModelMatrix(params);
params.mVertexBuffer->setBuffer(mask);
@@ -607,10 +584,6 @@ BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params)
if( tex )
{
bump = gBumpImageList.getBrightnessDarknessImage( tex, bump_code );
- //------------------------------------------
- //error check to make sure bump is valid
- llassert_always(!bump || bump->getNumRefs() == 1) ;
- //------------------------------------------
}
break;
@@ -625,11 +598,6 @@ BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params)
if (bump)
{
- //------------------------------------------
- //error check to make sure bump is valid
- llassert_always(bump->getNumRefs() > 0 && bump->getNumRefs() < 100000) ;
- //------------------------------------------
-
bump->bind(1);
bump->bind(0);
return TRUE;
@@ -1121,22 +1089,6 @@ void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
{
LLImageGL::unbindTexture(0);
}
-
- if (LLPipeline::sDynamicReflections)
- {
- LLCubeMap* cube_map = params.mReflectionMap;
-
- if (!cube_map && params.mModelMatrix)
- {
- cube_map = gPipeline.findReflectionMap(params.mModelMatrix->getTranslation());
- }
-
- if (cube_map)
- {
- cube_map->enableTexture(cube_channel);
- cube_map->bind();
- }
- }
}
params.mVertexBuffer->setBuffer(mask);
diff --git a/indra/newview/lldriverparam.cpp b/indra/newview/lldriverparam.cpp
index b3daad9fb33dae19e8399d9f0fea136e863a9de4..e88381d9e92e931a84f1d2652af1191fcdf2765a 100644
--- a/indra/newview/lldriverparam.cpp
+++ b/indra/newview/lldriverparam.cpp
@@ -34,6 +34,7 @@
#include "lldriverparam.h"
#include "llfasttimer.h"
+#include "llvoavatar.h"
//-----------------------------------------------------------------------------
// LLDriverParamInfo
diff --git a/indra/newview/lldriverparam.h b/indra/newview/lldriverparam.h
index 46b8609038a3a98ada7a4c89124960da9ea5c0f6..8170873849b72038237aee704547951e2bf0bafd 100644
--- a/indra/newview/lldriverparam.h
+++ b/indra/newview/lldriverparam.h
@@ -32,9 +32,10 @@
#ifndef LL_LLDRIVERPARAM_H
#define LL_LLDRIVERPARAM_H
-#include "llvoavatar.h"
#include "llviewervisualparam.h"
+class LLVOAvatar;
+
//-----------------------------------------------------------------------------
struct LLDrivenEntryInfo
diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp
index 8474762d9b00e3829fed568fca7049e39a302727..b2f5caa57d06a3d1ff0d086fec67fe5eca6b57e5 100644
--- a/indra/newview/llface.cpp
+++ b/indra/newview/llface.cpp
@@ -57,7 +57,6 @@
extern BOOL gPickFaces;
BOOL LLFace::sSafeRenderSelect = TRUE; // FALSE
-S32 LLFace::sDeleteLock = 0 ;
#define DOTVEC(a,b) (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2])
@@ -178,9 +177,6 @@ void LLFace::init(LLDrawable* drawablep, LLViewerObject* objp)
void LLFace::destroy()
{
- llassert_always(sDeleteLock >= 1);
- --sDeleteLock;
-
mDrawablep = NULL;
mVObjp = NULL;
diff --git a/indra/newview/llface.h b/indra/newview/llface.h
index 34c81c3fdd77f99e1ec3c5049936204f93ef03ba..0391cda66fc0a0dd9e2a6c2e64fc3d4a9dfb2eec 100644
--- a/indra/newview/llface.h
+++ b/indra/newview/llface.h
@@ -296,9 +296,6 @@ class LLFace
lhs->getTexture() < rhs->getTexture();
}
};
-
-public://paranoia check only
- static S32 sDeleteLock ;
};
#endif // LL_LLFACE_H
diff --git a/indra/newview/llfloateranimpreview.cpp b/indra/newview/llfloateranimpreview.cpp
index 6d4ff5a1a78dd036f2c765b005294708d9877e27..417ac0e86879a8796d6f2ef679e4c33291f692c6 100644
--- a/indra/newview/llfloateranimpreview.cpp
+++ b/indra/newview/llfloateranimpreview.cpp
@@ -76,13 +76,14 @@ const F32 PREVIEW_CAMERA_DISTANCE = 4.f;
const F32 MIN_CAMERA_ZOOM = 0.5f;
const F32 MAX_CAMERA_ZOOM = 10.f;
+const F32 BASE_ANIM_TIME_OFFSET = 5.f;
+
//-----------------------------------------------------------------------------
// LLFloaterAnimPreview()
//-----------------------------------------------------------------------------
LLFloaterAnimPreview::LLFloaterAnimPreview(const std::string& filename) :
LLFloaterNameDesc(filename)
{
- mLastSliderValue = 0.f;
mLastMouseX = 0;
mLastMouseY = 0;
@@ -414,20 +415,32 @@ void LLFloaterAnimPreview::resetMotion()
LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
BOOL paused = avatarp->areAnimationsPaused();
- mPauseRequest = NULL;
+ // *TODO: Fix awful casting hack
+ LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID);
+
+ // Set emotion
+ std::string emote = childGetValue("emote_combo").asString();
+ motionp->setEmote(mIDList[emote]);
- LLUUID anim_id = mIDList[childGetValue("preview_base_anim").asString()];
- avatarp->stopMotion(anim_id, TRUE);
- avatarp->stopMotion(mMotionID, TRUE);
- avatarp->startMotion(anim_id, 5.f);
- avatarp->startMotion(mMotionID);
- childSetValue("playback_slider", 0.0);
- mLastSliderValue = 0.0f;
+ LLUUID base_id = mIDList[childGetValue("preview_base_anim").asString()];
+ avatarp->deactivateAllMotions();
+ avatarp->startMotion(base_id, BASE_ANIM_TIME_OFFSET);
+ avatarp->startMotion(mMotionID, 0.0f);
+ childSetValue("playback_slider", 0.0f);
+
+ // Set pose
+ std::string handpose = childGetValue("hand_pose_combo").asString();
+ avatarp->startMotion( ANIM_AGENT_HAND_MOTION, 0.0f );
+ motionp->setHandPose(LLHandMotion::getHandPose(handpose));
if (paused)
{
mPauseRequest = avatarp->requestPause();
}
+ else
+ {
+ mPauseRequest = NULL;
+ }
}
//-----------------------------------------------------------------------------
@@ -538,7 +551,8 @@ void LLFloaterAnimPreview::onMouseCaptureLost()
void LLFloaterAnimPreview::onBtnPlay(void* user_data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
if (previewp->mMotionID.notNull() && previewp->mAnimPreview)
{
@@ -569,22 +583,14 @@ void LLFloaterAnimPreview::onBtnPlay(void* user_data)
void LLFloaterAnimPreview::onBtnStop(void* user_data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
if (previewp->mMotionID.notNull() && previewp->mAnimPreview)
{
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
-
- // is the motion looping and have we passed the loop in point?
- if (previewp->childGetValue("loop_check").asBoolean() &&
- (F32)previewp->childGetValue("loop_in_point").asReal() <= (F32)previewp->childGetValue("playback_slider").asReal() * 100.f)
- {
- avatarp->stopMotion(previewp->mMotionID, FALSE);
- }
- else
- {
- avatarp->stopMotion(previewp->mMotionID, FALSE);
- }
+ previewp->resetMotion();
+ previewp->mPauseRequest = avatarp->requestPause();
}
}
@@ -594,43 +600,24 @@ void LLFloaterAnimPreview::onBtnStop(void* user_data)
void LLFloaterAnimPreview::onSliderMove(LLUICtrl* ctrl, void*user_data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
if (previewp->mAnimPreview)
{
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
+ F32 slider_value = (F32)previewp->childGetValue("playback_slider").asReal();
+ LLUUID base_id = previewp->mIDList[previewp->childGetValue("preview_base_anim").asString()];
LLMotion* motionp = avatarp->findMotion(previewp->mMotionID);
- LLMotion* base_motionp =
- avatarp->findMotion(previewp->mIDList[previewp->childGetValue("preview_base_anim").asString()]);
-
- if (motionp && base_motionp)
- {
- if (!avatarp->isMotionActive(previewp->mMotionID))
- {
- previewp->resetMotion();
- }
-
- previewp->mPauseRequest = avatarp->requestPause();
- F32 original_activation_time = motionp->mActivationTimestamp;
- motionp->mActivationTimestamp -= ((F32)previewp->childGetValue("playback_slider").asReal() - previewp->mLastSliderValue) *
- motionp->getDuration();
- base_motionp->mActivationTimestamp -= ((F32)previewp->childGetValue("playback_slider").asReal() - previewp->mLastSliderValue) *
- base_motionp->getDuration();
-
- if (motionp->mSendStopTimestamp != F32_MIN)
- {
- motionp->mSendStopTimestamp = motionp->mSendStopTimestamp - original_activation_time + motionp->mActivationTimestamp;
- }
-
- if (motionp->mStopTimestamp != F32_MIN)
- {
- motionp->mStopTimestamp = motionp->mStopTimestamp - original_activation_time + motionp->mActivationTimestamp;
- }
- previewp->refresh();
- }
+ F32 duration = motionp->getDuration();// + motionp->getEaseOutDuration();
+ F32 delta_time = duration * slider_value;
+ avatarp->deactivateAllMotions();
+ avatarp->startMotion(base_id, delta_time + BASE_ANIM_TIME_OFFSET);
+ avatarp->startMotion(previewp->mMotionID, delta_time);
+ previewp->mPauseRequest = avatarp->requestPause();
+ previewp->refresh();
}
- previewp->mLastSliderValue = (F32)previewp->childGetValue("playback_slider").asReal();
}
//-----------------------------------------------------------------------------
@@ -639,8 +626,8 @@ void LLFloaterAnimPreview::onSliderMove(LLUICtrl* ctrl, void*user_data)
void LLFloaterAnimPreview::onCommitBaseAnim(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
-
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
if (previewp->mAnimPreview)
{
@@ -669,8 +656,9 @@ void LLFloaterAnimPreview::onCommitBaseAnim(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitLoop(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
-
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
+
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -688,7 +676,8 @@ void LLFloaterAnimPreview::onCommitLoop(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitLoopIn(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -708,7 +697,8 @@ void LLFloaterAnimPreview::onCommitLoopIn(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitLoopOut(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -728,7 +718,8 @@ void LLFloaterAnimPreview::onCommitLoopOut(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitName(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -747,13 +738,10 @@ void LLFloaterAnimPreview::onCommitName(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitHandPose(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
-
- LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
- LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
+ if (!previewp->getEnabled())
+ return;
- motionp->setHandPose(LLHandMotion::getHandPose(previewp->childGetValue("hand_pose_combo").asString()));
- previewp->resetMotion();
+ previewp->resetMotion(); // sets hand pose
}
//-----------------------------------------------------------------------------
@@ -762,13 +750,10 @@ void LLFloaterAnimPreview::onCommitHandPose(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitEmote(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
- LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
- LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
-
- motionp->setEmote(previewp->mIDList[previewp->childGetValue("emote_combo").asString()]);
- previewp->resetMotion();
+ previewp->resetMotion(); // ssts emote
}
//-----------------------------------------------------------------------------
@@ -777,7 +762,8 @@ void LLFloaterAnimPreview::onCommitEmote(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitPriority(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -791,7 +777,8 @@ void LLFloaterAnimPreview::onCommitPriority(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitEaseIn(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -806,7 +793,8 @@ void LLFloaterAnimPreview::onCommitEaseIn(LLUICtrl* ctrl, void* data)
void LLFloaterAnimPreview::onCommitEaseOut(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return;
+ if (!previewp->getEnabled())
+ return;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -820,9 +808,9 @@ void LLFloaterAnimPreview::onCommitEaseOut(LLUICtrl* ctrl, void* data)
//-----------------------------------------------------------------------------
BOOL LLFloaterAnimPreview::validateEaseIn(LLUICtrl* spin, void* data)
{
- LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
-
- if (!previewp->getEnabled()) return FALSE;
+ LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
+ if (!previewp->getEnabled())
+ return FALSE;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -843,7 +831,8 @@ BOOL LLFloaterAnimPreview::validateEaseOut(LLUICtrl* spin, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
- if (!previewp->getEnabled()) return FALSE;
+ if (!previewp->getEnabled())
+ return FALSE;
LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
@@ -863,8 +852,8 @@ BOOL LLFloaterAnimPreview::validateEaseOut(LLUICtrl* spin, void* data)
BOOL LLFloaterAnimPreview::validateLoopIn(LLUICtrl* ctrl, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
-
- if (!previewp->getEnabled()) return FALSE;
+ if (!previewp->getEnabled())
+ return FALSE;
F32 loop_in_value = (F32)previewp->childGetValue("loop_in_point").asReal();
F32 loop_out_value = (F32)previewp->childGetValue("loop_out_point").asReal();
@@ -892,8 +881,8 @@ BOOL LLFloaterAnimPreview::validateLoopIn(LLUICtrl* ctrl, void* data)
BOOL LLFloaterAnimPreview::validateLoopOut(LLUICtrl* spin, void* data)
{
LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
-
- if (!previewp->getEnabled()) return FALSE;
+ if (!previewp->getEnabled())
+ return FALSE;
F32 loop_out_value = (F32)previewp->childGetValue("loop_out_point").asReal();
F32 loop_in_value = (F32)previewp->childGetValue("loop_in_point").asReal();
@@ -948,11 +937,8 @@ void LLFloaterAnimPreview::refresh()
{
if (motionp)
{
- F32 fraction_complete;
- fraction_complete = motionp->getLastUpdateTime() / motionp->getDuration();
-
+ F32 fraction_complete = motionp->getLastUpdateTime() / motionp->getDuration();
childSetValue("playback_slider", fraction_complete);
- mLastSliderValue = fraction_complete;
}
mPlayButton->setImages(std::string("button_anim_pause.tga"),
std::string("button_anim_pause_selected.tga"));
@@ -965,7 +951,7 @@ void LLFloaterAnimPreview::refresh()
mPlayButton->setImages(std::string("button_anim_play.tga"),
std::string("button_anim_play_selected.tga"));
- mStopButton->setEnabled(FALSE);
+ mStopButton->setEnabled(TRUE); // stop also resets, leave enabled.
}
childEnable("ok_btn");
mAnimPreview->requestUpdate();
@@ -1038,12 +1024,12 @@ LLPreviewAnimation::LLPreviewAnimation(S32 width, S32 height) : LLDynamicTexture
mDummyAvatar = (LLVOAvatar*)gObjectList.createObjectViewer(LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
mDummyAvatar->createDrawable(&gPipeline);
mDummyAvatar->mIsDummy = TRUE;
- mDummyAvatar->mSpecialRenderMode = 2;
+ mDummyAvatar->mSpecialRenderMode = 1;
mDummyAvatar->setPositionAgent(LLVector3::zero);
mDummyAvatar->slamPosition();
mDummyAvatar->updateJointLODs();
mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
- mDummyAvatar->startMotion(ANIM_AGENT_STAND, 5.f);
+ mDummyAvatar->startMotion(ANIM_AGENT_STAND, BASE_ANIM_TIME_OFFSET);
mDummyAvatar->mSkirtLOD.setVisible(FALSE, TRUE);
gPipeline.markVisible(mDummyAvatar->mDrawable, *LLViewerCamera::getInstance());
@@ -1111,30 +1097,15 @@ BOOL LLPreviewAnimation::render()
//avatarp->setAnimationData("LookAtPoint", (void *)&mCameraRelPos);
- //RN: timestep must be zero, because paused animations will never initialize
- // av skeleton otherwise
- avatarp->setTimeStep(0.f);
- if (avatarp->areAnimationsPaused())
- {
- avatarp->updateMotion(TRUE);
- }
- else
- {
- avatarp->updateMotion();
- }
+ //SJB: Animation is updated in LLVOAvatar::updateCharacter
- LLVertexBuffer::unbind();
- avatarp->updateLOD();
-
-
- avatarp->mRoot.updateWorldMatrixChildren();
-
- stop_glerror();
-
- LLGLDepthTest gls_depth(GL_TRUE);
-
if (avatarp->mDrawable.notNull())
{
+ avatarp->updateLOD();
+
+ LLVertexBuffer::unbind();
+ LLGLDepthTest gls_depth(GL_TRUE);
+
LLDrawPoolAvatar *avatarPoolp = (LLDrawPoolAvatar *)avatarp->mDrawable->getFace(0)->getPool();
avatarp->dirtyMesh();
avatarPoolp->renderAvatars(avatarp); // renders only one avatar
diff --git a/indra/newview/llfloateranimpreview.h b/indra/newview/llfloateranimpreview.h
index 693e3f8fbfb216c707d9d4be94956639156f5ca5..d13dfdcdb816a1e00e476256cb592ee56d8129ff 100644
--- a/indra/newview/llfloateranimpreview.h
+++ b/indra/newview/llfloateranimpreview.h
@@ -118,7 +118,6 @@ class LLFloaterAnimPreview : public LLFloaterNameDesc
S32 mLastMouseY;
LLButton* mPlayButton;
LLButton* mStopButton;
- F32 mLastSliderValue;
LLRect mPreviewRect;
LLRectf mPreviewImageRect;
LLAssetID mMotionID;
diff --git a/indra/newview/llfloatergroups.cpp b/indra/newview/llfloatergroups.cpp
index a85b4ec0e94de1b7bd89e949017a17d095a714e5..ca3332e4ad5d7b9701044631c4ff7d6b8944a2ac 100644
--- a/indra/newview/llfloatergroups.cpp
+++ b/indra/newview/llfloatergroups.cpp
@@ -438,7 +438,8 @@ void init_group_list(LLScrollListCtrl* ctrl, const LLUUID& highlight_id, U64 pow
{
id = gAgent.mGroups.get(i).mID;
LLGroupData* group_datap = &gAgent.mGroups.get(i);
- if ((group_datap->mPowers & powers_mask) != 0) {
+ if ((powers_mask == GP_ALL_POWERS) || ((group_datap->mPowers & powers_mask) != 0))
+ {
std::string style = "NORMAL";
if(highlight_id == id)
{
diff --git a/indra/newview/llfloaterworldmap.cpp b/indra/newview/llfloaterworldmap.cpp
index d38121047a6ce0e47adb175f6e99019ef8b38033..d26acaa892f8b120f528458174f12e644ef59cd8 100644
--- a/indra/newview/llfloaterworldmap.cpp
+++ b/indra/newview/llfloaterworldmap.cpp
@@ -871,8 +871,6 @@ void LLFloaterWorldMap::buildLandmarkIDLists()
{
list->selectItemRange(1, -1);
list->operateOnSelection(LLCtrlListInterface::OP_DELETE);
-
- llassert_always(list->getItemCount() == 1) ;
}
mLandmarkItemIDList.reset();
diff --git a/indra/newview/llhudeffectlookat.cpp b/indra/newview/llhudeffectlookat.cpp
index ea7413ea3fa58b9795a23aaf7350d2d80d3fbfb9..7a1df7e3b2fb4f38a954aa85c899499a6b8d0d5a 100644
--- a/indra/newview/llhudeffectlookat.cpp
+++ b/indra/newview/llhudeffectlookat.cpp
@@ -503,8 +503,8 @@ void LLHUDEffectLookAt::render()
LLVector3 target = mTargetPos + ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->mHeadp->getWorldPosition();
glMatrixMode(GL_MODELVIEW);
- glPushMatrix();
- glTranslatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
+ gGL.pushMatrix();
+ gGL.translatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
glScalef(0.3f, 0.3f, 0.3f);
gGL.begin(LLVertexBuffer::LINES);
{
@@ -519,7 +519,7 @@ void LLHUDEffectLookAt::render()
gGL.vertex3f(0.f, 0.f, -1.f);
gGL.vertex3f(0.f, 0.f, 1.f);
} gGL.end();
- glPopMatrix();
+ gGL.popMatrix();
}
}
diff --git a/indra/newview/llhudeffectpointat.cpp b/indra/newview/llhudeffectpointat.cpp
index 93344db622b07df5899efffd08a481a61baa59b8..310b0331c99be963b91e685dc62d57f27b59f27a 100644
--- a/indra/newview/llhudeffectpointat.cpp
+++ b/indra/newview/llhudeffectpointat.cpp
@@ -331,8 +331,8 @@ void LLHUDEffectPointAt::render()
LLGLSNoTexture gls_no_texture;
LLVector3 target = mTargetPos + mSourceObject->getRenderPosition();
- glPushMatrix();
- glTranslatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
+ gGL.pushMatrix();
+ gGL.translatef(target.mV[VX], target.mV[VY], target.mV[VZ]);
glScalef(0.3f, 0.3f, 0.3f);
gGL.begin(LLVertexBuffer::LINES);
{
@@ -346,7 +346,7 @@ void LLHUDEffectPointAt::render()
gGL.vertex3f(0.f, 0.f, -1.f);
gGL.vertex3f(0.f, 0.f, 1.f);
} gGL.end();
- glPopMatrix();
+ gGL.popMatrix();
}
}
diff --git a/indra/newview/llimpanel.cpp b/indra/newview/llimpanel.cpp
index 8a8321f9a08abcc92d5e486ad6b1b16fee026998..754935edc6c4348e41133fba6c5f6ea83827289c 100644
--- a/indra/newview/llimpanel.cpp
+++ b/indra/newview/llimpanel.cpp
@@ -1215,6 +1215,12 @@ LLFloaterIMPanel::~LLFloaterIMPanel()
delete mVoiceChannel;
mVoiceChannel = NULL;
+
+ //delete focus lost callback
+ if(mInputEditor)
+ {
+ mInputEditor->setFocusLostCallback( NULL );
+ }
}
BOOL LLFloaterIMPanel::postBuild()
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index 8aa51ad048f21d48951b0f806a58df3d416ee1b6..d3671239bb49db041dfd595b4d664c290071a9c9 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -76,6 +76,7 @@
#include "llviewerinventory.h"
#include "llviewerobjectlist.h"
#include "llviewerwindow.h"
+#include "llvoavatar.h"
#include "llwearable.h"
#include "llwearablelist.h"
#include "llviewermessage.h"
diff --git a/indra/newview/llmemoryview.cpp b/indra/newview/llmemoryview.cpp
index ccaed78727997dbceec075a94d8d1a0a8f7790bc..75f05f6d0cf7dd8e83ed9a6f17c56a5a542312ff 100644
--- a/indra/newview/llmemoryview.cpp
+++ b/indra/newview/llmemoryview.cpp
@@ -41,6 +41,7 @@
#include "llfontgl.h"
#include "llmemtype.h"
+#include "llcharacter.h"
#include "llui.h"
#include "llviewercontrol.h"
#include "llstat.h"
@@ -120,6 +121,7 @@ static const struct mtv_display_info mtv_display_table[] =
{ LLMemType::MTYPE_SPACE_PARTITION, "Space Partition", &LLColor4::blue2 },
{ LLMemType::MTYPE_VERTEX_DATA, "Vertex Buffer", &LLColor4::blue3 },
{ LLMemType::MTYPE_AVATAR, "Avatar", &LLColor4::purple1 },
+ { LLMemType::MTYPE_ANIMATION, "Animation", &LLColor4::purple3 },
{ LLMemType::MTYPE_REGIONS, "Regions", &LLColor4::blue1 },
{ LLMemType::MTYPE_VOLUME, "Volume", &LLColor4::pink1 },
{ LLMemType::MTYPE_PRIMITIVE, "Profile", &LLColor4::pink2 },
@@ -208,10 +210,25 @@ void LLMemoryView::draw()
if (textw > labelwidth)
labelwidth = textw;
}
+
+ S32 num_avatars = 0;
+ S32 num_motions = 0;
+ S32 num_loading_motions = 0;
+ S32 num_loaded_motions = 0;
+ S32 num_active_motions = 0;
+ S32 num_deprecated_motions = 0;
+ for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
+ iter != LLCharacter::sInstances.end(); ++iter)
+ {
+ num_avatars++;
+ (*iter)->getMotionController().incMotionCounts(num_motions, num_loading_motions, num_loaded_motions, num_active_motions, num_deprecated_motions);
+ }
+
x = xleft;
- tdesc = llformat("Total Bytes: %d MB Overhead: %d KB",
- LLMemType::sTotalMem >> 20, LLMemType::sOverheadMem >> 10);
- LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
+ tdesc = llformat("Total Bytes: %d MB Overhead: %d KB Avs %d Motions:%d Loading:%d Loaded:%d Active:%d Dep:%d",
+ LLMemType::sTotalMem >> 20, LLMemType::sOverheadMem >> 10,
+ num_avatars, num_motions, num_loading_motions, num_loaded_motions, num_active_motions, num_deprecated_motions);
+ LLFontGL::sMonospace->renderUTF8(tdesc, 0, x, y, LLColor4::white, LLFontGL::LEFT, LLFontGL::TOP);
}
// Bars
diff --git a/indra/newview/llmutelist.cpp b/indra/newview/llmutelist.cpp
index e2b5c821ae0a6009b79ad7d8cdf5917325c6f865..5311a594fbc25faa5150d46d8c9473be4139c1e0 100644
--- a/indra/newview/llmutelist.cpp
+++ b/indra/newview/llmutelist.cpp
@@ -72,9 +72,6 @@
#include "llviewerobjectlist.h"
-std::map<LLUUID, F32> LLMuteList::sUserVolumeSettings;
-
-
// "emptymutelist"
class LLDispatchEmptyMuteList : public LLDispatchHandler
{
@@ -182,10 +179,19 @@ LLMuteList* LLMuteList::getInstance()
// LLMuteList()
//-----------------------------------------------------------------------------
LLMuteList::LLMuteList() :
- mIsLoaded(FALSE)
+ mIsLoaded(FALSE),
+ mUserVolumesLoaded(FALSE)
{
gGenericDispatcher.addHandler("emptymutelist", &sDispatchEmptyMuteList);
+}
+void LLMuteList::loadUserVolumes()
+{
+ // call once, after LLDir::setLindenUserDir() has been called
+ if (mUserVolumesLoaded)
+ return;
+ mUserVolumesLoaded = TRUE;
+
// load per-resident voice volume information
// conceptually, this is part of the mute list information, although it is only stored locally
std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "volume_settings.xml");
@@ -201,7 +207,7 @@ LLMuteList::LLMuteList() :
for (LLSD::map_const_iterator iter = settings_llsd.beginMap();
iter != settings_llsd.endMap(); ++iter)
{
- sUserVolumeSettings.insert(std::make_pair(LLUUID(iter->first), (F32)iter->second.asReal()));
+ mUserVolumeSettings.insert(std::make_pair(LLUUID(iter->first), (F32)iter->second.asReal()));
}
}
@@ -213,7 +219,7 @@ LLMuteList::~LLMuteList()
std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "volume_settings.xml");
LLSD settings_llsd;
- for(user_volume_map_t::iterator iter = sUserVolumeSettings.begin(); iter != sUserVolumeSettings.end(); ++iter)
+ for(user_volume_map_t::iterator iter = mUserVolumeSettings.begin(); iter != mUserVolumeSettings.end(); ++iter)
{
settings_llsd[iter->first.asString()] = iter->second;
}
@@ -668,6 +674,8 @@ BOOL LLMuteList::isMuted(const LLUUID& id, const std::string& name, U32 flags) c
//-----------------------------------------------------------------------------
void LLMuteList::requestFromServer(const LLUUID& agent_id)
{
+ loadUserVolumes();
+
std::string agent_id_string;
std::string filename;
agent_id.toString(agent_id_string);
@@ -705,15 +713,15 @@ void LLMuteList::cache(const LLUUID& agent_id)
void LLMuteList::setSavedResidentVolume(const LLUUID& id, F32 volume)
{
// store new value in volume settings file
- sUserVolumeSettings[id] = volume;
+ mUserVolumeSettings[id] = volume;
}
F32 LLMuteList::getSavedResidentVolume(const LLUUID& id)
{
const F32 DEFAULT_VOLUME = 0.5f;
-
- user_volume_map_t::iterator found_it = sUserVolumeSettings.find(id);
- if (found_it != sUserVolumeSettings.end())
+
+ user_volume_map_t::iterator found_it = mUserVolumeSettings.find(id);
+ if (found_it != mUserVolumeSettings.end())
{
return found_it->second;
}
diff --git a/indra/newview/llmutelist.h b/indra/newview/llmutelist.h
index cc6f5c9762d86ae922e91957ccb46ec7fc7c2b83..c1b887b8773a6239a36bf06a5d5a845d0c764078 100644
--- a/indra/newview/llmutelist.h
+++ b/indra/newview/llmutelist.h
@@ -131,6 +131,8 @@ class LLMuteList : public LLSingleton<LLMuteList>
F32 getSavedResidentVolume(const LLUUID& id);
private:
+ void loadUserVolumes();
+
BOOL loadFromFile(const std::string& filename);
BOOL saveToFile(const std::string& filename);
@@ -171,11 +173,12 @@ class LLMuteList : public LLSingleton<LLMuteList>
observer_set_t mObservers;
BOOL mIsLoaded;
+ BOOL mUserVolumesLoaded;
friend class LLDispatchEmptyMuteList;
typedef std::map<LLUUID, F32> user_volume_map_t;
- static user_volume_map_t sUserVolumeSettings;
+ user_volume_map_t mUserVolumeSettings;
};
class LLMuteListObserver
diff --git a/indra/newview/llpanellogin.cpp b/indra/newview/llpanellogin.cpp
index c252c54ad795321e5b1a97f6839d80be633642ab..a8dc35f99c4194edc33bf4bf71020cb90d33399a 100644
--- a/indra/newview/llpanellogin.cpp
+++ b/indra/newview/llpanellogin.cpp
@@ -777,9 +777,8 @@ void LLPanelLogin::getFields(std::string &firstname, std::string &lastname, std:
remember = sInstance->childGetValue("remember_check");
}
-
-// static. Return TRUE if user made a choice from the popup
-BOOL LLPanelLogin::getServer(std::string &server, S32 &domain_name)
+// static
+BOOL LLPanelLogin::isGridComboDirty()
{
BOOL user_picked = FALSE;
if (!sInstance)
@@ -789,25 +788,8 @@ BOOL LLPanelLogin::getServer(std::string &server, S32 &domain_name)
else
{
LLComboBox* combo = sInstance->getChild<LLComboBox>("server_combo");
- LLSD combo_val = combo->getValue();
- if (LLSD::TypeInteger == combo_val.type())
- {
- domain_name = combo->getValue().asInteger();
-
- if ((S32)GRID_INFO_OTHER == domain_name)
- {
- server = LLViewerLogin::getInstance()->getGridLabel();
- }
- }
- else
- {
- // no valid selection, return other
- domain_name = (S32)GRID_INFO_OTHER;
- server = combo_val.asString();
- }
user_picked = combo->isDirty();
}
-
return user_picked;
}
@@ -941,19 +923,13 @@ void LLPanelLogin::loadLoginPage()
curl_free(curl_version);
// Grid
- std::string grid;
- S32 grid_index;
- getServer( grid, grid_index );
+ char* curl_grid = curl_escape(LLViewerLogin::getInstance()->getGridLabel().c_str(), 0);
+ oStr << "&grid=" << curl_grid;
+ curl_free(curl_grid);
gViewerWindow->setMenuBackgroundColor(false, !LLViewerLogin::getInstance()->isInProductionGrid());
gLoginMenuBarView->setBackgroundColor(gMenuBarView->getBackgroundColor());
- if (!grid.empty())
- {
- char* curl_grid = curl_escape(grid.c_str(), 0);
- oStr << "&grid=" << curl_grid;
- curl_free(curl_grid);
- }
#if USE_VIEWER_AUTH
LLURLSimString::sInstance.parse();
@@ -1167,9 +1143,29 @@ void LLPanelLogin::onSelectServer(LLUICtrl*, void*)
{
// The user twiddled with the grid choice ui.
// apply the selection to the grid setting.
- std::string grid;
+ std::string grid_label;
S32 grid_index;
- getServer( grid, grid_index );
+
+ LLComboBox* combo = sInstance->getChild<LLComboBox>("server_combo");
+ LLSD combo_val = combo->getValue();
+
+ if (LLSD::TypeInteger == combo_val.type())
+ {
+ grid_index = combo->getValue().asInteger();
+
+ if ((S32)GRID_INFO_OTHER == grid_index)
+ {
+ // This happens if the user specifies a custom grid
+ // via command line.
+ grid_label = combo->getSimple();
+ }
+ }
+ else
+ {
+ // no valid selection, return other
+ grid_index = (S32)GRID_INFO_OTHER;
+ grid_label = combo_val.asString();
+ }
// This new seelction will override preset uris
// from the command line.
@@ -1178,11 +1174,10 @@ void LLPanelLogin::onSelectServer(LLUICtrl*, void*)
if(grid_index != GRID_INFO_OTHER)
{
vl->setGridChoice((EGridInfo)grid_index);
- grid = vl->getGridLabel();
}
else
{
- vl->setGridChoice(grid);
+ vl->setGridChoice(grid_label);
}
// grid changed so show new splash screen (possibly)
diff --git a/indra/newview/llpanellogin.h b/indra/newview/llpanellogin.h
index 69bf54ecc408548e6f3b383b56a9765aa42f18ac..2429ac0f1b60ba7d27dc30db634dba86aef81aa8 100644
--- a/indra/newview/llpanellogin.h
+++ b/indra/newview/llpanellogin.h
@@ -92,8 +92,8 @@ class LLPanelLogin:
static void getFields(std::string& firstname, std::string& lastname,
std::string& password, BOOL& remember);
- static BOOL getServer(std::string& server, S32& domain_name);
- static void getLocation(std::string& location);
+ static BOOL isGridComboDirty();
+ static void getLocation(std::string &location);
static void close();
diff --git a/indra/newview/llpreviewanim.cpp b/indra/newview/llpreviewanim.cpp
index 868278472f79291f7e8702c55980b1a2775fb8f5..4e3d102b0e2dd7c0aac6ab7f72cd519d10fd3f7d 100644
--- a/indra/newview/llpreviewanim.cpp
+++ b/indra/newview/llpreviewanim.cpp
@@ -194,6 +194,7 @@ void LLPreviewAnim::onClose(bool app_quitting)
if (motion)
{
+ // *TODO: minor memory leak here, user data is never deleted (Use real callbacks)
motion->setDeactivateCallback(NULL, (void *)NULL);
}
}
diff --git a/indra/newview/llselectmgr.cpp b/indra/newview/llselectmgr.cpp
index 755477830199063e971ab0d7e4df12695a61fb58..8ebaeb67585a762098233861e4764a132b64eaca 100644
--- a/indra/newview/llselectmgr.cpp
+++ b/indra/newview/llselectmgr.cpp
@@ -4855,18 +4855,9 @@ void LLSelectMgr::renderSilhouettes(BOOL for_hud)
for (S32 pass = 0; pass < 2; pass++)
{
- LLObjectSelection::iterator end_ = mSelectedObjects->end();
- S32 num_nodes = mSelectedObjects->getNumNodes() ;
- LLObjectSelection::iterator prev_iter = mSelectedObjects->end();
for (LLObjectSelection::iterator iter = mSelectedObjects->begin();
iter != mSelectedObjects->end(); iter++)
{
- llassert_always(end_ == mSelectedObjects->end()) ;//mSelectedObjects should not grow
- llassert_always(prev_iter != iter) ; //iter should move
- llassert_always(num_nodes > 0) ; //iter should not circle inside mSelectedObjects.
- num_nodes-- ;
- prev_iter = iter ;
-
LLSelectNode* node = *iter;
LLViewerObject* objectp = node->getObject();
if (!objectp)
diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index b6ef8337095c174d920dbe10667e62285ee1c913..a62b1ac56a3d494b95f00733969ae98ec4e435c5 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -1158,7 +1158,6 @@ void LLSpatialGroup::destroyGL()
mVertexBuffer = NULL;
mBufferMap.clear();
- mReflectionMap = NULL;
clearDrawMap();
if (mOcclusionQuery)
@@ -1350,7 +1349,6 @@ LLSpatialPartition::LLSpatialPartition(U32 data_mask, U32 buffer_usage)
mDepthMask = FALSE;
mSlopRatio = 0.25f;
mRenderByGroup = TRUE;
- mImageEnabled = FALSE;
mInfiniteFarClip = FALSE;
LLGLNamePool::registerPool(&sQueryPool);
@@ -1564,12 +1562,7 @@ class LLOctreeCull : public LLSpatialGroup::OctreeTraveler
virtual void preprocess(LLSpatialGroup* group)
{
- if (LLPipeline::sDynamicReflections &&
- group->mOctreeNode->getSize().mdV[0] == 16.0 &&
- group->mDistance < 64.f)
- {
- group->mSpatialPartition->markReimage(group);
- }
+
}
virtual void processGroup(LLSpatialGroup* group)
@@ -1837,76 +1830,6 @@ BOOL earlyFail(LLCamera* camera, LLSpatialGroup* group)
return TRUE;
}
-void LLSpatialPartition::markReimage(LLSpatialGroup* group)
-{
- if (mImageEnabled && group->isState(LLSpatialGroup::IMAGE_DIRTY))
- {
- if (!group->isState(LLSpatialGroup::IN_IMAGE_QUEUE))
- {
- group->setState(LLSpatialGroup::IN_IMAGE_QUEUE);
- mImageQueue.push(group);
- }
- }
-}
-
-void LLSpatialPartition::processImagery(LLCamera* camera)
-{
- if (!mImageEnabled)
- {
- return;
- }
-
- U32 process_count = 1;
-
- S32 pull_count = (S32) mImageQueue.size();
-
- while (process_count > 0 && pull_count > 0 && !mImageQueue.empty())
- {
- pull_count--;
- LLPointer<LLSpatialGroup> group = mImageQueue.front();
- mImageQueue.pop();
-
- if (group->isDead())
- {
- continue;
- }
-
- if (group->isState(LLSpatialGroup::GEOM_DIRTY))
- { //put it back
- mImageQueue.push(group);
- continue;
- }
-
- group->clearState(LLSpatialGroup::IN_IMAGE_QUEUE);
- if (LLPipeline::sDynamicReflections)
- {
- process_count--;
- LLVector3 origin = group->mBounds[0];
- /*LLVector3 at = camera->getOrigin()-origin;
- at.normVec();
- origin += at* (at * group->mBounds[1]);*/
-
- LLCamera cube_cam;
- cube_cam.setOrigin(origin);
- cube_cam.setFar(64.f);
-
- LLPointer<LLCubeMap> cube_map = group->mReflectionMap;
- group->mReflectionMap = NULL;
- if (cube_map.isNull())
- {
- cube_map = new LLCubeMap();
- cube_map->initGL();
- }
-
- gPipeline.generateReflectionMap(gPipeline.mCubeBuffer, cube_cam);
- gPipeline.blurReflectionMap(gPipeline.mCubeBuffer, cube_map);
- group->mReflectionMap = cube_map;
- group->setState(LLSpatialGroup::GEOM_DIRTY);
- }
-
- group->clearState(LLSpatialGroup::IMAGE_DIRTY);
- }
-}
void pushVerts(LLDrawInfo* params, U32 mask)
{
diff --git a/indra/newview/llspatialpartition.h b/indra/newview/llspatialpartition.h
index 6ea22c2f66fddd67b7d52d8a0dc120752014bb1c..7e872915b9ac271191b8ff61bb3aeec852880a4f 100644
--- a/indra/newview/llspatialpartition.h
+++ b/indra/newview/llspatialpartition.h
@@ -66,7 +66,6 @@ class LLDrawInfo : public LLRefCount
LLPointer<LLVertexBuffer> mVertexBuffer;
LLPointer<LLViewerImage> mTexture;
- LLPointer<LLCubeMap> mReflectionMap;
LLColor4U mGlowColor;
S32 mDebugColor;
const LLMatrix4* mTextureMatrix;
@@ -262,7 +261,6 @@ class LLSpatialGroup : public LLOctreeListener<LLDrawable>
LLPointer<LLVertexBuffer> mVertexBuffer;
F32* mOcclusionVerts;
GLuint mOcclusionQuery;
- LLPointer<LLCubeMap> mReflectionMap;
U32 mBufferUsage;
draw_map_t mDrawMap;
@@ -314,8 +312,6 @@ class LLSpatialPartition: public LLGeometryManager
virtual void rebuildGeom(LLSpatialGroup* group);
S32 cull(LLCamera &camera, std::vector<LLDrawable *>* results = NULL, BOOL for_select = FALSE); // Cull on arbitrary frustum
- void markReimage(LLSpatialGroup* group);
- void processImagery(LLCamera* camera);
BOOL isVisible(const LLVector3& v);
@@ -326,23 +322,12 @@ class LLSpatialPartition: public LLGeometryManager
void restoreGL();
void resetVertexBuffers();
-protected:
-
- typedef std::set<LLPointer<LLSpatialGroup> > spatial_group_set_t;
- spatial_group_set_t mSpatialGroups;
-
- typedef std::queue<LLPointer<LLSpatialGroup> > spatial_group_queue_t;
-
- //things that need an image update
- spatial_group_queue_t mImageQueue;
-
public:
LLSpatialGroup::OctreeNode* mOctree;
BOOL mOcclusionEnabled; // if TRUE, occlusion culling is performed
BOOL mInfiniteFarClip; // if TRUE, frustum culling ignores far clip plane
U32 mBufferUsage;
BOOL mRenderByGroup;
- BOOL mImageEnabled;
U32 mLODSeed;
U32 mLODPeriod; //number of frames between LOD updates for a given spatial group (staggered by mLODSeed)
U32 mVertexDataMask;
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 7fe55d6efdba46fd9cdc5b260fd8e420d2b8e204..ada8ab5fdcefef119c916db8bcf6fe27caab39b1 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -816,26 +816,11 @@ BOOL idle_startup()
if (show_connect_box)
{
- // TODO only set loginuri based on server choice if ! USE_VIEWER_AUTH
- std::string server_label;
- S32 domain_name_index;
- BOOL user_picked_server = LLPanelLogin::getServer( server_label, domain_name_index );
- if((EGridInfo)domain_name_index == GRID_INFO_OTHER)
+ if ( LLPanelLogin::isGridComboDirty() )
{
- // Since the grid chosen was an 'other', set the choice by string.
- LLViewerLogin::getInstance()->setGridChoice(server_label);
- }
- else
- {
- // Set the choice according to index.
- LLViewerLogin::getInstance()->setGridChoice((EGridInfo)domain_name_index);
- }
-
- if ( user_picked_server )
- { // User picked a grid from the popup, so clear the
- // stored uris and they will be re-generated from the GridChoice
+ // User picked a grid from the popup, so clear the
+ // stored uris and they will be reacquired from the grid choice.
sAuthUris.clear();
- LLViewerLogin::getInstance()->resetURIs();
}
std::string location;
@@ -2224,6 +2209,18 @@ BOOL idle_startup()
{
do_normal_idle = TRUE;
+ // Avoid generic Ruth avatar in Orientation Island by starting
+ // our outfit load as soon as possible. This will be replaced
+ // with a more definitive patch from featurettes-4 later. JC
+ if (gAgent.isFirstLogin()
+ && !gInitialOutfit.empty() // registration set up an outfit
+ && gAgent.getAvatarObject() // can't wear clothes until have obj
+ && !gAgent.isGenderChosen() ) // nothing already loaded
+ {
+ llinfos << "Wearing initial outfit " << gInitialOutfit << llendl;
+ callback_choose_gender(-1, NULL);
+ }
+
F32 timeout_frac = timeout.getElapsedTimeF32()/PRECACHING_DELAY;
// wait precache-delay and for agent's avatar or a lot longer.
if(((timeout_frac > 1.f) && gAgent.getAvatarObject())
@@ -2234,7 +2231,7 @@ BOOL idle_startup()
else
{
update_texture_fetch();
- set_startup_status(0.60f + 0.40f * timeout_frac,
+ set_startup_status(0.60f + 0.20f * timeout_frac,
"Loading world...",
gAgent.mMOTD);
}
@@ -2264,7 +2261,7 @@ BOOL idle_startup()
else
{
update_texture_fetch();
- set_startup_status(0.f + 0.25f * wearables_time / MAX_WEARABLES_TIME,
+ set_startup_status(0.80f + 0.20f * wearables_time / MAX_WEARABLES_TIME,
LLTrans::getString("LoginDownloadingClothing"),
gAgent.mMOTD);
}
diff --git a/indra/newview/llstartup.h b/indra/newview/llstartup.h
index b5de15d98310180e3a555f77878fabc323100c40..38319c8d8aa63b6207be60606922001f20237502 100644
--- a/indra/newview/llstartup.h
+++ b/indra/newview/llstartup.h
@@ -73,6 +73,8 @@ enum EStartupState{
// exported symbols
extern BOOL gAgentMovementCompleted;
extern LLPointer<LLImageGL> gStartImageGL;
+extern std::string gInitialOutfit;
+extern std::string gInitialOutfitGender; // "male" or "female"
class LLStartUp
{
diff --git a/indra/newview/lltexlayer.h b/indra/newview/lltexlayer.h
index 59a0660a947d9403ee6c5504942b6d318177e254..befb262a4c667acc7e52e5fc88c343d260760ceb 100644
--- a/indra/newview/lltexlayer.h
+++ b/indra/newview/lltexlayer.h
@@ -40,7 +40,6 @@
#include "lluuid.h"
#include "llviewerimage.h"
#include "llviewervisualparam.h"
-#include "llvoavatar.h"
#include "llwearable.h"
#include "v4color.h"
#include "llfloater.h"
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index f32e4dd531164a8e5db456357c36e7d5e518d711..9a043b8d15a807edb3cbbef9ef1b3cdec7204012 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -48,7 +48,6 @@
#include "llviewerregion.h"
//////////////////////////////////////////////////////////////////////////////
-
//static
class LLTextureFetchWorker : public LLWorkerClass
{
@@ -435,6 +434,7 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
LLTextureFetchWorker::~LLTextureFetchWorker()
{
+ llassert_always(LLWorkerClass::sDeleteLock) ;
// llinfos << "Destroy: " << mID
// << " Decoded=" << mDecodedDiscard
// << " Requested=" << mRequestedDiscard
@@ -1052,9 +1052,11 @@ bool LLTextureFetchWorker::processSimulatorPackets()
{
if (mLastPacket >= mFirstPacket)
{
+ llassert_always(mFormattedImage) ;
S32 buffer_size = mFormattedImage->getDataSize();
for (S32 i = mFirstPacket; i<=mLastPacket; i++)
{
+ llassert_always(mPackets[i]) ;
buffer_size += mPackets[i]->mSize;
}
bool have_all_data = mLastPacket >= mTotalPackets-1;
@@ -1436,13 +1438,16 @@ void LLTextureFetch::removeFromNetworkQueue(LLTextureFetchWorker* worker)
// call lockQueue() first!
void LLTextureFetch::removeRequest(LLTextureFetchWorker* worker, bool cancel)
{
- mRequestMap.erase(worker->mID);
+ size_t erased_1 = mRequestMap.erase(worker->mID);
+ llassert_always(erased_1 > 0) ;
size_t erased = mNetworkQueue.erase(worker->mID);
if (cancel && erased > 0)
{
mCancelQueue[worker->mHost].insert(worker->mID);
}
- worker->scheduleDelete();
+ llassert_always(!(worker->getFlags(LLWorkerClass::WCF_DELETE_REQUESTED))) ;
+
+ worker->scheduleDelete();
}
// call lockQueue() first!
diff --git a/indra/newview/lltoolpie.cpp b/indra/newview/lltoolpie.cpp
index 5954a7f0ff5a93797c18ff9aad5b782f8f9dec22..b6bcf9544df98a8f3d9ca4ea4ef0ca748a9fc383 100644
--- a/indra/newview/lltoolpie.cpp
+++ b/indra/newview/lltoolpie.cpp
@@ -309,7 +309,13 @@ BOOL LLToolPie::pickAndShowMenu(S32 x, S32 y, MASK mask, BOOL always_show)
}
else if (mHitObjectID == gAgent.getID() )
{
- llassert_always(gPieSelf) ;
+ if(!gPieSelf)
+ {
+ //either at very early startup stage or at late quitting stage,
+ //this event is ignored.
+ return TRUE ;
+ }
+
gPieSelf->show(x, y, mPieMouseButtonDown);
}
else if (object)
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index eec1fff94247f88b5e536c00b1e034eb55a39696..422546c811f821702c16fe12b2bdbd406b4433b3 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -447,7 +447,6 @@ void settings_setup_listeners()
gSavedSettings.getControl("RenderTerrainDetail")->getSignal()->connect(boost::bind(&handleTerrainDetailChanged, _1));
gSavedSettings.getControl("RenderAvatarVP")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _1));
gSavedSettings.getControl("VertexShaderEnable")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _1));
- gSavedSettings.getControl("RenderDynamicReflections")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _1));
gSavedSettings.getControl("RenderGlow")->getSignal()->connect(boost::bind(&handleReleaseGLBufferChanged, _1));
gSavedSettings.getControl("RenderGlow")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _1));
gSavedSettings.getControl("EnableRippleWater")->getSignal()->connect(boost::bind(&handleSetShaderChanged, _1));
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index b7b85105ccdf70af277250b05d9bed2387f09a54..d4249ce13542af7adc8752113b01702808a8495a 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -613,7 +613,6 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
if (!for_snapshot)
{
LLAppViewer::instance()->pingMainloopTimeout("Display:Imagery");
- gPipeline.processImagery(*LLViewerCamera::getInstance());
gPipeline.generateWaterReflection(*LLViewerCamera::getInstance());
}
@@ -823,6 +822,7 @@ void render_hud_attachments()
//cull, sort, and render hud objects
static LLCullResult result;
+ LLSpatialGroup::sNoDelete = TRUE;
gPipeline.updateCull(hud_cam, result);
gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_BUMP);
@@ -834,6 +834,8 @@ void render_hud_attachments()
gPipeline.renderGeom(hud_cam);
+ LLSpatialGroup::sNoDelete = FALSE;
+
render_hud_elements();
//restore type mask
gPipeline.setRenderTypeMask(mask);
diff --git a/indra/newview/llviewerjoint.cpp b/indra/newview/llviewerjoint.cpp
index 176bf9273aa213608cffa7d298dfec6df04224d2..71d98b73de69b64f42a4cb79b0dcce0efbb3218f 100644
--- a/indra/newview/llviewerjoint.cpp
+++ b/indra/newview/llviewerjoint.cpp
@@ -118,123 +118,124 @@ void LLViewerJoint::setValid( BOOL valid, BOOL recursive )
//--------------------------------------------------------------------
// renderSkeleton()
+// DEBUG (UNUSED)
//--------------------------------------------------------------------
-void LLViewerJoint::renderSkeleton(BOOL recursive)
-{
- F32 nc = 0.57735f;
-
- //----------------------------------------------------------------
- // push matrix stack
- //----------------------------------------------------------------
- glPushMatrix();
-
- //----------------------------------------------------------------
- // render the bone to my parent
- //----------------------------------------------------------------
- if (mComponents & SC_BONE)
- {
- drawBone();
- }
-
- //----------------------------------------------------------------
- // offset to joint position and
- // rotate to our orientation
- //----------------------------------------------------------------
- glLoadIdentity();
- glMultMatrixf( &getWorldMatrix().mMatrix[0][0] );
-
- //----------------------------------------------------------------
- // render joint axes
- //----------------------------------------------------------------
- if (mComponents & SC_AXES)
- {
- gGL.begin(LLVertexBuffer::LINES);
- gGL.color3f( 1.0f, 0.0f, 0.0f );
- gGL.vertex3f( 0.0f, 0.0f, 0.0f );
- gGL.vertex3f( 0.1f, 0.0f, 0.0f );
-
- gGL.color3f( 0.0f, 1.0f, 0.0f );
- gGL.vertex3f( 0.0f, 0.0f, 0.0f );
- gGL.vertex3f( 0.0f, 0.1f, 0.0f );
-
- gGL.color3f( 0.0f, 0.0f, 1.0f );
- gGL.vertex3f( 0.0f, 0.0f, 0.0f );
- gGL.vertex3f( 0.0f, 0.0f, 0.1f );
- gGL.end();
- }
-
- //----------------------------------------------------------------
- // render the joint graphic
- //----------------------------------------------------------------
- if (mComponents & SC_JOINT)
- {
- gGL.color3f( 1.0f, 1.0f, 0.0f );
-
- gGL.begin(LLVertexBuffer::TRIANGLES);
-
- // joint top half
- glNormal3f(nc, nc, nc);
- gGL.vertex3f(0.0f, 0.0f, 0.05f);
- gGL.vertex3f(0.05f, 0.0f, 0.0f);
- gGL.vertex3f(0.0f, 0.05f, 0.0f);
-
- glNormal3f(-nc, nc, nc);
- gGL.vertex3f(0.0f, 0.0f, 0.05f);
- gGL.vertex3f(0.0f, 0.05f, 0.0f);
- gGL.vertex3f(-0.05f, 0.0f, 0.0f);
+// void LLViewerJoint::renderSkeleton(BOOL recursive)
+// {
+// F32 nc = 0.57735f;
+
+// //----------------------------------------------------------------
+// // push matrix stack
+// //----------------------------------------------------------------
+// glPushMatrix();
+
+// //----------------------------------------------------------------
+// // render the bone to my parent
+// //----------------------------------------------------------------
+// if (mComponents & SC_BONE)
+// {
+// drawBone();
+// }
+
+// //----------------------------------------------------------------
+// // offset to joint position and
+// // rotate to our orientation
+// //----------------------------------------------------------------
+// glLoadIdentity();
+// glMultMatrixf( &getWorldMatrix().mMatrix[0][0] );
+
+// //----------------------------------------------------------------
+// // render joint axes
+// //----------------------------------------------------------------
+// if (mComponents & SC_AXES)
+// {
+// gGL.begin(LLVertexBuffer::LINES);
+// gGL.color3f( 1.0f, 0.0f, 0.0f );
+// gGL.vertex3f( 0.0f, 0.0f, 0.0f );
+// gGL.vertex3f( 0.1f, 0.0f, 0.0f );
+
+// gGL.color3f( 0.0f, 1.0f, 0.0f );
+// gGL.vertex3f( 0.0f, 0.0f, 0.0f );
+// gGL.vertex3f( 0.0f, 0.1f, 0.0f );
+
+// gGL.color3f( 0.0f, 0.0f, 1.0f );
+// gGL.vertex3f( 0.0f, 0.0f, 0.0f );
+// gGL.vertex3f( 0.0f, 0.0f, 0.1f );
+// gGL.end();
+// }
+
+// //----------------------------------------------------------------
+// // render the joint graphic
+// //----------------------------------------------------------------
+// if (mComponents & SC_JOINT)
+// {
+// gGL.color3f( 1.0f, 1.0f, 0.0f );
+
+// gGL.begin(LLVertexBuffer::TRIANGLES);
+
+// // joint top half
+// glNormal3f(nc, nc, nc);
+// gGL.vertex3f(0.0f, 0.0f, 0.05f);
+// gGL.vertex3f(0.05f, 0.0f, 0.0f);
+// gGL.vertex3f(0.0f, 0.05f, 0.0f);
+
+// glNormal3f(-nc, nc, nc);
+// gGL.vertex3f(0.0f, 0.0f, 0.05f);
+// gGL.vertex3f(0.0f, 0.05f, 0.0f);
+// gGL.vertex3f(-0.05f, 0.0f, 0.0f);
- glNormal3f(-nc, -nc, nc);
- gGL.vertex3f(0.0f, 0.0f, 0.05f);
- gGL.vertex3f(-0.05f, 0.0f, 0.0f);
- gGL.vertex3f(0.0f, -0.05f, 0.0f);
-
- glNormal3f(nc, -nc, nc);
- gGL.vertex3f(0.0f, 0.0f, 0.05f);
- gGL.vertex3f(0.0f, -0.05f, 0.0f);
- gGL.vertex3f(0.05f, 0.0f, 0.0f);
+// glNormal3f(-nc, -nc, nc);
+// gGL.vertex3f(0.0f, 0.0f, 0.05f);
+// gGL.vertex3f(-0.05f, 0.0f, 0.0f);
+// gGL.vertex3f(0.0f, -0.05f, 0.0f);
+
+// glNormal3f(nc, -nc, nc);
+// gGL.vertex3f(0.0f, 0.0f, 0.05f);
+// gGL.vertex3f(0.0f, -0.05f, 0.0f);
+// gGL.vertex3f(0.05f, 0.0f, 0.0f);
- // joint bottom half
- glNormal3f(nc, nc, -nc);
- gGL.vertex3f(0.0f, 0.0f, -0.05f);
- gGL.vertex3f(0.0f, 0.05f, 0.0f);
- gGL.vertex3f(0.05f, 0.0f, 0.0f);
-
- glNormal3f(-nc, nc, -nc);
- gGL.vertex3f(0.0f, 0.0f, -0.05f);
- gGL.vertex3f(-0.05f, 0.0f, 0.0f);
- gGL.vertex3f(0.0f, 0.05f, 0.0f);
+// // joint bottom half
+// glNormal3f(nc, nc, -nc);
+// gGL.vertex3f(0.0f, 0.0f, -0.05f);
+// gGL.vertex3f(0.0f, 0.05f, 0.0f);
+// gGL.vertex3f(0.05f, 0.0f, 0.0f);
+
+// glNormal3f(-nc, nc, -nc);
+// gGL.vertex3f(0.0f, 0.0f, -0.05f);
+// gGL.vertex3f(-0.05f, 0.0f, 0.0f);
+// gGL.vertex3f(0.0f, 0.05f, 0.0f);
- glNormal3f(-nc, -nc, -nc);
- gGL.vertex3f(0.0f, 0.0f, -0.05f);
- gGL.vertex3f(0.0f, -0.05f, 0.0f);
- gGL.vertex3f(-0.05f, 0.0f, 0.0f);
-
- glNormal3f(nc, -nc, -nc);
- gGL.vertex3f(0.0f, 0.0f, -0.05f);
- gGL.vertex3f(0.05f, 0.0f, 0.0f);
- gGL.vertex3f(0.0f, -0.05f, 0.0f);
+// glNormal3f(-nc, -nc, -nc);
+// gGL.vertex3f(0.0f, 0.0f, -0.05f);
+// gGL.vertex3f(0.0f, -0.05f, 0.0f);
+// gGL.vertex3f(-0.05f, 0.0f, 0.0f);
+
+// glNormal3f(nc, -nc, -nc);
+// gGL.vertex3f(0.0f, 0.0f, -0.05f);
+// gGL.vertex3f(0.05f, 0.0f, 0.0f);
+// gGL.vertex3f(0.0f, -0.05f, 0.0f);
- gGL.end();
- }
-
- //----------------------------------------------------------------
- // render children
- //----------------------------------------------------------------
- if (recursive)
- {
- for (child_list_t::iterator iter = mChildren.begin();
- iter != mChildren.end(); ++iter)
- {
- LLViewerJoint* joint = (LLViewerJoint*)(*iter);
- joint->renderSkeleton();
- }
- }
-
- //----------------------------------------------------------------
- // pop matrix stack
- //----------------------------------------------------------------
- glPopMatrix();
-}
+// gGL.end();
+// }
+
+// //----------------------------------------------------------------
+// // render children
+// //----------------------------------------------------------------
+// if (recursive)
+// {
+// for (child_list_t::iterator iter = mChildren.begin();
+// iter != mChildren.end(); ++iter)
+// {
+// LLViewerJoint* joint = (LLViewerJoint*)(*iter);
+// joint->renderSkeleton();
+// }
+// }
+
+// //----------------------------------------------------------------
+// // pop matrix stack
+// //----------------------------------------------------------------
+// glPopMatrix();
+// }
//--------------------------------------------------------------------
@@ -330,59 +331,60 @@ U32 LLViewerJoint::render( F32 pixelArea, BOOL first_pass )
//--------------------------------------------------------------------
// drawBone()
+// DEBUG (UNUSED)
//--------------------------------------------------------------------
-void LLViewerJoint::drawBone()
-{
- if ( mParent == NULL )
- return;
+// void LLViewerJoint::drawBone()
+// {
+// if ( mParent == NULL )
+// return;
- F32 boneSize = 0.02f;
+// F32 boneSize = 0.02f;
- // rotate to point to child (bone direction)
- glPushMatrix();
+// // rotate to point to child (bone direction)
+// glPushMatrix();
- LLVector3 boneX = getPosition();
- F32 length = boneX.normVec();
+// LLVector3 boneX = getPosition();
+// F32 length = boneX.normVec();
- LLVector3 boneZ(1.0f, 0.0f, 1.0f);
+// LLVector3 boneZ(1.0f, 0.0f, 1.0f);
- LLVector3 boneY = boneZ % boneX;
- boneY.normVec();
+// LLVector3 boneY = boneZ % boneX;
+// boneY.normVec();
- boneZ = boneX % boneY;
+// boneZ = boneX % boneY;
- LLMatrix4 rotateMat;
- rotateMat.setFwdRow( boneX );
- rotateMat.setLeftRow( boneY );
- rotateMat.setUpRow( boneZ );
- glMultMatrixf( &rotateMat.mMatrix[0][0] );
+// LLMatrix4 rotateMat;
+// rotateMat.setFwdRow( boneX );
+// rotateMat.setLeftRow( boneY );
+// rotateMat.setUpRow( boneZ );
+// glMultMatrixf( &rotateMat.mMatrix[0][0] );
- // render the bone
- gGL.color3f( 0.5f, 0.5f, 0.0f );
+// // render the bone
+// gGL.color3f( 0.5f, 0.5f, 0.0f );
- gGL.begin(LLVertexBuffer::TRIANGLES);
+// gGL.begin(LLVertexBuffer::TRIANGLES);
- gGL.vertex3f( length, 0.0f, 0.0f);
- gGL.vertex3f( 0.0f, boneSize, 0.0f);
- gGL.vertex3f( 0.0f, 0.0f, boneSize);
+// gGL.vertex3f( length, 0.0f, 0.0f);
+// gGL.vertex3f( 0.0f, boneSize, 0.0f);
+// gGL.vertex3f( 0.0f, 0.0f, boneSize);
- gGL.vertex3f( length, 0.0f, 0.0f);
- gGL.vertex3f( 0.0f, 0.0f, -boneSize);
- gGL.vertex3f( 0.0f, boneSize, 0.0f);
+// gGL.vertex3f( length, 0.0f, 0.0f);
+// gGL.vertex3f( 0.0f, 0.0f, -boneSize);
+// gGL.vertex3f( 0.0f, boneSize, 0.0f);
- gGL.vertex3f( length, 0.0f, 0.0f);
- gGL.vertex3f( 0.0f, -boneSize, 0.0f);
- gGL.vertex3f( 0.0f, 0.0f, -boneSize);
+// gGL.vertex3f( length, 0.0f, 0.0f);
+// gGL.vertex3f( 0.0f, -boneSize, 0.0f);
+// gGL.vertex3f( 0.0f, 0.0f, -boneSize);
- gGL.vertex3f( length, 0.0f, 0.0f);
- gGL.vertex3f( 0.0f, 0.0f, boneSize);
- gGL.vertex3f( 0.0f, -boneSize, 0.0f);
+// gGL.vertex3f( length, 0.0f, 0.0f);
+// gGL.vertex3f( 0.0f, 0.0f, boneSize);
+// gGL.vertex3f( 0.0f, -boneSize, 0.0f);
- gGL.end();
+// gGL.end();
- // restore matrix
- glPopMatrix();
-}
+// // restore matrix
+// glPopMatrix();
+// }
//--------------------------------------------------------------------
// isTransparent()
@@ -437,13 +439,13 @@ void LLViewerJoint::updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind)
}
}
-void LLViewerJoint::updateGeometry()
+void LLViewerJoint::updateJointGeometry()
{
for (child_list_t::iterator iter = mChildren.begin();
iter != mChildren.end(); ++iter)
{
LLViewerJoint* joint = (LLViewerJoint*)(*iter);
- joint->updateGeometry();
+ joint->updateJointGeometry();
}
}
diff --git a/indra/newview/llviewerjoint.h b/indra/newview/llviewerjoint.h
index 605f40979baa8710832c95e95cc8419aae748e24..07d1f4c235e61f6fdc6bfd7856305767f4e22c8d 100644
--- a/indra/newview/llviewerjoint.h
+++ b/indra/newview/llviewerjoint.h
@@ -60,7 +60,12 @@ class LLViewerJoint :
// Primarily for debugging and character setup
// Derived classes may add text/graphic output.
// Draw skeleton graphic for debugging and character setup
- virtual void renderSkeleton(BOOL recursive=TRUE);
+ void renderSkeleton(BOOL recursive=TRUE); // debug only (unused)
+
+ // Draws a bone graphic to the parent joint.
+ // Derived classes may add text/graphic output.
+ // Called by renderSkeleton().
+ void drawBone(); // debug only (unused)
// Render character hierarchy.
// Traverses the entire joint hierarchy, setting up
@@ -68,11 +73,6 @@ class LLViewerJoint :
// Derived classes may add text/graphic output.
virtual U32 render( F32 pixelArea, BOOL first_pass = TRUE ); // Returns triangle count
- // Draws a bone graphic to the parent joint.
- // Derived classes may add text/graphic output.
- // Called by renderSkeleton().
- virtual void drawBone();
-
// Returns true if this object is transparent.
// This is used to determine in which order to draw objects.
virtual BOOL isTransparent();
@@ -127,7 +127,7 @@ class LLViewerJoint :
virtual void updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pixel_area);
virtual void updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind = FALSE);
virtual BOOL updateLOD(F32 pixel_area, BOOL activate);
- virtual void updateGeometry();
+ virtual void updateJointGeometry();
virtual void dump();
void setVisible( BOOL visible, BOOL recursive );
diff --git a/indra/newview/llviewerjointattachment.cpp b/indra/newview/llviewerjointattachment.cpp
index ce61c3a2cd89e773a099a4f4f8fd7828cd4ca36c..0a2e328015e7d885a7537ea0db465a9708a6db5b 100644
--- a/indra/newview/llviewerjointattachment.cpp
+++ b/indra/newview/llviewerjointattachment.cpp
@@ -56,7 +56,6 @@ extern LLPipeline gPipeline;
// LLViewerJointAttachment()
//-----------------------------------------------------------------------------
LLViewerJointAttachment::LLViewerJointAttachment() :
-mJoint(NULL),
mAttachedObject(NULL),
mVisibleInFirst(FALSE),
mGroup(0),
diff --git a/indra/newview/llviewerjointattachment.h b/indra/newview/llviewerjointattachment.h
index aa41252ab9d386c565f2213c26925cdbb74eb041..81e72e18b3b12685331b7b6d1e34faf78e94d33a 100644
--- a/indra/newview/llviewerjointattachment.h
+++ b/indra/newview/llviewerjointattachment.h
@@ -68,7 +68,6 @@ class LLViewerJointAttachment :
// accessors
//
- void setJoint (LLJoint* joint) { mJoint = joint; }
void setPieSlice(S32 pie_slice) { mPieSlice = pie_slice; }
void setVisibleInFirstPerson(BOOL visibility) { mVisibleInFirst = visibility; }
BOOL getVisibleInFirstPerson() { return mVisibleInFirst; }
@@ -99,7 +98,6 @@ class LLViewerJointAttachment :
void calcLOD();
protected:
- LLJoint* mJoint;
// Backlink only; don't make this an LLPointer.
LLViewerObject* mAttachedObject;
BOOL mVisibleInFirst;
diff --git a/indra/newview/llviewerjointmesh.cpp b/indra/newview/llviewerjointmesh.cpp
index 8772149a86abac921033ea113b532d528806c2e9..95166278d5d08fbe9b69aea5464460bf334d6862 100644
--- a/indra/newview/llviewerjointmesh.cpp
+++ b/indra/newview/llviewerjointmesh.cpp
@@ -873,7 +873,7 @@ void LLViewerJointMesh::updateVectorize()
}
}
-void LLViewerJointMesh::updateGeometry()
+void LLViewerJointMesh::updateJointGeometry()
{
if (!(mValid
&& mMesh
diff --git a/indra/newview/llviewerjointmesh.h b/indra/newview/llviewerjointmesh.h
index 4cef1552ca6281b42604ed995a091e1cbff68303..3de9076c3d5c85e0de208e049c52fff17aefc461 100644
--- a/indra/newview/llviewerjointmesh.h
+++ b/indra/newview/llviewerjointmesh.h
@@ -142,7 +142,7 @@ class LLViewerJointMesh : public LLViewerJoint
/*virtual*/ void updateFaceSizes(U32 &num_vertices, U32& num_indices, F32 pixel_area);
/*virtual*/ void updateFaceData(LLFace *face, F32 pixel_area, BOOL damp_wind = FALSE);
/*virtual*/ BOOL updateLOD(F32 pixel_area, BOOL activate);
- /*virtual*/ void updateGeometry();
+ /*virtual*/ void updateJointGeometry();
/*virtual*/ void dump();
void setIsTransparent(BOOL is_transparent) { mIsTransparent = is_transparent; }
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 946167b90e8fe9e3dc235b274fa25da1d700806b..347ddac7977dbe75134fd87ca532aeeeb7e78d1d 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -1429,11 +1429,6 @@ void init_debug_rendering_menu(LLMenuGL* menu)
item = new LLMenuItemCheckGL("Run Multiple Threads", menu_toggle_control, NULL, menu_check_control, (void*)"RunMultipleThreads");
menu->append(item);
-#ifndef LL_RELEASE_FOR_DOWNLOAD
- item = new LLMenuItemCheckGL("Dynamic Reflections", menu_toggle_control, NULL, menu_check_control, (void*)"RenderDynamicReflections");
- menu->append(item);
-#endif
-
item = new LLMenuItemCheckGL("Cheesy Beacon", menu_toggle_control, NULL, menu_check_control, (void*)"CheesyBeacon");
menu->append(item);
diff --git a/indra/newview/llviewernetwork.cpp b/indra/newview/llviewernetwork.cpp
index d2d8f774a0d13d6586419ec7f845322705b93476..23bec370640f00681c415d222019a1b576230549 100644
--- a/indra/newview/llviewernetwork.cpp
+++ b/indra/newview/llviewernetwork.cpp
@@ -120,13 +120,8 @@ static LLGridData gGridInfo[GRID_INFO_COUNT] =
"" }
};
-#if LL_RELEASE_FOR_DOWNLOAD
- // Default userserver for production builds is agni
- const EGridInfo DEFAULT_GRID_CHOICE = GRID_INFO_AGNI;
-#else
- // Default userserver for development builds is none
- const EGridInfo DEFAULT_GRID_CHOICE = GRID_INFO_NONE;
-#endif
+const EGridInfo DEFAULT_GRID_CHOICE = GRID_INFO_AGNI;
+
unsigned char gMACAddress[MAC_ADDRESS_BYTES]; /* Flawfinder: ignore */
@@ -142,7 +137,7 @@ void LLViewerLogin::setGridChoice(EGridInfo grid)
llerrs << "Invalid grid index specified." << llendl;
}
- if(mGridChoice != grid)
+ if(mGridChoice != grid || gSavedSettings.getS32("ServerChoice") != grid)
{
mGridChoice = grid;
if(GRID_INFO_LOCAL == mGridChoice)
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 1c0aaec29a8be32557cd07912a7d47d662d30ba8..8cd295b8a828aefc5e32e6c4c99b555360be56de 100644
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -685,7 +685,6 @@ void LLViewerObjectList::update(LLAgent &agent, LLWorld &world)
idle_iter != idle_list.end(); idle_iter++)
{
objectp = *idle_iter;
- llassert_always(objectp) ;
if (!objectp->idleUpdate(agent, world, frame_time))
{
// If Idle Update returns false, kill object!
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index b90f665abd9c27f677d618489578a18d2b38581a..8588d99b2181cc53f69ec361886d076bdec8786b 100644
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -52,6 +52,7 @@
#include "lldebugview.h"
#include "llfasttimerview.h"
#include "llviewerregion.h"
+#include "llvoavatar.h"
#include "llfloaterhtml.h"
#include "llviewerwindow.h" // *TODO: remove, only used for width/height
#include "llworld.h"
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 068f4c86e9ef36f6ebfbb6310c27b77ad970321a..b37b66effafc3db88ab605846898b0f85110c8d3 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -4477,7 +4477,6 @@ BOOL LLViewerWindow::rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_hei
else
{
display(do_rebuild, scale_factor, subimage_x+(subimage_y*llceil(scale_factor)), use_fbo);
- render_ui_and_swap();
}
S32 subimage_x_offset = llclamp(buffer_x_offset - (subimage_x * window_width), 0, window_width);
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index 4b7ad71e80155017a1317d0962dcab0c6f4b6edc..cf2c094deda56ab79c26dfbb97568e1c31da31e3 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -886,52 +886,53 @@ LLVOAvatar::LLVOAvatar(
if (LLCharacter::sInstances.size() == 1)
{
LLKeyframeMotion::setVFS(gStaticVFS);
- addMotion( ANIM_AGENT_BUSY, LLNullMotion::create );
- addMotion( ANIM_AGENT_CROUCH, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_CROUCHWALK, LLKeyframeWalkMotion::create );
- addMotion( ANIM_AGENT_EXPRESS_AFRAID, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_ANGER, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_BORED, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_CRY, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_DISDAIN, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_EMBARRASSED, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_FROWN, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_KISS, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_LAUGH, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_OPEN_MOUTH, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_REPULSED, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_SAD, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_SHRUG, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_SMILE, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_SURPRISE, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_TONGUE_OUT, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_TOOTHSMILE, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_WINK, LLEmote::create );
- addMotion( ANIM_AGENT_EXPRESS_WORRY, LLEmote::create );
- addMotion( ANIM_AGENT_RUN, LLKeyframeWalkMotion::create );
- addMotion( ANIM_AGENT_STAND, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_STAND_1, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_STAND_2, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_STAND_3, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_STAND_4, LLKeyframeStandMotion::create );
- addMotion( ANIM_AGENT_STANDUP, LLKeyframeFallMotion::create );
- addMotion( ANIM_AGENT_TURNLEFT, LLKeyframeWalkMotion::create );
- addMotion( ANIM_AGENT_TURNRIGHT, LLKeyframeWalkMotion::create );
- addMotion( ANIM_AGENT_WALK, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_BUSY, LLNullMotion::create );
+ registerMotion( ANIM_AGENT_CROUCH, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_CROUCHWALK, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_EXPRESS_AFRAID, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_ANGER, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_BORED, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_CRY, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_DISDAIN, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_EMBARRASSED, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_FROWN, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_KISS, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_LAUGH, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_OPEN_MOUTH, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_REPULSED, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_SAD, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_SHRUG, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_SMILE, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_SURPRISE, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_TONGUE_OUT, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_TOOTHSMILE, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_WINK, LLEmote::create );
+ registerMotion( ANIM_AGENT_EXPRESS_WORRY, LLEmote::create );
+ registerMotion( ANIM_AGENT_RUN, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_STAND, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_STAND_1, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_STAND_2, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_STAND_3, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_STAND_4, LLKeyframeStandMotion::create );
+ registerMotion( ANIM_AGENT_STANDUP, LLKeyframeFallMotion::create );
+ registerMotion( ANIM_AGENT_TURNLEFT, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_TURNRIGHT, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_WALK, LLKeyframeWalkMotion::create );
// motions without a start/stop bit
- addMotion( ANIM_AGENT_BODY_NOISE, LLBodyNoiseMotion::create );
- addMotion( ANIM_AGENT_BREATHE_ROT, LLBreatheMotionRot::create );
- addMotion( ANIM_AGENT_EDITING, LLEditingMotion::create );
- addMotion( ANIM_AGENT_EYE, LLEyeMotion::create );
- addMotion( ANIM_AGENT_FEMALE_WALK, LLKeyframeWalkMotion::create );
- addMotion( ANIM_AGENT_FLY_ADJUST, LLFlyAdjustMotion::create );
- addMotion( ANIM_AGENT_HAND_MOTION, LLHandMotion::create );
- addMotion( ANIM_AGENT_HEAD_ROT, LLHeadRotMotion::create );
- addMotion( ANIM_AGENT_PELVIS_FIX, LLPelvisFixMotion::create );
- addMotion( ANIM_AGENT_SIT_FEMALE, LLKeyframeMotion::create );
- addMotion( ANIM_AGENT_TARGET, LLTargetingMotion::create );
- addMotion( ANIM_AGENT_WALK_ADJUST, LLWalkAdjustMotion::create );
+ registerMotion( ANIM_AGENT_BODY_NOISE, LLBodyNoiseMotion::create );
+ registerMotion( ANIM_AGENT_BREATHE_ROT, LLBreatheMotionRot::create );
+ registerMotion( ANIM_AGENT_EDITING, LLEditingMotion::create );
+ registerMotion( ANIM_AGENT_EYE, LLEyeMotion::create );
+ registerMotion( ANIM_AGENT_FEMALE_WALK, LLKeyframeWalkMotion::create );
+ registerMotion( ANIM_AGENT_FLY_ADJUST, LLFlyAdjustMotion::create );
+ registerMotion( ANIM_AGENT_HAND_MOTION, LLHandMotion::create );
+ registerMotion( ANIM_AGENT_HEAD_ROT, LLHeadRotMotion::create );
+ registerMotion( ANIM_AGENT_PELVIS_FIX, LLPelvisFixMotion::create );
+ registerMotion( ANIM_AGENT_SIT_FEMALE, LLKeyframeMotion::create );
+ registerMotion( ANIM_AGENT_TARGET, LLTargetingMotion::create );
+ registerMotion( ANIM_AGENT_WALK_ADJUST, LLWalkAdjustMotion::create );
+
}
if (gNoRender)
@@ -3362,7 +3363,7 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
// the rest should only be done occasionally for far away avatars
//--------------------------------------------------------------------
- if (!mIsSelf && sUseImpostors && !mNeedsAnimUpdate && !sFreezeCounter)
+ if (!mIsSelf && !mIsDummy && sUseImpostors && !mNeedsAnimUpdate && !sFreezeCounter)
{
F32 impostor_area = 256.f*512.f*(8.125f - LLVOAvatar::sLODFactor*8.f);
if (LLMuteList::getInstance()->isMuted(getID()))
@@ -3383,22 +3384,13 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
if (!visible)
{
- if (!mMotionController.isPaused())
- {
- mMotionController.pause();
- mMotionController.updateMotion();
- mMotionController.unpause();
- }
- else
- {
- mMotionController.updateMotion();
- }
+ updateMotions(LLCharacter::HIDDEN_UPDATE);
return FALSE;
}
}
-
+
// change animation time quanta based on avatar render load
- if (!mIsSelf)
+ if (!mIsSelf && !mIsDummy)
{
F32 time_quantum = clamp_rescale((F32)sInstances.size(), 10.f, 35.f, 0.f, 0.25f);
F32 pixel_area_scale = clamp_rescale(mPixelArea, 100, 5000, 1.f, 0.f);
@@ -3672,10 +3664,10 @@ BOOL LLVOAvatar::updateCharacter(LLAgent &agent)
mSpeed = speed;
// update animations
- {
- LLFastTimer t(LLFastTimer::FTM_UPDATE_ANIMATION);
- updateMotion();
- }
+ if (mSpecialRenderMode == 1) // Animation Preview
+ updateMotions(LLCharacter::FORCE_UPDATE);
+ else
+ updateMotions(LLCharacter::NORMAL_UPDATE);
// update head position
updateHeadOffset();
@@ -3851,9 +3843,6 @@ void LLVOAvatar::updateVisibility()
}
else
{
- // calculate avatar distance wrt head
- mDrawable->updateDistance(*LLViewerCamera::getInstance());
-
if (!mDrawable->getSpatialGroup() || mDrawable->getSpatialGroup()->isVisible())
{
visible = TRUE;
@@ -3870,8 +3859,7 @@ void LLVOAvatar::updateVisibility()
visible = FALSE;
}
}
- else
- if( !mFirstAppearanceMessageReceived )
+ else if( !mFirstAppearanceMessageReceived )
{
visible = FALSE;
}
@@ -4017,19 +4005,19 @@ U32 LLVOAvatar::renderSkinned(EAvatarRenderPass pass)
if (mNeedsSkin)
{
//generate animated mesh
- mLowerBodyLOD.updateGeometry();
- mUpperBodyLOD.updateGeometry();
+ mLowerBodyLOD.updateJointGeometry();
+ mUpperBodyLOD.updateJointGeometry();
if( isWearingWearableType( WT_SKIRT ) )
{
- mSkirtLOD.updateGeometry();
+ mSkirtLOD.updateJointGeometry();
}
if (!mIsSelf || gAgent.needsRenderHead())
{
- mEyeLashLOD.updateGeometry();
- mHeadLOD.updateGeometry();
- mHairLOD.updateGeometry();
+ mEyeLashLOD.updateJointGeometry();
+ mHeadLOD.updateJointGeometry();
+ mHairLOD.updateJointGeometry();
}
mNeedsSkin = FALSE;
@@ -5789,6 +5777,7 @@ void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent)
//-----------------------------------------------------------------------------
BOOL LLVOAvatar::updateJointLODs()
{
+ const F32 MAX_PIXEL_AREA = 100000000.f;
F32 lod_factor = (sLODFactor * AVATAR_LOD_TWEAK_RANGE + (1.f - AVATAR_LOD_TWEAK_RANGE));
F32 avatar_num_min_factor = clamp_rescale(sLODFactor, 0.f, 1.f, 0.25f, 0.6f);
F32 avatar_num_factor = clamp_rescale((F32)sNumVisibleAvatars, 8, 25, 1.f, avatar_num_min_factor);
@@ -5799,7 +5788,7 @@ BOOL LLVOAvatar::updateJointLODs()
{
if(gAgent.cameraCustomizeAvatar() || gAgent.cameraMouselook())
{
- mAdjustedPixelArea = 1000000;
+ mAdjustedPixelArea = MAX_PIXEL_AREA;
}
else
{
@@ -5808,7 +5797,7 @@ BOOL LLVOAvatar::updateJointLODs()
}
else if (mIsDummy)
{
- mAdjustedPixelArea = 1000000;
+ mAdjustedPixelArea = MAX_PIXEL_AREA;
}
else
{
@@ -6762,7 +6751,7 @@ void LLVOAvatar::dumpTotalLocalTextureByteCount()
BOOL LLVOAvatar::isVisible()
{
- return mDrawable.notNull() && mDrawable->isVisible();
+ return mDrawable.notNull() && (mDrawable->isVisible() || mIsDummy);
}
@@ -9724,7 +9713,8 @@ BOOL LLVOAvatar::updateLOD()
mDrawable->clearState(LLDrawable::REBUILD_GEOMETRY);
}
-
+ updateVisibility();
+
return res;
}
diff --git a/indra/newview/llvoavatar.h b/indra/newview/llvoavatar.h
index b991ae305eb39a210c60f381925d34afbb0fb7e4..54fd7d370f7751cc86dddb6aab0ced5590c10c0c 100644
--- a/indra/newview/llvoavatar.h
+++ b/indra/newview/llvoavatar.h
@@ -757,9 +757,9 @@ class LLVOAvatar :
//--------------------------------------------------------------------
F32 mSpeed;
- //
+ //--------------------------------------------------------------------
// Shadow stuff
- //
+ //--------------------------------------------------------------------
LLDrawable* mShadow;
BOOL mInAir;
LLFrameTimer mTimeInAir;
@@ -1013,7 +1013,7 @@ class LLVOAvatar :
LLHost getObjectHost() const;
S32 getLocalDiscardLevel( S32 index);
-//Ventrella
+
//-----------------------------------------------------------------------------------------------
// the Voice Visualizer is responsible for detecting the user's voice signal, and when the
// user speaks, it puts a voice symbol over the avatar's head, and triggering gesticulations
@@ -1021,7 +1021,6 @@ class LLVOAvatar :
private:
LLVoiceVisualizer * mVoiceVisualizer;
int mCurrentGesticulationLevel;
-//End Ventrella
private:
static S32 sFreezeCounter ;
diff --git a/indra/newview/llvoiceclient.h b/indra/newview/llvoiceclient.h
index 85a1674d985b3b73d42964367cca4f6745a91a06..f864b75bec3307438027c72ebb024a07b1522e41 100644
--- a/indra/newview/llvoiceclient.h
+++ b/indra/newview/llvoiceclient.h
@@ -31,8 +31,6 @@
#ifndef LL_VOICE_CLIENT_H
#define LL_VOICE_CLIENT_H
-// This would create a circular reference -- just do a forward definition of necessary class names.
-//#include "llvoavatar.h"
class LLVOAvatar;
class LLVivoxProtocolParser;
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 16c6bcdd5f92013d677483275060d6e81d661ca3..b84f8d8e4b4d57a4967de60efe554c4dc239a11f 100644
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -1952,7 +1952,6 @@ LLVolumePartition::LLVolumePartition()
mPartitionType = LLViewerRegion::PARTITION_VOLUME;
mSlopRatio = 0.25f;
mBufferUsage = GL_DYNAMIC_DRAW_ARB;
- mImageEnabled = TRUE;
}
LLVolumeBridge::LLVolumeBridge(LLDrawable* drawablep)
@@ -2045,7 +2044,6 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
draw_info->mGroup = group;
draw_info->mVSize = facep->getVirtualSize();
draw_vec.push_back(draw_info);
- draw_info->mReflectionMap = group->mReflectionMap;
draw_info->mTextureMatrix = tex_mat;
draw_info->mModelMatrix = model_mat;
draw_info->mGlowColor.setVec(0,0,0,glow);
@@ -2163,20 +2161,6 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
LLFastTimer ftm2(LLFastTimer::FTM_REBUILD_VOLUME_VB);
- //find reflection map
- if (group->mSpatialPartition->mImageEnabled && LLPipeline::sDynamicReflections)
- {
- if (group->mReflectionMap.isNull())
- {
- LLSpatialGroup* parent = group->getParent();
- while (parent && group->mReflectionMap.isNull())
- {
- group->mReflectionMap = parent->mReflectionMap;
- parent = parent->getParent();
- }
- }
- }
-
group->clearDrawMap();
mFaceList.clear();
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 539379c9a13e8bf7ee066ac910f6c2d4bd157631..3679b57da83efed59306ca1a222623db6630ddf7 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -217,7 +217,6 @@ BOOL LLPipeline::sDisableShaders = FALSE;
BOOL LLPipeline::sRenderBump = TRUE;
BOOL LLPipeline::sUseFarClip = TRUE;
BOOL LLPipeline::sSkipUpdate = FALSE;
-BOOL LLPipeline::sDynamicReflections = FALSE;
BOOL LLPipeline::sWaterReflections = FALSE;
BOOL LLPipeline::sRenderGlow = FALSE;
BOOL LLPipeline::sReflectionRender = FALSE;
@@ -474,15 +473,14 @@ void LLPipeline::createGLBuffers()
{
assertInitialized();
- if (LLPipeline::sDynamicReflections ||
- LLPipeline::sWaterReflections)
+ if (LLPipeline::sWaterReflections)
{ //water reflection texture
U32 res = (U32) gSavedSettings.getS32("RenderWaterRefResolution");
mWaterRef.allocate(res,res,GL_RGBA,TRUE);
mWaterDis.allocate(res,res,GL_RGBA,TRUE);
- if (LLPipeline::sDynamicReflections)
+#if 0 //cube map buffers (keep for future work)
{
//reflection map generation buffers
if (mCubeFrameBuffer == 0)
@@ -538,8 +536,10 @@ void LLPipeline::createGLBuffers()
}
}
}
+#endif
}
+
stop_glerror();
if (LLPipeline::sRenderGlow)
@@ -910,6 +910,15 @@ void LLPipeline::unlinkDrawable(LLDrawable *drawable)
}
mLights.erase(drawablep);
+ for (light_set_t::iterator iter = mNearbyLights.begin();
+ iter != mNearbyLights.end(); iter++)
+ {
+ if (iter->drawable == drawablep)
+ {
+ mNearbyLights.erase(iter);
+ break;
+ }
+ }
}
U32 LLPipeline::addObject(LLViewerObject *vobj)
@@ -1777,17 +1786,16 @@ void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
LLSpatialGroup* group = drawablep->getSpatialGroup();
if (!group || group->changeLOD())
{
- if (!drawablep->isActive() && drawablep->isVisible())
+ if (drawablep->isVisible() && !sSkipUpdate)
{
- if (!sSkipUpdate)
+ if (!drawablep->isActive())
{
drawablep->updateDistance(camera);
}
- }
- else if (drawablep->isAvatar() && drawablep->isVisible())
- {
- LLVOAvatar* vobj = (LLVOAvatar*) drawablep->getVObj().get();
- vobj->updateVisibility();
+ else if (drawablep->isAvatar())
+ {
+ drawablep->updateDistance(camera); // calls vobj->updateLOD() which calls LLVOAvatar::updateVisibility()
+ }
}
}
@@ -3147,6 +3155,11 @@ void LLPipeline::calcNearbyLights(LLCamera& camera)
{
assertInitialized();
+ if (LLPipeline::sReflectionRender)
+ {
+ return;
+ }
+
if (mLightingDetail >= 1)
{
// mNearbyLight (and all light_set_t's) are sorted such that
@@ -4801,21 +4814,6 @@ void LLPipeline::renderBloom(BOOL for_snapshot)
}
-void LLPipeline::processImagery(LLCamera& camera)
-{
- for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->getRegionList().begin();
- iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
- {
- LLViewerRegion* region = *iter;
- LLSpatialPartition* part = region->getSpatialPartition(LLViewerRegion::PARTITION_VOLUME);
- if (part)
- {
- part->processImagery(&camera);
- }
- }
-}
-
-
inline float sgn(float a)
{
if (a > 0.0F) return (1.0F);
@@ -5026,26 +5024,6 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
}
}
-LLCubeMap* LLPipeline::findReflectionMap(const LLVector3& location)
-{
- LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosAgent(location);
- if (region)
- {
- LLSpatialPartition* part = region->getSpatialPartition(LLViewerRegion::PARTITION_VOLUME);
- if (part)
- {
- LLSpatialGroup::OctreeNode* node = part->mOctree->getNodeAt(LLVector3d(location), 32.0);
- if (node)
- {
- LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
- return group->mReflectionMap;
- }
- }
- }
-
- return NULL;
-}
-
void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL texture)
{
for (LLCullResult::sg_list_t::iterator i = sCull->beginVisibleGroups(); i != sCull->endVisibleGroups(); ++i)
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index a96fe0865d175de7c11a9321a19dc4928b444f99..e98be79120d4c6d185a901b55ce6f05eb804135e 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -96,8 +96,6 @@ class LLPipeline
void bindScreenToTexture();
void renderBloom(BOOL for_snapshot);
- LLCubeMap* findReflectionMap(const LLVector3& location);
-
void init();
void cleanup();
BOOL isInit() { return mInitialized; };
@@ -183,7 +181,6 @@ class LLPipeline
void renderGeom(LLCamera& camera, BOOL forceVBOUpdate = FALSE);
void renderGeomDeferred();
- void processImagery(LLCamera& camera);
void generateWaterReflection(LLCamera& camera);
void renderHighlights();
void renderDebug();
@@ -371,7 +368,6 @@ class LLPipeline
static BOOL sUseFBO;
static BOOL sUseFarClip;
static BOOL sSkipUpdate; //skip lod updates
- static BOOL sDynamicReflections;
static BOOL sWaterReflections;
static BOOL sDynamicLOD;
static BOOL sReflectionRender;