Local Assets: client-side preview of local mesh, animation, texture, and material files

indra/llcommon/llsdserialize_xml.cpp

@@ -549,9 +549,17 @@ void LLSDXMLParser::Impl::parsePart(const char* buf, llssize len)
         && len > 0 )
     {
         XML_Status status = XML_Parse(mParser, buf, (int)len, 0);
-        if (status == XML_STATUS_ERROR)
+        // A short, complete document (e.g. "<llsd><map /></llsd>") may be
+        // wholly contained in this first chunk. Reaching </llsd> calls
+        // XML_StopParser(false), which makes XML_Parse return XML_STATUS_ERROR
+        // even though the parse succeeded -- mGracefullStop distinguishes that
+        // graceful stop from a real error, matching parse()/parseLines().
+        if (status == XML_STATUS_ERROR && !mGracefullStop)
         {
-            LL_INFOS() << "Unexpected XML parsing error at start" << LL_ENDL;
+            if (mEmitErrors)
+            {
+                LL_INFOS() << "Unexpected XML parsing error at start" << LL_ENDL;
+            }
         }
     }
 }

indra/llcommon/tests/llsdserialize_test.cpp

@@ -57,6 +57,7 @@ typedef U32 uint32_t;
 #include "../test/namedtempfile.h"
 #include "stringize.h"
 #include "StringVec.h"
+#include "wrapllerrs.h"
 #include <functional>
 
 typedef std::function<void(const LLSD& data, std::ostream& str)> FormatterFunction;
@@ -243,6 +244,33 @@ namespace tut
         xml_test("binary", expected);
     }
 
+    template<> template<>
+    void sd_xml_object::test<7>()
+    {
+        // A complete, single-line legacy <llsd> document (no embedded '\n')
+        // is read entirely into the header buffer by LLSDSerialize::deserialize
+        // and handed to LLSDXMLParser::parsePart(). Reaching </llsd> within that
+        // first chunk calls XML_StopParser(false), which makes expat report
+        // XML_STATUS_ERROR even though the parse succeeded. parsePart() used to
+        // log a spurious "Unexpected XML parsing error" for that graceful stop.
+        // Empty containers are the common single-line form that triggered it.
+        auto deserialize_no_spurious_error =
+            [](const std::string& xml, const LLSD& expected)
+            {
+                CaptureLog capture(LLError::LEVEL_INFO);
+                std::istringstream input(xml);
+                LLSD parsed;
+                bool ok = LLSDSerialize::deserialize(parsed, input, xml.size());
+                ensure(STRINGIZE("deserialize " << xml << " succeeded"), ok);
+                ensure_equals(STRINGIZE("deserialize " << xml << " value"), parsed, expected);
+                ensure(STRINGIZE("no spurious parse error for " << xml),
+                       capture.messageWith("Unexpected XML parsing error", false).empty());
+            };
+
+        deserialize_no_spurious_error("<llsd><map /></llsd>\n", LLSD::emptyMap());
+        deserialize_no_spurious_error("<llsd><array /></llsd>\n", LLSD::emptyArray());
+    }
+
     class TestLLSDSerializeData
     {
     public:

indra/llimage/llpngwrapper.cpp

@@ -237,7 +237,7 @@ void LLPngWrapper::normalizeImage()
     //      1. Expand any palettes
     //      2. Convert grayscales to RGB
     //      3. Create alpha layer from transparency
-    //      4. Ensure 8-bpp for all images
+    //      4. Ensure 8-bpp for all images (16-bit accurately scaled, not truncated)
     //      5. Set (or guess) gamma
 
     if (mColorType == PNG_COLOR_TYPE_PALETTE)
@@ -263,7 +263,13 @@ void LLPngWrapper::normalizeImage()
     }
     else if (mBitDepth == 16)
     {
+#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
+        // Accurate linear 16->8 reduction (round(v/257)) rather than
+        // png_set_strip_16's biased low-byte truncation (v>>8).
+        png_set_scale_16(mReadPngPtr);
+#else
         png_set_strip_16(mReadPngPtr);
+#endif
     }
 
     const F64 SCREEN_GAMMA = 2.2;

indra/llprimitive/llmodel.cpp

@@ -886,6 +886,12 @@ LLSD LLModel::writeModel(
 
             LLVector3 pos_range = max_pos - min_pos;
 
+            // O(1) per-vertex weight lookup for the skinning block below; without
+            // it the per-vertex getJointInfluences() scan makes this loop O(V^2)
+            // and freezes the uploader on dense rigged meshes. Built once per
+            // model (empty/cheap when unskinned).
+            JointWeightCache weight_cache(*model[idx]);
+
             for (S32 i = 0; i < model[idx]->getNumVolumeFaces(); ++i)
             { //for each face
                 const LLVolumeFace& face = model[idx]->getVolumeFace(i);
@@ -1044,10 +1050,10 @@ LLSD LLModel::writeModel(
                         {
                             LLVector3 pos(face.mPositions[j].getF32ptr());
 
-                            weight_list& weights = model[idx]->getJointInfluences(pos);
+                            const weight_list& weights = weight_cache.influences(pos);
 
                             S32 count = 0;
-                            for (weight_list::iterator iter = weights.begin(); iter != weights.end(); ++iter)
+                            for (weight_list::const_iterator iter = weights.begin(); iter != weights.end(); ++iter)
                             {
                                 // Note joint index cannot exceed 255.
                                 if (iter->mJointIdx < 255 && iter->mJointIdx >= 0)
@@ -1291,6 +1297,66 @@ LLModel::weight_list& LLModel::getJointInfluences(const LLVector3& pos)
     }
 }
 
+LLModel::JointWeightCache::JointWeightCache(LLModel& model)
+    : mModel(model)
+{
+    mCells.reserve(model.mSkinWeights.size());
+    for (const weight_map::value_type& entry : model.mSkinWeights)
+    {
+        mCells[cellKey(entry.first)].push_back(&entry);
+    }
+}
+
+LLModel::JointWeightCache::CellKey LLModel::JointWeightCache::cellKey(const LLVector3& p)
+{
+    return { llfloor(p.mV[VX] / WELD_EPSILON),
+             llfloor(p.mV[VY] / WELD_EPSILON),
+             llfloor(p.mV[VZ] / WELD_EPSILON) };
+}
+
+const LLModel::weight_list& LLModel::JointWeightCache::influences(const LLVector3& pos) const
+{
+    // Match radius == cell size == the weld epsilon, so a key within epsilon of
+    // pos is in pos's cell or an immediate neighbour. Scan the 3x3x3 block,
+    // counting in-epsilon candidates and tracking the closest.
+    const CellKey base = cellKey(pos);
+    const weight_list* best = nullptr;
+    F32 best_dist = WELD_EPSILON;
+    S32 in_epsilon = 0;
+    for (S32 dx = -1; dx <= 1; ++dx)
+    {
+        for (S32 dy = -1; dy <= 1; ++dy)
+        {
+            for (S32 dz = -1; dz <= 1; ++dz)
+            {
+                auto it = mCells.find({ base.x + dx, base.y + dy, base.z + dz });
+                if (it == mCells.end())
+                {
+                    continue;
+                }
+                for (const weight_map::value_type* e : it->second)
+                {
+                    const F32 d = (e->first - pos).length();
+                    if (d < WELD_EPSILON)
+                    {
+                        ++in_epsilon;
+                        if (d < best_dist)
+                        {
+                            best_dist = d;
+                            best = &e->second;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Defer to the full search unless we found exactly one in-epsilon match.
+    // getJointInfluences() returns the FIRST weld-epsilon match in map order, so
+    // on a miss (closest-point fallback) or an ambiguous tie (multiple keys
+    // within epsilon) we mirror it exactly instead of guessing the closest.
+    return (best && in_epsilon == 1) ? *best : mModel.getJointInfluences(pos);
+}
+
 void LLModel::setConvexHullDecomposition(
     const LLModel::convex_hull_decomposition& decomp, const std::vector<LLModel::PhysicsMesh>& decomp_mesh)
 {

indra/llprimitive/llmodel.h

@@ -32,6 +32,7 @@
 #include "v4math.h"
 #include "m4math.h"
 #include <queue>
+#include <unordered_map>
 
 class daeElement;
 class domMesh;
@@ -288,6 +289,42 @@ class alignas(16) LLModel : public LLVolume
     //get list of weight influences closest to given position
     weight_list& getJointInfluences(const LLVector3& pos);
 
+    // O(1) accelerator for getJointInfluences(). That function linearly scans
+    // mSkinWeights, so calling it once per vertex (writeModel, LOD vertex-buffer
+    // fill, local-mesh preview) is O(V^2) and stalls the main thread for seconds
+    // on a dense rigged mesh. Build one of these once before a per-vertex loop,
+    // then call influences() per vertex for an O(1) lookup -- making the weight
+    // pass O(V). It snapshots pointers into the model's current mSkinWeights, so
+    // construct it after the weights are final and do not mutate mSkinWeights
+    // while it is alive. A position with no key within the weld epsilon falls
+    // back to getJointInfluences() (preserving its exact-find / closest-point
+    // path), so results are identical to calling that function directly.
+    class JointWeightCache
+    {
+    public:
+        explicit JointWeightCache(LLModel& model);
+        const weight_list& influences(const LLVector3& pos) const;
+
+    private:
+        static constexpr F32 WELD_EPSILON = 1e-5f; // == jointPositionalLookup()'s tolerance
+        struct CellKey
+        {
+            S32 x, y, z;
+            bool operator==(const CellKey& o) const { return x == o.x && y == o.y && z == o.z; }
+        };
+        struct CellHash
+        {
+            size_t operator()(const CellKey& k) const
+            {
+                return (size_t)(((U32)k.x * 73856093u) ^ ((U32)k.y * 19349663u) ^ ((U32)k.z * 83492791u));
+            }
+        };
+        static CellKey cellKey(const LLVector3& p);
+
+        LLModel& mModel;
+        std::unordered_map<CellKey, std::vector<const weight_map::value_type*>, CellHash> mCells;
+    };
+
     LLMeshSkinInfo mSkinInfo;
 
     std::string mRequestedLabel; // name requested in UI, if any.

indra/llui/llconsole.cpp

@@ -189,7 +189,7 @@ void LLConsole::draw()
     // draw remaining lines
     F32 y_pos = 0.f;
 
-    LLUIImagePtr imagep = LLUI::getUIImage("transparent");
+    LLUIImagePtr imagep = LLUI::getUIImage("transparent.j2c");
 
     static LLCachedControl<F32> console_bg_opacity(*LLUI::getInstance()->mSettingGroups["config"], "ConsoleBackgroundOpacity", 0.7f);
     F32 console_opacity = llclamp(console_bg_opacity(), 0.f, 1.f);

indra/newview/CMakeLists.txt

@@ -380,6 +380,7 @@ set(viewer_SOURCE_FILES
     llfloaterlandholdings.cpp
     llfloaterlinkreplace.cpp
     llfloaterloadprefpreset.cpp
+    llfloaterlocalassets.cpp
     llfloatermarketplacelistings.cpp
     llfloatermap.cpp
     llfloatermediasettings.cpp
@@ -513,6 +514,9 @@ set(viewer_SOURCE_FILES
     lllistview.cpp
     lllocalbitmaps.cpp
     lllocalgltfmaterials.cpp
+    lllocalmesh.cpp
+    lllocalanim.cpp
+    lllocalassetpaths.cpp
     lllocationhistory.cpp
     lllocationinputctrl.cpp
     lllogchat.cpp
@@ -1144,6 +1148,7 @@ set(viewer_HEADER_FILES
     llfloaterlandholdings.h
     llfloaterlinkreplace.h
     llfloaterloadprefpreset.h
+    llfloaterlocalassets.h
     llfloatermap.h
     llfloatermarketplace.h
     llfloatermarketplacelistings.h
@@ -1276,6 +1281,9 @@ set(viewer_HEADER_FILES
     lllistview.h
     lllocalbitmaps.h
     lllocalgltfmaterials.h
+    lllocalmesh.h
+    lllocalanim.h
+    lllocalassetpaths.h
     lllocationhistory.h
     lllocationinputctrl.h
     lllogchat.h

indra/newview/app_settings/commands.xml

@@ -127,6 +127,16 @@
            is_running_function="Floater.IsOpen"
            is_running_parameters="inventory"
            />
+  <command name="local_assets"
+           available_in_toybox="true"
+           icon="Command_LocalAssets_Icon"
+           label_ref="Command_LocalAssets_Label"
+           tooltip_ref="Command_LocalAssets_Tooltip"
+           execute_function="Floater.ToggleOrBringToFront"
+           execute_parameters="local_assets"
+           is_running_function="Floater.IsOpen"
+           is_running_parameters="local_assets"
+           />
   <command name="map"
            available_in_toybox="true"
            icon="Command_Map_Icon"