mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-02-06 11:15:33 +00:00
Code Issues Releases Wiki Activity

Rewrite NiBlendInterpolator+friends loading

Browse source
This commit is contained in:
Alexei Kotov 2023-09-13 23:15:14 +03:00
parent 956ede52fb
commit a224bea6d4
5 changed files with 142 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
components/nif/controller.cpp
View file

@ -540,71 +540,63 @@ namespace Nif
void NiBlendInterpolator::read(NIFStream* nif) void NiBlendInterpolator::read(NIFStream* nif)
{ {
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 112)) if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 112))
mManagerControlled = nif->getChar() & 1;
size_t numInterps = 0;
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109))
{ {
numInterps = nif->getUShort(); nif->read(mFlags);
mArrayGrowBy = nif->getUShort(); mItems.resize(nif->get<uint8_t>());
} nif->read(mWeightThreshold);
else if (!(mFlags & Flag_ManagerControlled))
{
numInterps = nif->getChar();
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 112))
{ {
mWeightThreshold = nif->getFloat(); mInterpCount = nif->get<uint8_t>();
if (!mManagerControlled) mSingleIndex = nif->get<uint8_t>();
{ mHighPriority = nif->get<int8_t>();
mInterpCount = nif->getChar(); mNextHighPriority = nif->get<int8_t>();
mSingleIndex = nif->getChar(); nif->read(mSingleTime);
mHighPriority = nif->getChar(); nif->read(mHighWeightsSum);
mNextHighPriority = nif->getChar(); nif->read(mNextHighWeightsSum);
mSingleTime = nif->getFloat(); nif->read(mHighEaseSpinner);
mHighWeightsSum = nif->getFloat(); for (Item& item : mItems)
mNextHighWeightsSum = nif->getFloat(); item.read(nif);
mHighEaseSpinner = nif->getFloat();
}
} }
return;
} }
if (!mManagerControlled) if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 110))
{ {
mItems.resize(numInterps); mItems.resize(nif->get<uint8_t>());
for (Item& item : mItems) for (Item& item : mItems)
item.read(nif); item.read(nif);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);
if (nif->get<bool>())
mFlags |= Flag_OnlyUseHighestWeight;
mInterpCount = nif->get<uint8_t>();
mSingleIndex = nif->get<uint8_t>();
mSingleInterpolator.read(nif);
nif->read(mSingleTime);
mHighPriority = nif->get<int8_t>();
mNextHighPriority = nif->get<int8_t>();
return;
} }
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 111)) mItems.resize(nif->get<uint16_t>());
nif->read(mArrayGrowBy);
for (Item& item : mItems)
item.read(nif);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);
if (nif->get<bool>())
mFlags |= Flag_OnlyUseHighestWeight;
nif->read(mInterpCount);
nif->read(mSingleIndex);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 108))
{ {
mManagerControlled = nif->getBoolean(); mSingleInterpolator.read(nif);
mWeightThreshold = nif->getFloat(); nif->read(mSingleTime);
mOnlyUseHighestWeight = nif->getBoolean();
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109))
{
mInterpCount = nif->getUShort();
mSingleIndex = nif->getUShort();
}
else
{
mInterpCount = nif->getChar();
mSingleIndex = nif->getChar();
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 108))
{
mSingleInterpolator.read(nif);
mSingleTime = nif->getFloat();
}
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109))
{
mHighPriority = nif->getInt();
mNextHighPriority = nif->getInt();
}
else
{
mHighPriority = nif->getChar();
mNextHighPriority = nif->getChar();
}
} }
nif->read(mHighPriority);
nif->read(mNextHighPriority);
} }
void NiBlendInterpolator::post(Reader& nif) void NiBlendInterpolator::post(Reader& nif)
@ -617,13 +609,13 @@ namespace Nif
void NiBlendInterpolator::Item::read(NIFStream* nif) void NiBlendInterpolator::Item::read(NIFStream* nif)
{ {
mInterpolator.read(nif); mInterpolator.read(nif);
mWeight = nif->getFloat(); nif->read(mWeight);
mNormalizedWeight = nif->getFloat(); nif->read(mNormalizedWeight);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109)) if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 110))
mPriority = nif->getInt(); mPriority = nif->get<int8_t>();
else else
mPriority = nif->getChar(); nif->read(mPriority);
mEaseSpinner = nif->getFloat(); nif->read(mEaseSpinner);
} }
void NiBlendInterpolator::Item::post(Reader& nif) void NiBlendInterpolator::Item::post(Reader& nif)
@ -631,38 +623,4 @@ namespace Nif
mInterpolator.post(nif); mInterpolator.post(nif);
} }
void NiBlendBoolInterpolator::read(NIFStream* nif)
{
NiBlendInterpolator::read(nif);
mValue = nif->getChar() != 0;
}
void NiBlendFloatInterpolator::read(NIFStream* nif)
{
NiBlendInterpolator::read(nif);
mValue = nif->getFloat();
}
void NiBlendPoint3Interpolator::read(NIFStream* nif)
{
NiBlendInterpolator::read(nif);
mValue = nif->getVector3();
}
void NiBlendTransformInterpolator::read(NIFStream* nif)
{
NiBlendInterpolator::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109))
{
mPosValue = nif->getVector3();
nif->read(mRotValue);
mScaleValue = nif->getFloat();
if (!nif->getBoolean())
mPosValue = osg::Vec3f();
if (!nif->getBoolean())
mRotValue = osg::Quat();
if (!nif->getBoolean())
mScaleValue = 1.f;
}
}
} }

89
components/nif/controller.hpp
View file

@ -1,30 +1,8 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008-2010 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: https://openmw.org/
This file (controller.h) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
https://www.gnu.org/licenses/ .
*/
#ifndef OPENMW_COMPONENTS_NIF_CONTROLLER_HPP #ifndef OPENMW_COMPONENTS_NIF_CONTROLLER_HPP
#define OPENMW_COMPONENTS_NIF_CONTROLLER_HPP #define OPENMW_COMPONENTS_NIF_CONTROLLER_HPP
#include "base.hpp" #include "base.hpp"
#include "niftypes.hpp"
#include "property.hpp" #include "property.hpp"
namespace Nif namespace Nif
@ -378,24 +356,29 @@ namespace Nif
// Abstract // Abstract
struct NiBlendInterpolator : public NiInterpolator struct NiBlendInterpolator : public NiInterpolator
{ {
enum Flags
{
Flag_ManagerControlled = 0x1,
Flag_OnlyUseHighestWeight = 0x2,
};
struct Item struct Item
{ {
NiInterpolatorPtr mInterpolator; NiInterpolatorPtr mInterpolator;
float mWeight, mNormalizedWeight; float mWeight, mNormalizedWeight;
int mPriority; int32_t mPriority;
float mEaseSpinner; float mEaseSpinner;
void read(NIFStream* nif); void read(NIFStream* nif);
void post(Reader& nif); void post(Reader& nif);
}; };
bool mManagerControlled{ false }; uint8_t mFlags{ 0 };
bool mOnlyUseHighestWeight{ false }; uint16_t mArrayGrowBy{ 0 };
unsigned short mArrayGrowBy{ 0 };
float mWeightThreshold; float mWeightThreshold;
unsigned short mInterpCount; uint16_t mInterpCount;
unsigned short mSingleIndex; uint16_t mSingleIndex;
int mHighPriority, mNextHighPriority; int32_t mHighPriority, mNextHighPriority;
float mSingleTime; float mSingleTime;
float mHighWeightsSum, mNextHighWeightsSum; float mHighWeightsSum, mNextHighWeightsSum;
float mHighEaseSpinner; float mHighEaseSpinner;
@ -406,31 +389,37 @@ namespace Nif
void post(Reader& nif) override; void post(Reader& nif) override;
}; };
struct NiBlendBoolInterpolator : public NiBlendInterpolator template <typename T>
struct TypedNiBlendInterpolator : public NiBlendInterpolator
{ {
char mValue; T mValue;
void read(NIFStream* nif) override;
void read(NIFStream* nif) override
{
NiBlendInterpolator::read(nif);
nif->read(mValue);
}
}; };
struct NiBlendFloatInterpolator : public NiBlendInterpolator template <>
struct TypedNiBlendInterpolator<NiQuatTransform> : public NiBlendInterpolator
{ {
float mValue; NiQuatTransform mValue;
void read(NIFStream* nif) override;
void read(NIFStream* nif) override
{
NiBlendInterpolator::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109))
nif->read(mValue);
}
}; };
struct NiBlendPoint3Interpolator : public NiBlendInterpolator using NiBlendBoolInterpolator = TypedNiBlendInterpolator<uint8_t>;
{ using NiBlendFloatInterpolator = TypedNiBlendInterpolator<float>;
osg::Vec3f mValue; using NiBlendPoint3Interpolator = TypedNiBlendInterpolator<osg::Vec3f>;
void read(NIFStream* nif) override; using NiBlendTransformInterpolator = TypedNiBlendInterpolator<NiQuatTransform>;
};
struct NiBlendTransformInterpolator : public NiBlendInterpolator }
{
osg::Vec3f mPosValue;
osg::Quat mRotValue;
float mScaleValue;
void read(NIFStream* nif) override;
};
} // Namespace
#endif #endif

22
components/nif/nifstream.cpp
View file

@ -137,6 +137,22 @@ namespace Nif
read(transform.mScale); read(transform.mScale);
} }
template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform& transform)
{
read(transform.mTranslation);
read(transform.mRotation);
read(transform.mScale);
if (getVersion() >= generateVersion(10, 1, 0, 110))
return;
if (!get<bool>())
transform.mTranslation = osg::Vec3f();
if (!get<bool>())
transform.mRotation = osg::Quat();
if (!get<bool>())
transform.mScale = 1.f;
}
template <> template <>
void NIFStream::read<bool>(bool& data) void NIFStream::read<bool>(bool& data)
{ {
@ -197,6 +213,12 @@ namespace Nif
readRange(*this, dest, size); readRange(*this, dest, size);
} }
template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform* dest, size_t size)
{
readRange(*this, dest, size);
}
template <> template <>
void NIFStream::read<bool>(bool* dest, size_t size) void NIFStream::read<bool>(bool* dest, size_t size)
{ {

4
components/nif/nifstream.hpp
View file

@ -175,6 +175,8 @@ namespace Nif
template <> template <>
void NIFStream::read<NiTransform>(NiTransform& transform); void NIFStream::read<NiTransform>(NiTransform& transform);
template <> template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform& transform);
template <>
void NIFStream::read<bool>(bool& data); void NIFStream::read<bool>(bool& data);
template <> template <>
void NIFStream::read<std::string>(std::string& str); void NIFStream::read<std::string>(std::string& str);
@ -194,6 +196,8 @@ namespace Nif
template <> template <>
void NIFStream::read<NiTransform>(NiTransform* dest, size_t size); void NIFStream::read<NiTransform>(NiTransform* dest, size_t size);
template <> template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform* dest, size_t size);
template <>
void NIFStream::read<bool>(bool* dest, size_t size); void NIFStream::read<bool>(bool* dest, size_t size);
template <> template <>
void NIFStream::read<std::string>(std::string* dest, size_t size); void NIFStream::read<std::string>(std::string* dest, size_t size);

26
components/nif/niftypes.hpp
View file

@ -25,6 +25,7 @@
#define OPENMW_COMPONENTS_NIF_NIFTYPES_HPP #define OPENMW_COMPONENTS_NIF_NIFTYPES_HPP
#include <osg/Matrixf> #include <osg/Matrixf>
#include <osg/Quat>
#include <osg/Vec3f> #include <osg/Vec3f>
// Common types used in NIF files // Common types used in NIF files
@ -80,5 +81,30 @@ namespace Nif
} }
}; };
struct NiQuatTransform
{
osg::Vec3f mTranslation;
osg::Quat mRotation;
float mScale;
osg::Matrixf toMatrix() const
{
osg::Matrixf transform(mRotation);
transform.setTrans(mTranslation);
for (int i = 0; i < 3; i++)
transform(i, i) *= mScale;
return transform;
}
bool isIdentity() const { return mTranslation == osg::Vec3f() && mRotation == osg::Quat() && mScale == 1.f; }
static const NiQuatTransform& getIdentity()
{
static const NiQuatTransform identity = { osg::Vec3f(), osg::Quat(), 1.f };
return identity;
}
};
} // Namespace } // Namespace
#endif #endif