Second Life viewer sources 1.18.1.2

8 files changed, 144 insertions, 107 deletions

diff --git a/linden/indra/llcharacter/lljoint.cpp b/linden/indra/llcharacter/lljoint.cpp
index 6141cc0..07c34a8 100644
--- a/linden/indra/llcharacter/lljoint.cpp
+++ b/linden/indra/llcharacter/lljoint.cpp
@@ -485,39 +485,6 @@ void LLJoint::setSkinOffset( const LLVector3& offset )
         mSkinOffset = offset;
 }
 
-//-----------------------------------------------------------------------------
-// setConstraintSilhouette()
-//-----------------------------------------------------------------------------
-void LLJoint::setConstraintSilhouette(LLDynamicArray<LLVector3>& silhouette)
-{
-        S32 i;
-
-        mConstraintSilhouette.reset();
-        for (i = 0; i < silhouette.count(); i++)
-        {
-                if (i % 2 == 1)
-                {
-                        // skip normals
-                        continue;
-                }
-                mConstraintSilhouette[i / 2] = silhouette[i];
-        }
-        LLQuaternion inv_parent_rotation = LLQuaternion::DEFAULT;
-
-        if (getParent())
-        {
-                inv_parent_rotation = ~getParent()->getWorldRotation();
-        }
-
-        for (i = 0; i < mConstraintSilhouette.count(); i++)
-        {
-                LLVector3 vert = mConstraintSilhouette[i];
-
-                vert -= getWorldPosition();
-                vert.normVec();
-                vert = vert * inv_parent_rotation;
-        }
-}
 
 //-----------------------------------------------------------------------------
 // clampRotation()
diff --git a/linden/indra/llcharacter/lljoint.h b/linden/indra/llcharacter/lljoint.h
index f188968..d1e0107 100644
--- a/linden/indra/llcharacter/lljoint.h
+++ b/linden/indra/llcharacter/lljoint.h
@@ -85,7 +85,6 @@ protected:
 
 public:
         U32                             mDirtyFlags;
-        BOOL                    mWorldRotationDirty;
         BOOL                    mUpdateXform;
 
         // describes the skin binding pose
@@ -93,8 +92,6 @@ public:
 
         S32                             mJointNum;
 
-        LLDynamicArray<LLVector3> mConstraintSilhouette;
-
         // child joints
         typedef std::list<LLJoint*> child_list_t;
         child_list_t mChildren;
@@ -171,8 +168,6 @@ public:
 
         LLXformMatrix   *getXform() { return &mXform; }
 
-        void setConstraintSilhouette(LLDynamicArray<LLVector3>& silhouette);
-
         void clampRotation(LLQuaternion old_rot, LLQuaternion new_rot);
 
         virtual BOOL isAnimatable() { return TRUE; }
diff --git a/linden/indra/llcharacter/llmotion.cpp b/linden/indra/llcharacter/llmotion.cpp
index b13ea60..40a30a4 100644
--- a/linden/indra/llcharacter/llmotion.cpp
+++ b/linden/indra/llcharacter/llmotion.cpp
@@ -126,6 +126,11 @@ void LLMotion::setDeactivateCallback( void (*cb)(void *), void* userdata )
         mDeactivateCallbackUserData = userdata;
 }
 
+BOOL LLMotion::isBlending()
+{
+        return mPose.getWeight() < 1.f;
+}
+
 //-----------------------------------------------------------------------------
 // activate()
 //-----------------------------------------------------------------------------
@@ -142,10 +147,16 @@ void LLMotion::activate()
 void LLMotion::deactivate()
 {
         mActive = FALSE;
+        mPose.setWeight(0.f);
 
         if (mDeactivateCallback) (*mDeactivateCallback)(mDeactivateCallbackUserData);
 
         onDeactivate();
 }
 
+BOOL LLMotion::canDeprecate()
+{
+        return TRUE;
+}
+
 // End
diff --git a/linden/indra/llcharacter/llmotion.h b/linden/indra/llcharacter/llmotion.h
index 48d402a..e60b0c0 100644
--- a/linden/indra/llcharacter/llmotion.h
+++ b/linden/indra/llcharacter/llmotion.h
@@ -99,13 +99,14 @@ public:
 
         void setStopped(BOOL stopped) { mStopped = stopped; }
 
+        BOOL isBlending();
+
         void activate();
 
         void deactivate();
 
         BOOL isActive() { return mActive; }
 
-
 public:
         //-------------------------------------------------------------------------
         // animation callbacks to be implemented by subclasses
@@ -145,6 +146,11 @@ public:
         // called when a motion is deactivated
         virtual void onDeactivate() = 0;
 
+        // can we crossfade this motion with a new instance when restarted?
+        // should ultimately always be TRUE, but lack of emote blending, etc
+        // requires this
+        virtual BOOL canDeprecate();
+
         // optional callback routine called when animation deactivated.
         void    setDeactivateCallback( void (*cb)(void *), void* userdata );
 
diff --git a/linden/indra/llcharacter/llmotioncontroller.cpp b/linden/indra/llcharacter/llmotioncontroller.cpp
index 2427fd8..aebfaf6 100644
--- a/linden/indra/llcharacter/llmotioncontroller.cpp
+++ b/linden/indra/llcharacter/llmotioncontroller.cpp
@@ -194,34 +194,44 @@ void LLMotionController::deleteAllMotions()
 //-----------------------------------------------------------------------------
 void LLMotionController::addLoadedMotion(LLMotion* motionp)
 {
+        std::set<LLUUID> motions_to_kill;
+
+        // gather all inactive, loaded motions
         if (mLoadedMotions.size() > MAX_MOTION_INSTANCES)
         {
                 // too many motions active this frame, kill all blenders
                 mPoseBlender.clearBlenders();
 
-                for (U32 i = 0; i < mLoadedMotions.size(); i++)
+                for (motion_list_t::iterator loaded_motion_it = mLoadedMotions.begin(); 
+                        loaded_motion_it != mLoadedMotions.end(); 
+                        ++loaded_motion_it)
                 {
-                        LLMotion* cur_motionp = mLoadedMotions.front();
-                        mLoadedMotions.pop_front();
+                        LLMotion* cur_motionp = *loaded_motion_it;
                         
                         // motion isn't playing, delete it
                         if (!isMotionActive(cur_motionp))
                         {
-                                mCharacter->requestStopMotion(cur_motionp);
-                                mAllMotions.erase(cur_motionp->getID());
-                                delete cur_motionp;
-                                if (mLoadedMotions.size() <= MAX_MOTION_INSTANCES)
-                                {
-                                        break;
-                                }
-                        }
-                        else
-                        {
-                                // put active motion on back
-                                mLoadedMotions.push_back(cur_motionp);
+                                motions_to_kill.insert(cur_motionp->getID());
                         }
                 }
         }
+
+        // clean up all inactive, loaded motions
+        for (std::set<LLUUID>::iterator motion_it = motions_to_kill.begin();
+                motion_it != motions_to_kill.end();
+                ++motion_it)
+        {
+                // look up the motion again by ID to get canonical instance
+                // and kill it only if that one is inactive
+                LLUUID motion_id = *motion_it;
+                LLMotion* motionp = findMotion(motion_id);
+                if (motionp && !isMotionActive(motionp))
+                {
+                        removeMotion(motion_id);
+                }
+        }
+
+        // add new motion to loaded list
         mLoadedMotions.push_back(motionp);
 }
 
@@ -280,14 +290,24 @@ BOOL LLMotionController::addMotion( const LLUUID& id, LLMotionConstructor constr
 void LLMotionController::removeMotion( const LLUUID& id)
 {
         LLMotion* motionp = findMotion(id);
+        
+        removeMotionInstance(motionp);
+
+        mAllMotions.erase(id);
+}
+
+// removes instance of a motion from all runtime structures, but does
+// not erase entry by ID, as this could be a duplicate instance
+// use removeMotion(id) to remove all references to a given motion by id.
+void LLMotionController::removeMotionInstance(LLMotion* motionp)
+{
         if (motionp)
         {
-                stopMotionLocally(id, TRUE);
+                stopMotionInstance(motionp, TRUE);
 
                 mLoadingMotions.erase(motionp);
                 mLoadedMotions.remove(motionp);
                 mActiveMotions.remove(motionp);
-                mAllMotions.erase(id);
                 delete motionp;
         }
 }
@@ -348,28 +368,39 @@ LLMotion* LLMotionController::createMotion( const LLUUID &id )
 //-----------------------------------------------------------------------------
 BOOL LLMotionController::startMotion(const LLUUID &id, F32 start_offset)
 {
-        // look for motion in our list of created motions
-        LLMotion *motion = createMotion(id);
+        // do we have an instance of this motion for this character?
+        LLMotion *motion = findMotion(id);
+
+        // motion that is stopping will be allowed to stop but
+        // replaced by a new instance of that motion
+        if (motion
+                && motion->canDeprecate()
+                && motion->getFadeWeight() > 0.01f // not LOD-ed out
+                && (motion->isBlending() || motion->getStopTime() != 0.f))
+        {
+                deprecateMotionInstance(motion);
+                // force creation of new instance
+                motion = NULL;
+        }
+
+        // create new motion instance
+        if (!motion)
+        {
+                motion = createMotion(id);
+        }
 
         if (!motion)
         {
                 return FALSE;
         }
-        //if the motion is already active, then we're done
-        else if (isMotionActive(motion)) // motion is playing and...
+        //if the motion is already active and allows deprecation, then let it keep playing
+        else if (motion->canDeprecate() && isMotionActive(motion))
         {       
-                if (motion->isStopped()) // motion has been stopped
-                {
-                        deactivateMotion(motion, false);
-                }
-                else if (mTime < motion->mSendStopTimestamp)    // motion is still active
-                {
-                        return TRUE;
-                }
+                return TRUE;
         }
 
 //      llinfos << "Starting motion " << name << llendl;
-        return activateMotion(motion, mTime - start_offset);
+        return activateMotionInstance(motion, mTime - start_offset);
 }
 
 
@@ -380,6 +411,12 @@ BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate
 {
         // if already inactive, return false
         LLMotion *motion = findMotion(id);
+
+        return stopMotionInstance(motion, stop_immediate);
+}
+
+BOOL LLMotionController::stopMotionInstance(LLMotion* motion, BOOL stop_immediate)
+{
         if (!motion)
         {
                 return FALSE;
@@ -396,7 +433,7 @@ BOOL LLMotionController::stopMotionLocally(const LLUUID &id, BOOL stop_immediate
 
                 if (stop_immediate)
                 {
-                        deactivateMotion(motion, false);
+                        deactivateMotionInstance(motion);
                 }
                 return TRUE;
         }
@@ -492,7 +529,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                 {
                         if (motionp->isStopped() && mTime > motionp->getStopTime() + motionp->getEaseOutDuration())
                         {
-                                deactivateMotion(motionp, false);
+                                deactivateMotionInstance(motionp);
                         }
                         else if (motionp->isStopped() && mTime > motionp->getStopTime())
                         {
@@ -510,7 +547,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                                 if (mLastTime <= motionp->mSendStopTimestamp)
                                 {
                                         mCharacter->requestStopMotion( motionp );
-                                        stopMotionLocally(motionp->getID(), FALSE);
+                                        stopMotionInstance(motionp, FALSE);
                                 }
                         }
                         else if (mTime >= motionp->mActivationTimestamp)
@@ -538,7 +575,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                                 if (mLastTime <= motionp->mSendStopTimestamp)
                                 {
                                         mCharacter->requestStopMotion( motionp );
-                                        stopMotionLocally(motionp->getID(), FALSE);
+                                        stopMotionInstance(motionp, FALSE);
                                 }
                         }
 
@@ -546,7 +583,8 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                         {
                                 if (motionp->isStopped() && mTime > motionp->getStopTime() + motionp->getEaseOutDuration())
                                 {
-                                        deactivateMotion(motionp, true);
+                                        posep->setWeight(0.f);
+                                        deactivateMotionInstance(motionp);
                                 }
                                 continue;
                         }
@@ -572,7 +610,8 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                         }
                         else
                         {
-                                deactivateMotion(motionp, true);
+                                posep->setWeight(0.f);
+                                deactivateMotionInstance(motionp);
                                 continue;
                         }
                 }
@@ -617,7 +656,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                                 if (mLastTime <= motionp->mSendStopTimestamp)
                                 {
                                         mCharacter->requestStopMotion( motionp );
-                                        stopMotionLocally(motionp->getID(), FALSE);
+                                        stopMotionInstance(motionp, FALSE);
                                 }
                         }
 
@@ -661,7 +700,7 @@ void LLMotionController::updateMotionsByType(LLMotion::LLMotionBlendType anim_ty
                                 // propagate this to the network
                                 // as not all viewers are guaranteed to have access to the same logic
                                 mCharacter->requestStopMotion( motionp );
-                                stopMotionLocally(motionp->getID(), FALSE);
+                                stopMotionInstance(motionp, FALSE);
                         }
 
                 }
@@ -733,7 +772,7 @@ void LLMotionController::updateMotion()
                         // this motion should be playing
                         if (!motionp->isStopped())
                         {
-                                activateMotion(motionp, mTime);
+                                activateMotionInstance(motionp, mTime);
                         }
                 }
                 else if (status == LLMotion::STATUS_FAILURE)
@@ -741,6 +780,7 @@ void LLMotionController::updateMotion()
                         llinfos << "Motion " << motionp->getID() << " init failed." << llendl;
                         sRegistry.markBad(motionp->getID());
                         mLoadingMotions.erase(curiter);
+
                         mAllMotions.erase(motionp->getID());
                         delete motionp;
                 }
@@ -773,9 +813,9 @@ void LLMotionController::updateMotion()
 
 
 //-----------------------------------------------------------------------------
-// activateMotion()
+// activateMotionInstance()
 //-----------------------------------------------------------------------------
-BOOL LLMotionController::activateMotion(LLMotion *motion, F32 time)
+BOOL LLMotionController::activateMotionInstance(LLMotion *motion, F32 time)
 {
         if (mLoadingMotions.find(motion) != mLoadingMotions.end())
         {
@@ -818,23 +858,38 @@ BOOL LLMotionController::activateMotion(LLMotion *motion, F32 time)
 }
 
 //-----------------------------------------------------------------------------
-// deactivateMotion()
+// deactivateMotionInstance()
 //-----------------------------------------------------------------------------
-BOOL LLMotionController::deactivateMotion(LLMotion *motion, bool remove_weight)
+BOOL LLMotionController::deactivateMotionInstance(LLMotion *motion)
 {
-        if( remove_weight )
+        motion->deactivate();
+
+        motion_set_t::iterator found_it = mDeprecatedMotions.find(motion);
+        if (found_it != mDeprecatedMotions.end())
         {
-                // immediately remove pose weighting instead of letting it time out
-                LLPose *posep = motion->getPose();
-                posep->setWeight(0.f);
+                // deprecated motions need to be completely excised
+                removeMotionInstance(motion);   
+                mDeprecatedMotions.erase(found_it);
+        }
+        else
+        {
+                // for motions that we are keeping, simply remove from active queue
+                mActiveMotions.remove(motion);
         }
-        
-        motion->deactivate();
-        mActiveMotions.remove(motion);
 
         return TRUE;
 }
 
+void LLMotionController::deprecateMotionInstance(LLMotion* motion)
+{
+        mDeprecatedMotions.insert(motion);
+
+        //fade out deprecated motion
+        stopMotionInstance(motion, FALSE);
+        //no longer canonical
+        mAllMotions.erase(motion->getID());
+}
+
 //-----------------------------------------------------------------------------
 // isMotionActive()
 //-----------------------------------------------------------------------------
@@ -857,7 +912,7 @@ bool LLMotionController::isMotionLoading(LLMotion* motion)
 //-----------------------------------------------------------------------------
 LLMotion *LLMotionController::findMotion(const LLUUID& id)
 {
-        return mAllMotions[id];
+        return get_if_there<LLUUID, LLMotion*>(mAllMotions, id, NULL);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/linden/indra/llcharacter/llmotioncontroller.h b/linden/indra/llcharacter/llmotioncontroller.h
index 959a16a..efc12d5 100644
--- a/linden/indra/llcharacter/llmotioncontroller.h
+++ b/linden/indra/llcharacter/llmotioncontroller.h
@@ -179,16 +179,21 @@ public:
         LLMotion *findMotion( const LLUUID& id );
 
 protected:
+        // 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 activateMotion(LLMotion *motion, F32 time);
-        BOOL deactivateMotion(LLMotion *motion, bool remove_weight);
+        BOOL activateMotionInstance(LLMotion *motion, F32 time);
+        BOOL deactivateMotionInstance(LLMotion *motion);
+        void deprecateMotionInstance(LLMotion* motion);
+        BOOL stopMotionInstance(LLMotion *motion, BOOL stop_imemdiate);
+        void removeMotionInstance(LLMotion* motion);
         void updateRegularMotions();
         void updateAdditiveMotions();
         void resetJointSignatures();
         void updateMotionsByType(LLMotion::LLMotionBlendType motion_type);
-protected:
 
+protected:
         F32                                     mTimeFactor;
         static LLMotionRegistry sRegistry;
         LLPoseBlender           mPoseBlender;
@@ -203,11 +208,13 @@ protected:
 //      Once an animations is loaded, it will be initialized and put on the mLoadedMotions deque.
 //      Any animation that is currently playing also sits in the mActiveMotions list.
 
-        std::map<LLUUID, LLMotion*>     mAllMotions;
+        typedef std::map<LLUUID, LLMotion*> motion_map_t;
+        motion_map_t    mAllMotions;
 
         motion_set_t            mLoadingMotions;
         motion_list_t           mLoadedMotions;
         motion_list_t           mActiveMotions;
+        motion_set_t            mDeprecatedMotions;
         
         LLFrameTimer            mTimer;
         F32                                     mTime;
diff --git a/linden/indra/llcharacter/llpose.cpp b/linden/indra/llcharacter/llpose.cpp
index ccedc1e..a07cd58 100644
--- a/linden/indra/llcharacter/llpose.cpp
+++ b/linden/indra/llcharacter/llpose.cpp
@@ -275,9 +275,9 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
                 joint_state_index < JSB_NUM_JOINT_STATES && mJointStates[joint_state_index] != NULL;
                 joint_state_index++)
         {
-                U32 current_usage = mJointStates[joint_state_index]->getUsage();
-                F32 current_weight = mJointStates[joint_state_index]->getWeight();
                 LLJointState* jsp = mJointStates[joint_state_index];
+                U32 current_usage = jsp->getUsage();
+                F32 current_weight = jsp->getWeight();
 
                 if (current_weight == 0.f)
                 {
@@ -292,17 +292,14 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
 
                                 // add in pos for this jointstate modulated by weight
                                 added_pos += jsp->getPosition() * (new_weight_sum - sum_weights[POS_WEIGHT]);
-                                //sum_weights[POS_WEIGHT] = new_weight_sum;
                         }
 
-                        // now do scale
                         if(current_usage & LLJointState::SCALE)
                         {
                                 F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[SCALE_WEIGHT]);
 
                                 // add in scale for this jointstate modulated by weight
                                 added_scale += jsp->getScale() * (new_weight_sum - sum_weights[SCALE_WEIGHT]);
-                                //sum_weights[SCALE_WEIGHT] = new_weight_sum;
                         }
 
                         if (current_usage & LLJointState::ROT)
@@ -311,7 +308,6 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
 
                                 // add in rotation for this jointstate modulated by weight
                                 added_rot = nlerp((new_weight_sum - sum_weights[ROT_WEIGHT]), added_rot, jsp->getRotation()) * added_rot;
-                                //sum_weights[ROT_WEIGHT] = new_weight_sum;
                         }
                 }
                 else
@@ -326,13 +322,13 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
                                         F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[POS_WEIGHT]);
 
                                         // blend positions from both
-                                        blended_pos = lerp(mJointStates[joint_state_index]->getPosition(), blended_pos, sum_weights[POS_WEIGHT] / new_weight_sum);
+                                        blended_pos = lerp(jsp->getPosition(), blended_pos, sum_weights[POS_WEIGHT] / new_weight_sum);
                                         sum_weights[POS_WEIGHT] = new_weight_sum;
                                 } 
                                 else
                                 {
                                         // copy position from current
-                                        blended_pos = mJointStates[joint_state_index]->getPosition();
+                                        blended_pos = jsp->getPosition();
                                         sum_weights[POS_WEIGHT] = current_weight;
                                 }
                         }
@@ -345,13 +341,13 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
                                         F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[SCALE_WEIGHT]);
 
                                         // blend scales from both
-                                        blended_scale = lerp(mJointStates[joint_state_index]->getScale(), blended_scale, sum_weights[SCALE_WEIGHT] / new_weight_sum);
+                                        blended_scale = lerp(jsp->getScale(), blended_scale, sum_weights[SCALE_WEIGHT] / new_weight_sum);
                                         sum_weights[SCALE_WEIGHT] = new_weight_sum;
                                 } 
                                 else
                                 {
                                         // copy scale from current
-                                        blended_scale = mJointStates[joint_state_index]->getScale();
+                                        blended_scale = jsp->getScale();
                                         sum_weights[SCALE_WEIGHT] = current_weight;
                                 }
                         }
@@ -364,13 +360,13 @@ void LLJointStateBlender::blendJointStates(BOOL apply_now)
                                         F32 new_weight_sum = llmin(1.f, current_weight + sum_weights[ROT_WEIGHT]);
 
                                         // blend rotations from both
-                                        blended_rot = nlerp(sum_weights[ROT_WEIGHT] / new_weight_sum, mJointStates[joint_state_index]->getRotation(), blended_rot);
+                                        blended_rot = nlerp(sum_weights[ROT_WEIGHT] / new_weight_sum, jsp->getRotation(), blended_rot);
                                         sum_weights[ROT_WEIGHT] = new_weight_sum;
                                 } 
                                 else
                                 {
                                         // copy rotation from current
-                                        blended_rot = mJointStates[joint_state_index]->getRotation();
+                                        blended_rot = jsp->getRotation();
                                         sum_weights[ROT_WEIGHT] = current_weight;
                                 }
                         }
diff --git a/linden/indra/llcharacter/llpose.h b/linden/indra/llcharacter/llpose.h
index f57f7de..4e1bb64 100644
--- a/linden/indra/llcharacter/llpose.h
+++ b/linden/indra/llcharacter/llpose.h
@@ -81,7 +81,7 @@ public:
         S32 getNumJointStates() const;
 };
 
-const S32 JSB_NUM_JOINT_STATES = 4;
+const S32 JSB_NUM_JOINT_STATES = 6;
 
 class LLJointStateBlender
 {