Work on CFBStreamedCompression; defined 24-bit ANIM3 format

2025-12-08 21:47:42 +00:00 · 2016-08-26 12:23:59 -10:00
parent d9448cae05
commit f9cef44029
22 changed files with 526 additions and 85 deletions
--- a/Runtime/Character/CFBStreamedCompression.cpp
+++ b/Runtime/Character/CFBStreamedCompression.cpp
@@ -0,0 +1,112 @@
+#include "CFBStreamedCompression.hpp"
+
+namespace urde
+{
+
+CFBStreamedCompression::CFBStreamedCompression(CInputStream& in, IObjectStore& objStore)
+{
+    x0_scratchSize = in.readUint32Big();
+    x4_evnt = in.readUint32Big();
+
+    xc_rotsAndOffs = GetRotationsAndOffsets(x0_scratchSize / 4 + 1, in);
+
+    if (x4_evnt)
+        x8_evntToken = objStore.GetObj(SObjectTag{FOURCC('EVNT'), x4_evnt});
+}
+
+std::unique_ptr<u32[]> CFBStreamedCompression::GetRotationsAndOffsets(u32 words, CInputStream& in)
+{
+    std::unique_ptr<u32[]> ret(new u32[words]);
+
+    Header head;
+    head.read(in);
+    *reinterpret_cast<Header*>(ret.get()) = head;
+
+    u32* bitmapOut = &ret[9];
+    u32 bitmapBitCount = in.readUint32Big();
+    bitmapOut[0] = bitmapBitCount;
+    u32 bitmapWordCount = (bitmapBitCount + 31) / 32;
+    for (u32 i=0 ; i<bitmapWordCount ; ++i)
+        bitmapOut[i+1] = in.readUint32Big();
+
+    in.readUint32Big();
+    u8* chans = reinterpret_cast<u8*>(bitmapOut + bitmapWordCount + 1);
+    u8* bs = ReadBoneChannelDescriptors(chans, in);
+    u32 bsWords = ComputeBitstreamWords(chans);
+
+    u32* bsPtr = reinterpret_cast<u32*>(bs);
+    for (u32 w=0 ; w<bsWords ; ++w)
+        bsPtr[w] = in.readUint32Big();
+
+    return ret;
+}
+
+u8* CFBStreamedCompression::ReadBoneChannelDescriptors(u8* out, CInputStream& in)
+{
+    u32 boneChanCount = in.readUint32Big();
+    *reinterpret_cast<u32*>(out) = boneChanCount;
+    out += 4;
+
+    for (int b=0 ; b<boneChanCount ; ++b)
+    {
+        *reinterpret_cast<u32*>(out) = in.readUint32Big();
+        out += 4;
+
+        *reinterpret_cast<u16*>(out) = in.readUint16Big();
+        out += 2;
+
+        for (int i=0 ; i<3 ; ++i)
+        {
+            *reinterpret_cast<s16*>(out) = in.readInt16Big();
+            out += 2;
+            *reinterpret_cast<u8*>(out) = in.readUByte();
+            out += 1;
+        }
+
+        u16 tCount = in.readUint16Big();
+        *reinterpret_cast<u16*>(out) = tCount;
+        out += 2;
+
+        if (tCount)
+        {
+            for (int i=0 ; i<3 ; ++i)
+            {
+                *reinterpret_cast<s16*>(out) = in.readInt16Big();
+                out += 2;
+                *reinterpret_cast<u8*>(out) = in.readUByte();
+                out += 1;
+            }
+        }
+    }
+
+    return out;
+}
+
+u32 CFBStreamedCompression::ComputeBitstreamWords(const u8* chans)
+{
+    u32 boneChanCount = *reinterpret_cast<const u32*>(chans);
+    chans += 4;
+
+    u16 keyCount = *reinterpret_cast<const u16*>(chans);
+
+    u32 totalBits = 0;
+    for (u32 c=0 ; c<boneChanCount ; ++c)
+    {
+        totalBits += *reinterpret_cast<const u8*>(chans + 0x8);
+        totalBits += *reinterpret_cast<const u8*>(chans + 0xb);
+        totalBits += *reinterpret_cast<const u8*>(chans + 0xe);
+        u16 tKeyCount = *reinterpret_cast<const u16*>(chans + 0xf);
+        chans += 0x11;
+        if (tKeyCount)
+        {
+            totalBits += *reinterpret_cast<const u8*>(chans + 0x2);
+            totalBits += *reinterpret_cast<const u8*>(chans + 0x5);
+            totalBits += *reinterpret_cast<const u8*>(chans + 0x8);
+            chans += 0x9;
+        }
+    }
+
+    return (totalBits * keyCount + 31) / 32;
+}
+
+}