More RigInverter work

DataSpec/DNACommon/ANCS.hpp

@@ -85,6 +85,10 @@ bool ReadANCSToBlender(hecl::BlenderConnection& conn,
     /* Establish ANCS blend */
     if (!conn.createBlend(outPath, hecl::BlenderConnection::BlendType::Actor))
         return false;
+
+    std::string firstName;
+    typename ANCSDNA::CINFType firstCinf;
+    {
         hecl::BlenderConnection::PyOutStream os = conn.beginPythonOut(true);
 
         os.format("import bpy\n"
@@ -104,7 +108,6 @@ bool ReadANCSToBlender(hecl::BlenderConnection& conn,
                   "actor_data = bpy.context.scene.hecl_sact_data\n",
                   pakRouter.getBestEntryName(entry).c_str());
 
-    typename ANCSDNA::CINFType cinf;
         std::unordered_set<typename PAKRouter::IDType> cinfsDone;
         for (const auto& info : chResInfo)
         {
@@ -116,8 +119,14 @@ bool ReadANCSToBlender(hecl::BlenderConnection& conn,
             /* Build CINF if needed */
             if (cinfsDone.find(info.cinf) == cinfsDone.end())
             {
+                typename ANCSDNA::CINFType cinf;
                 pakRouter.lookupAndReadDNA(info.cinf, cinf);
                 cinf.sendCINFToBlender(os, info.cinf);
+                if (cinfsDone.empty())
+                {
+                    firstName = ANCSDNA::CINFType::GetCINFArmatureName(info.cinf);
+                    firstCinf = cinf;
+                }
                 cinfsDone.insert(info.cinf);
             }
             else
@@ -163,8 +172,18 @@ bool ReadANCSToBlender(hecl::BlenderConnection& conn,
                 }
             }
         }
+    }
 
-    DNAANIM::RigInverter<typename ANCSDNA::CINFType> inverter(cinf);
+    {
+        hecl::BlenderConnection::DataStream ds = conn.beginData();
+        std::unordered_map<std::string,
+        hecl::BlenderConnection::DataStream::Matrix3f> matrices = ds.getBoneMatrices(firstName);
+        ds.close();
+        DNAANIM::RigInverter<typename ANCSDNA::CINFType> inverter(firstCinf, matrices);
+
+        hecl::BlenderConnection::PyOutStream os = conn.beginPythonOut(true);
+        os << "import bpy\n"
+              "actor_data = bpy.context.scene.hecl_sact_data\n";
 
         /* Get animation primitives */
         std::map<atUint32, AnimationResInfo<typename PAKRouter::IDType>> animResInfo;
@@ -182,8 +201,7 @@ bool ReadANCSToBlender(hecl::BlenderConnection& conn,
             os.format("actor_action = actor_data.actions.add()\n"
                       "actor_action.name = '%s'\n", id.second.name.c_str());
         }
-
+    }
-    os.close();
     conn.saveBlend();
     return true;
 }

DataSpec/DNACommon/RigInverter.cpp

@@ -52,8 +52,6 @@ RigInverter<CINFType>::Bone::Bone(const CINFType& cinf, const typename CINFType:
         m_tail /= float(actualChildren);
         if (m_tail.magSquared() < 0.001f)
             m_tail = naturalTail;
-        else
-            m_inverter = zeus::CQuaternion(m_tail, naturalTail);
     }
     else if (parentIdx != -1)
     {
@@ -62,8 +60,6 @@ RigInverter<CINFType>::Bone::Bone(const CINFType& cinf, const typename CINFType:
         m_tail = zeus::CVector3f(origBone.origin) * 2.f - zeus::CVector3f(pBone.origin);
         if (m_tail.magSquared() < 0.001f)
             m_tail = naturalTail;
-        else
-            m_inverter = zeus::CQuaternion(m_tail, naturalTail);
     }
     else
     {
@@ -81,13 +77,38 @@ RigInverter<CINFType>::RigInverter(const CINFType& cinf)
         m_bones.emplace_back(cinf, b);
 }
 
+template <class CINFType>
+RigInverter<CINFType>::RigInverter(const CINFType& cinf,
+                                   const std::unordered_map<std::string,
+                                   hecl::BlenderConnection::DataStream::Matrix3f>& matrices)
+: m_cinf(cinf)
+{
+    m_bones.reserve(cinf.bones.size());
+    for (const typename CINFType::Bone& b : cinf.bones)
+    {
+        m_bones.emplace_back(cinf, b);
+        const std::string* name = cinf.getBoneNameFromId(b.id);
+        if (name)
+        {
+            auto search = matrices.find(*name);
+            if (search != matrices.cend())
+            {
+                m_bones.back().m_inverter = zeus::CMatrix3f(search->second[0],
+                                                            search->second[1],
+                                                            search->second[2]);
+                m_bones.back().m_restorer = m_bones.back().m_inverter.transposed();
+            }
+        }
+    }
+}
+
 template <class CINFType>
 zeus::CQuaternion
 RigInverter<CINFType>::transformRotation(atUint32 boneId, const zeus::CQuaternion& origRot) const
 {
     for (const Bone& b : m_bones)
         if (b.m_origBone.id == boneId)
-            return b.m_inverter * origRot;
+            return b.m_inverter * zeus::CMatrix3f(origRot) * b.m_restorer;
     return origRot;
 }
     

DataSpec/DNACommon/RigInverter.hpp

@@ -2,7 +2,9 @@
 #define __COMMON_RIGINVERTER_HPP__
 
 #include "zeus/CVector3f.hpp"
+#include "zeus/CMatrix3f.hpp"
 #include "zeus/CQuaternion.hpp"
+#include "BlenderConnection.hpp"
 
 namespace DataSpec
 {
@@ -18,7 +20,8 @@ public:
     struct Bone
     {
         const typename CINFType::Bone& m_origBone;
-        zeus::CQuaternion m_inverter;
+        zeus::CMatrix3f m_inverter;
+        zeus::CMatrix3f m_restorer;
         zeus::CVector3f m_tail;
         zeus::CVector3f m_parentDelta;
         Bone(const CINFType& cinf, const typename CINFType::Bone& origBone);
@@ -28,6 +31,9 @@ private:
     std::vector<Bone> m_bones;
 public:
     RigInverter(const CINFType& cinf);
+    RigInverter(const CINFType& cinf,
+                const std::unordered_map<std::string,
+                hecl::BlenderConnection::DataStream::Matrix3f>& matrices);
     const CINFType& getCINF() const {return m_cinf;}
     const std::vector<Bone>& getBones() const {return m_bones;}
     zeus::CQuaternion transformRotation(atUint32 boneId, const zeus::CQuaternion& origRot) const;

DataSpec/DNAMP1/ANIM.cpp

@@ -13,6 +13,10 @@ void ANIM::IANIM::sendANIMToBlender(hecl::BlenderConnection::PyOutStream& os, co
     os.format("act.hecl_fps = round(%f)\n", (1.0f / mainInterval));
 
     auto kit = chanKeys.begin();
+
+    std::vector<zeus::CQuaternion> fixedRotKeys;
+    std::vector<zeus::CVector3f> fixedTransKeys;
+
     for (const std::pair<atUint32, bool>& bone : bones)
     {
         const std::string* bName = rig.getCINF().getBoneNameFromId(bone.first);
@@ -45,13 +49,14 @@ void ANIM::IANIM::sendANIMToBlender(hecl::BlenderConnection::PyOutStream& os, co
               "crv.keyframe_points[-1].interpolation = 'LINEAR'\n"
               "\n";
 
+        if (bone.first == 3)
+            printf("");
         ANIMOutStream ao = os.beginANIMCurve();
         
         {
             const std::vector<DNAANIM::Value>& rotKeys = *kit++;
-            std::vector<zeus::CQuaternion> fixedRotKeys;
+            fixedRotKeys.clear();
             fixedRotKeys.resize(rotKeys.size());
-            fprintf(stderr, "alloc %d\n", rotKeys.size());
             
             for (int c=0 ; c<4 ; ++c)
             {
@@ -70,14 +75,12 @@ void ANIM::IANIM::sendANIMToBlender(hecl::BlenderConnection::PyOutStream& os, co
                 for (const zeus::CQuaternion& val : fixedRotKeys)
                     ao.write(*frameit++, val[c]);
             }
-            
-            fprintf(stderr, "size %d\n", fixedRotKeys.size());
         }
 
         if (bone.second)
         {
             const std::vector<DNAANIM::Value>& transKeys = *kit++;
-            std::vector<zeus::CVector3f> fixedTransKeys;
+            fixedTransKeys.clear();
             fixedTransKeys.resize(transKeys.size());
 
             for (int c=0 ; c<3 ; ++c)

DataSpec/DNAMP1/CINF.hpp

@@ -114,6 +114,11 @@ struct CINF : BigDNA
         os << "bpy.ops.object.mode_set(mode='OBJECT')\n";
     }
 
+    static std::string GetCINFArmatureName(const UniqueID32& cinfId)
+    {
+        return hecl::Format("CINF_%08X", cinfId.toUint32());
+    }
+
     CINF() = default;
     using Armature = hecl::BlenderConnection::DataStream::Actor::Armature;
 

DataSpec/DNAMP2/CINF.hpp

@@ -109,6 +109,11 @@ struct CINF : BigDNA
 
         os << "bpy.ops.object.mode_set(mode='OBJECT')\n";
     }
+
+    static std::string GetCINFArmatureName(const UniqueID32& cinfId)
+    {
+        return hecl::Format("CINF_%08X", cinfId.toUint32());
+    }
 };
 
 }

DataSpec/DNAMP3/CINF.hpp

@@ -42,6 +42,11 @@ struct CINF : DNAMP2::CINF
 
         os << "bpy.ops.object.mode_set(mode='OBJECT')\n";
     }
+
+    static std::string GetCINFArmatureName(const UniqueID64& cinfId)
+    {
+        return hecl::Format("CINF_%016" PRIX64, cinfId.toUint64());
+    }
 };
 
 }

hecl

@@ -1 +1 @@
-Subproject commit 71e97f724085893d27eaab6da71abf02aa37cb1b
+Subproject commit 76788ee293a8e25131e6fae118b9337f70b8f371

specter

@@ -1 +1 @@
-Subproject commit a1d60af72c17c4df4152f36766ec9e39c9c56200
+Subproject commit 38768581b2fb0504a4e1043333176ebc9bc86d13