viewer#3070 Make mesh repository account for avatars

when calculating priority

Author: akleshchev

indra/newview/llmeshrepository.cpp

@@ -3783,7 +3783,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
         {
             //first request for this mesh
             mLoadingMeshes[detail][mesh_id].push_back(vobj);
-            mPendingRequests.push_back(PendingRequestLOD(mesh_params, detail));
+            mPendingRequests.emplace_back(new PendingRequestLOD(mesh_params, detail));
             LLMeshRepository::sLODPending++;
         }
     }
@@ -3842,6 +3842,44 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
     return detail;
 }
 
+F32 calculate_score(LLVOVolume* object)
+{
+    if (!object)
+    {
+        return -1.f;
+    }
+    LLDrawable* drawable = object->mDrawable;
+    if (!drawable)
+    {
+        return -1;
+    }
+    if (drawable->isState(LLDrawable::RIGGED) || object->isAttachment())
+    {
+        LLVOAvatar* avatar = object->getAvatar();
+        LLDrawable* av_drawable = avatar ? avatar->mDrawable : nullptr;
+        if (avatar && av_drawable)
+        {
+            // See LLVOVolume::calcLOD()
+            F32 radius;
+            if (avatar->isControlAvatar())
+            {
+                const LLVector3* box = avatar->getLastAnimExtents();
+                LLVector3 diag = box[1] - box[0];
+                radius = diag.magVec() * 0.5f;
+            }
+            else
+            {
+                // Volume in a rigged mesh attached to a regular avatar.
+                const LLVector3* box = avatar->getLastAnimExtents();
+                LLVector3 diag = box[1] - box[0];
+                radius = diag.magVec();
+            }
+            return radius / llmax(av_drawable->mDistanceWRTCamera, 1.f);
+        }
+    }
+    return drawable->getRadius() / llmax(drawable->mDistanceWRTCamera, 1.f);
+}
+
 void LLMeshRepository::notifyLoadedMeshes()
 { //called from main thread
     LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; //LL_RECORD_BLOCK_TIME(FTM_MESH_FETCH);
@@ -4041,15 +4079,10 @@ void LLMeshRepository::notifyLoadedMeshes()
                         F32 max_score = 0.f;
                         for (auto obj_iter = iter->second.begin(); obj_iter != iter->second.end(); ++obj_iter)
                         {
-                            LLVOVolume* object = *obj_iter;
-                            if (object)
+                            F32 cur_score = calculate_score(*obj_iter);
+                            if (cur_score >= 0.f)
                             {
-                                LLDrawable* drawable = object->mDrawable;
-                                if (drawable)
-                                {
-                                    F32 cur_score = drawable->getRadius()/llmax(drawable->mDistanceWRTCamera, 1.f);
-                                    max_score = llmax(max_score, cur_score);
-                                }
+                                max_score = llmax(max_score, cur_score);
                             }
                         }
 
@@ -4061,25 +4094,20 @@ void LLMeshRepository::notifyLoadedMeshes()
                     F32 max_score = 0.f;
                     for (auto obj_iter = iter->second.begin(); obj_iter != iter->second.end(); ++obj_iter)
                     {
-                        LLVOVolume* object = *obj_iter;
-                        if (object)
+                        F32 cur_score = calculate_score(*obj_iter);
+                        if (cur_score >= 0.f)
                         {
-                            LLDrawable* drawable = object->mDrawable;
-                            if (drawable)
-                            {
-                                F32 cur_score = drawable->getRadius() / llmax(drawable->mDistanceWRTCamera, 1.f);
-                                max_score = llmax(max_score, cur_score);
-                            }
+                            max_score = llmax(max_score, cur_score);
                         }
                     }
 
                     score_map[iter->first] = max_score;
                 }
 
                 //set "score" for pending requests
-                for (std::vector<PendingRequestBase>::iterator iter = mPendingRequests.begin(); iter != mPendingRequests.end(); ++iter)
+                for (std::unique_ptr<PendingRequestBase>& req_p : mPendingRequests)
                 {
-                    iter->setScore(score_map[iter->getId()]);
+                    req_p->setScore(score_map[req_p->getId()]);
                 }
 
                 //sort by "score"
@@ -4089,24 +4117,25 @@ void LLMeshRepository::notifyLoadedMeshes()
 
             while (!mPendingRequests.empty() && push_count > 0)
             {
-                PendingRequestBase& request = mPendingRequests.front();
-                switch (request.getRequestType())
+                std::unique_ptr<PendingRequestBase>& req_p = mPendingRequests.front();
+                switch (req_p->getRequestType())
                 {
                 case MESH_REQUEST_LOD:
                     {
-                        PendingRequestLOD& lod = (PendingRequestLOD&)request;
-                        mThread->loadMeshLOD(lod.mMeshParams, lod.mLOD);
+                        PendingRequestLOD* lod = (PendingRequestLOD*)req_p.get();
+                        mThread->loadMeshLOD(lod->mMeshParams, lod->mLOD);
                         LLMeshRepository::sLODPending--;
                         break;
                     }
                 case MESH_REQUEST_SKIN:
                     {
-                        PendingRequestUUID& skin = (PendingRequestUUID&)request;
-                        mThread->loadMeshSkinInfo(skin.getId());
+                        PendingRequestUUID* skin = (PendingRequestUUID*)req_p.get();
+                        mThread->loadMeshSkinInfo(skin->getId());
                         break;
                     }
 
                 default:
+                    LL_ERRS() << "Unknown request type in LLMeshRepository::notifyLoadedMeshes" << LL_ENDL;
                     break;
                 }
                 mPendingRequests.erase(mPendingRequests.begin());
@@ -4305,7 +4334,7 @@ const LLMeshSkinInfo* LLMeshRepository::getSkinInfo(const LLUUID& mesh_id, LLVOV
             {
                 //first request for this mesh
                 mLoadingSkins[mesh_id].push_back(requesting_obj);
-                mPendingRequests.push_back(PendingRequestUUID(mesh_id, MESH_REQUEST_SKIN));
+                mPendingRequests.emplace_back(new PendingRequestUUID(mesh_id, MESH_REQUEST_SKIN));
             }
         }
     }

indra/newview/llmeshrepository.h

@@ -212,9 +212,9 @@ class PendingRequestBase
 public:
     struct CompareScoreGreater
     {
-        bool operator()(const PendingRequestBase& lhs, const PendingRequestBase& rhs)
+        bool operator()(const std::unique_ptr<PendingRequestBase>& lhs, const std::unique_ptr<PendingRequestBase>& rhs)
         {
-            return lhs.mScore > rhs.mScore; // greatest = first
+            return lhs->mScore > rhs->mScore; // greatest = first
         }
     };
 
@@ -229,7 +229,7 @@ class PendingRequestBase
     void setScore(F32 score) { mScore = score; }
     F32 getScore() const { return mScore; }
     LLUUID getId() const { return mId; }
-    virtual EMeshRequestType getRequestType() const { return MESH_REQUEST_UKNOWN; }
+    virtual EMeshRequestType getRequestType() const = 0;
 
 protected:
     F32 mScore;
@@ -760,7 +760,8 @@ class LLMeshRepository
 
     LLMutex*                    mMeshMutex;
 
-    std::vector<PendingRequestBase> mPendingRequests;
+    typedef std::vector <std::unique_ptr<PendingRequestBase> > pending_requests_vec;
+    pending_requests_vec mPendingRequests;
 
     //list of mesh ids awaiting skin info
     typedef boost::unordered_map<LLUUID, std::vector<LLVOVolume*> > skin_load_map;