Merge branch 'release/2026.01' into maxim/2025.07-Flat-UI

1 files changed, 297 insertions, 344 deletions

diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index 8d5f94cdbb..c0b1a5326a 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -256,6 +256,7 @@
 //     mDecompositionRequests   mMutex        rw.repo.mMutex, ro.repo.none [5]
 //     mPhysicsShapeRequests    mMutex        rw.repo.mMutex, ro.repo.none [5]
 //     mDecompositionQ          mMutex        rw.repo.mLoadedMutex, rw.main.mLoadedMutex [5] (was:  [0])
+//     mPhysicsQ                mMutex        rw.repo.mLoadedMutex, rw.main.mLoadedMutex [5] (was:  [0])
 //     mHeaderReqQ              mMutex        ro.repo.none [5], rw.repo.mMutex, rw.any.mMutex
 //     mLODReqQ                 mMutex        ro.repo.none [5], rw.repo.mMutex, rw.any.mMutex
 //     mUnavailableQ            mMutex        rw.repo.none [0], ro.main.none [5], rw.main.mLoadedMutex
@@ -653,12 +654,10 @@ public:
           mRequestedBytes(requested_bytes)
         {}
 
-    virtual ~LLMeshHandlerBase()
-        {}
+    virtual ~LLMeshHandlerBase() = default;
 
-protected:
-    LLMeshHandlerBase(const LLMeshHandlerBase &);               // Not defined
-    void operator=(const LLMeshHandlerBase &);                  // Not defined
+    LLMeshHandlerBase(const LLMeshHandlerBase &) = delete;
+    LLMeshHandlerBase& operator=(const LLMeshHandlerBase&) = delete;
 
 public:
     virtual void onCompleted(LLCore::HttpHandle handle, LLCore::HttpResponse * response);
@@ -692,9 +691,8 @@ public:
     }
     virtual ~LLMeshHeaderHandler();
 
-protected:
-    LLMeshHeaderHandler(const LLMeshHeaderHandler &);           // Not defined
-    void operator=(const LLMeshHeaderHandler &);                // Not defined
+    LLMeshHeaderHandler(const LLMeshHeaderHandler&) = delete;
+    LLMeshHeaderHandler& operator=(const LLMeshHeaderHandler&) = delete;
 
 public:
     virtual void processData(LLCore::BufferArray * body, S32 body_offset, U8 * data, S32 data_size);
@@ -718,9 +716,8 @@ public:
         }
     virtual ~LLMeshLODHandler();
 
-protected:
-    LLMeshLODHandler(const LLMeshLODHandler &);                 // Not defined
-    void operator=(const LLMeshLODHandler &);                   // Not defined
+    LLMeshLODHandler(const LLMeshLODHandler&) = delete;
+    LLMeshLODHandler& operator=(const LLMeshLODHandler&) = delete;
 
 public:
     virtual void processData(LLCore::BufferArray * body, S32 body_offset, U8 * data, S32 data_size);
@@ -749,9 +746,8 @@ public:
     }
     virtual ~LLMeshSkinInfoHandler();
 
-protected:
-    LLMeshSkinInfoHandler(const LLMeshSkinInfoHandler &);       // Not defined
-    void operator=(const LLMeshSkinInfoHandler &);              // Not defined
+    LLMeshSkinInfoHandler(const LLMeshSkinInfoHandler&) = delete;
+    LLMeshSkinInfoHandler& operator=(const LLMeshSkinInfoHandler&) = delete;
 
     void processSkin(U8* data, S32 data_size);
 
@@ -777,9 +773,8 @@ public:
     {}
     virtual ~LLMeshDecompositionHandler();
 
-protected:
-    LLMeshDecompositionHandler(const LLMeshDecompositionHandler &);     // Not defined
-    void operator=(const LLMeshDecompositionHandler &);                 // Not defined
+    LLMeshDecompositionHandler(const LLMeshDecompositionHandler&) = delete;
+    LLMeshDecompositionHandler& operator=(const LLMeshDecompositionHandler&) = delete;
 
 public:
     virtual void processData(LLCore::BufferArray * body, S32 body_offset, U8 * data, S32 data_size);
@@ -803,9 +798,8 @@ public:
     {}
     virtual ~LLMeshPhysicsShapeHandler();
 
-protected:
-    LLMeshPhysicsShapeHandler(const LLMeshPhysicsShapeHandler &);   // Not defined
-    void operator=(const LLMeshPhysicsShapeHandler &);              // Not defined
+    LLMeshPhysicsShapeHandler(const LLMeshPhysicsShapeHandler&) = delete;
+    LLMeshPhysicsShapeHandler& operator=(const LLMeshPhysicsShapeHandler&) = delete;
 
 public:
     virtual void processData(LLCore::BufferArray * body, S32 body_offset, U8 * data, S32 data_size);
@@ -942,20 +936,20 @@ LLMeshRepoThread::LLMeshRepoThread()
     mSkinMapMutex = new LLMutex();
     mSignal = new LLCondition();
     mHttpRequest = new LLCore::HttpRequest;
-    mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
+    mHttpOptions = std::make_shared<LLCore::HttpOptions>();
     mHttpOptions->setTransferTimeout(SMALL_MESH_XFER_TIMEOUT);
     mHttpOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
-    mHttpLargeOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
+    mHttpLargeOptions = std::make_shared<LLCore::HttpOptions>();
     mHttpLargeOptions->setTransferTimeout(LARGE_MESH_XFER_TIMEOUT);
     mHttpLargeOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
-    mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
+    mHttpHeaders = std::make_shared<LLCore::HttpHeaders>();
     mHttpHeaders->append(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_VND_LL_MESH);
     mHttpPolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_MESH2);
     mHttpLargePolicyClass = app_core_http.getPolicy(LLAppCoreHttp::AP_LARGE_MESH);
 
     // Lod processing is expensive due to the number of requests
     // and a need to do expensive cacheOptimize().
-    mMeshThreadPool.reset(new LL::ThreadPool("MeshLodProcessing", 2));
+    mMeshThreadPool = std::make_unique<LL::ThreadPool>("MeshLodProcessing", 2);
     mMeshThreadPool->start();
 }
 
@@ -982,6 +976,12 @@ LLMeshRepoThread::~LLMeshRepoThread()
         mDecompositionQ.pop_front();
     }
 
+    while (!mPhysicsQ.empty())
+    {
+        delete mPhysicsQ.front();
+        mPhysicsQ.pop_front();
+    }
+
     delete mHttpRequest;
     mHttpRequest = nullptr;
     delete mMutex;
@@ -1646,7 +1646,7 @@ bool LLMeshRepoThread::fetchMeshSkinInfo(const LLUUID& mesh_id)
 
             if (!http_url.empty())
             {
-                LLMeshHandlerBase::ptr_t handler(new LLMeshSkinInfoHandler(mesh_id, offset, size));
+                LLMeshHandlerBase::ptr_t handler = std::make_shared<LLMeshSkinInfoHandler>(mesh_id, offset, size);
                 LLCore::HttpHandle handle = getByteRange(http_url, offset, size, handler);
                 if (LLCORE_HTTP_HANDLE_INVALID == handle)
                 {
@@ -1754,7 +1754,7 @@ bool LLMeshRepoThread::fetchMeshDecomposition(const LLUUID& mesh_id)
 
             if (!http_url.empty())
             {
-                LLMeshHandlerBase::ptr_t handler(new LLMeshDecompositionHandler(mesh_id, offset, size));
+                LLMeshHandlerBase::ptr_t handler = std::make_shared<LLMeshDecompositionHandler>(mesh_id, offset, size);
                 LLCore::HttpHandle handle = getByteRange(http_url, offset, size, handler);
                 if (LLCORE_HTTP_HANDLE_INVALID == handle)
                 {
@@ -1853,7 +1853,7 @@ bool LLMeshRepoThread::fetchMeshPhysicsShape(const LLUUID& mesh_id)
 
             if (!http_url.empty())
             {
-                LLMeshHandlerBase::ptr_t handler(new LLMeshPhysicsShapeHandler(mesh_id, offset, size));
+                LLMeshHandlerBase::ptr_t handler = std::make_shared<LLMeshPhysicsShapeHandler>(mesh_id, offset, size);
                 LLCore::HttpHandle handle = getByteRange(http_url, offset, size, handler);
                 if (LLCORE_HTTP_HANDLE_INVALID == handle)
                 {
@@ -1981,7 +1981,7 @@ bool LLMeshRepoThread::fetchMeshHeader(const LLVolumeParams& mesh_params)
         //within the first 4KB
         //NOTE -- this will break of headers ever exceed 4KB
 
-        LLMeshHandlerBase::ptr_t handler(new LLMeshHeaderHandler(mesh_params, 0, MESH_HEADER_SIZE));
+        LLMeshHandlerBase::ptr_t handler = std::make_shared<LLMeshHeaderHandler>(mesh_params, 0, MESH_HEADER_SIZE);
         LLCore::HttpHandle handle = getByteRange(http_url, 0, MESH_HEADER_SIZE, handler);
         if (LLCORE_HTTP_HANDLE_INVALID == handle)
         {
@@ -2157,7 +2157,7 @@ bool LLMeshRepoThread::fetchMeshLOD(const LLVolumeParams& mesh_params, S32 lod)
             {
                 LL_DEBUGS(LOG_MESH) << "Mesh/Cache: Mesh body for ID " << mesh_id << " - was retrieved from the simulator." << LL_ENDL;
 
-                LLMeshHandlerBase::ptr_t handler(new LLMeshLODHandler(mesh_params, lod, offset, size));
+                LLMeshHandlerBase::ptr_t handler = std::make_shared<LLMeshLODHandler>(mesh_params, lod, offset, size);
                 LLCore::HttpHandle handle = getByteRange(http_url, offset, size, handler);
                 if (LLCORE_HTTP_HANDLE_INVALID == handle)
                 {
@@ -2565,12 +2565,12 @@ EMeshProcessingResult LLMeshRepoThread::physicsShapeReceived(const LLUUID& mesh_
 
     {
         LLMutexLock lock(mLoadedMutex);
-        mDecompositionQ.push_back(d);
+        mPhysicsQ.push_back(d);
     }
     return MESH_OK;
 }
 
-LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data, const LLMeshUploadThread::lod_sources_map_t& sources_list,
+LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list_t& data, const LLMeshUploadThread::lod_sources_map_t& sources_list,
                                        LLVector3& scale, bool upload_textures,
                                        bool upload_skin, bool upload_joints, bool lock_scale_if_joint_position,
                                        const std::string & upload_url, LLUUID destination_folder_id, bool do_upload,
@@ -2604,11 +2604,11 @@ LLMeshUploadThread::LLMeshUploadThread(LLMeshUploadThread::instance_list& data,
     mMeshUploadTimeOut = gSavedSettings.getS32("MeshUploadTimeOut");
 
     mHttpRequest = new LLCore::HttpRequest;
-    mHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions);
+    mHttpOptions = std::make_shared<LLCore::HttpOptions>();
     mHttpOptions->setTransferTimeout(mMeshUploadTimeOut);
     mHttpOptions->setUseRetryAfter(gSavedSettings.getBOOL("MeshUseHttpRetryAfter"));
     mHttpOptions->setRetries(UPLOAD_RETRY_LIMIT);
-    mHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders);
+    mHttpHeaders = std::make_shared<LLCore::HttpHeaders>();
     mHttpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_LLSD_XML);
     mHttpPolicyClass = LLAppViewer::instance()->getAppCoreHttp().getPolicy(LLAppCoreHttp::AP_UPLOADS);
 }
@@ -2652,7 +2652,7 @@ void LLMeshUploadThread::DecompRequest::completed()
 void LLMeshUploadThread::preStart()
 {
     //build map of LLModel refs to instances for callbacks
-    for (instance_list::iterator iter = mInstanceList.begin(); iter != mInstanceList.end(); ++iter)
+    for (instance_list_t::iterator iter = mInstanceList.begin(); iter != mInstanceList.end(); ++iter)
     {
         mInstance[iter->mModel].push_back(*iter);
     }
@@ -2701,6 +2701,179 @@ LLSD llsd_from_file(std::string filename)
     return result;
 }
 
+void LLMeshUploadThread::packModelIntance(
+    LLModel* model,
+    LLMeshUploadThread::instance_list_t& instance_list,
+    std::string& model_name,
+    LLSD& res,
+    S32& mesh_num,
+    S32& texture_num,
+    S32& instance_num,
+    std::unordered_set<LLViewerTexture* >& textures,
+    std::unordered_map<LLViewerTexture*, S32> texture_index,
+    std::unordered_map<LLModel*, S32>& mesh_index,
+    std::vector<std::string>& texture_list_dest,
+    bool include_textures
+    )
+{
+    LLMeshUploadData data;
+    data.mBaseModel = model;
+
+    LLModelInstance& first_instance = *(instance_list.begin());
+    for (S32 i = 0; i < 5; i++)
+    {
+        data.mModel[i] = first_instance.mLOD[i];
+    }
+
+    if (mesh_index.find(data.mBaseModel) == mesh_index.end())
+    {
+        // Have not seen this model before - create a new mesh_list entry for it.
+        if (model_name.empty())
+        {
+            model_name = data.mBaseModel->getName();
+        }
+
+        std::stringstream ostr;
+
+        LLModel::Decomposition& decomp =
+            data.mModel[LLModel::LOD_PHYSICS].notNull() ?
+            data.mModel[LLModel::LOD_PHYSICS]->mPhysics :
+            data.mBaseModel->mPhysics;
+
+        decomp.mBaseHull = mHullMap[data.mBaseModel];
+
+        LLSD mesh_header = LLModel::writeModel(
+            ostr,
+            data.mModel[LLModel::LOD_PHYSICS],
+            data.mModel[LLModel::LOD_HIGH],
+            data.mModel[LLModel::LOD_MEDIUM],
+            data.mModel[LLModel::LOD_LOW],
+            data.mModel[LLModel::LOD_IMPOSTOR],
+            decomp,
+            mUploadSkin,
+            mUploadJoints,
+            mLockScaleIfJointPosition,
+            LLModel::WRITE_BINARY,
+            false,
+            data.mBaseModel->mSubmodelID);
+
+        data.mAssetData = ostr.str();
+        std::string str = ostr.str();
+
+        res["mesh_list"][mesh_num] = LLSD::Binary(str.begin(), str.end());
+        mesh_index[data.mBaseModel] = mesh_num;
+        mesh_num++;
+    }
+
+    // For all instances that use this model
+    for (instance_list_t::iterator instance_iter = instance_list.begin();
+        instance_iter != instance_list.end();
+        ++instance_iter)
+    {
+        LLModelInstance& instance = *instance_iter;
+
+        LLSD instance_entry;
+
+        for (S32 i = 0; i < 5; i++)
+        {
+            data.mModel[i] = instance.mLOD[i];
+        }
+
+        LLVector3 pos, scale;
+        LLQuaternion rot;
+        LLMatrix4 transformation = instance.mTransform;
+        decomposeMeshMatrix(transformation, pos, rot, scale);
+        instance_entry["position"] = ll_sd_from_vector3(pos);
+        instance_entry["rotation"] = ll_sd_from_quaternion(rot);
+        instance_entry["scale"] = ll_sd_from_vector3(scale);
+
+        instance_entry["material"] = LL_MCODE_WOOD;
+        if (model->mSubmodelID)
+        {
+            // Should it really be different?
+            instance_entry["physics_shape_type"] = (U8)(LLViewerObject::PHYSICS_SHAPE_NONE);
+        }
+        else
+        {
+            instance_entry["physics_shape_type"] = data.mModel[LLModel::LOD_PHYSICS].notNull() ? (U8)(LLViewerObject::PHYSICS_SHAPE_PRIM) : (U8)(LLViewerObject::PHYSICS_SHAPE_CONVEX_HULL);
+        }
+        instance_entry["mesh"] = mesh_index[data.mBaseModel];
+        instance_entry["mesh_name"] = instance.mLabel;
+
+        instance_entry["face_list"] = LLSD::emptyArray();
+
+        // We want to be able to allow more than 8 materials...
+        //
+        S32 end = llmin((S32)data.mBaseModel->mMaterialList.size(), instance.mModel->getNumVolumeFaces());
+
+        for (S32 face_num = 0; face_num < end; face_num++)
+        {
+            // multiple faces can reuse the same material
+            LLImportMaterial& material = instance.mMaterial[data.mBaseModel->mMaterialList[face_num]];
+            LLSD face_entry = LLSD::emptyMap();
+
+            LLViewerFetchedTexture* texture = NULL;
+
+            if (material.mDiffuseMapFilename.size())
+            {
+                texture = FindViewerTexture(material);
+            }
+
+            if ((texture != NULL) &&
+                (textures.find(texture) == textures.end()))
+            {
+                textures.insert(texture);
+            }
+
+            std::stringstream texture_str;
+            if (texture != NULL && include_textures && mUploadTextures)
+            {
+                if (texture->hasSavedRawImage())
+                {
+                    LLImageDataLock lock(texture->getSavedRawImage());
+
+                    LLPointer<LLImageJ2C> upload_file =
+                        LLViewerTextureList::convertToUploadFile(texture->getSavedRawImage());
+
+                    if (!upload_file.isNull() && upload_file->getDataSize() && !upload_file->isBufferInvalid())
+                    {
+                        texture_str.write((const char*)upload_file->getData(), upload_file->getDataSize());
+                    }
+                }
+            }
+
+            if (texture != NULL &&
+                mUploadTextures &&
+                texture_index.find(texture) == texture_index.end())
+            {
+                texture_index[texture] = texture_num;
+                std::string str = texture_str.str();
+                res["texture_list"][texture_num] = LLSD::Binary(str.begin(), str.end());
+                // store indexes for error handling;
+                texture_list_dest.push_back(material.mDiffuseMapFilename);
+                texture_num++;
+            }
+
+            // Subset of TextureEntry fields.
+            if (texture != NULL && mUploadTextures)
+            {
+                face_entry["image"] = texture_index[texture];
+                face_entry["scales"] = 1.0;
+                face_entry["scalet"] = 1.0;
+                face_entry["offsets"] = 0.0;
+                face_entry["offsett"] = 0.0;
+                face_entry["imagerot"] = 0.0;
+            }
+            face_entry["diffuse_color"] = ll_sd_from_color4(material.mDiffuseColor);
+            face_entry["fullbright"] = material.mFullbright;
+            instance_entry["face_list"][face_num] = face_entry;
+        }
+
+        res["instance_list"][instance_num] = instance_entry;
+        instance_num++;
+    }
+}
+
 void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, std::vector<std::string>& texture_list_dest, bool include_textures)
 {
     LLSD result;
@@ -2734,6 +2907,7 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, std::vector<std::string>&
     }
     S32 mesh_num = 0;
     S32 texture_num = 0;
+    S32 instance_num = 0;
 
     std::unordered_set<LLViewerTexture* > textures;
     std::unordered_map<LLViewerTexture*,S32> texture_index;
@@ -2741,7 +2915,34 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, std::vector<std::string>&
     std::unordered_map<LLModel*,S32> mesh_index;
     std::string model_name;
 
-    S32 instance_num = 0;
+    // If server gets a m1, m2, m3, m4 list, m1 becomes the root
+    // and the rest go as m4, m3, m2
+    // to counter that mInstance is sorted as m4, m3, m2, m1
+    // and we grab m1 from the end and send it first
+    LLModel* root_model = nullptr;
+    for (instance_map_t::reverse_iterator iter = mInstance.rbegin(); iter != mInstance.rend(); ++iter)
+    {
+        if (iter->first->mSubmodelID)
+        {
+            // Submodel can't be root
+            continue;
+        }
+        root_model = iter->first;
+        packModelIntance(
+            iter->first,
+            iter->second,
+            model_name,
+            res,
+            mesh_num,
+            texture_num,
+            instance_num,
+            textures,
+            texture_index,
+            mesh_index,
+            texture_list_dest,
+            include_textures);
+        break;
+    }
 
     // Handle models, ignore submodels for now.
     // Probably should pre-sort by mSubmodelID instead of running twice.
@@ -2749,319 +2950,53 @@ void LLMeshUploadThread::wholeModelToLLSD(LLSD& dest, std::vector<std::string>&
     // deterministic order.
     for (auto& iter : mInstance)
     {
-        LLMeshUploadData data;
-        data.mBaseModel = iter.first;
-
-        if (data.mBaseModel->mSubmodelID)
+        if (iter.first->mSubmodelID)
         {
             // These are handled below to insure correct parenting order on creation
             // due to map walking being based on model address (aka random)
             continue;
         }
-
-        LLModelInstance& first_instance = *(iter.second.begin());
-        for (S32 i = 0; i < 5; i++)
+        if (root_model == iter.first)
         {
-            data.mModel[i] = first_instance.mLOD[i];
-        }
-
-        if (mesh_index.find(data.mBaseModel) == mesh_index.end())
-        {
-            // Have not seen this model before - create a new mesh_list entry for it.
-            if (model_name.empty())
-            {
-                model_name = data.mBaseModel->getName();
-            }
-
-            std::stringstream ostr;
-
-            LLModel::Decomposition& decomp =
-                data.mModel[LLModel::LOD_PHYSICS].notNull() ?
-                data.mModel[LLModel::LOD_PHYSICS]->mPhysics :
-                data.mBaseModel->mPhysics;
-
-            decomp.mBaseHull = mHullMap[data.mBaseModel];
-
-            LLSD mesh_header = LLModel::writeModel(
-                ostr,
-                data.mModel[LLModel::LOD_PHYSICS],
-                data.mModel[LLModel::LOD_HIGH],
-                data.mModel[LLModel::LOD_MEDIUM],
-                data.mModel[LLModel::LOD_LOW],
-                data.mModel[LLModel::LOD_IMPOSTOR],
-                decomp,
-                mUploadSkin,
-                mUploadJoints,
-                mLockScaleIfJointPosition,
-                LLModel::WRITE_BINARY,
-                false,
-                data.mBaseModel->mSubmodelID);
-
-            data.mAssetData = ostr.str();
-            std::string str = ostr.str();
-
-            res["mesh_list"][mesh_num] = LLSD::Binary(str.begin(),str.end());
-            mesh_index[data.mBaseModel] = mesh_num;
-            mesh_num++;
-        }
-
-        // For all instances that use this model
-        for (instance_list::iterator instance_iter = iter.second.begin();
-             instance_iter != iter.second.end();
-             ++instance_iter)
-        {
-
-            LLModelInstance& instance = *instance_iter;
-
-            LLSD instance_entry;
-
-            for (S32 i = 0; i < 5; i++)
-            {
-                data.mModel[i] = instance.mLOD[i];
-            }
-
-            LLVector3 pos, scale;
-            LLQuaternion rot;
-            LLMatrix4 transformation = instance.mTransform;
-            decomposeMeshMatrix(transformation,pos,rot,scale);
-            instance_entry["position"] = ll_sd_from_vector3(pos);
-            instance_entry["rotation"] = ll_sd_from_quaternion(rot);
-            instance_entry["scale"] = ll_sd_from_vector3(scale);
-
-            instance_entry["material"] = LL_MCODE_WOOD;
-            instance_entry["physics_shape_type"] = data.mModel[LLModel::LOD_PHYSICS].notNull() ? (U8)(LLViewerObject::PHYSICS_SHAPE_PRIM) : (U8)(LLViewerObject::PHYSICS_SHAPE_CONVEX_HULL);
-            instance_entry["mesh"] = mesh_index[data.mBaseModel];
-            instance_entry["mesh_name"] = instance.mLabel;
-
-            instance_entry["face_list"] = LLSD::emptyArray();
-
-            // We want to be able to allow more than 8 materials...
-            //
-            S32 end = llmin((S32)data.mBaseModel->mMaterialList.size(), instance.mModel->getNumVolumeFaces()) ;
-
-            for (S32 face_num = 0; face_num < end; face_num++)
-            {
-                // multiple faces can reuse the same material
-                LLImportMaterial& material = instance.mMaterial[data.mBaseModel->mMaterialList[face_num]];
-                LLSD face_entry = LLSD::emptyMap();
-
-                LLViewerFetchedTexture *texture = NULL;
-
-                if (material.mDiffuseMapFilename.size())
-                {
-                    texture = FindViewerTexture(material);
-                }
-
-                if ((texture != NULL) &&
-                    (textures.find(texture) == textures.end()))
-                {
-                    textures.insert(texture);
-                }
-
-                std::stringstream texture_str;
-                if (texture != NULL && include_textures && mUploadTextures)
-                {
-                    if (texture->hasSavedRawImage())
-                    {
-                        LLImageDataLock lock(texture->getSavedRawImage());
-
-                        LLPointer<LLImageJ2C> upload_file =
-                            LLViewerTextureList::convertToUploadFile(texture->getSavedRawImage());
-
-                        if (!upload_file.isNull() && upload_file->getDataSize() && !upload_file->isBufferInvalid())
-                        {
-                            texture_str.write((const char*) upload_file->getData(), upload_file->getDataSize());
-                        }
-                    }
-                }
-
-                if (texture != NULL &&
-                    mUploadTextures &&
-                    texture_index.find(texture) == texture_index.end())
-                {
-                    texture_index[texture] = texture_num;
-                    std::string str = texture_str.str();
-                    res["texture_list"][texture_num] = LLSD::Binary(str.begin(),str.end());
-                    // store indexes for error handling;
-                    texture_list_dest.push_back(material.mDiffuseMapFilename);
-                    texture_num++;
-                }
-
-                // Subset of TextureEntry fields.
-                if (texture != NULL && mUploadTextures)
-                {
-                    face_entry["image"] = texture_index[texture];
-                    face_entry["scales"] = 1.0;
-                    face_entry["scalet"] = 1.0;
-                    face_entry["offsets"] = 0.0;
-                    face_entry["offsett"] = 0.0;
-                    face_entry["imagerot"] = 0.0;
-                }
-                face_entry["diffuse_color"] = ll_sd_from_color4(material.mDiffuseColor);
-                face_entry["fullbright"] = material.mFullbright;
-                instance_entry["face_list"][face_num] = face_entry;
-            }
-
-            res["instance_list"][instance_num] = instance_entry;
-            instance_num++;
+            // Reached root, root was already packed and is last non-submodel
+            break;
         }
+        packModelIntance(
+            iter.first,
+            iter.second,
+            model_name,
+            res,
+            mesh_num,
+            texture_num,
+            instance_num,
+            textures,
+            texture_index,
+            mesh_index,
+            texture_list_dest,
+            include_textures);
     }
 
     // Now handle the submodels.
     for (auto& iter : mInstance)
     {
-        LLMeshUploadData data;
-        data.mBaseModel = iter.first;
-
-        if (!data.mBaseModel->mSubmodelID)
+        if (!iter.first->mSubmodelID)
         {
             // These were handled above already...
-            //
             continue;
         }
-
-        LLModelInstance& first_instance = *(iter.second.begin());
-        for (S32 i = 0; i < 5; i++)
-        {
-            data.mModel[i] = first_instance.mLOD[i];
-        }
-
-        if (mesh_index.find(data.mBaseModel) == mesh_index.end())
-        {
-            // Have not seen this model before - create a new mesh_list entry for it.
-            if (model_name.empty())
-            {
-                model_name = data.mBaseModel->getName();
-            }
-
-            std::stringstream ostr;
-
-            LLModel::Decomposition& decomp =
-                data.mModel[LLModel::LOD_PHYSICS].notNull() ?
-                data.mModel[LLModel::LOD_PHYSICS]->mPhysics :
-                data.mBaseModel->mPhysics;
-
-            decomp.mBaseHull = mHullMap[data.mBaseModel];
-
-            LLSD mesh_header = LLModel::writeModel(
-                ostr,
-                data.mModel[LLModel::LOD_PHYSICS],
-                data.mModel[LLModel::LOD_HIGH],
-                data.mModel[LLModel::LOD_MEDIUM],
-                data.mModel[LLModel::LOD_LOW],
-                data.mModel[LLModel::LOD_IMPOSTOR],
-                decomp,
-                mUploadSkin,
-                mUploadJoints,
-                mLockScaleIfJointPosition,
-                LLModel::WRITE_BINARY,
-                false,
-                data.mBaseModel->mSubmodelID);
-
-            data.mAssetData = ostr.str();
-            std::string str = ostr.str();
-
-            res["mesh_list"][mesh_num] = LLSD::Binary(str.begin(),str.end());
-            mesh_index[data.mBaseModel] = mesh_num;
-            mesh_num++;
-        }
-
-        // For all instances that use this model
-        for (instance_list::iterator instance_iter = iter.second.begin();
-             instance_iter != iter.second.end();
-             ++instance_iter)
-        {
-
-            LLModelInstance& instance = *instance_iter;
-
-            LLSD instance_entry;
-
-            for (S32 i = 0; i < 5; i++)
-            {
-                data.mModel[i] = instance.mLOD[i];
-            }
-
-            LLVector3 pos, scale;
-            LLQuaternion rot;
-            LLMatrix4 transformation = instance.mTransform;
-            decomposeMeshMatrix(transformation,pos,rot,scale);
-            instance_entry["position"] = ll_sd_from_vector3(pos);
-            instance_entry["rotation"] = ll_sd_from_quaternion(rot);
-            instance_entry["scale"] = ll_sd_from_vector3(scale);
-
-            instance_entry["material"] = LL_MCODE_WOOD;
-            instance_entry["physics_shape_type"] = (U8)(LLViewerObject::PHYSICS_SHAPE_NONE);
-            instance_entry["mesh"] = mesh_index[data.mBaseModel];
-
-            instance_entry["face_list"] = LLSD::emptyArray();
-
-            // We want to be able to allow more than 8 materials...
-            //
-            S32 end = llmin((S32)instance.mMaterial.size(), instance.mModel->getNumVolumeFaces()) ;
-
-            for (S32 face_num = 0; face_num < end; face_num++)
-            {
-                LLImportMaterial& material = instance.mMaterial[data.mBaseModel->mMaterialList[face_num]];
-                LLSD face_entry = LLSD::emptyMap();
-
-                LLViewerFetchedTexture *texture = NULL;
-
-                if (material.mDiffuseMapFilename.size())
-                {
-                    texture = FindViewerTexture(material);
-                }
-
-                if ((texture != NULL) &&
-                    (textures.find(texture) == textures.end()))
-                {
-                    textures.insert(texture);
-                }
-
-                std::stringstream texture_str;
-                if (texture != NULL && include_textures && mUploadTextures)
-                {
-                    if (texture->hasSavedRawImage())
-                    {
-                        LLImageDataLock lock(texture->getSavedRawImage());
-
-                        LLPointer<LLImageJ2C> upload_file =
-                            LLViewerTextureList::convertToUploadFile(texture->getSavedRawImage());
-
-                        if (!upload_file.isNull() && upload_file->getDataSize())
-                        {
-                            texture_str.write((const char*) upload_file->getData(), upload_file->getDataSize());
-                        }
-                    }
-                }
-
-                if (texture != NULL &&
-                    mUploadTextures &&
-                    texture_index.find(texture) == texture_index.end())
-                {
-                    texture_index[texture] = texture_num;
-                    std::string str = texture_str.str();
-                    res["texture_list"][texture_num] = LLSD::Binary(str.begin(),str.end());
-                    texture_num++;
-                }
-
-                // Subset of TextureEntry fields.
-                if (texture != NULL && mUploadTextures)
-                {
-                    face_entry["image"] = texture_index[texture];
-                    face_entry["scales"] = 1.0;
-                    face_entry["scalet"] = 1.0;
-                    face_entry["offsets"] = 0.0;
-                    face_entry["offsett"] = 0.0;
-                    face_entry["imagerot"] = 0.0;
-                }
-                face_entry["diffuse_color"] = ll_sd_from_color4(material.mDiffuseColor);
-                face_entry["fullbright"] = material.mFullbright;
-                instance_entry["face_list"][face_num] = face_entry;
-            }
-
-            res["instance_list"][instance_num] = instance_entry;
-            instance_num++;
-        }
+        packModelIntance(
+            iter.first,
+            iter.second,
+            model_name,
+            res,
+            mesh_num,
+            texture_num,
+            instance_num,
+            textures,
+            texture_index,
+            mesh_index,
+            texture_list_dest,
+            include_textures);
     }
 
     if (model_name.empty()) model_name = "mesh model";
@@ -3077,7 +3012,7 @@ void LLMeshUploadThread::generateHulls()
 {
     bool has_valid_requests = false ;
 
-    for (instance_map::iterator iter = mInstance.begin(); iter != mInstance.end(); ++iter)
+    for (instance_map_t::iterator iter = mInstance.begin(); iter != mInstance.end(); ++iter)
     {
         LLMeshUploadData data;
         data.mBaseModel = iter->first;
@@ -3441,13 +3376,14 @@ void LLMeshRepoThread::notifyLoadedMeshes()
         }
     }
 
-    if (!mSkinInfoQ.empty() || !mSkinUnavailableQ.empty() || ! mDecompositionQ.empty())
+    if (!mSkinInfoQ.empty() || !mSkinUnavailableQ.empty() || !mDecompositionQ.empty() || !mPhysicsQ.empty())
     {
         if (mLoadedMutex->trylock())
         {
             std::deque<LLPointer<LLMeshSkinInfo>> skin_info_q;
             std::deque<UUIDBasedRequest> skin_info_unavail_q;
             std::list<LLModel::Decomposition*> decomp_q;
+            std::list<LLModel::Decomposition*> physics_q;
 
             if (! mSkinInfoQ.empty())
             {
@@ -3464,6 +3400,11 @@ void LLMeshRepoThread::notifyLoadedMeshes()
                 decomp_q.swap(mDecompositionQ);
             }
 
+            if (!mPhysicsQ.empty())
+            {
+                physics_q.swap(mPhysicsQ);
+            }
+
             mLoadedMutex->unlock();
 
             // Process the elements free of the lock
@@ -3480,9 +3421,15 @@ void LLMeshRepoThread::notifyLoadedMeshes()
 
             while (! decomp_q.empty())
             {
-                gMeshRepo.notifyDecompositionReceived(decomp_q.front());
+                gMeshRepo.notifyDecompositionReceived(decomp_q.front(), false);
                 decomp_q.pop_front();
             }
+
+            while (!physics_q.empty())
+            {
+                gMeshRepo.notifyDecompositionReceived(physics_q.front(), true);
+                physics_q.pop_front();
+            }
         }
     }
 
@@ -4367,7 +4314,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
         else
         {
             //first request for this mesh
-            std::shared_ptr<PendingRequestBase> request(new PendingRequestLOD(mesh_params, new_lod));
+            std::shared_ptr<PendingRequestBase> request = std::make_shared<PendingRequestLOD>(mesh_params, new_lod);
             mPendingRequests.emplace_back(request);
             mLoadingMeshes[new_lod][mesh_id].initData(vobj, request);
             LLMeshRepository::sLODPending++;
@@ -4724,13 +4671,13 @@ void LLMeshRepository::notifySkinInfoUnavailable(const LLUUID& mesh_id)
     }
 }
 
-void LLMeshRepository::notifyDecompositionReceived(LLModel::Decomposition* decomp)
+void LLMeshRepository::notifyDecompositionReceived(LLModel::Decomposition* decomp, bool physics_mesh)
 {
-    decomposition_map::iterator iter = mDecompositionMap.find(decomp->mMeshID);
+    LLUUID decomp_id = decomp->mMeshID; // Copy to avoid invalidation in below deletion
+    decomposition_map::iterator iter = mDecompositionMap.find(decomp_id);
     if (iter == mDecompositionMap.end())
     { //just insert decomp into map
-        mDecompositionMap[decomp->mMeshID] = decomp;
-        mLoadingDecompositions.erase(decomp->mMeshID);
+        mDecompositionMap[decomp_id] = decomp;
         sCacheBytesDecomps += decomp->sizeBytes();
     }
     else
@@ -4738,10 +4685,17 @@ void LLMeshRepository::notifyDecompositionReceived(LLModel::Decomposition* decom
         sCacheBytesDecomps -= iter->second->sizeBytes();
         iter->second->merge(decomp);
         sCacheBytesDecomps += iter->second->sizeBytes();
-
-        mLoadingDecompositions.erase(decomp->mMeshID);
         delete decomp;
     }
+
+    if (physics_mesh)
+    {
+        mLoadingPhysicsShapes.erase(decomp_id);
+    }
+    else
+    {
+        mLoadingDecompositions.erase(decomp_id);
+    }
 }
 
 void LLMeshRepository::notifyMeshLoaded(const LLVolumeParams& mesh_params, LLVolume* volume, S32 lod)
@@ -4858,7 +4812,7 @@ const LLMeshSkinInfo* LLMeshRepository::getSkinInfo(const LLUUID& mesh_id, LLVOV
             else
             {
                 //first request for this mesh
-                std::shared_ptr<PendingRequestBase> request(new PendingRequestUUID(mesh_id, MESH_REQUEST_SKIN));
+                std::shared_ptr<PendingRequestBase> request = std::make_shared<PendingRequestUUID>(mesh_id, MESH_REQUEST_SKIN);
                 mLoadingSkins[mesh_id].initData(requesting_obj, request);
                 mPendingRequests.emplace_back(request);
             }
@@ -4888,7 +4842,6 @@ void LLMeshRepository::fetchPhysicsShape(const LLUUID& mesh_id)
             std::unordered_set<LLUUID>::iterator iter = mLoadingPhysicsShapes.find(mesh_id);
             if (iter == mLoadingPhysicsShapes.end())
             { //no request pending for this skin info
-                // *FIXME:  Nothing ever deletes entries, can't be right
                 mLoadingPhysicsShapes.insert(mesh_id);
                 mPendingPhysicsShapeRequests.push(mesh_id);
             }