mirror
/
openmw
mirror of https://github.com/OpenMW/openmw
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'nifresizepurge' into 'master' 

Reserve capacity for the remaining NIF collections

See merge request OpenMW/openmw!5049
This commit is contained in:
Alexei Kotov 2025-12-16 12:11:19 +03:00
parent 8b92f68537 3927eaef66
commit 1e5979b80f
7 changed files with 165 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
components/nif/controller.cpp
View File

@ -211,10 +211,9 @@ namespace Nif
nif->read(mSpawnMultiplier);
nif->read(mSpawnSpeedChaos);
nif->read(mSpawnDirChaos);
mParticles.resize(nif->get<uint16_t>());
const uint16_t numParticles = nif->get<uint16_t>();
nif->read(mNumValid);
for (NiParticleInfo& particle : mParticles)
particle.read(nif);
nif->readVectorOfRecords(numParticles, mParticles);
nif->skip(4); // NiEmitterModifier link
}
mModifier.read(nif);
@ -347,9 +346,7 @@ namespace Nif
{
NiInterpController::read(nif);
mExtraTargets.resize(nif->get<uint16_t>());
for (NiAVObjectPtr& extraTarget : mExtraTargets)
extraTarget.read(nif);
nif->readVectorOfRecords<uint16_t>(mExtraTargets);
}
void NiMultiTargetTransformController::post(Reader& nif)
@ -413,12 +410,13 @@ namespace Nif
return;
}
mInterpolators.resize(nif->get<uint32_t>());
mWeights.resize(mInterpolators.size());
for (size_t i = 0; i < mInterpolators.size(); i++)
const uint32_t numInterpolators = nif->get<uint32_t>();
mInterpolators.reserve(numInterpolators);
mWeights.reserve(numInterpolators);
for (size_t i = 0; i < numInterpolators; ++i)
{
mInterpolators[i].read(nif);
nif->read(mWeights[i]);
mInterpolators.emplace_back().read(nif);
nif->read(mWeights.emplace_back());
}
}
@ -733,7 +731,7 @@ namespace Nif
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 112))
{
nif->read(mFlags);
mItems.resize(nif->get<uint8_t>());
const uint8_t numItems = nif->get<uint8_t>();
nif->read(mWeightThreshold);
if (!(mFlags & Flag_ManagerControlled))
{
@ -745,17 +743,14 @@ namespace Nif
nif->read(mHighWeightsSum);
nif->read(mNextHighWeightsSum);
nif->read(mHighEaseSpinner);
for (Item& item : mItems)
item.read(nif);
nif->readVectorOfRecords(numItems, mItems);
}
return;
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 110))
{
mItems.resize(nif->get<uint8_t>());
for (Item& item : mItems)
item.read(nif);
nif->readVectorOfRecords<uint8_t>(mItems);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);
@ -770,10 +765,9 @@ namespace Nif
return;
}
mItems.resize(nif->get<uint16_t>());
const uint16_t numItems = nif->get<uint16_t>();
nif->read(mArrayGrowBy);
for (Item& item : mItems)
item.read(nif);
nif->readVectorOfRecords(numItems, mItems);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);

141
components/nif/data.cpp
View File

@ -17,6 +17,24 @@ namespace Nif
stream.read(weight);
}
void readNiTriShapeDataMatchGroup(NIFStream& stream, std::vector<unsigned short>& value)
{
stream.readVector(value, stream.get<uint16_t>());
}
struct ReadNiGeometryDataUVSet
{
uint16_t mNumVertices;
void operator()(NIFStream& stream, std::vector<osg::Vec2f>& value) const
{
stream.readVector(value, mNumVertices);
// Flip the texture coordinates to convert them to the OpenGL convention of bottom-left image origin
for (osg::Vec2f& uv : value)
uv.y() = 1.f - uv.y();
}
};
struct ReadNiSkinDataBoneInfo
{
bool mHasVertexWeights;
@ -46,6 +64,27 @@ namespace Nif
stream.readVector(value.mVertices, mNumVerts);
}
};
struct ReadNiAdditionalGeometryDataDataBlock
{
bool mBSPacked;
void operator()(NIFStream& stream, NiAdditionalGeometryData::DataBlock& value) const
{
stream.read(value.mValid);
if (!value.mValid)
return;
stream.read(value.mBlockSize);
stream.readVector(value.mBlockOffsets, stream.get<uint32_t>());
stream.readVector(value.mDataSizes, stream.get<uint32_t>());
stream.readVector(value.mData, value.mDataSizes.size() * value.mBlockSize);
if (!mBSPacked)
return;
stream.read(value.mShaderIndex);
stream.read(value.mTotalSize);
}
};
}
void NiGeometryData::read(NIFStream* nif)
@ -118,14 +157,8 @@ namespace Nif
if (hasData)
{
mUVList.resize(numUVs);
for (std::vector<osg::Vec2f>& list : mUVList)
{
nif->readVector(list, mNumVertices);
// flip the texture coordinates to convert them to the OpenGL convention of bottom-left image origin
for (osg::Vec2f& uv : list)
uv.y() = 1.f - uv.y();
}
const ReadNiGeometryDataUVSet readUVSet{ .mNumVertices = mNumVertices };
nif->readVectorOfRecords(numUVs, readUVSet, mUVList);
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
@ -152,9 +185,7 @@ namespace Nif
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD && !nif->get<bool>())
numIndices = 0;
nif->readVector(mTriangles, numIndices);
mMatchGroups.resize(nif->get<uint16_t>());
for (auto& group : mMatchGroups)
nif->readVector(group, nif->get<uint16_t>());
nif->readVectorOfRecords<uint16_t>(readNiTriShapeDataMatchGroup, mMatchGroups);
}
void NiTriStripsData::read(NIFStream* nif)
@ -165,11 +196,12 @@ namespace Nif
nif->read(numStrips);
std::vector<uint16_t> lengths;
nif->readVector(lengths, numStrips);
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD && !nif->get<bool>())
numStrips = 0;
mStrips.resize(numStrips);
for (int i = 0; i < numStrips; i++)
nif->readVector(mStrips[i], lengths[i]);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD || nif->get<bool>())
{
mStrips.reserve(numStrips);
for (size_t i = 0; i < numStrips; ++i)
nif->readVector(mStrips.emplace_back(), lengths[i]);
}
}
void NiLinesData::read(NIFStream* nif)
@ -403,19 +435,20 @@ namespace Nif
mPartitions.post(nif);
}
void BSSkinBoneData::BoneInfo::read(NIFStream* nif)
{
nif->read(mBoundSphere);
nif->read(mTransform);
}
void BSSkinBoneData::read(NIFStream* nif)
{
mBones.resize(nif->get<uint32_t>());
for (BoneInfo& bone : mBones)
{
nif->read(bone.mBoundSphere);
nif->read(bone.mTransform);
}
nif->readVectorOfRecords<uint32_t>(mBones);
}
void NiSkinPartition::read(NIFStream* nif)
{
mPartitions.resize(nif->get<uint32_t>());
const uint32_t numPartitions = nif->get<uint32_t>();
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
{
@ -423,13 +456,13 @@ namespace Nif
nif->read(mVertexSize);
mVertexDesc.read(nif);
mVertexData.resize(mDataSize / mVertexSize);
for (auto& vertexData : mVertexData)
vertexData.read(nif, mVertexDesc.mFlags);
uint32_t numVertices = mDataSize / mVertexSize;
mVertexData.reserve(numVertices);
for (uint32_t i = 0; i < numVertices; ++i)
mVertexData.emplace_back().read(nif, mVertexDesc.mFlags);
}
for (auto& partition : mPartitions)
partition.read(nif);
nif->readVectorOfRecords(numPartitions, mPartitions);
}
void NiSkinPartition::Partition::read(NIFStream* nif)
@ -452,9 +485,9 @@ namespace Nif
{
if (numStrips)
{
mStrips.resize(numStrips);
for (size_t i = 0; i < numStrips; i++)
nif->readVector(mStrips[i], stripLengths[i]);
mStrips.reserve(numStrips);
for (size_t i = 0; i < numStrips; ++i)
nif->readVector(mStrips.emplace_back(), stripLengths[i]);
}
else
nif->readVector(mTriangles, numTriangles * 3);
@ -524,17 +557,15 @@ namespace Nif
void NiPalette::read(NIFStream* nif)
{
bool useAlpha = nif->get<uint8_t>() != 0;
uint32_t alphaMask = useAlpha ? 0 : 0xFF000000;
uint32_t numEntries;
nif->read(numEntries);
// Fill the entire palette with black even if there isn't enough entries.
mColors.resize(numEntries > 256 ? numEntries : 256);
const bool useAlpha = nif->get<uint8_t>() != 0;
const uint32_t alphaMask = useAlpha ? 0 : 0xFF000000;
const uint32_t numEntries = nif->get<uint32_t>();
for (uint32_t i = 0; i < numEntries; i++)
{
nif->read(mColors[i]);
mColors[i] |= alphaMask;
const uint32_t color = nif->get<uint32_t>();
// Indices past 255 are always unused
if (i < 256)
mColors[i] = color | alphaMask;
}
}
@ -566,12 +597,10 @@ namespace Nif
void NiAdditionalGeometryData::read(NIFStream* nif)
{
nif->read(mNumVertices);
mBlockInfos.resize(nif->get<uint32_t>());
for (DataStream& info : mBlockInfos)
info.read(nif);
mBlocks.resize(nif->get<uint32_t>());
for (DataBlock& block : mBlocks)
block.read(nif, recType == RC_BSPackedAdditionalGeometryData);
nif->readVectorOfRecords<uint32_t>(mBlockInfos);
const ReadNiAdditionalGeometryDataDataBlock readDataBlock{ .mBSPacked
= recType == RC_BSPackedAdditionalGeometryData };
nif->readVectorOfRecords<uint32_t>(readDataBlock, mBlocks);
}
void NiAdditionalGeometryData::DataStream::read(NIFStream* nif)
@ -585,22 +614,6 @@ namespace Nif
nif->read(mFlags);
}
void NiAdditionalGeometryData::DataBlock::read(NIFStream* nif, bool bsPacked)
{
nif->read(mValid);
if (!mValid)
return;
nif->read(mBlockSize);
nif->readVector(mBlockOffsets, nif->get<uint32_t>());
nif->readVector(mDataSizes, nif->get<uint32_t>());
nif->readVector(mData, mDataSizes.size() * mBlockSize);
if (bsPacked)
{
nif->read(mShaderIndex);
nif->read(mTotalSize);
}
}
void BSMultiBound::read(NIFStream* nif)
{
mData.read(nif);
@ -646,9 +659,7 @@ namespace Nif
void BSAnimNotes::read(NIFStream* nif)
{
mList.resize(nif->get<uint16_t>());
for (auto& note : mList)
note.read(nif);
nif->readVectorOfRecords<uint16_t>(mList);
}
void BSAnimNotes::post(Reader& nif)

10
components/nif/data.hpp
View File

@ -266,6 +266,8 @@ namespace Nif
{
osg::BoundingSpheref mBoundSphere;
NiTransform mTransform;
void read(NIFStream* nif);
};
std::vector<BoneInfo> mBones;
@ -293,8 +295,8 @@ namespace Nif
};
std::vector<Partition> mPartitions;
unsigned int mDataSize;
unsigned int mVertexSize;
uint32_t mDataSize;
uint32_t mVertexSize;
BSVertexDesc mVertexDesc;
std::vector<BSVertexData> mVertexData;
@ -348,7 +350,7 @@ namespace Nif
struct NiPalette : public Record
{
// 32-bit RGBA colors that correspond to 8-bit indices
std::vector<uint32_t> mColors;
std::array<uint32_t, 256> mColors{};
void read(NIFStream* nif) override;
};
@ -406,8 +408,6 @@ namespace Nif
std::vector<char> mData;
uint32_t mShaderIndex;
uint32_t mTotalSize;
void read(NIFStream* nif, bool bsPacked);
};
uint16_t mNumVertices;

29
components/nif/extra.cpp
View File

@ -64,11 +64,10 @@ namespace Nif
{
Extra::read(nif);
const uint32_t num = nif->get<uint32_t>();
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
nif->readVectorOfRecords(num, mLegacyMarkers);
nif->readVectorOfRecords<uint32_t>(mLegacyMarkers);
else
nif->readVectorOfRecords(num, mMarkers);
nif->readVectorOfRecords<uint32_t>(mMarkers);
}
void BSInvMarker::read(NIFStream* nif)
@ -94,9 +93,7 @@ namespace Nif
{
Extra::read(nif);
mData.resize(nif->get<uint32_t>());
for (BoneLOD& lod : mData)
lod.read(nif);
nif->readVectorOfRecords<uint32_t>(mData);
}
void BSBoneLODExtraData::BoneLOD::read(NIFStream* nif)
@ -109,9 +106,7 @@ namespace Nif
{
NiFloatExtraData::read(nif);
mBlocks.resize(nif->get<uint16_t>());
for (Block& block : mBlocks)
block.read(nif);
nif->readVectorOfRecords<uint16_t>(mBlocks);
}
void BSDecalPlacementVectorExtraData::Block::read(NIFStream* nif)
@ -143,9 +138,7 @@ namespace Nif
{
NiExtraData::read(nif);
mPoints.resize(nif->get<uint32_t>());
for (Point& point : mPoints)
point.read(nif);
nif->readVectorOfRecords<uint32_t>(mPoints);
}
void BSConnectPoint::Children::read(NIFStream* nif)
@ -179,9 +172,7 @@ namespace Nif
nif->read(mLOD1TriOffset);
nif->read(mLOD2TriCount);
nif->read(mLOD2TriOffset);
mCombined.resize(nif->get<uint32_t>());
for (BSPackedGeomDataCombined& data : mCombined)
data.read(nif);
nif->readVectorOfRecords<uint32_t>(mCombined);
mVertexDesc.read(nif);
}
@ -194,12 +185,8 @@ namespace Nif
nif->read(mNumTriangles);
nif->read(mFlags1);
nif->read(mFlags2);
mObjects.resize(nif->get<uint32_t>());
for (BSPackedGeomObject& object : mObjects)
object.read(nif);
mObjectData.resize(mObjects.size());
for (BSPackedSharedGeomData& objectData : mObjectData)
objectData.read(nif);
nif->readVectorOfRecords<uint32_t>(mObjects);
nif->readVectorOfRecords(mObjects.size(), mObjectData);
}
}

89
components/nif/node.cpp
View File

@ -63,6 +63,16 @@ namespace
namespace Nif
{
namespace
{
void readBSDistantObjectInstanceTransform(NIFStream& stream, osg::Matrixf& value)
{
std::array<float, 16> mat;
stream.readArray(mat);
value.set(mat.data());
}
}
void BoundingVolume::read(NIFStream* nif)
{
nif->read(mType);
@ -200,12 +210,13 @@ namespace Nif
{
if (nif->getVersion() < NIFStream::generateVersion(10, 0, 1, 0))
return;
std::uint32_t numNames = 0;
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
mNames.resize(nif->get<uint32_t>());
numNames = nif->get<uint32_t>();
else if (nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 3))
mNames.resize(nif->get<bool>());
nif->readVector(mNames, mNames.size());
nif->readVector(mExtra, mNames.size());
numNames = nif->get<bool>();
nif->readVector(mNames, numNames);
nif->readVector(mExtra, numNames);
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
nif->read(mActive);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS)
@ -371,9 +382,7 @@ namespace Nif
{
NiTriShape::read(nif);
mSegments.resize(nif->get<uint32_t>());
for (SegmentData& segment : mSegments)
segment.read(nif);
nif->readVectorOfRecords<uint32_t>(mSegments);
}
void BSLODTriShape::read(NIFStream* nif)
@ -540,17 +549,19 @@ namespace Nif
mAlphaProperty.read(nif);
mVertDesc.read(nif);
size_t numTriangleIndices;
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
mTriangles.resize(nif->get<uint32_t>() * 3);
numTriangleIndices = nif->get<uint32_t>() * 3;
else
mTriangles.resize(nif->get<uint16_t>() * 3);
mVertData.resize(nif->get<uint16_t>());
numTriangleIndices = nif->get<uint16_t>() * 3;
nif->read(mNumVertices);
mVertData.reserve(mNumVertices);
nif->read(mDataSize);
if (mDataSize > 0)
{
for (auto& vertex : mVertData)
vertex.read(nif, mVertDesc.mFlags);
nif->readVector(mTriangles, mTriangles.size());
for (uint16_t i = 0; i < mNumVertices; ++i)
mVertData.emplace_back().read(nif, mVertDesc.mFlags);
nif->readVector(mTriangles, numTriangleIndices);
}
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
@ -558,9 +569,9 @@ namespace Nif
nif->read(mParticleDataSize);
if (mParticleDataSize > 0)
{
nif->readVector(mParticleVerts, mVertData.size() * 3);
nif->readVector(mParticleNormals, mVertData.size() * 3);
nif->readVector(mParticleTriangles, mTriangles.size());
nif->readVector(mParticleVerts, mNumVertices * 3);
nif->readVector(mParticleNormals, mNumVertices * 3);
nif->readVector(mParticleTriangles, numTriangleIndices);
}
}
}
@ -582,8 +593,8 @@ namespace Nif
nif->read(mDynamicDataSize);
// nifly style.
// Consider complaining if mDynamicDataSize * 16 != mVertData.size()?
nif->readVector(mDynamicData, mVertData.size());
// Consider complaining if mDynamicDataSize * 16 != mNumVertices?
nif->readVector(mDynamicData, mNumVertices);
}
void BSMeshLODTriShape::read(NIFStream* nif)
@ -606,9 +617,7 @@ namespace Nif
nif->read(mStartIndex);
nif->read(mNumPrimitives);
nif->read(mParentArrayIndex);
mSubSegments.resize(nif->get<uint32_t>());
for (SubSegment& subsegment : mSubSegments)
subsegment.read(nif);
nif->readVectorOfRecords<uint32_t>(mSubSegments);
}
void BSSubIndexTriShape::SubSegmentDataRecord::read(NIFStream* nif)
@ -622,22 +631,19 @@ namespace Nif
{
uint32_t numArrayIndices;
nif->read(numArrayIndices);
mDataRecords.resize(nif->get<uint32_t>());
const uint32_t numRecords = nif->get<uint32_t>();
nif->readVector(mArrayIndices, numArrayIndices);
for (SubSegmentDataRecord& dataRecord : mDataRecords)
dataRecord.read(nif);
nif->readVectorOfRecords(numRecords, mDataRecords);
mSSFFile = nif->getSizedString(nif->get<uint16_t>());
}
void BSSubIndexTriShape::Segmentation::read(NIFStream* nif)
{
nif->read(mNumPrimitives);
mSegments.resize(nif->get<uint32_t>());
const uint32_t numSegments = nif->get<uint32_t>();
nif->read(mNumTotalSegments);
for (Segment& segment : mSegments)
segment.read(nif);
if (mSegments.size() < mNumTotalSegments)
nif->readVectorOfRecords(numSegments, mSegments);
if (numSegments < mNumTotalSegments)
mSubSegmentData.read(nif);
}
@ -646,11 +652,7 @@ namespace 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);
}
nif->readVectorOfRecords<uint32_t>(mSegments);
else if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4 && mDataSize > 0)
mSegmentation.read(nif);
}
@ -752,30 +754,23 @@ namespace Nif
{
mResourceID.read(nif);
nif->skip(12 * nif->get<uint32_t>()); // Unknown data
mTransforms.resize(nif->get<uint32_t>());
for (osg::Matrixf& transform : mTransforms)
{
std::array<float, 16> mat;
nif->readArray(mat);
transform.set(mat.data());
}
nif->readVectorOfRecords<uint32_t>(readBSDistantObjectInstanceTransform, mTransforms);
}
void BSShaderTextureArray::read(NIFStream* nif)
{
nif->skip(1); // Unknown
mTextureArrays.resize(nif->get<uint32_t>());
for (std::vector<std::string>& textureArray : mTextureArrays)
nif->getSizedStrings(textureArray, nif->get<uint32_t>());
const uint32_t numArrays = nif->get<uint32_t>();
mTextureArrays.reserve(numArrays);
for (uint32_t i = 0; i < numArrays; ++i)
nif->getSizedStrings(mTextureArrays.emplace_back(), nif->get<uint32_t>());
}
void BSDistantObjectInstancedNode::read(NIFStream* nif)
{
BSMultiBoundNode::read(nif);
mInstances.resize(nif->get<uint32_t>());
for (BSDistantObjectInstance& instance : mInstances)
instance.read(nif);
nif->readVectorOfRecords<uint32_t>(mInstances);
for (BSShaderTextureArray& textureArray : mShaderTextureArrays)
textureArray.read(nif);
}

1
components/nif/node.hpp
View File

@ -385,6 +385,7 @@ namespace Nif
NiAlphaPropertyPtr mAlphaProperty;
BSVertexDesc mVertDesc;
uint32_t mDataSize;
uint16_t mNumVertices;
std::vector<BSVertexData> mVertData;
std::vector<unsigned short> mTriangles;
uint32_t mParticleDataSize;

87
components/nif/physics.cpp
View File

@ -7,6 +7,13 @@
namespace Nif
{
namespace
{
void readBoneTransformGroup(NIFStream& stream, std::vector<bhkPoseArray::BoneTransform>& value)
{
stream.readVectorOfRecords<uint32_t>(value);
}
}
/// Non-record data types
@ -566,13 +573,7 @@ namespace Nif
void bhkPackedNiTriStripsShape::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
uint16_t numSubshapes;
nif->read(numSubshapes);
mSubshapes.resize(numSubshapes);
for (hkSubPartData& subshape : mSubshapes)
subshape.read(nif);
}
nif->readVectorOfRecords<uint16_t>(mSubshapes);
nif->read(mUserData);
nif->skip(4); // Unused
nif->read(mRadius);
@ -589,12 +590,7 @@ namespace Nif
void hkPackedNiTriStripsData::read(NIFStream* nif)
{
uint32_t numTriangles;
nif->read(numTriangles);
mTriangles.resize(numTriangles);
for (uint32_t i = 0; i < numTriangles; i++)
mTriangles[i].read(nif);
nif->readVectorOfRecords<uint32_t>(mTriangles);
uint32_t numVertices;
nif->read(numVertices);
bool compressed = false;
@ -605,13 +601,7 @@ namespace Nif
else
nif->skip(6 * numVertices); // Half-precision vectors are not currently supported
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS)
{
uint16_t numSubshapes;
nif->read(numSubshapes);
mSubshapes.resize(numSubshapes);
for (hkSubPartData& subshape : mSubshapes)
subshape.read(nif);
}
nif->readVectorOfRecords<uint16_t>(mSubshapes);
}
void bhkSphereRepShape::read(NIFStream* nif)
@ -733,9 +723,7 @@ namespace Nif
nif->read(mRadius);
nif->skip(8); // Unknown
nif->read(mScale);
mShapeProperties.resize(nif->get<uint32_t>());
for (bhkWorldObjCInfoProperty& property : mShapeProperties)
property.read(nif);
nif->readVectorOfRecords<uint32_t>(mShapeProperties);
nif->skip(12); // Unknown
readRecordList(nif, mDataList);
}
@ -759,11 +747,7 @@ namespace Nif
mHavokMaterial.read(nif);
mChildShapeProperty.read(nif);
mChildFilterProperty.read(nif);
uint32_t numFilters;
nif->read(numFilters);
mHavokFilters.resize(numFilters);
for (HavokFilter& filter : mHavokFilters)
filter.read(nif);
nif->readVectorOfRecords<uint32_t>(mHavokFilters);
}
void bhkListShape::post(Reader& nif)
@ -803,35 +787,12 @@ namespace Nif
nif->skip(nif->get<uint32_t>() * 4); // Unused
nif->skip(nif->get<uint32_t>() * 4); // Unused
nif->skip(nif->get<uint32_t>() * 4); // Unused
uint32_t numMaterials;
nif->read(numMaterials);
mMaterials.resize(numMaterials);
for (bhkMeshMaterial& material : mMaterials)
material.read(nif);
nif->readVectorOfRecords<uint32_t>(mMaterials);
nif->skip(4); // Unused
uint32_t numTransforms;
nif->read(numTransforms);
mChunkTransforms.resize(numTransforms);
for (bhkQsTransform& transform : mChunkTransforms)
transform.read(nif);
nif->readVectorOfRecords<uint32_t>(mChunkTransforms);
nif->readVector(mBigVerts, nif->get<uint32_t>());
uint32_t numBigTriangles;
nif->read(numBigTriangles);
mBigTris.resize(numBigTriangles);
for (bhkCMSBigTri& tri : mBigTris)
tri.read(nif);
uint32_t numChunks;
nif->read(numChunks);
mChunks.resize(numChunks);
for (bhkCMSChunk& chunk : mChunks)
chunk.read(nif);
nif->readVectorOfRecords<uint32_t>(mBigTris);
nif->readVectorOfRecords<uint32_t>(mChunks);
nif->skip(4); // Unused
}
@ -910,9 +871,7 @@ namespace Nif
if (numPivots % 2 != 0)
throw Nif::Exception(
"Invalid number of constraints in bhkBallSocketConstraintChain", nif->getFile().getFilename());
mConstraints.resize(numPivots / 2);
for (bhkBallAndSocketConstraintCInfo& info : mConstraints)
info.read(nif);
nif->readVectorOfRecords(numPivots / 2, mConstraints);
nif->read(mTau);
nif->read(mDamping);
nif->read(mConstraintForceMixing);
@ -1009,9 +968,7 @@ namespace Nif
nif->read(mFriction);
nif->read(mRadius);
mHavokMaterial.read(nif);
mConstraints.resize(nif->get<uint32_t>());
for (bhkWrappedConstraintData& constraint : mConstraints)
constraint.read(nif);
nif->readVectorOfRecords<uint32_t>(mConstraints);
}
void bhkPoseArray::BoneTransform::read(NIFStream* nif)
@ -1024,13 +981,7 @@ namespace Nif
void bhkPoseArray::read(NIFStream* nif)
{
nif->readVector(mBones, nif->get<uint32_t>());
mPoses.resize(nif->get<uint32_t>());
for (std::vector<BoneTransform>& pose : mPoses)
{
pose.resize(nif->get<uint32_t>());
for (BoneTransform& transform : pose)
transform.read(nif);
}
nif->readVectorOfRecords<uint32_t>(readBoneTransformGroup, mPoses);
}
} // Namespace