|
|
|
@ -1,200 +1,149 @@
|
|
|
|
|
#include "data.hpp"
|
|
|
|
|
|
|
|
|
|
#include <components/debug/debuglog.hpp>
|
|
|
|
|
|
|
|
|
|
#include "exception.hpp"
|
|
|
|
|
#include "nifkey.hpp"
|
|
|
|
|
#include "node.hpp"
|
|
|
|
|
|
|
|
|
|
#include <components/debug/debuglog.hpp>
|
|
|
|
|
|
|
|
|
|
namespace Nif
|
|
|
|
|
{
|
|
|
|
|
void NiSkinInstance::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
data.read(nif);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 101))
|
|
|
|
|
partitions.read(nif);
|
|
|
|
|
root.read(nif);
|
|
|
|
|
readRecordList(nif, bones);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiSkinInstance::post(Reader& nif)
|
|
|
|
|
{
|
|
|
|
|
data.post(nif);
|
|
|
|
|
partitions.post(nif);
|
|
|
|
|
root.post(nif);
|
|
|
|
|
postRecordList(nif, bones);
|
|
|
|
|
|
|
|
|
|
if (data.empty() || root.empty())
|
|
|
|
|
throw Nif::Exception("NiSkinInstance missing root or data", nif.getFilename());
|
|
|
|
|
|
|
|
|
|
if (bones.size() != data->bones.size())
|
|
|
|
|
throw Nif::Exception("Mismatch in NiSkinData bone count", nif.getFilename());
|
|
|
|
|
|
|
|
|
|
for (auto& bone : bones)
|
|
|
|
|
{
|
|
|
|
|
if (bone.empty())
|
|
|
|
|
throw Nif::Exception("Oops: Missing bone! Don't know how to handle this.", nif.getFilename());
|
|
|
|
|
bone->setBone();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void BSDismemberSkinInstance::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiSkinInstance::read(nif);
|
|
|
|
|
unsigned int numPartitions = nif->getUInt();
|
|
|
|
|
nif->skip(4 * numPartitions); // Body part information
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiGeometryData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 114))
|
|
|
|
|
nif->getInt(); // Group ID. (Almost?) always 0.
|
|
|
|
|
nif->read(mGroupId);
|
|
|
|
|
|
|
|
|
|
int verts = nif->getUShort();
|
|
|
|
|
// Note: has special meaning for NiPSysData (unimplemented)
|
|
|
|
|
nif->read(mNumVertices);
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
nif->skip(2); // Keep flags and compress flags
|
|
|
|
|
{
|
|
|
|
|
nif->read(mKeepFlags);
|
|
|
|
|
nif->read(mCompressFlags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
nif->readVector(vertices, verts);
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mVertices, mNumVertices);
|
|
|
|
|
|
|
|
|
|
unsigned int dataFlags = 0;
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
|
|
|
|
|
dataFlags = nif->getUShort();
|
|
|
|
|
{
|
|
|
|
|
nif->read(mDataFlags);
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS
|
|
|
|
|
&& nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
|
|
|
|
|
nif->getUInt(); // Material CRC
|
|
|
|
|
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS
|
|
|
|
|
&& nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
|
|
|
|
|
nif->read(mMaterialHash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
{
|
|
|
|
|
nif->readVector(normals, verts);
|
|
|
|
|
if (dataFlags & 0x1000)
|
|
|
|
|
nif->readVector(mNormals, mNumVertices);
|
|
|
|
|
if (mDataFlags & DataFlag_HasTangents)
|
|
|
|
|
{
|
|
|
|
|
nif->readVector(tangents, verts);
|
|
|
|
|
nif->readVector(bitangents, verts);
|
|
|
|
|
nif->readVector(mTangents, mNumVertices);
|
|
|
|
|
nif->readVector(mBitangents, mNumVertices);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
center = nif->getVector3();
|
|
|
|
|
radius = nif->getFloat();
|
|
|
|
|
nif->read(mBoundingSphere);
|
|
|
|
|
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
nif->readVector(colors, verts);
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mColors, mNumVertices);
|
|
|
|
|
|
|
|
|
|
unsigned int numUVs = dataFlags;
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0))
|
|
|
|
|
numUVs = nif->getUShort();
|
|
|
|
|
nif->read(mDataFlags);
|
|
|
|
|
|
|
|
|
|
// In Morrowind this field only corresponds to the number of UV sets.
|
|
|
|
|
// In later games only the first 6 bits are used as a count and the rest are flags.
|
|
|
|
|
// In 4.0.0.2 the flags field corresponds to the number of UV sets.
|
|
|
|
|
// In later revisions the part that corresponds to the number is narrower.
|
|
|
|
|
uint16_t numUVs = mDataFlags;
|
|
|
|
|
if (nif->getVersion() > NIFFile::NIFVersion::VER_MW)
|
|
|
|
|
{
|
|
|
|
|
numUVs &= 0x3f;
|
|
|
|
|
numUVs &= DataFlag_NumUVsMask;
|
|
|
|
|
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() > 0)
|
|
|
|
|
numUVs &= 0x1;
|
|
|
|
|
numUVs &= DataFlag_HasUV;
|
|
|
|
|
}
|
|
|
|
|
else if (!nif->get<bool>())
|
|
|
|
|
numUVs = 0;
|
|
|
|
|
|
|
|
|
|
bool hasUVs = true;
|
|
|
|
|
if (nif->getVersion() <= NIFFile::NIFVersion::VER_MW)
|
|
|
|
|
hasUVs = nif->getBoolean();
|
|
|
|
|
if (hasUVs)
|
|
|
|
|
mUVList.resize(numUVs);
|
|
|
|
|
for (std::vector<osg::Vec2f>& list : mUVList)
|
|
|
|
|
{
|
|
|
|
|
uvlist.resize(numUVs);
|
|
|
|
|
for (unsigned int i = 0; i < numUVs; i++)
|
|
|
|
|
{
|
|
|
|
|
nif->readVector(uvlist[i], verts);
|
|
|
|
|
// flip the texture coordinates to convert them to the OpenGL convention of bottom-left image origin
|
|
|
|
|
for (unsigned int uv = 0; uv < uvlist[i].size(); ++uv)
|
|
|
|
|
{
|
|
|
|
|
uvlist[i][uv] = osg::Vec2f(uvlist[i][uv].x(), 1.f - uvlist[i][uv].y());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
|
|
|
|
|
nif->getUShort(); // Consistency flags
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
|
|
|
|
|
nif->skip(4); // Additional data
|
|
|
|
|
{
|
|
|
|
|
nif->read(mConsistencyType);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
|
|
|
|
|
nif->skip(4); // Additional data
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiTriBasedGeomData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiGeometryData::read(nif);
|
|
|
|
|
mNumTriangles = nif->getUShort();
|
|
|
|
|
|
|
|
|
|
nif->read(mNumTriangles);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiTriShapeData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiTriBasedGeomData::read(nif);
|
|
|
|
|
|
|
|
|
|
// We have three times as many vertices as triangles, so this
|
|
|
|
|
// is always equal to mNumTriangles * 3.
|
|
|
|
|
int cnt = nif->getInt();
|
|
|
|
|
bool hasTriangles = true;
|
|
|
|
|
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD)
|
|
|
|
|
hasTriangles = nif->getBoolean();
|
|
|
|
|
if (hasTriangles)
|
|
|
|
|
nif->readVector(triangles, cnt);
|
|
|
|
|
|
|
|
|
|
// Read the match list, which lists the vertices that are equal to
|
|
|
|
|
// vertices. We don't actually need need this for anything, so
|
|
|
|
|
// just skip it.
|
|
|
|
|
unsigned short verts = nif->getUShort();
|
|
|
|
|
for (unsigned short i = 0; i < verts; i++)
|
|
|
|
|
{
|
|
|
|
|
// Number of vertices matching vertex 'i'
|
|
|
|
|
int num = nif->getUShort();
|
|
|
|
|
nif->skip(num * sizeof(short));
|
|
|
|
|
}
|
|
|
|
|
uint32_t numIndices;
|
|
|
|
|
nif->read(numIndices);
|
|
|
|
|
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>());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiTriStripsData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiTriBasedGeomData::read(nif);
|
|
|
|
|
|
|
|
|
|
// Number of triangle strips
|
|
|
|
|
int numStrips = nif->getUShort();
|
|
|
|
|
|
|
|
|
|
std::vector<unsigned short> lengths;
|
|
|
|
|
uint16_t numStrips;
|
|
|
|
|
nif->read(numStrips);
|
|
|
|
|
std::vector<uint16_t> lengths;
|
|
|
|
|
nif->readVector(lengths, numStrips);
|
|
|
|
|
|
|
|
|
|
// "Has Strips" flag. Exceptionally useful.
|
|
|
|
|
bool hasStrips = true;
|
|
|
|
|
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD)
|
|
|
|
|
hasStrips = nif->getBoolean();
|
|
|
|
|
if (!hasStrips || !numStrips)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
strips.resize(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(strips[i], lengths[i]);
|
|
|
|
|
nif->readVector(mStrips[i], lengths[i]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiLinesData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiGeometryData::read(nif);
|
|
|
|
|
size_t num = vertices.size();
|
|
|
|
|
|
|
|
|
|
std::vector<uint8_t> flags;
|
|
|
|
|
nif->readVector(flags, num);
|
|
|
|
|
nif->readVector(flags, mNumVertices);
|
|
|
|
|
// Can't construct a line from a single vertex.
|
|
|
|
|
if (num < 2)
|
|
|
|
|
if (mNumVertices < 2)
|
|
|
|
|
return;
|
|
|
|
|
// There can't be more than 2 indices for each vertex
|
|
|
|
|
mLines.reserve(mNumVertices * 2);
|
|
|
|
|
// Convert connectivity flags into usable geometry. The last element needs special handling.
|
|
|
|
|
for (size_t i = 0; i < num - 1; ++i)
|
|
|
|
|
for (uint16_t i = 0; i < mNumVertices - 1; ++i)
|
|
|
|
|
{
|
|
|
|
|
if (flags[i] & 1)
|
|
|
|
|
{
|
|
|
|
|
lines.emplace_back(i);
|
|
|
|
|
lines.emplace_back(i + 1);
|
|
|
|
|
mLines.emplace_back(i);
|
|
|
|
|
mLines.emplace_back(i + 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// If there are just two vertices, they can be connected twice. Probably isn't critical.
|
|
|
|
|
if (flags[num - 1] & 1)
|
|
|
|
|
if (flags[mNumVertices - 1] & 1)
|
|
|
|
|
{
|
|
|
|
|
lines.emplace_back(num - 1);
|
|
|
|
|
lines.emplace_back(0);
|
|
|
|
|
mLines.emplace_back(mNumVertices - 1);
|
|
|
|
|
mLines.emplace_back(0);
|
|
|
|
|
}
|
|
|
|
|
mLines.shrink_to_fit();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiParticlesData::read(NIFStream* nif)
|
|
|
|
@ -203,26 +152,47 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
// Should always match the number of vertices
|
|
|
|
|
if (nif->getVersion() <= NIFFile::NIFVersion::VER_MW)
|
|
|
|
|
numParticles = nif->getUShort();
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(10, 0, 1, 0))
|
|
|
|
|
std::fill(particleRadii.begin(), particleRadii.end(), nif->getFloat());
|
|
|
|
|
else if (nif->getBoolean())
|
|
|
|
|
nif->readVector(particleRadii, vertices.size());
|
|
|
|
|
activeCount = nif->getUShort();
|
|
|
|
|
nif->read(mNumParticles);
|
|
|
|
|
else if (nif->getVersion() != NIFFile::NIFVersion::VER_BGS || nif->getBethVersion() == 0)
|
|
|
|
|
mNumParticles = mNumVertices;
|
|
|
|
|
|
|
|
|
|
bool numRadii = 1;
|
|
|
|
|
if (nif->getVersion() > NIFStream::generateVersion(10, 0, 1, 0))
|
|
|
|
|
numRadii = nif->get<bool>() ? mNumParticles : 0;
|
|
|
|
|
nif->readVector(mRadii, numRadii);
|
|
|
|
|
nif->read(mActiveCount);
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mSizes, mNumParticles);
|
|
|
|
|
|
|
|
|
|
// Particle sizes
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
nif->readVector(sizes, vertices.size());
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0) && nif->getBoolean())
|
|
|
|
|
nif->readVector(rotations, vertices.size());
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
|
|
|
|
|
{
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
nif->readVector(rotationAngles, vertices.size());
|
|
|
|
|
if (nif->getBoolean())
|
|
|
|
|
nif->readVector(rotationAxes, vertices.size());
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mRotations, mNumParticles);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
|
|
|
|
|
{
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mRotationAngles, mNumParticles);
|
|
|
|
|
if (nif->get<bool>())
|
|
|
|
|
nif->readVector(mRotationAxes, mNumParticles);
|
|
|
|
|
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() > 0)
|
|
|
|
|
{
|
|
|
|
|
nif->read(mHasTextureIndices);
|
|
|
|
|
uint32_t numSubtextureOffsets;
|
|
|
|
|
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
|
|
|
|
|
numSubtextureOffsets = nif->get<uint8_t>();
|
|
|
|
|
else
|
|
|
|
|
nif->read(numSubtextureOffsets);
|
|
|
|
|
nif->readVector(mSubtextureOffsets, numSubtextureOffsets);
|
|
|
|
|
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
|
|
|
|
|
{
|
|
|
|
|
nif->read(mAspectRatio);
|
|
|
|
|
nif->read(mAspectFlags);
|
|
|
|
|
nif->read(mAspectRatio2);
|
|
|
|
|
nif->read(mAspectSpeed);
|
|
|
|
|
nif->read(mAspectSpeed2);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -230,8 +200,8 @@ namespace Nif
|
|
|
|
|
{
|
|
|
|
|
NiParticlesData::read(nif);
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0) && nif->getBoolean())
|
|
|
|
|
nif->readVector(rotations, vertices.size());
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0) && nif->get<bool>())
|
|
|
|
|
nif->readVector(mRotations, mNumParticles);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiPosData::read(NIFStream* nif)
|
|
|
|
@ -242,10 +212,10 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
void NiUVData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
|
for (FloatKeyMapPtr& keys : mKeyList)
|
|
|
|
|
{
|
|
|
|
|
mKeyList[i] = std::make_shared<FloatKeyMap>();
|
|
|
|
|
mKeyList[i]->read(nif);
|
|
|
|
|
keys = std::make_shared<FloatKeyMap>();
|
|
|
|
|
keys->read(nif);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -255,58 +225,61 @@ namespace Nif
|
|
|
|
|
mKeyList->read(nif);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiPixelData::read(NIFStream* nif)
|
|
|
|
|
void NiPixelFormat::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
fmt = (Format)nif->getUInt();
|
|
|
|
|
|
|
|
|
|
if (nif->getVersion() < NIFStream::generateVersion(10, 4, 0, 2))
|
|
|
|
|
mFormat = static_cast<Format>(nif->get<uint32_t>());
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
|
|
|
|
|
{
|
|
|
|
|
for (unsigned int i = 0; i < 4; ++i)
|
|
|
|
|
colorMask[i] = nif->getUInt();
|
|
|
|
|
bpp = nif->getUInt();
|
|
|
|
|
nif->skip(8); // "Old Fast Compare". Whatever that means.
|
|
|
|
|
nif->readArray(mColorMasks);
|
|
|
|
|
nif->read(mBitsPerPixel);
|
|
|
|
|
nif->readArray(mCompareBits);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
pixelTiling = nif->getUInt();
|
|
|
|
|
nif->read(mPixelTiling);
|
|
|
|
|
}
|
|
|
|
|
else // TODO: see if anything from here needs to be implemented
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
bpp = nif->getChar();
|
|
|
|
|
nif->skip(4); // Renderer hint
|
|
|
|
|
nif->skip(4); // Extra data
|
|
|
|
|
nif->skip(4); // Flags
|
|
|
|
|
pixelTiling = nif->getUInt();
|
|
|
|
|
mBitsPerPixel = nif->get<uint8_t>();
|
|
|
|
|
nif->read(mRendererHint);
|
|
|
|
|
nif->read(mExtraData);
|
|
|
|
|
nif->read(mFlags);
|
|
|
|
|
nif->read(mPixelTiling);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(20, 3, 0, 4))
|
|
|
|
|
sRGB = nif->getBoolean();
|
|
|
|
|
nif->skip(4 * 10); // Channel data
|
|
|
|
|
nif->read(mUseSrgb);
|
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
|
|
mChannels[i].read(nif);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
palette.read(nif);
|
|
|
|
|
|
|
|
|
|
numberOfMipmaps = nif->getUInt();
|
|
|
|
|
|
|
|
|
|
// Bytes per pixel, should be bpp / 8
|
|
|
|
|
/* int bytes = */ nif->getUInt();
|
|
|
|
|
void NiPixelFormat::ChannelData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
mType = static_cast<Type>(nif->get<uint32_t>());
|
|
|
|
|
mConvention = static_cast<Convention>(nif->get<uint32_t>());
|
|
|
|
|
nif->read(mBitsPerChannel);
|
|
|
|
|
nif->read(mSigned);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < numberOfMipmaps; i++)
|
|
|
|
|
void NiPixelData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
mPixelFormat.read(nif);
|
|
|
|
|
mPalette.read(nif);
|
|
|
|
|
mMipmaps.resize(nif->get<uint32_t>());
|
|
|
|
|
nif->read(mBytesPerPixel);
|
|
|
|
|
for (Mipmap& mip : mMipmaps)
|
|
|
|
|
{
|
|
|
|
|
// Image size and offset in the following data field
|
|
|
|
|
Mipmap m;
|
|
|
|
|
m.width = nif->getUInt();
|
|
|
|
|
m.height = nif->getUInt();
|
|
|
|
|
m.dataOffset = nif->getUInt();
|
|
|
|
|
mipmaps.push_back(m);
|
|
|
|
|
nif->read(mip.mWidth);
|
|
|
|
|
nif->read(mip.mHeight);
|
|
|
|
|
nif->read(mip.mOffset);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Read the data
|
|
|
|
|
unsigned int numPixels = nif->getUInt();
|
|
|
|
|
bool hasFaces = nif->getVersion() >= NIFStream::generateVersion(10, 4, 0, 2);
|
|
|
|
|
unsigned int numFaces = hasFaces ? nif->getUInt() : 1;
|
|
|
|
|
nif->readVector(data, numPixels * numFaces);
|
|
|
|
|
uint32_t numPixels;
|
|
|
|
|
nif->read(numPixels);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 4, 0, 2))
|
|
|
|
|
nif->read(mNumFaces);
|
|
|
|
|
nif->readVector(mData, numPixels * mNumFaces);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiPixelData::post(Reader& nif)
|
|
|
|
|
{
|
|
|
|
|
palette.post(nif);
|
|
|
|
|
mPalette.post(nif);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiColorData::read(NIFStream* nif)
|
|
|
|
@ -317,62 +290,110 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
void NiVisData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
int count = nif->getInt();
|
|
|
|
|
mVis.resize(count);
|
|
|
|
|
for (size_t i = 0; i < mVis.size(); i++)
|
|
|
|
|
mKeys = std::make_shared<std::map<float, bool>>();
|
|
|
|
|
uint32_t numKeys;
|
|
|
|
|
nif->read(numKeys);
|
|
|
|
|
for (size_t i = 0; i < numKeys; i++)
|
|
|
|
|
{
|
|
|
|
|
mVis[i].time = nif->getFloat();
|
|
|
|
|
mVis[i].isSet = (nif->getChar() != 0);
|
|
|
|
|
float time;
|
|
|
|
|
char value;
|
|
|
|
|
nif->read(time);
|
|
|
|
|
nif->read(value);
|
|
|
|
|
(*mKeys)[time] = (value != 0);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiSkinData::read(NIFStream* nif)
|
|
|
|
|
void NiSkinInstance::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
trafo.rotation = nif->getMatrix3();
|
|
|
|
|
trafo.pos = nif->getVector3();
|
|
|
|
|
trafo.scale = nif->getFloat();
|
|
|
|
|
mData.read(nif);
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 101))
|
|
|
|
|
mPartitions.read(nif);
|
|
|
|
|
mRoot.read(nif);
|
|
|
|
|
readRecordList(nif, mBones);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int boneNum = nif->getInt();
|
|
|
|
|
if (nif->getVersion() >= NIFFile::NIFVersion::VER_MW
|
|
|
|
|
&& nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
partitions.read(nif);
|
|
|
|
|
void NiSkinInstance::post(Reader& nif)
|
|
|
|
|
{
|
|
|
|
|
mData.post(nif);
|
|
|
|
|
mPartitions.post(nif);
|
|
|
|
|
mRoot.post(nif);
|
|
|
|
|
postRecordList(nif, mBones);
|
|
|
|
|
|
|
|
|
|
if (mData.empty() || mRoot.empty())
|
|
|
|
|
throw Nif::Exception("NiSkinInstance missing root or data", nif.getFilename());
|
|
|
|
|
|
|
|
|
|
if (mBones.size() != mData->mBones.size())
|
|
|
|
|
throw Nif::Exception("Mismatch in NiSkinData bone count", nif.getFilename());
|
|
|
|
|
|
|
|
|
|
for (auto& bone : mBones)
|
|
|
|
|
{
|
|
|
|
|
if (bone.empty())
|
|
|
|
|
throw Nif::Exception("Oops: Missing bone! Don't know how to handle this.", nif.getFilename());
|
|
|
|
|
bone->setBone();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void BSDismemberSkinInstance::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
NiSkinInstance::read(nif);
|
|
|
|
|
|
|
|
|
|
mParts.resize(nif->get<uint32_t>());
|
|
|
|
|
for (BodyPart& part : mParts)
|
|
|
|
|
{
|
|
|
|
|
nif->read(part.mFlags);
|
|
|
|
|
nif->read(part.mType);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiSkinData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
nif->read(mTransform.rotation);
|
|
|
|
|
nif->read(mTransform.pos);
|
|
|
|
|
nif->read(mTransform.scale);
|
|
|
|
|
|
|
|
|
|
uint32_t numBones;
|
|
|
|
|
nif->read(numBones);
|
|
|
|
|
bool hasVertexWeights = true;
|
|
|
|
|
if (nif->getVersion() > NIFStream::generateVersion(4, 2, 1, 0))
|
|
|
|
|
hasVertexWeights = nif->getBoolean();
|
|
|
|
|
if (nif->getVersion() >= NIFFile::NIFVersion::VER_MW)
|
|
|
|
|
{
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
mPartitions.read(nif);
|
|
|
|
|
|
|
|
|
|
bones.resize(boneNum);
|
|
|
|
|
for (BoneInfo& bi : bones)
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 1, 0))
|
|
|
|
|
nif->read(hasVertexWeights);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mBones.resize(numBones);
|
|
|
|
|
for (BoneInfo& bi : mBones)
|
|
|
|
|
{
|
|
|
|
|
bi.trafo.rotation = nif->getMatrix3();
|
|
|
|
|
bi.trafo.pos = nif->getVector3();
|
|
|
|
|
bi.trafo.scale = nif->getFloat();
|
|
|
|
|
bi.boundSphereCenter = nif->getVector3();
|
|
|
|
|
bi.boundSphereRadius = nif->getFloat();
|
|
|
|
|
nif->read(bi.mTransform.rotation);
|
|
|
|
|
nif->read(bi.mTransform.pos);
|
|
|
|
|
nif->read(bi.mTransform.scale);
|
|
|
|
|
nif->read(bi.mBoundSphere);
|
|
|
|
|
|
|
|
|
|
size_t numVertices = nif->getUShort();
|
|
|
|
|
uint16_t numVertices;
|
|
|
|
|
nif->read(numVertices);
|
|
|
|
|
|
|
|
|
|
if (!hasVertexWeights)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
bi.weights.resize(numVertices);
|
|
|
|
|
for (size_t j = 0; j < bi.weights.size(); j++)
|
|
|
|
|
bi.mWeights.resize(numVertices);
|
|
|
|
|
for (auto& [vertex, weight] : bi.mWeights)
|
|
|
|
|
{
|
|
|
|
|
bi.weights[j].vertex = nif->getUShort();
|
|
|
|
|
bi.weights[j].weight = nif->getFloat();
|
|
|
|
|
nif->read(vertex);
|
|
|
|
|
nif->read(weight);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiSkinData::post(Reader& nif)
|
|
|
|
|
{
|
|
|
|
|
partitions.post(nif);
|
|
|
|
|
mPartitions.post(nif);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiSkinPartition::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
nif->read(mPartitionNum);
|
|
|
|
|
mPartitions.resize(mPartitionNum);
|
|
|
|
|
mPartitions.resize(nif->get<uint32_t>());
|
|
|
|
|
|
|
|
|
|
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
|
|
|
|
|
{
|
|
|
|
@ -391,103 +412,76 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
void NiSkinPartition::Partition::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
size_t numVertices = nif->getUShort();
|
|
|
|
|
size_t numTriangles = nif->getUShort();
|
|
|
|
|
size_t numBones = nif->getUShort();
|
|
|
|
|
size_t numStrips = nif->getUShort();
|
|
|
|
|
size_t bonesPerVertex = nif->getUShort();
|
|
|
|
|
nif->readVector(bones, numBones);
|
|
|
|
|
|
|
|
|
|
bool hasVertexMap = true;
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
hasVertexMap = nif->getBoolean();
|
|
|
|
|
if (hasVertexMap)
|
|
|
|
|
nif->readVector(vertexMap, numVertices);
|
|
|
|
|
|
|
|
|
|
bool hasVertexWeights = true;
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
hasVertexWeights = nif->getBoolean();
|
|
|
|
|
if (hasVertexWeights)
|
|
|
|
|
nif->readVector(weights, numVertices * bonesPerVertex);
|
|
|
|
|
|
|
|
|
|
uint16_t numVertices, numTriangles, numBones, numStrips, bonesPerVertex;
|
|
|
|
|
nif->read(numVertices);
|
|
|
|
|
nif->read(numTriangles);
|
|
|
|
|
nif->read(numBones);
|
|
|
|
|
nif->read(numStrips);
|
|
|
|
|
nif->read(bonesPerVertex);
|
|
|
|
|
nif->readVector(mBones, numBones);
|
|
|
|
|
bool hasPresenceFlags = nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0);
|
|
|
|
|
if (!hasPresenceFlags || nif->get<bool>())
|
|
|
|
|
nif->readVector(mVertexMap, numVertices);
|
|
|
|
|
if (!hasPresenceFlags || nif->get<bool>())
|
|
|
|
|
nif->readVector(mWeights, numVertices * bonesPerVertex);
|
|
|
|
|
std::vector<unsigned short> stripLengths;
|
|
|
|
|
nif->readVector(stripLengths, numStrips);
|
|
|
|
|
|
|
|
|
|
bool hasFaces = true;
|
|
|
|
|
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
hasFaces = nif->getBoolean();
|
|
|
|
|
if (hasFaces)
|
|
|
|
|
if (!hasPresenceFlags || nif->get<bool>())
|
|
|
|
|
{
|
|
|
|
|
if (numStrips)
|
|
|
|
|
{
|
|
|
|
|
strips.resize(numStrips);
|
|
|
|
|
mStrips.resize(numStrips);
|
|
|
|
|
for (size_t i = 0; i < numStrips; i++)
|
|
|
|
|
nif->readVector(strips[i], stripLengths[i]);
|
|
|
|
|
nif->readVector(mStrips[i], stripLengths[i]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
nif->readVector(triangles, numTriangles * 3);
|
|
|
|
|
nif->readVector(mTriangles, numTriangles * 3);
|
|
|
|
|
}
|
|
|
|
|
bool hasBoneIndices = nif->getChar() != 0;
|
|
|
|
|
if (hasBoneIndices)
|
|
|
|
|
nif->readVector(boneIndices, numVertices * bonesPerVertex);
|
|
|
|
|
if (nif->get<uint8_t>() != 0)
|
|
|
|
|
nif->readVector(mBoneIndices, numVertices * bonesPerVertex);
|
|
|
|
|
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
|
|
|
|
|
{
|
|
|
|
|
nif->getChar(); // LOD level
|
|
|
|
|
nif->getBoolean(); // Global VB
|
|
|
|
|
nif->read(mLODLevel);
|
|
|
|
|
nif->read(mGlobalVB);
|
|
|
|
|
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
|
|
|
|
|
{
|
|
|
|
|
mVertexDesc.read(nif);
|
|
|
|
|
nif->readVector(mTrueTriangles, numTriangles * 3);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
|
|
|
|
|
// Not technically a part of the loading process
|
|
|
|
|
if (mTrueTriangles.empty() && !mVertexMap.empty())
|
|
|
|
|
{
|
|
|
|
|
mVertexDesc.read(nif);
|
|
|
|
|
nif->readVector(trueTriangles, numTriangles * 3);
|
|
|
|
|
if (!mStrips.empty())
|
|
|
|
|
{
|
|
|
|
|
mTrueStrips = mStrips;
|
|
|
|
|
for (auto& strip : mTrueStrips)
|
|
|
|
|
for (auto& index : strip)
|
|
|
|
|
index = mVertexMap[index];
|
|
|
|
|
}
|
|
|
|
|
else if (!mTriangles.empty())
|
|
|
|
|
{
|
|
|
|
|
mTrueTriangles = mTriangles;
|
|
|
|
|
for (unsigned short& index : mTrueTriangles)
|
|
|
|
|
index = mVertexMap[index];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::vector<unsigned short> NiSkinPartition::Partition::getTrueTriangles() const
|
|
|
|
|
{
|
|
|
|
|
if (!trueTriangles.empty())
|
|
|
|
|
return trueTriangles;
|
|
|
|
|
|
|
|
|
|
std::vector<unsigned short> remappedTriangles;
|
|
|
|
|
if (vertexMap.empty() || triangles.empty())
|
|
|
|
|
return remappedTriangles;
|
|
|
|
|
|
|
|
|
|
remappedTriangles = triangles;
|
|
|
|
|
|
|
|
|
|
for (unsigned short& index : remappedTriangles)
|
|
|
|
|
index = vertexMap[index];
|
|
|
|
|
return remappedTriangles;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::vector<std::vector<unsigned short>> NiSkinPartition::Partition::getTrueStrips() const
|
|
|
|
|
{
|
|
|
|
|
if (!trueTriangles.empty())
|
|
|
|
|
return {};
|
|
|
|
|
|
|
|
|
|
std::vector<std::vector<unsigned short>> remappedStrips;
|
|
|
|
|
if (vertexMap.empty() || strips.empty())
|
|
|
|
|
return remappedStrips;
|
|
|
|
|
|
|
|
|
|
remappedStrips = strips;
|
|
|
|
|
for (auto& strip : remappedStrips)
|
|
|
|
|
for (auto& index : strip)
|
|
|
|
|
index = vertexMap[index];
|
|
|
|
|
|
|
|
|
|
return remappedStrips;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiMorphData::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
int morphCount = nif->getInt();
|
|
|
|
|
int vertCount = nif->getInt();
|
|
|
|
|
nif->getChar(); // Relative targets, always 1
|
|
|
|
|
uint32_t numMorphs, numVerts;
|
|
|
|
|
nif->read(numMorphs);
|
|
|
|
|
nif->read(numVerts);
|
|
|
|
|
nif->read(mRelativeTargets);
|
|
|
|
|
|
|
|
|
|
mMorphs.resize(morphCount);
|
|
|
|
|
for (int i = 0; i < morphCount; i++)
|
|
|
|
|
mMorphs.resize(numMorphs);
|
|
|
|
|
for (MorphData& morph : mMorphs)
|
|
|
|
|
{
|
|
|
|
|
mMorphs[i].mKeyFrames = std::make_shared<FloatKeyMap>();
|
|
|
|
|
mMorphs[i].mKeyFrames->read(nif, /*morph*/ true);
|
|
|
|
|
nif->readVector(mMorphs[i].mVertices, vertCount);
|
|
|
|
|
morph.mKeyFrames = std::make_shared<FloatKeyMap>();
|
|
|
|
|
morph.mKeyFrames->read(nif, /*morph*/ true);
|
|
|
|
|
nif->readVector(morph.mVertices, numVerts);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
@ -498,7 +492,7 @@ namespace Nif
|
|
|
|
|
if (mRotations->mInterpolationType == InterpolationType_XYZ)
|
|
|
|
|
{
|
|
|
|
|
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
|
|
|
|
|
mAxisOrder = static_cast<AxisOrder>(nif->getInt());
|
|
|
|
|
mAxisOrder = static_cast<AxisOrder>(nif->get<uint32_t>());
|
|
|
|
|
mXRotations = std::make_shared<FloatKeyMap>();
|
|
|
|
|
mYRotations = std::make_shared<FloatKeyMap>();
|
|
|
|
|
mZRotations = std::make_shared<FloatKeyMap>();
|
|
|
|
@ -514,18 +508,24 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
void NiPalette::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
unsigned int alphaMask = !nif->getChar() ? 0xFF000000 : 0;
|
|
|
|
|
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.
|
|
|
|
|
colors.resize(256);
|
|
|
|
|
unsigned int numEntries = nif->getUInt();
|
|
|
|
|
for (unsigned int i = 0; i < numEntries; i++)
|
|
|
|
|
colors[i] = nif->getUInt() | alphaMask;
|
|
|
|
|
mColors.resize(numEntries > 256 ? numEntries : 256);
|
|
|
|
|
for (uint32_t i = 0; i < numEntries; i++)
|
|
|
|
|
{
|
|
|
|
|
nif->read(mColors[i]);
|
|
|
|
|
mColors[i] |= alphaMask;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void NiStringPalette::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
palette = nif->getStringPalette();
|
|
|
|
|
if (nif->getUInt() != palette.size())
|
|
|
|
|
mPalette = nif->getStringPalette();
|
|
|
|
|
if (nif->get<uint32_t>() != mPalette.size())
|
|
|
|
|
Log(Debug::Warning) << "NIFFile Warning: Failed size check in NiStringPalette. File: "
|
|
|
|
|
<< nif->getFile().getFilename();
|
|
|
|
|
}
|
|
|
|
@ -548,15 +548,14 @@ namespace Nif
|
|
|
|
|
|
|
|
|
|
void BSMultiBoundOBB::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
mCenter = nif->getVector3();
|
|
|
|
|
mSize = nif->getVector3();
|
|
|
|
|
mRotation = nif->getMatrix3();
|
|
|
|
|
nif->read(mCenter);
|
|
|
|
|
nif->read(mSize);
|
|
|
|
|
nif->read(mRotation);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void BSMultiBoundSphere::read(NIFStream* nif)
|
|
|
|
|
{
|
|
|
|
|
mCenter = nif->getVector3();
|
|
|
|
|
mRadius = nif->getFloat();
|
|
|
|
|
nif->read(mSphere);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // Namespace
|
|
|
|
|