Read BSSubIndexTriShape

It's currently handled exactly like BSTriShape, which works ok enough for our purposes

components/nif/niffile.cpp

@@ -280,6 +280,7 @@ namespace Nif
             { "BSLODTriShape", &construct<BSLODTriShape, RC_BSLODTriShape> },
             { "BSMeshLODTriShape", &construct<BSMeshLODTriShape, RC_BSMeshLODTriShape> },
             { "BSSegmentedTriShape", &construct<BSSegmentedTriShape, RC_BSSegmentedTriShape> },
+            { "BSSubIndexTriShape", &construct<BSSubIndexTriShape, RC_BSSubIndexTriShape> },
 
             // PARTICLES
 

components/nif/node.cpp

@@ -218,17 +218,20 @@ namespace Nif
         }
     }
 
+    void BSSegmentedTriShape::SegmentData::read(NIFStream* nif)
+    {
+        nif->read(mFlags);
+        nif->read(mStartIndex);
+        nif->read(mNumTriangles);
+    }
+
     void BSSegmentedTriShape::read(NIFStream* nif)
     {
         NiTriShape::read(nif);
 
         mSegments.resize(nif->get<uint32_t>());
         for (SegmentData& segment : mSegments)
-        {
-            nif->read(segment.mFlags);
-            nif->read(segment.mStartIndex);
-            nif->read(segment.mNumTriangles);
-        }
+            segment.read(nif);
     }
 
     void BSLODTriShape::read(NIFStream* nif)
@@ -447,6 +450,68 @@ namespace Nif
         nif->readArray(mLOD);
     }
 
+    void BSSubIndexTriShape::SubSegment::read(NIFStream* nif)
+    {
+        nif->read(mStartIndex);
+        nif->read(mNumPrimitives);
+        nif->read(mArrayIndex);
+        nif->skip(4); // Unknown
+    }
+
+    void BSSubIndexTriShape::Segment::read(NIFStream* nif)
+    {
+        nif->read(mStartIndex);
+        nif->read(mNumPrimitives);
+        nif->read(mParentArrayIndex);
+        mSubSegments.resize(nif->get<uint32_t>());
+        for (SubSegment& subsegment : mSubSegments)
+            subsegment.read(nif);
+    }
+
+    void BSSubIndexTriShape::SubSegmentDataRecord::read(NIFStream* nif)
+    {
+        nif->read(mUserSlotID);
+        nif->read(mMaterial);
+        nif->readVector(mExtraData, nif->get<uint32_t>());
+    }
+
+    void BSSubIndexTriShape::SubSegmentData::read(NIFStream* nif)
+    {
+        uint32_t numArrayIndices;
+        nif->read(numArrayIndices);
+        mDataRecords.resize(nif->get<uint32_t>());
+        nif->readVector(mArrayIndices, numArrayIndices);
+        for (SubSegmentDataRecord& dataRecord : mDataRecords)
+            dataRecord.read(nif);
+        mSSFFile = nif->getSizedString(nif->get<uint16_t>());
+    }
+
+    void BSSubIndexTriShape::Segmentation::read(NIFStream* nif)
+    {
+        nif->read(mNumPrimitives);
+        mSegments.resize(nif->get<uint32_t>());
+        nif->read(mNumTotalSegments);
+        for (Segment& segment : mSegments)
+            segment.read(nif);
+
+        if (mSegments.size() < mNumTotalSegments)
+            mSubSegmentData.read(nif);
+    }
+
+    void BSSubIndexTriShape::read(NIFStream* nif)
+    {
+        BSTriShape::read(nif);
+
+        if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
+        {
+            mSegments.resize(nif->get<uint32_t>());
+            for (BSSegmentedTriShape::SegmentData& segment : mSegments)
+                segment.read(nif);
+        }
+        else if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4 && mDataSize > 0)
+            mSegmentation.read(nif);
+    }
+
     void BSVertexDesc::read(NIFStream* nif)
     {
         uint64_t data;

components/nif/node.hpp

@@ -164,6 +164,8 @@ namespace Nif
             uint8_t mFlags;
             uint32_t mStartIndex;
             uint32_t mNumTriangles;
+
+            void read(NIFStream* nif);
         };
 
         std::vector<SegmentData> mSegments;
@@ -396,6 +398,61 @@ namespace Nif
         void read(NIFStream* nif) override;
     };
 
+    struct BSSubIndexTriShape : BSTriShape
+    {
+        struct SubSegment
+        {
+            uint32_t mStartIndex;
+            uint32_t mNumPrimitives;
+            uint32_t mArrayIndex;
+
+            void read(NIFStream* nif);
+        };
+
+        struct Segment
+        {
+            uint32_t mStartIndex;
+            uint32_t mNumPrimitives;
+            uint32_t mParentArrayIndex;
+            std::vector<SubSegment> mSubSegments;
+
+            void read(NIFStream* nif);
+        };
+
+        struct SubSegmentDataRecord
+        {
+            uint32_t mUserSlotID;
+            uint32_t mMaterial;
+            std::vector<float> mExtraData;
+
+            void read(NIFStream* nif);
+        };
+
+        struct SubSegmentData
+        {
+            std::vector<uint32_t> mArrayIndices;
+            std::vector<SubSegmentDataRecord> mDataRecords;
+            std::string mSSFFile;
+
+            void read(NIFStream* nif);
+        };
+
+        struct Segmentation
+        {
+            uint32_t mNumPrimitives;
+            uint32_t mNumTotalSegments;
+            std::vector<Segment> mSegments;
+            SubSegmentData mSubSegmentData;
+
+            void read(NIFStream* nif);
+        };
+
+        std::vector<BSSegmentedTriShape::SegmentData> mSegments; // SSE
+        Segmentation mSegmentation; // FO4
+
+        void read(NIFStream* nif) override;
+    };
+
     struct BSValueNode : NiNode
     {
         enum Flags

components/nif/record.hpp

@@ -132,6 +132,7 @@ namespace Nif
         RC_BSSkinBoneData,
         RC_BSSkinInstance,
         RC_BSSkyShaderProperty,
+        RC_BSSubIndexTriShape,
         RC_BSTriShape,
         RC_BSWArray,
         RC_BSWaterShaderProperty,

components/nifosg/nifloader.cpp

@@ -109,6 +109,7 @@ namespace
             case Nif::RC_BSTriShape:
             case Nif::RC_BSDynamicTriShape:
             case Nif::RC_BSMeshLODTriShape:
+            case Nif::RC_BSSubIndexTriShape:
                 return true;
         }
         return false;