mirror of
https://github.com/OpenMW/openmw.git
synced 2025-11-04 05:26:39 +00:00
410 lines
11 KiB
C++
410 lines
11 KiB
C++
/*
|
|
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
|
|
#define OPENMW_COMPONENTS_NIF_CONTROLLER_HPP
|
|
|
|
#include "base.hpp"
|
|
|
|
namespace Nif
|
|
{
|
|
|
|
struct ControlledBlock
|
|
{
|
|
std::string mTargetName;
|
|
NiInterpolatorPtr mInterpolator;
|
|
ControllerPtr mController;
|
|
NiBlendInterpolatorPtr mBlendInterpolator;
|
|
unsigned short mBlendIndex;
|
|
unsigned char mPriority;
|
|
NiStringPalettePtr mStringPalette;
|
|
size_t mNodeNameOffset;
|
|
size_t mPropertyTypeOffset;
|
|
size_t mControllerTypeOffset;
|
|
size_t mControllerIdOffset;
|
|
size_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;
|
|
unsigned int 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 };
|
|
Controller::ExtrapolationMode mExtrapolationMode{ Controller::ExtrapolationMode::Constant };
|
|
float mFrequency{ 1.f };
|
|
float mPhase{ 1.f };
|
|
float mStartTime, mStopTime;
|
|
bool mPlayBackwards{ false };
|
|
NiControllerManagerPtr mManager;
|
|
NiStringPalettePtr mStringPalette;
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
// Base class for controllers that use NiInterpolators to animate objects.
|
|
struct NiInterpController : public Controller
|
|
{
|
|
// 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 NiParticleSystemController : public Controller
|
|
{
|
|
enum BSPArrayController
|
|
{
|
|
BSPArrayController_AtNode = 0x8,
|
|
BSPArrayController_AtVertex = 0x10
|
|
};
|
|
|
|
struct Particle
|
|
{
|
|
osg::Vec3f velocity;
|
|
float lifetime;
|
|
float lifespan;
|
|
float timestamp;
|
|
unsigned short vertex;
|
|
};
|
|
|
|
float velocity;
|
|
float velocityRandom;
|
|
|
|
float verticalDir; // 0=up, pi/2=horizontal, pi=down
|
|
float verticalAngle;
|
|
float horizontalDir;
|
|
float horizontalAngle;
|
|
|
|
osg::Vec4f color;
|
|
float size;
|
|
float startTime;
|
|
float stopTime;
|
|
|
|
float emitRate;
|
|
float lifetime;
|
|
float lifetimeRandom;
|
|
|
|
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.
|
|
};
|
|
int emitFlags;
|
|
|
|
osg::Vec3f offsetRandom;
|
|
|
|
NodePtr emitter;
|
|
|
|
int numParticles;
|
|
int activeCount;
|
|
std::vector<Particle> particles;
|
|
|
|
NiParticleModifierPtr affectors;
|
|
NiParticleModifierPtr colliders;
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
|
|
bool noAutoAdjust() const { return emitFlags & EmitFlag_NoAutoAdjust; }
|
|
bool emitAtVertex() const { return flags & BSPArrayController_AtVertex; }
|
|
};
|
|
using NiBSPArrayController = NiParticleSystemController;
|
|
|
|
struct NiMaterialColorController : public NiPoint3InterpController
|
|
{
|
|
NiPosDataPtr mData;
|
|
unsigned int mTargetColor;
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiPathController : public Controller
|
|
{
|
|
NiPosDataPtr posData;
|
|
NiFloatDataPtr floatData;
|
|
|
|
enum Flags
|
|
{
|
|
Flag_OpenCurve = 0x020,
|
|
Flag_AllowFlip = 0x040,
|
|
Flag_Bank = 0x080,
|
|
Flag_ConstVelocity = 0x100,
|
|
Flag_Follow = 0x200,
|
|
Flag_FlipFollowAxis = 0x400
|
|
};
|
|
|
|
int bankDir;
|
|
float maxBankAngle, smoothing;
|
|
short followAxis;
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiLookAtController : public Controller
|
|
{
|
|
NodePtr target;
|
|
unsigned short lookAtFlags{ 0 };
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiUVController : public Controller
|
|
{
|
|
NiUVDataPtr data;
|
|
unsigned int uvSet;
|
|
|
|
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
|
|
{
|
|
NodeList 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
|
|
{
|
|
int mTexSlot; // NiTexturingProperty::TextureType
|
|
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 bhkBlendController : public Controller
|
|
{
|
|
void read(NIFStream* nif) override;
|
|
};
|
|
|
|
struct NiControllerManager : public Controller
|
|
{
|
|
bool mCumulative;
|
|
NiControllerSequenceList mSequences;
|
|
NiDefaultAVObjectPalettePtr mObjectPalette;
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiInterpolator : public Record
|
|
{
|
|
};
|
|
|
|
struct NiPoint3Interpolator : public NiInterpolator
|
|
{
|
|
osg::Vec3f defaultVal;
|
|
NiPosDataPtr data;
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiBoolInterpolator : public NiInterpolator
|
|
{
|
|
char defaultVal;
|
|
NiBoolDataPtr data;
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiFloatInterpolator : public NiInterpolator
|
|
{
|
|
float defaultVal;
|
|
NiFloatDataPtr data;
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiTransformInterpolator : public NiInterpolator
|
|
{
|
|
osg::Vec3f defaultPos;
|
|
osg::Quat defaultRot;
|
|
float defaultScale;
|
|
NiKeyframeDataPtr data;
|
|
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
struct NiColorInterpolator : public NiInterpolator
|
|
{
|
|
osg::Vec4f defaultVal;
|
|
NiColorDataPtr data;
|
|
void read(NIFStream* nif) override;
|
|
void post(Reader& nif) override;
|
|
};
|
|
|
|
// Abstract
|
|
struct NiBlendInterpolator : public NiInterpolator
|
|
{
|
|
struct Item
|
|
{
|
|
NiInterpolatorPtr mInterpolator;
|
|
float mWeight, mNormalizedWeight;
|
|
int mPriority;
|
|
float mEaseSpinner;
|
|
|
|
void read(NIFStream* nif);
|
|
void post(Reader& nif);
|
|
};
|
|
|
|
bool mManagerControlled{ false };
|
|
bool mOnlyUseHighestWeight{ false };
|
|
unsigned short mArrayGrowBy{ 0 };
|
|
float mWeightThreshold;
|
|
unsigned short mInterpCount;
|
|
unsigned short mSingleIndex;
|
|
int 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;
|
|
};
|
|
|
|
struct NiBlendBoolInterpolator : public NiBlendInterpolator
|
|
{
|
|
char mValue;
|
|
void read(NIFStream* nif) override;
|
|
};
|
|
|
|
struct NiBlendFloatInterpolator : public NiBlendInterpolator
|
|
{
|
|
float mValue;
|
|
void read(NIFStream* nif) override;
|
|
};
|
|
|
|
struct NiBlendPoint3Interpolator : public NiBlendInterpolator
|
|
{
|
|
osg::Vec3f mValue;
|
|
void read(NIFStream* nif) override;
|
|
};
|
|
|
|
struct NiBlendTransformInterpolator : public NiBlendInterpolator
|
|
{
|
|
osg::Vec3f mPosValue;
|
|
osg::Quat mRotValue;
|
|
float mScaleValue;
|
|
void read(NIFStream* nif) override;
|
|
};
|
|
|
|
} // Namespace
|
|
#endif
|