Something went wrong. Try again.
OpenMW is an open implementation of the Morrowind engine
Something went wrong. Try again.
18 kB · 656 lines
C++
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657#ifndef OPENMW_COMPONENTS_NIF_CONTROLLER_HPP#define OPENMW_COMPONENTS_NIF_CONTROLLER_HPP
#include "base.hpp"#include "niftypes.hpp"#include "property.hpp"
namespace Nif{
struct ControlledBlock { std::string mTargetName; NiInterpolatorPtr mInterpolator; NiTimeControllerPtr mController; NiBlendInterpolatorPtr mBlendInterpolator; uint16_t mBlendIndex; uint8_t mPriority; NiStringPalettePtr mStringPalette; uint32_t mNodeNameOffset; uint32_t mPropertyTypeOffset; uint32_t mControllerTypeOffset; uint32_t mControllerIdOffset; uint32_t mInterpolatorIdOffset; std::string mNodeName; std::string mPropertyType; std::string mControllerType; std::string mControllerId; std::string mInterpolatorId;
void read(NIFStream* nif); void post(Reader& nif); };
// Gamebryo KF root node record type (pre-10.0) struct NiSequence : public Record { std::string mName; std::string mAccumRootName; ExtraPtr mTextKeys; uint32_t mArrayGrowBy; std::vector<ControlledBlock> mControlledBlocks;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Gamebryo KF root node record type (10.0+) struct NiControllerSequence : public NiSequence { float mWeight{ 1.f }; NiTimeController::ExtrapolationMode mExtrapolationMode{ NiTimeController::ExtrapolationMode::Constant }; float mFrequency{ 1.f }; float mPhase{ 1.f }; float mStartTime, mStopTime; bool mPlayBackwards{ false }; NiControllerManagerPtr mManager; NiStringPalettePtr mStringPalette; BSAnimNotesList mAnimNotesList;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Base class for controllers that use NiInterpolators to animate objects. struct NiInterpController : public NiTimeController { // Usually one of the flags. bool mManagerControlled{ false };
void read(NIFStream* nif) override; };
// Base class for controllers that use one NiInterpolator. struct NiSingleInterpController : public NiInterpController { NiInterpolatorPtr mInterpolator;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Base class for controllers that use a NiFloatInterpolator to animate their target. struct NiFloatInterpController : public NiSingleInterpController { };
// Ditto for NiBoolInterpolator. struct NiBoolInterpController : public NiSingleInterpController { };
// Ditto for NiPoint3Interpolator. struct NiPoint3InterpController : public NiSingleInterpController { };
struct NiParticleInfo { osg::Vec3f mVelocity; osg::Vec3f mRotationAxis; float mAge; float mLifespan; float mLastUpdate; uint16_t mSpawnGeneration; uint16_t mCode;
void read(NIFStream* nif); };
struct NiParticleSystemController : public NiTimeController { enum BSPArrayController { BSPArrayController_AtNode = 0x8, BSPArrayController_AtVertex = 0x10 };
enum EmitFlags { EmitFlag_NoAutoAdjust = 0x1 // If this flag is set, we use the emitRate value. Otherwise, // we calculate an emit rate so that the maximum number of particles // in the system (numParticles) is never exceeded. };
float mSpeed; float mSpeedVariation; float mDeclination; float mDeclinationVariation; float mPlanarAngle; float mPlanarAngleVariation; osg::Vec3f mInitialNormal; osg::Vec4f mInitialColor; float mInitialSize; float mEmitStartTime; float mEmitStopTime; bool mResetParticleSystem{ false }; float mBirthRate; float mLifetime; float mLifetimeVariation; uint16_t mEmitFlags{ 0 }; osg::Vec3f mEmitterDimensions; NiAVObjectPtr mEmitter; uint16_t mNumSpawnGenerations; float mPercentageSpawned; uint16_t mSpawnMultiplier; float mSpawnSpeedChaos; float mSpawnDirChaos; uint16_t mNumParticles; uint16_t mNumValid; std::vector<NiParticleInfo> mParticles; NiParticleModifierPtr mModifier; NiParticleModifierPtr mCollider; uint8_t mStaticTargetBound;
void read(NIFStream* nif) override; void post(Reader& nif) override;
bool noAutoAdjust() const { return mEmitFlags & EmitFlag_NoAutoAdjust; } bool emitAtVertex() const { return mFlags & BSPArrayController_AtVertex; } }; using NiBSPArrayController = NiParticleSystemController;
struct NiLightColorController : public NiPoint3InterpController { enum class Mode { DiffuseSpecular = 0, Ambient = 1, };
NiPosDataPtr mData; Mode mMode = Mode::DiffuseSpecular;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiMaterialColorController : public NiPoint3InterpController { enum class TargetColor { Ambient = 0, Diffuse = 1, Specular = 2, Emissive = 3, };
NiPosDataPtr mData; TargetColor mTargetColor = TargetColor::Ambient;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiPathController : public NiTimeController { enum Flags { Flag_CVDataNeedsUpdate = 0x01, Flag_OpenCurve = 0x02, Flag_AllowFlip = 0x04, Flag_Bank = 0x08, Flag_ConstVelocity = 0x10, Flag_Follow = 0x20, Flag_FlipFollowAxis = 0x40, };
uint16_t mPathFlags; int32_t mBankDirection; float mMaxBankAngle; float mSmoothing; uint16_t mFollowAxis; NiPosDataPtr mPathData; NiFloatDataPtr mPercentData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiLookAtController : public NiTimeController { enum Flags { Flag_Flip = 0x1, Flag_LookYAxis = 0x2, Flag_LookZAxis = 0x4, };
uint16_t mLookAtFlags{ 0 }; NiAVObjectPtr mLookAt;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiUVController : public NiTimeController { NiUVDataPtr mData; uint16_t mUvSet;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiKeyframeController : public NiSingleInterpController { NiKeyframeDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiMultiTargetTransformController : public NiInterpController { NiAVObjectList mExtraTargets;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiAlphaController : public NiFloatInterpController { NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiRollController : public NiSingleInterpController { NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiGeomMorpherController : public NiInterpController { bool mUpdateNormals{ false }; bool mAlwaysActive{ false }; NiMorphDataPtr mData; NiInterpolatorList mInterpolators; std::vector<float> mWeights;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiVisController : public NiBoolInterpController { NiVisDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiFlipController : public NiFloatInterpController { NiTexturingProperty::TextureType mTexSlot; float mDelta; // Time between two flips. delta = (start_time - stop_time) / num_sources NiSourceTextureList mSources;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiTextureTransformController : public NiFloatInterpController { bool mShaderMap; NiTexturingProperty::TextureType mTexSlot; uint32_t mTransformMember; NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiBoneLODController : NiTimeController { struct SkinInfo { NiTriBasedGeomPtr mShape; NiSkinInstancePtr mSkin;
void read(NIFStream* nif); };
uint32_t mLOD; uint32_t mNumNodeGroups; std::vector<NiAVObjectList> mNodeGroups; std::vector<std::vector<SkinInfo>> mSkinnedShapeGroups; NiTriBasedGeomList mShapeGroups;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct bhkBlendController : public NiTimeController { void read(NIFStream* nif) override; };
struct BSEffectShaderPropertyFloatController : public NiFloatInterpController { uint32_t mControlledVariable;
void read(NIFStream* nif) override; };
struct BSEffectShaderPropertyColorController : public NiPoint3InterpController { uint32_t mControlledColor;
void read(NIFStream* nif) override; };
struct BSKeyframeController : NiKeyframeController { NiKeyframeDataPtr mData2;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct BSLagBoneController : NiTimeController { float mLinearVelocity; float mLinearRotation; float mMaximumDistance;
void read(NIFStream* nif) override; };
struct BSProceduralLightningController : NiTimeController { NiInterpolatorPtr mGenerationInterp; NiInterpolatorPtr mMutationInterp; NiInterpolatorPtr mSubdivisionInterp; NiInterpolatorPtr mNumBranchesInterp; NiInterpolatorPtr mNumBranchesVarInterp; NiInterpolatorPtr mLengthInterp; NiInterpolatorPtr mLengthVarInterp; NiInterpolatorPtr mWidthInterp; NiInterpolatorPtr mArcOffsetInterp; uint16_t mSubdivisions; uint16_t mNumBranches; uint16_t mNumBranchesVar; float mLength; float mLengthVar; float mWidth; float mChildWidthMult; float mArcOffset; bool mFadeMainBolt; bool mFadeChildBolts; bool mAnimateArcOffset; BSShaderPropertyPtr mShaderProperty;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiControllerManager : public NiTimeController { bool mCumulative; NiControllerSequenceList mSequences; NiDefaultAVObjectPalettePtr mObjectPalette;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Abstract struct NiExtraDataController : NiSingleInterpController { std::string mExtraDataName;
void read(NIFStream* nif) override; };
struct NiFloatExtraDataController : NiExtraDataController { NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiFloatsExtraDataController : NiExtraDataController { int32_t mFloatsExtraDataIndex; NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiFloatsExtraDataPoint3Controller : NiExtraDataController { int32_t mFloatsExtraDataIndex;
void read(NIFStream* nif) override; };
// Abstract struct NiInterpolator : public Record { };
template <class T, class DataPtr> struct TypedNiInterpolator : public NiInterpolator { T mDefaultValue; DataPtr mData;
void read(NIFStream* nif) override { nif->read(mDefaultValue); mData.read(nif); }
void post(Reader& nif) override { mData.post(nif); } };
using NiPoint3Interpolator = TypedNiInterpolator<osg::Vec3f, NiPosDataPtr>; using NiBoolInterpolator = TypedNiInterpolator<bool, NiBoolDataPtr>; using NiFloatInterpolator = TypedNiInterpolator<float, NiFloatDataPtr>; using NiTransformInterpolator = TypedNiInterpolator<NiQuatTransform, NiKeyframeDataPtr>; using NiColorInterpolator = TypedNiInterpolator<osg::Vec4f, NiColorDataPtr>;
struct NiPathInterpolator : public NiInterpolator { // Uses the same flags as NiPathController uint16_t mFlags; int32_t mBankDirection; float mMaxBankAngle; float mSmoothing; uint16_t mFollowAxis; NiPosDataPtr mPathData; NiFloatDataPtr mPercentData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
struct NiLookAtInterpolator : NiInterpolator { // Uses the same flags as NiLookAtController uint16_t mLookAtFlags{ 0 }; NiAVObjectPtr mLookAt; std::string mLookAtName; NiQuatTransform mTransform; NiInterpolatorPtr mTranslation; NiInterpolatorPtr mRoll; NiInterpolatorPtr mScale;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Abstract struct NiBlendInterpolator : public NiInterpolator { enum Flags { Flag_ManagerControlled = 0x1, Flag_OnlyUseHighestWeight = 0x2, };
struct Item { NiInterpolatorPtr mInterpolator; float mWeight, mNormalizedWeight; int32_t mPriority; float mEaseSpinner;
void read(NIFStream* nif); void post(Reader& nif); };
uint8_t mFlags{ 0 }; uint16_t mArrayGrowBy{ 0 }; float mWeightThreshold; uint16_t mInterpCount; uint16_t mSingleIndex; int32_t mHighPriority, mNextHighPriority; float mSingleTime; float mHighWeightsSum, mNextHighWeightsSum; float mHighEaseSpinner; std::vector<Item> mItems; NiInterpolatorPtr mSingleInterpolator;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
template <typename T> struct TypedNiBlendInterpolator : public NiBlendInterpolator { T mValue;
void read(NIFStream* nif) override { NiBlendInterpolator::read(nif);
nif->read(mValue); } };
template <> struct TypedNiBlendInterpolator<NiQuatTransform> : public NiBlendInterpolator { NiQuatTransform mValue;
void read(NIFStream* nif) override { NiBlendInterpolator::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 109)) nif->read(mValue); } };
using NiBlendBoolInterpolator = TypedNiBlendInterpolator<uint8_t>; using NiBlendFloatInterpolator = TypedNiBlendInterpolator<float>; using NiBlendPoint3Interpolator = TypedNiBlendInterpolator<osg::Vec3f>; using NiBlendTransformInterpolator = TypedNiBlendInterpolator<NiQuatTransform>;
// Abstract struct NiBSplineInterpolator : public NiInterpolator { float mStartTime; float mStopTime; NiBSplineDataPtr mSplineData; NiBSplineBasisDataPtr mBasisData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
// Abstract struct NiBSplineFloatInterpolator : public NiBSplineInterpolator { float mValue; uint32_t mHandle;
void read(NIFStream* nif) override; };
struct NiBSplineCompFloatInterpolator : public NiBSplineFloatInterpolator { float mOffset; float mHalfRange;
void read(NIFStream* nif) override; };
// Abstract struct NiBSplinePoint3Interpolator : public NiBSplineInterpolator { osg::Vec3f mValue; uint32_t mHandle;
void read(NIFStream* nif) override; };
struct NiBSplineCompPoint3Interpolator : public NiBSplinePoint3Interpolator { float mOffset; float mHalfRange;
void read(NIFStream* nif) override; };
struct NiBSplineTransformInterpolator : public NiBSplineInterpolator { NiQuatTransform mValue; uint32_t mTranslationHandle; uint32_t mRotationHandle; uint32_t mScaleHandle;
void read(NIFStream* nif) override; };
struct NiBSplineCompTransformInterpolator : public NiBSplineTransformInterpolator { float mTranslationOffset; float mTranslationHalfRange; float mRotationOffset; float mRotationHalfRange; float mScaleOffset; float mScaleHalfRange;
void read(NIFStream* nif) override; };
struct BSTreadTransform { std::string mName; NiQuatTransform mTransform1; NiQuatTransform mTransform2;
void read(NIFStream* nif); };
struct BSTreadTransfInterpolator : public NiInterpolator { std::vector<BSTreadTransform> mTransforms; NiFloatDataPtr mData;
void read(NIFStream* nif) override; void post(Reader& nif) override; };
}#endif