1 files changed, 198 insertions, 1 deletions

diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp
index de05054f4b..8af0057c88 100644
--- a/indra/newview/llviewerobject.cpp
+++ b/indra/newview/llviewerobject.cpp
@@ -107,6 +107,7 @@
 #include "llmeshrepository.h"
 #include "llgltfmateriallist.h"
 #include "llgl.h"
+#include "gltf/asset.h"
 
 //#define DEBUG_UPDATE_TYPE
 
@@ -1481,6 +1482,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys,
 
                     // alpha was flipped so that it zero encoded better
                     coloru.mV[3] = 255 - coloru.mV[3];
+
                     mText->setColor(LLColor4(coloru));
                     mText->setString(temp_string);
 
@@ -1804,6 +1806,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys,
                 {
                     std::string temp_string;
                     dp->unpackString(temp_string, "Text");
+
                     LLColor4U coloru;
                     dp->unpackBinaryDataFixed(coloru.mV, 4, "Color");
                     coloru.mV[3] = 255 - coloru.mV[3];
@@ -4241,6 +4244,184 @@ const LLVector3 &LLViewerObject::getPositionAgent() const
     return mPositionAgent;
 }
 
+LLMatrix4a LLViewerObject::getGLTFAssetToAgentTransform() const
+{
+    LLMatrix4 root;
+    root.initScale(getScale());
+    root.rotate(getRenderRotation());
+    root.translate(getRenderPosition());
+
+    LLMatrix4a mat;
+    mat.loadu((F32*)root.mMatrix);
+
+    return mat;
+}
+
+LLVector3 LLViewerObject::getGLTFNodePositionAgent(S32 node_index) const
+{
+    LLVector3 ret;
+    getGLTFNodeTransformAgent(node_index, &ret, nullptr, nullptr);
+    return ret;
+
+}
+
+LLMatrix4a LLViewerObject::getAgentToGLTFAssetTransform() const
+{
+    LLMatrix4 root;
+    LLVector3 scale = getScale();
+    scale.mV[0] = 1.f / scale.mV[0];
+    scale.mV[1] = 1.f / scale.mV[1];
+    scale.mV[2] = 1.f / scale.mV[2];
+
+    root.translate(-getRenderPosition());
+    root.rotate(~getRenderRotation());
+
+    LLMatrix4 scale_mat;
+    scale_mat.initScale(scale);
+
+    root *= scale_mat;
+    LLMatrix4a mat;
+    mat.loadu((F32*)root.mMatrix);
+
+    return mat;
+}
+
+LLMatrix4a LLViewerObject::getGLTFNodeTransformAgent(S32 node_index) const
+{
+    LLMatrix4a mat;
+
+    if (mGLTFAsset && node_index >= 0 && node_index < mGLTFAsset->mNodes.size())
+    {
+        auto& node = mGLTFAsset->mNodes[node_index];
+
+        LLMatrix4a asset_to_agent = getGLTFAssetToAgentTransform();
+        LLMatrix4a node_to_agent;
+        LLMatrix4a am;
+        am.loadu(glm::value_ptr(node.mAssetMatrix));
+        matMul(am, asset_to_agent, node_to_agent);
+
+        mat = node_to_agent;
+    }
+    else
+    {
+        mat.setIdentity();
+    }
+
+    return mat;
+}
+
+void LLViewerObject::getGLTFNodeTransformAgent(S32 node_index, LLVector3* position, LLQuaternion* rotation, LLVector3* scale) const
+{
+    LLMatrix4a node_to_agent = getGLTFNodeTransformAgent(node_index);
+
+    if (position)
+    {
+        LLVector4a p = node_to_agent.getTranslation();
+        position->set(p.getF32ptr());
+    }
+
+    if (rotation)
+    {
+        rotation->set(node_to_agent.asMatrix4());
+    }
+
+    if (scale)
+    {
+        scale->mV[0] = node_to_agent.mMatrix[0].getLength3().getF32();
+        scale->mV[1] = node_to_agent.mMatrix[1].getLength3().getF32();
+        scale->mV[2] = node_to_agent.mMatrix[2].getLength3().getF32();
+    }
+}
+
+void decomposeMatrix(const LLMatrix4a& mat, LLVector3& position, LLQuaternion& rotation, LLVector3& scale)
+{
+    LLVector4a p = mat.getTranslation();
+    position.set(p.getF32ptr());
+
+    rotation.set(mat.asMatrix4());
+
+    scale.mV[0] = mat.mMatrix[0].getLength3().getF32();
+    scale.mV[1] = mat.mMatrix[1].getLength3().getF32();
+    scale.mV[2] = mat.mMatrix[2].getLength3().getF32();
+}
+
+void LLViewerObject::setGLTFNodeRotationAgent(S32 node_index, const LLQuaternion& rotation)
+{
+    if (mGLTFAsset && node_index >= 0 && node_index < mGLTFAsset->mNodes.size())
+    {
+        auto& node = mGLTFAsset->mNodes[node_index];
+
+        LLMatrix4a agent_to_asset = getAgentToGLTFAssetTransform();
+        LLMatrix4a agent_to_node = agent_to_asset;
+
+        if (node.mParent != -1)
+        {
+            auto& parent = mGLTFAsset->mNodes[node.mParent];
+            LLMatrix4a ami;
+            ami.loadu(glm::value_ptr(parent.mAssetMatrixInv));
+            matMul(agent_to_asset, ami, agent_to_node);
+        }
+
+        LLQuaternion agent_to_node_rot(agent_to_node.asMatrix4());
+        LLQuaternion new_rot;
+
+        new_rot = rotation * agent_to_node_rot;
+        new_rot.normalize();
+
+        LLVector3 pos;
+        LLQuaternion rot;
+        LLVector3 scale;
+        LLMatrix4a mat;
+        mat.loadu(glm::value_ptr(node.mMatrix));
+        decomposeMatrix(mat, pos, rot, scale);
+
+        mat.asMatrix4().initAll(scale, new_rot, pos);
+
+        node.mMatrix = glm::make_mat4(mat.getF32ptr());
+
+        mGLTFAsset->updateTransforms();
+    }
+}
+
+void LLViewerObject::moveGLTFNode(S32 node_index, const LLVector3& offset)
+{
+    if (mGLTFAsset && node_index >= 0 && node_index < mGLTFAsset->mNodes.size())
+    {
+        auto& node = mGLTFAsset->mNodes[node_index];
+
+        LLMatrix4a agent_to_asset = getAgentToGLTFAssetTransform();
+        LLMatrix4a agent_to_node;
+        LLMatrix4a ami;
+        ami.loadu(glm::value_ptr(node.mAssetMatrixInv));
+        matMul(agent_to_asset, ami, agent_to_node);
+
+        LLVector4a origin = LLVector4a::getZero();
+        LLVector4a offset_v;
+        offset_v.load3(offset.mV);
+
+
+        agent_to_node.affineTransform(offset_v, offset_v);
+        agent_to_node.affineTransform(origin, origin);
+
+        offset_v.sub(origin);
+        offset_v.getF32ptr()[3] = 1.f;
+
+        LLMatrix4a trans;
+        trans.setIdentity();
+        trans.mMatrix[3] = offset_v;
+
+        LLMatrix4a mat;
+        mat.loadu(glm::value_ptr(node.mMatrix));
+
+        matMul(trans, mat, mat);
+
+        node.mMatrix = glm::make_mat4(mat.getF32ptr());
+
+        // TODO -- only update transforms for this node and its children (or use a dirty flag)
+        mGLTFAsset->updateTransforms();
+    }
+}
+
 const LLVector3 &LLViewerObject::getPositionRegion() const
 {
     if (!isRoot())
@@ -5228,7 +5409,6 @@ S32 LLViewerObject::setTEFullbright(const U8 te, const U8 fullbright)
     return retval;
 }
 
-
 S32 LLViewerObject::setTEMediaFlags(const U8 te, const U8 media_flags)
 {
     // this might need work for media type
@@ -7326,6 +7506,23 @@ void LLViewerObject::shrinkWrap()
     }
 }
 
+void LLViewerObject::setGLTFAsset(const LLUUID& id)
+{
+    //get the sculpt params and set the sculpt type and id
+    auto* param = getExtraParameterEntryCreate(LLNetworkData::PARAMS_SCULPT);
+
+    LLSculptParams* sculpt_params = (LLSculptParams*)param->data;
+    sculpt_params->setSculptTexture(id, LL_SCULPT_TYPE_GLTF);
+
+    setParameterEntryInUse(LLNetworkData::PARAMS_SCULPT, true, true);
+
+    // Update the volume
+    LLVolumeParams volume_params;
+    volume_params.setSculptID(id, LL_SCULPT_TYPE_GLTF);
+    updateVolume(volume_params);
+}
+
+
 class ObjectPhysicsProperties : public LLHTTPNode
 {
 public: