CINF/CSKR integration

DataSpec/DNAMP2/CINF.hpp

@@ -0,0 +1,103 @@
+#ifndef _DNAMP2_CINF_HPP_
+#define _DNAMP2_CINF_HPP_
+
+#include "BlenderConnection.hpp"
+#include "../DNACommon/DNACommon.hpp"
+
+namespace Retro
+{
+namespace DNAMP2
+{
+
+struct CINF : BigDNA
+{
+    DECL_DNA
+    Value<atUint32> boneCount;
+    struct Bone : BigDNA
+    {
+        DECL_DNA
+        Value<atUint32> id;
+        Value<atUint32> parentId;
+        Value<atVec3f> origin;
+        Value<atUint32> linkedCount;
+        Vector<atUint32, DNA_COUNT(linkedCount)> linked;
+    };
+    Vector<Bone, DNA_COUNT(boneCount)> bones;
+
+    Value<atUint32> boneIdCount;
+    Vector<atUint32, DNA_COUNT(boneIdCount)> boneIds;
+
+    Value<atUint32> nameCount;
+    struct Name : BigDNA
+    {
+        DECL_DNA
+        String<-1> name;
+        Value<atUint32> boneId;
+    };
+    Vector<Name, DNA_COUNT(nameCount)> names;
+
+    atUint32 getBoneIdxFromId(atUint32 id) const
+    {
+        atUint32 idx = 0;
+        for (atUint32 bid : boneIds)
+        {
+            if (bid == id)
+                return idx;
+            ++idx;
+        }
+        return 0;
+    }
+
+    const std::string* getBoneNameFromId(atUint32 id) const
+    {
+        for (const Name& name : names)
+            if (id == name.boneId)
+                return &name.name;
+        return nullptr;
+    }
+
+    void sendVertexGroupsToBlender(HECL::BlenderConnection::PyOutStream& os) const
+    {
+        for (atUint32 bid : boneIds)
+        {
+            for (const Name& name : names)
+            {
+                if (name.boneId == bid)
+                {
+                    os.format("obj.vertex_groups.new('%s')\n", name.name.c_str());
+                    break;
+                }
+            }
+        }
+    }
+
+    void sendCINFToBlender(HECL::BlenderConnection::PyOutStream& os, const UniqueID32& cinfId) const
+    {
+        os.format("arm = bpy.data.armatures.new('CINF_%08X')\n"
+                  "arm_obj = bpy.data.objects.new(arm.name, arm)\n"
+                  "bpy.context.scene.objects.link(arm_obj)\n"
+                  "bpy.context.scene.objects.active = arm_obj\n"
+                  "bpy.ops.object.mode_set(mode='EDIT')\n"
+                  "arm_bone_table = {}\n",
+                  cinfId.toUint32());
+
+        for (const Bone& bone : bones)
+            os.format("bone = arm.edit_bones.new('%s')\n"
+                      "bone.head = (%f,%f,%f)\n"
+                      "bone.tail = bone.head\n"
+                      "bone.tail[1] += 0.5\n"
+                      "arm_bone_table[%u] = bone\n", getBoneNameFromId(bone.id)->c_str(),
+                      bone.origin.vec[0], bone.origin.vec[1], bone.origin.vec[2], bone.id);
+
+        for (const Bone& bone : bones)
+            if (bone.parentId != 2)
+                os.format("arm_bone_table[%u].parent = arm_bone_table[%u]\n", bone.id, bone.parentId);
+
+        os << "bpy.ops.object.mode_set(mode='OBJECT')\n";
+    }
+};
+
+}
+}
+
+#endif // _DNAMP2_CINF_HPP_

DataSpec/DNAMP2/CMDL.hpp

@@ -5,6 +5,8 @@
 #include "../DNACommon/CMDL.hpp"
 #include "CMDLMaterials.hpp"
 #include "DNAMP2.hpp"
+#include "CINF.hpp"
+#include "CSKR.hpp"
 
 namespace Retro
 {
@@ -23,7 +25,7 @@ struct CMDL
         HECL::BlenderConnection& conn = HECL::BlenderConnection::SharedConnection();
         if (!conn.createBlend(outPath.getAbsolutePath()))
             return false;
-        DNACMDL::ReadCMDLToBlender<PAKRouter<PAKBridge>, MaterialSet, 4>
+        DNACMDL::ReadCMDLToBlender<PAKRouter<PAKBridge>, MaterialSet, std::pair<CSKR*,CINF*>, 4>
                 (conn, rs, pakRouter, entry, dataSpec.getMasterShaderPath());
         return conn.saveBlend();
     }

DataSpec/DNAMP2/CMakeLists.txt

@@ -1,6 +1,8 @@
 make_dnalist(liblist
              MLVL
-             CMDLMaterials)
+             CMDLMaterials
+             CINF
+             CSKR)
 add_library(DNAMP2
             DNAMP2.hpp DNAMP2.cpp
             ${liblist}

DataSpec/DNAMP2/CSKR.hpp

@@ -0,0 +1,50 @@
+#ifndef _DNAMP2_CSKR_HPP_
+#define _DNAMP2_CSKR_HPP_
+
+#include "BlenderConnection.hpp"
+#include "../DNACommon/DNACommon.hpp"
+#include "CINF.hpp"
+
+namespace Retro
+{
+namespace DNAMP2
+{
+
+struct CSKR : BigDNA
+{
+    DECL_DNA
+    Value<atUint32> skinningRuleCount;
+    struct SkinningRule : BigDNA
+    {
+        DECL_DNA
+        Value<atUint32> weightCount;
+        struct Weight : BigDNA
+        {
+            DECL_DNA
+            Value<atUint32> boneId;
+            Value<float> weight;
+        };
+        Vector<Weight, DNA_COUNT(weightCount)> weights;
+        Value<atUint32> vertCount;
+    };
+    Vector<SkinningRule, DNA_COUNT(skinningRuleCount)> skinningRules;
+
+    void weightVertex(HECL::BlenderConnection::PyOutStream& os, const CINF& cinf, atUint32 idx) const
+    {
+        atUint32 accum = 0;
+        for (const SkinningRule& rule : skinningRules)
+        {
+            if (idx < accum + rule.vertCount)
+                for (const SkinningRule::Weight& weight : rule.weights)
+                    os.format("vert[dvert_lay][%u] = %f\n",
+                              cinf.getBoneIdxFromId(weight.boneId),
+                              weight.weight);
+            accum += rule.vertCount;
+        }
+    }
+};
+
+}
+}
+
+#endif // _DNAMP2_CSKR_HPP_

DataSpec/DNAMP2/DNAMP2.cpp

@@ -181,7 +181,7 @@ void PAKBridge::build()
 
 ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const DNAMP1::PAK::Entry& entry)
 {
-    switch (entry.type.toUint32())
+    switch (entry.type)
     {
     case SBIG('STRG'):
         return {STRG::Extract, nullptr, ".yaml"};