mirror
/
openmw-tes3mp
mirror of https://github.com/TES3MP/openmw-tes3mp.git
1
0
Fork 1
Code Issues Releases Wiki Activity

Change rotation/scale workaround in preparation for loading .kf controllers

Browse Source
c++11
scrawl 10 years ago
parent 15f9c1ddcf
commit 2db5df77f0
8 changed files with 121 additions and 53 deletions
Show Stats Download Patch File Download Diff File

2
components/CMakeLists.txt
Unescape Escape View File

@ -43,7 +43,7 @@ add_component_dir (nif
)
add_component_dir (nifosg
nifloader controller particle
nifloader controller particle userdata
)
#add_component_dir (nifcache

2
components/nif/niftypes.hpp
Unescape Escape View File

@ -46,7 +46,7 @@ struct Matrix3
struct Transformation
{
osg::Vec3f pos;
Matrix3 rotation;
Matrix3 rotation; // this can contain scale components too, including negative and nonuniform scales
float scale;
static const Transformation& getIdentity()

40
components/nifosg/controller.cpp
Unescape Escape View File

@ -4,15 +4,17 @@
#include <osg/TexMat>
#include <osg/Material>
#include <osg/Texture2D>
#include <osg/io_utils>
#include <osg/UserDataContainer>
#include <osgAnimation/MorphGeometry>
#include <osgParticle/Emitter>
#include <osg/io_utils>
#include <components/nif/data.hpp>
#include "userdata.hpp"
namespace NifOsg
{
@ -76,13 +78,10 @@ KeyframeController::KeyframeController(const KeyframeController &copy, const osg
, mTranslations(copy.mTranslations)
, mScales(copy.mScales)
, mNif(copy.mNif)
, mInitialQuat(copy.mInitialQuat)
, mInitialScale(copy.mInitialScale)
{
}
KeyframeController::KeyframeController(const Nif::NIFFilePtr &nif, const Nif::NiKeyframeData *data,
osg::Quat initialQuat, float initialScale)
KeyframeController::KeyframeController(const Nif::NIFFilePtr &nif, const Nif::NiKeyframeData *data)
: mRotations(&data->mRotations)
, mXRotations(&data->mXRotations)
, mYRotations(&data->mYRotations)
@ -90,9 +89,8 @@ KeyframeController::KeyframeController(const Nif::NIFFilePtr &nif, const Nif::Ni
, mTranslations(&data->mTranslations)
, mScales(&data->mScales)
, mNif(nif)
, mInitialQuat(initialQuat)
, mInitialScale(initialScale)
{ }
{
}
osg::Quat KeyframeController::interpKey(const Nif::QuaternionKeyMap::MapType &keys, float time)
{
@ -154,15 +152,35 @@ void KeyframeController::operator() (osg::Node* node, osg::NodeVisitor* nv)
float time = getInputValue(nv);
NodeUserData* userdata = static_cast<NodeUserData*>(trans->getUserDataContainer()->getUserObject(0));
Nif::Matrix3& rot = userdata->mRotationScale;
bool setRot = false;
if(mRotations->mKeys.size() > 0)
{
mat.setRotate(interpKey(mRotations->mKeys, time));
setRot = true;
}
else if (!mXRotations->mKeys.empty() || !mYRotations->mKeys.empty() || !mZRotations->mKeys.empty())
{
mat.setRotate(getXYZRotation(time));
setRot = true;
}
else
mat.setRotate(mInitialQuat);
{
// no rotation specified, use the previous value from the UserData
for (int i=0;i<3;++i)
for (int j=0;j<3;++j)
mat(j,i) = rot.mValues[i][j]; // NB column/row major difference
}
if (setRot) // copy the new values back to the UserData
for (int i=0;i<3;++i)
for (int j=0;j<3;++j)
rot.mValues[i][j] = mat(j,i); // NB column/row major difference
// let's hope no one's using multiple KeyframeControllers on the same node (not that would make any sense...)
float scale = mInitialScale;
float& scale = userdata->mScale;
if(mScales->mKeys.size() > 0)
scale = interpKey(mScales->mKeys, time);

7
components/nifosg/controller.hpp
Unescape Escape View File

@ -147,11 +147,9 @@ namespace NifOsg
const Nif::FloatKeyMap* mZRotations;
const Nif::Vector3KeyMap* mTranslations;
const Nif::FloatKeyMap* mScales;
// TODO: we don't need to keep the whole NIF around, just change the key maps to Referenced
Nif::NIFFilePtr mNif; // Hold a SharedPtr to make sure key lists stay valid
osg::Quat mInitialQuat;
float mInitialScale;
using ValueInterpolator::interpKey;
@ -161,8 +159,7 @@ namespace NifOsg
public:
/// @note The NiKeyFrameData must be valid as long as this KeyframeController exists.
KeyframeController(const Nif::NIFFilePtr& nif, const Nif::NiKeyframeData *data,
osg::Quat initialQuat, float initialScale);
KeyframeController(const Nif::NIFFilePtr& nif, const Nif::NiKeyframeData *data);
KeyframeController();
KeyframeController(const KeyframeController& copy, const osg::CopyOp& copyop);

17
components/nifosg/nifloader.cpp
Unescape Escape View File

@ -42,6 +42,7 @@
#include <components/nif/node.hpp>
#include "particle.hpp"
#include "userdata.hpp"
namespace
{
@ -191,12 +192,13 @@ namespace
{
if (_referenceFrame==RELATIVE_RF)
{
const NifOsg::NodeUserData* userdata = static_cast<const NifOsg::NodeUserData*>(getUserDataContainer()->getUserObject(0));
matrix.preMult(_matrix);
osg::Vec3 scale = matrix.getScale();
matrix.setRotate(osg::Quat());
matrix(0,0) = scale.x();
matrix(1,1) = scale.y();
matrix(2,2) = scale.z();
matrix(0,0) = userdata->mScale;
matrix(1,1) = userdata->mScale;
matrix(2,2) = userdata->mScale;
}
else // absolute
{
@ -365,7 +367,10 @@ namespace NifOsg
// - finding the correct emitter node for a particle system
// - establishing connections to the animated collision shapes, which are handled in a separate loader
// - finding a random child NiNode in NiBspArrayController
transformNode->setUserData(new RecIndexHolder(nifNode->recIndex));
// - storing the previous 3x3 rotation and scale values for when a KeyframeController wants to
// change only certain elements of the 4x4 transform
transformNode->getOrCreateUserDataContainer()->addUserObject(
new NodeUserData(nifNode->recIndex, nifNode->trafo.scale, nifNode->trafo.rotation));
if (nifNode->recType == Nif::RC_NiBSAnimationNode)
animflags |= nifNode->flags;
@ -471,7 +476,7 @@ namespace NifOsg
for (int j=0;j<3;++j)
mat(j,i) = nifNode->trafo.rotation.mValues[i][j];
osg::ref_ptr<KeyframeController> callback(new KeyframeController(mNif, key->data.getPtr(), mat.getRotate(), nifNode->trafo.scale));
osg::ref_ptr<KeyframeController> callback(new KeyframeController(mNif, key->data.getPtr()));
setupController(key, callback, animflags);
transformNode->addUpdateCallback(callback);

24
components/nifosg/particle.cpp
Unescape Escape View File

@ -8,6 +8,8 @@
#include <osg/io_utils>
#include "userdata.hpp"
namespace NifOsg
{
@ -279,4 +281,26 @@ void Emitter::emitParticles(double dt)
}
}
FindRecIndexVisitor::FindRecIndexVisitor(int recIndex)
: osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
, mFound(NULL)
, mRecIndex(recIndex)
{
}
void FindRecIndexVisitor::apply(osg::Node &searchNode)
{
if (searchNode.getUserDataContainer() && searchNode.getUserDataContainer()->getNumUserObjects())
{
NodeUserData* holder = dynamic_cast<NodeUserData*>(searchNode.getUserDataContainer()->getUserObject(0));
if (holder && holder->mIndex == mRecIndex)
{
mFound = static_cast<osg::Group*>(&searchNode);
mFoundPath = getNodePath();
return;
}
}
traverse(searchNode);
}
}

33
components/nifosg/particle.hpp
Unescape Escape View File

@ -7,6 +7,7 @@
#include <osgParticle/ModularEmitter>
#include <osg/NodeCallback>
#include <osg/UserDataContainer>
#include <components/nif/nifkey.hpp>
#include <components/nif/data.hpp>
@ -152,39 +153,13 @@ namespace NifOsg
osg::Vec3f mCachedWorldPositionDirection;
};
class RecIndexHolder : public osg::Referenced
{
public:
RecIndexHolder(int index) : mIndex(index) {}
int mIndex;
};
// NodeVisitor to find a child node with the given record index, stored in the node's user data.
// NodeVisitor to find a child node with the given record index, stored in the node's user data container.
class FindRecIndexVisitor : public osg::NodeVisitor
{
public:
FindRecIndexVisitor(int recIndex)
: osg::NodeVisitor(TRAVERSE_ALL_CHILDREN)
, mFound(NULL)
, mRecIndex(recIndex)
{
}
FindRecIndexVisitor(int recIndex);
virtual void apply(osg::Node &searchNode)
{
if (searchNode.getUserData())
{
RecIndexHolder* holder = static_cast<RecIndexHolder*>(searchNode.getUserData());
if (holder->mIndex == mRecIndex)
{
mFound = static_cast<osg::Group*>(&searchNode);
mFoundPath = getNodePath();
return;
}
}
traverse(searchNode);
}
virtual void apply(osg::Node &searchNode);
osg::Group* mFound;
osg::NodePath mFoundPath;

49
components/nifosg/userdata.hpp
Unescape Escape View File

@ -0,0 +1,49 @@
#ifndef OPENMW_COMPONENTS_NIFOSG_USERDATA_H
#define OPENMW_COMPONENTS_NIFOSG_USERDATA_H
#include <components/nif/niftypes.hpp>
#include <osg/Object>
namespace NifOsg
{
// Note if you are copying a scene graph with this user data you should use the DEEP_COPY_USERDATA copyop.
class NodeUserData : public osg::Object
{
public:
NodeUserData(int index, float scale, const Nif::Matrix3& rotationScale)
: mIndex(index), mScale(scale), mRotationScale(rotationScale)
{
}
NodeUserData()
: mIndex(0), mScale(0)
{
}
NodeUserData(const NodeUserData& copy, const osg::CopyOp& copyop)
: Object(copy, copyop)
, mIndex(copy.mIndex)
, mScale(copy.mScale)
, mRotationScale(copy.mRotationScale)
{
}
META_Object(NifOsg, NodeUserData)
// NIF record index
int mIndex;
// Hack: account for Transform differences between OSG and NIFs.
// OSG uses a 4x4 matrix, NIF's use a 3x3 rotationScale, float scale, and vec3 position.
// Decomposing the original components from the 4x4 matrix isn't possible, which causes
// problems when a KeyframeController wants to change only one of these components. So
// we store the scale and rotation components separately here.
// Note for a cleaner solution it would be possible to write a custom Transform node,
// but then we have to fork osgAnimation :/
float mScale;
Nif::Matrix3 mRotationScale;
};
}
#endif
Write Preview
Loading…
Cancel
Save