Importing Animated Models

最新推荐文章于 2024-08-18 08:42:19 发布
最新推荐文章于 2024-08-18 08:42:19 发布
阅读量829 收藏
点赞数 3
分类专栏： Rendering with DirectX && HLSL 文章标签： Skeletal animation Keyframe SceneNode Hierarchy

Importing Animated Models

在正式使用skinned model shader之前，需要先导入一个具体模型的动画数据。这是一个说起来容易做起来很难的任务，而且需要额外的plumbing（管道工程，对应于第15章导入模型时所讲的content pipeline）。值得庆幸的是，Open Asset Import Library（见第15章“Models”）支持动画模型，并且可以用于从多种不同格式的文件中获取动画数据。但是，要把该数据转换成渲染引擎能直接使用的格式并使引擎代码独立于Open Asset Import Library，需要做更多的工作（主要是因为在编译期执行数据转换操作比在应用程序执行时更好）。
实现动画系统要创建的第一个类是SceneNode类（见列表20.2）。

列表20.2 Declaration of the SceneNode Class

#pragma once

#include "Common.h"

namespace Library
{
	class SceneNode : public RTTI
	{
		RTTI_DECLARATIONS(SceneNode, RTTI)

	public:	
		const std::string& Name() const;
		SceneNode* Parent();
		std::vector<SceneNode*>& Children();
		const XMFLOAT4X4& Transform() const;
		XMMATRIX TransformMatrix() const;

		void SetParent(SceneNode* parent);

		void SetTransform(XMFLOAT4X4& transform);
		void SetTransform(CXMMATRIX transform);

		SceneNode(const std::string& name);
		SceneNode(const std::string& name, const XMFLOAT4X4& transform);

	protected:
		std::string mName;
		SceneNode* mParent;
		std::vector<SceneNode*> mChildren;
		XMFLOAT4X4 mTransform;

	private:
		SceneNode();
		SceneNode(const SceneNode& rhs);
		SceneNode& operator=(const SceneNode& rhs);
	};
}

SceneNode类主要建立了用于skeletal animation的hierarchical transformation structure（分层变换体系结构）。每一个SceneNode对象都包含一个名称，变换矩阵，父结点，一组子结点。如果父结点为NULL，表示该SceneNode对象为层次结构中的根结点。
接下来创建一个由SceneNode类派生的Bone类，该类的声明代码如列表20.3所示。

列表20.3 Declaration of the Bone Class

class Bone : public SceneNode
{
	RTTI_DECLARATIONS(Bone, SceneNode)

public:
	UINT Index() const;
	void SetIndex(UINT index);

	const XMFLOAT4X4& OffsetTransform() const;
	XMMATRIX OffsetTransformMatrix() const;

	Bone(const std::string& name, UINT index, const XMFLOAT4X4& offsetTransform);

private:
	Bone();
	Bone(const Bone& rhs);
	Bone& operator=(const Bone& rhs);

	UINT mIndex;					// Index into the model's bone container
	XMFLOAT4X4 mOffsetTransform;	// Transforms from mesh space to bone space
};

一个Bone类对象表示模型骨骼中的一个特定的组成部分。由于Bone类继承自SceneNode类，一个Bone对象也是一个SceneNode对象，因此具有与SceneNode对象同样的分层体系结构。每一个Bone和SceneNode对象都是独立的，支持在某个层次范围内执行变换操作，所有的层次都会影响模型的骨骼结构，但没有与之关联的vertices。第一次看到这种结构可以会觉得很奇怪，但实际上却是非常普通的做法。Bone类在SceneNode类的基础上增加一个成员变量index索引值，用于访问模型的骨骼，以及一个用于offset tranform（偏移计算的变换）矩阵变量mOffsetTransform。其中index值用于把vertices与shader中的bone变换矩阵数组关联起来（限shader输入结构体中的BoneIndices成员）。

变量mOffsetTransform用于把一个object从mesh space变换到bone space。之前要使用变换矩阵，是因为与该bone关联的vertices位于mesh space中（也就是local/model space），但是bone的变换运算都是在 bone space中（相对于父结点bone，bone结点自身也有一个坐标系）。因此，要使用一个bone变换矩阵对vertex进行变换，首先要使用mOffsetTransform变量把bone从mesh space变换到bone space。

完成了Bone类的定义之后，就可以在Model类中增加一组Bones变量。Model类中具体地实现代码如下：

std::vector<Bone*> mBones;
std::map<std::string, UINT> mBoneIndexMapping;
SceneNode* mRootNode;

其中成员变量mBones表示一组bones的集合，不考虑这些bones所处的层次。变量mBoneIndexMapping把一个bone的名称与bone在mBones数组中索引值进行一一对应。Bone类中的成员变量Bone::mIndex具有同样的映射，该变量用于表示在shader中访问bone transformations数组的索引值。这些独立的成员结构是使用Open Asset Import Library，并用于存储bone数据的方法产生的副作用。如果在编译期执行动画数据的转换操作，就可以去掉这些成员变量。

成员变量mRootNode表示变换分层结构中的根结点，并在模型中的所有bones都获取完成之后生成根结点。在Open Asset Import Library中以每一个mesh存储bone数据，因此需要在Mesh中增加获取bone数据的相关成员。具体包括两部分数据：bones本身以及bone vertex weights（权重）。列表20.4中列出BoneVertexWeight类的声明代码。

列表20.4 Declaration of the BoneVertexWeight Class

class BoneVertexWeights
{
public:
	typedef struct _VertexWeight
	{
		float Weight;
		UINT BoneIndex;

		_VertexWeight(float weight, UINT boneIndex)
			: Weight(weight), BoneIndex(boneIndex) { }
	} VertexWeight;

	const std::vector<VertexWeight>& Weights();

	void AddWeight(float weight, UINT boneIndex);

	static const UINT MaxBoneWeightsPerVertex = 4U;

private:
	std::vector<VertexWeight> mWeights;
};

使用Mesh类的成员变量Mesh::mBoneWeights（变量类型为std::vector<BoneVertexWeight>）可以把一个BoneVertexWeight类型的对象实例与mesh中每一个vertex进行关联。在Mesh类的构造函数中（使用Open Asset Import Library处理mesh结构的过程在该函数中完成）需要增加如列表20.5所示的代码。

列表20.5 Bone Processing with the Mesh Class Constructor

if (mesh.HasBones())
{
	mBoneWeights.resize(mesh.mNumVertices);

	for (UINT i = 0; i < mesh.mNumBones; i++)
	{
		aiBone* meshBone = mesh.mBones[i];

		// Look up the bone in the model's hierarchy, or add it if not found.
		UINT boneIndex = 0U;
		std::string boneName = meshBone->mName.C_Str();
		auto boneMappingIterator = mModel.mBoneIndexMapping.find(boneName);
		if (boneMappingIterator != mModel.mBoneIndexMapping.end())
		{
			boneIndex = boneMappingIterator->second;
		}
		else
		{
			boneIndex = mModel.mBones.size();
			XMMATRIX offsetMatrix = XMLoadFloat4x4(&(XMFLOAT4X4(reinterpret_cast<const float*>(meshBone->mOffsetMatrix[0]))));
			XMFLOAT4X4 offset;
			XMStoreFloat4x4(&offset, XMMatrixTranspose(offsetMatrix));

			Bone* modelBone = new Bone(boneName, boneIndex, offset);
			mModel.mBones.push_back(modelBone);
			mModel.mBoneIndexMapping[boneName] = boneIndex;
		}

		for (UINT i = 0; i < meshBone->mNumWeights; i++)
		{
			aiVertexWeight vertexWeight = meshBone->mWeights[i];
			mBoneWeights[vertexWeight.mVertexId].AddWeight(vertexWeight.mWeight, boneIndex);
		}
	}
}

在Open Asset Import Library中使用一个aiBone类对象的数组存储bone数据。一个aiBone对象中存储了bone的名称，offset transform矩阵以及vertex weights列表。在列表20.5所示的代码中，通过遍历aiBone对象的数组，并根据boner的名称在model的mBoneIndexMapping容器中查找每一个bone。如果没有找到指定名称的bone，就在mBoneIndexMapping容器中添加以该名称创建的bone（创建bone时需要把offset矩阵进行转置，因为存储的变换矩阵是列优先矩阵，而我们需要的是行优先矩阵）。之所以需要把Bone对象都添加到mBoneIndexMapping容器中，是因为bones都存储在model中，但是需要在所有的aiMesh对象之间共享数据。最后，使用aiVertexWeight::mVertexId变量把vertex weights都拷贝到Mesh::mBoneWeights容器中。

使用上面的方法，可以在mesh中找到大部分bone数据，但是骨骼层次结构是属于aiScene对象的一部分，而aiScene对象是在Model类的构造函数中处理的。更具体地说，aiScene对象中含有一个aiNode类型的成员变量mRootNode，其中aiNode结构体类似于SceneNode类，因此使用aiScene::mRootNode变量表示transformation hierarchy（变换层次结构）的根结点。可以使用递归函数Model::BuildSkeleton()处理这些分层结点，该函数代码如列表20.6所示。

列表20.6 Processing the Skeletal Hierarchy

SceneNode* Model::BuildSkeleton(aiNode& node, SceneNode* parentSceneNode)
{
	SceneNode* sceneNode = nullptr;

	auto boneMapping = mBoneIndexMapping.find(node.mName.C_Str());
	if (boneMapping == mBoneIndexMapping.end())
	{
		sceneNode = new SceneNode(node.mName.C_Str());
	}
	else
	{
		sceneNode = mBones[boneMapping->second];
	}

	XMMATRIX transform = XMLoadFloat4x4(&(XMFLOAT4X4(reinterpret_cast<const float*>(node.mTransformation[0]))));
	sceneNode->SetTransform(XMMatrixTranspose(transform));
	sceneNode->SetParent(parentSceneNode);

	for (UINT i = 0; i < node.mNumChildren; i++)
	{
		SceneNode* childSceneNode = BuildSkeleton(*(node.mChildren[i]), sceneNode);
		sceneNode->Children().push_back(childSceneNode);
	}

	return sceneNode;
}

首先调用BuildSkeleton()函数创建根结点aiSceneNode::mRootNode，然后通过递归创建根结点的每一个子结点。需要注意的是该结点层次并不需要组成全部的Bone对象。如果结点的名称与model中的一个Bone对象匹配，表示bone对象已经被使用了。否则，该结点表示一个没有任意vertices关联的变换，但是该变换却会影响到transformation hierarchy（变换层次结构）。在这种情况下，需要把以该结点名称创建一个新的SceneNode对象并添加到hierarchy结构中，而不能跳过这些结点。

现在，我们已经完成了导入模型骨骼结构所需要的全部数据，以及对应的skinning信息。最后一步是导入一些用于表示skeleton随着时间的变化如何进行变换的animations（动画数据）。Animations由一组 keyframes（关键侦）组成，一个keyframe表示一个时间点，并记录了在该时间点一个bone所要执行的变换。一个animation的帧率可能会创建成与游戏所期望的帧率保持一致。比如，如果游戏的运行帧率为60帧/秒，那么一个1秒时长的animation可能包含60个keyframes。但是，如果一个animation的关键帧数少于游戏的帧率，为了产生一个更平滑的animation可以在两个keybrames之间进行插值。
在Open Asset Import Library中，使用aiScene::mAnimations成员变量存储animations数据，该变量是一个aiAnimation类对象组成的数组。每一个aiAnimation对象实例都包括animation的名称，duration（持续时间，以ticks为单位），以及一秒钟的ticks数量。此外，还包含了多个keyframes集合，每一组keyframes对应了animation中的一个bone。AnimationClip类与aiAnimation数据结构类似（只是对aiAnimation进行了封装，以消除在示例程序中对Open Asset Import Library的公共依赖）。列表20.7中列出了AnimationClip类的声明代码。

列表20.7 Declaration of the AnimationClip Class

#pragma once

#include "Common.h"

struct aiAnimation;

namespace Library
{
	class Bone;
	class BoneAnimation;

	class AnimationClip
	{
		friend class Model;

	public:        
		~AnimationClip();
		
		const std::string& Name() const;
		float Duration() const;
		float TicksPerSecond() const;
		const std::vector<BoneAnimation*>& BoneAnimations() const;
		const std::map<Bone*, BoneAnimation*>& BoneAnimationsByBone() const;
		const UINT KeyframeCount() const;

		UINT GetTransform(float time, Bone& bone, XMFLOAT4X4& transform) const;
		void GetTransforms(float time, std::vector<XMFLOAT4X4>& boneTransforms) const;
		
		void GetTransformAtKeyframe(UINT keyframe, Bone& bone, XMFLOAT4X4& transform) const;
		void GetTransformsAtKeyframe(UINT keyframe, std::vector<XMFLOAT4X4>& boneTransforms) const;

		void GetInteropolatedTransform(float time, Bone& bone, XMFLOAT4X4& transform) const;
		void GetInteropolatedTransforms(float time, std::vector<XMFLOAT4X4>& boneTransforms) const;

	private:
		AnimationClip(Model& model, aiAnimation& animation);

		AnimationClip();
		AnimationClip(const AnimationClip& rhs);
		AnimationClip& operator=(const AnimationClip& rhs);

		std::string mName;
		float mDuration;
		float mTicksPerSecond;
		std::vector<BoneAnimation*> mBoneAnimations;
		std::map<Bone*, BoneAnimation*> mBoneAnimationsByBone;
		UINT mKeyframeCount;
	};
}

用于表示animation中每一个bone的keyframes集合都存储在BoneAnimation类型的mBoneAnimations容器中。BoneAnimation类的声明代码非常简短，只包含一个给定bone对象的keyframes集合。这些keyframes数据在AnimationClip类的私有构造函数中进行处理，该函数的实现代码如列表20.8所示。

列表20.8 Processing Animation Data

AnimationClip::AnimationClip(Model& model, aiAnimation& animation)
	: mName(animation.mName.C_Str()), mDuration(static_cast<float>(animation.mDuration)), mTicksPerSecond(static_cast<float>(animation.mTicksPerSecond)),
	mBoneAnimations(), mBoneAnimationsByBone(), mKeyframeCount(0)
{
	assert(animation.mNumChannels > 0);

	if (mTicksPerSecond <= 0.0f)
	{
		mTicksPerSecond = 1.0f;
	}

	for (UINT i = 0; i < animation.mNumChannels; i++)
	{
		BoneAnimation* boneAnimation = new BoneAnimation(model, *(animation.mChannels[i]));
		mBoneAnimations.push_back(boneAnimation);

		assert(mBoneAnimationsByBone.find(&(boneAnimation->GetBone())) == mBoneAnimationsByBone.end());
		mBoneAnimationsByBone[&(boneAnimation->GetBone())] = boneAnimation;
	}

	for (BoneAnimation* boneAnimation : mBoneAnimations)
	{
		if (boneAnimation->Keyframes().size() > mKeyframeCount)
		{
			mKeyframeCount = boneAnimation->Keyframes().size();
		}
	}
}

在AnimationClip类的成员变量mBoneAnimationByBone容器中，也引用了BoneAnimation对象，该map容器类型的变量主要用于快速查找获取一个指定bone的animation数据。此外，在AnimationClip的构造函数中还计算了成员变量mKeyframeCount。该变量是用于表示访问bone transformations数组的索引值（通过数组系列的索引位置而不是时间点），直到索引值达到最大的keyframe数量。但是，每一个BoneAnimation实例对象可以包含不同数量的keyframes。通过在BoneAnimation对象数组中选择最大的keyframe，就可以使用索引值获取到所有可用的keyframes。当BoneAnimation对象中的keyframes数量小于指定的索引值，需要clamp最后一个keyframe数量（也就是索引值不能超过最后的keyframe）。

使用索引值检索bone transformations，主要是在函数AnimationClip::GetTransform*()（单数版本）和AnimationClip::GetTransforms*()（复数版本）中完成。根据不同的索引值类型参数，这些函数的单数版本用于获取指定bone的transformation，而复数版本获取所有bones的transformations集合。而且这些函数需要依赖BoneAnimation类中对应的函数调用，BoneAnimation类如列表20.9所示。

列表20.9 Declaration of the BoneAnimation Class

#pragma once

#include "Common.h"

struct aiNodeAnim;

namespace Library
{
	class Model;
	class Bone;
	class Keyframe;

	class BoneAnimation
	{
		friend class AnimationClip;

	public:        
		~BoneAnimation();
		
		Bone& GetBone();
		const std::vector<Keyframe*> Keyframes() const;

		UINT GetTransform(float time, XMFLOAT4X4& transform) const;
		void GetTransformAtKeyframe(UINT keyframeIndex, XMFLOAT4X4& transform) const;
		void GetInteropolatedTransform(float time, XMFLOAT4X4& transform) const;		

	private:
		BoneAnimation(Model& model, aiNodeAnim& nodeAnim);

		BoneAnimation();
		BoneAnimation(const BoneAnimation& rhs);
		BoneAnimation& operator=(const BoneAnimation& rhs);

		UINT FindKeyframeIndex(float time) const;

		Model* mModel;
		Bone* mBone;
		std::vector<Keyframe*> mKeyframes;
	};
}

在BoneAnimation类的构造函数中获取所有的keyframe数据，如列表20.10所示。

列表20.10 Processing Keyframe Data

BoneAnimation::BoneAnimation(Model& model, aiNodeAnim& nodeAnim)
	: mModel(&model), mBone(nullptr), mKeyframes()
{
	UINT boneIndex = model.BoneIndexMapping().at(nodeAnim.mNodeName.C_Str());
	mBone = model.Bones().at(boneIndex);

	assert(nodeAnim.mNumPositionKeys == nodeAnim.mNumRotationKeys);
	assert(nodeAnim.mNumPositionKeys == nodeAnim.mNumScalingKeys);

	for (UINT i = 0; i < nodeAnim.mNumPositionKeys; i++)
	{
		aiVectorKey positionKey = nodeAnim.mPositionKeys[i];
		aiQuatKey rotationKey = nodeAnim.mRotationKeys[i];
		aiVectorKey scaleKey = nodeAnim.mScalingKeys[i];

		assert(positionKey.mTime == rotationKey.mTime);
		assert(positionKey.mTime == scaleKey.mTime);

		Keyframe* keyframe = new Keyframe(static_cast<float>(positionKey.mTime), XMFLOAT3(positionKey.mValue.x, positionKey.mValue.y, positionKey.mValue.z),
			XMFLOAT4(rotationKey.mValue.x, rotationKey.mValue.y, rotationKey.mValue.z, rotationKey.mValue.w), XMFLOAT3(scaleKey.mValue.x, scaleKey.mValue.y, scaleKey.mValue.z));
		mKeyframes.push_back(keyframe);
	}
}

在该构造函数中，通过遍历aiNodeAnim对象的数组，把对象中的相关数据拷贝到Keyframe对象实例中。Keyframe类的声明代码如列表20.11所示。

列表20.11 Declaration of the Keyframe Class

#pragma once

#include "Common.h"

namespace Library
{
	class Keyframe
	{
		friend class BoneAnimation;

	public:
		float Time() const;
		const XMFLOAT3& Translation() const;
		const XMFLOAT4& RotationQuaternion() const;
		const XMFLOAT3& Scale() const;

		XMVECTOR TranslationVector() const;
		XMVECTOR RotationQuaternionVector() const;
		XMVECTOR ScaleVector() const;

		XMMATRIX Transform() const;

	private:
		Keyframe(float time, const XMFLOAT3& translation, const XMFLOAT4& rotationQuaternion, const XMFLOAT3& scale);

		Keyframe();
		Keyframe(const Keyframe& rhs);
		Keyframe& operator=(const Keyframe& rhs);

		float mTime;
		XMFLOAT3 mTranslation;
		XMFLOAT4 mRotationQuaternion;
		XMFLOAT3 mScale;
	};
}

每一个keyframe对象中包含一个translation（平移），rotation（旋转）以及scale（缩放）变量，对应于animation中一个特定的时间点。其中rotaion变量使用一个 quaternion（四元数）表示，一个四元数是对复数的四维表示，用于更方便的执行三维旋转运算。在本书中使用Euler angles（欧拉角度）描述3D空间的旋转。这种旋转方法由一个单位向量（旋转轴axis）和一个旋转角度（θ angle）的组合表示。Quaternions提供了一种简单的方法把向量轴和旋转角度编码到四个数中，可以使用一个position vector（点向量）表示这四个数。使用quaternions还可以避免Euler angles导致的 gimbal lock（万向节死锁）问题，gimbal lock是指当Euler角度中的某两个轴变得平行时，就会失去其中一个的自由度。

Keyframe类的实现代码非常简单：仅仅是使用成员变量保存对应的数据，并对外提供访问这些数量的函数接口。但是，Keyframe::Transform()函数值得特别说明一下，在该函数中把translation，rotation以及scale组合到一个transformation（变换）矩阵中。

XMMATRIX Keyframe::Transform() const
{
	static XMVECTOR rotationOrigin = XMLoadFloat4(&Vector4Helper::Zero);

	return XMMatrixAffineTransformation(ScaleVector(), rotationOrigin, RotationQuaternionVector(), TranslationVector());
}

Keyframe::Transform()函数主要用于BoneAnimation类以及该类中的GetTransform*()相关函数。通过调用BoneAnimation::GetTransform()函数可以获取一个指定时间点的未经过插值的bone transformations。在该函数中通过调用BoneAnimation::FindKeyframeIndex()函数查找最后一个时间点小于指定时间点的keyframe。BoneAnimation::GetInterpolatedTransform()函数则是用于获取在给定时间点一前一后的两个keyframes，并对这两个frames的translation，rotation以及scale变量进行插值计算得到当前时间点的keyframe值。BoneAnimation::GetTransformAtKeyframe()函数返回指定keyframe的transformation，如果指定的索引值大于bone的keyframe数组大小，需要把索引值clamp为最后一个keyframe的索引值（之前已经讨论过，在一个animation中并不需要所有bones具有相同数量的keyframes）。列表20.12中这几函数中实现代码。

列表20.12 Bone Transformation Retrieval

UINT BoneAnimation::GetTransform(float time, XMFLOAT4X4& transform) const
{
	UINT keyframeIndex = FindKeyframeIndex(time);
	Keyframe* keyframe = mKeyframes[keyframeIndex];

	XMStoreFloat4x4(&transform, keyframe->Transform());

	return keyframeIndex;
}

void BoneAnimation::GetTransformAtKeyframe(UINT keyframeIndex, XMFLOAT4X4& transform) const
{
	// Clamp the keyframe
	if (keyframeIndex >= mKeyframes.size())
	{
		keyframeIndex = mKeyframes.size() - 1;
	}

	Keyframe* keyframe = mKeyframes[keyframeIndex];

	XMStoreFloat4x4(&transform, keyframe->Transform());
}

void BoneAnimation::GetInteropolatedTransform(float time, XMFLOAT4X4& transform) const
{
	Keyframe* firstKeyframe = mKeyframes.front();
	Keyframe* lastKeyframe = mKeyframes.back();

	if (time <= firstKeyframe->Time())
	{
		// Specified time is before the start time of the animation, so return the first keyframe
		XMStoreFloat4x4(&transform, firstKeyframe->Transform());
	}
	else if (time >= lastKeyframe->Time())
	{
		// Specified time is after the end time of the animation, so return the last keyframe
		XMStoreFloat4x4(&transform, lastKeyframe->Transform());
	}
	else
	{
		// Interpolate the transform between keyframes
		UINT keyframeIndex = FindKeyframeIndex(time);
		Keyframe* keyframeOne = mKeyframes[keyframeIndex];
		Keyframe* keyframeTwo = mKeyframes[keyframeIndex + 1];

		XMVECTOR translationOne = keyframeOne->TranslationVector();
		XMVECTOR rotationQuaternionOne = keyframeOne->RotationQuaternionVector();
		XMVECTOR scaleOne = keyframeOne->ScaleVector();

		XMVECTOR translationTwo = keyframeTwo->TranslationVector();
		XMVECTOR rotationQuaternionTwo = keyframeTwo->RotationQuaternionVector();
		XMVECTOR scaleTwo = keyframeTwo->ScaleVector();

		float lerpValue = ((time - keyframeOne->Time()) / (keyframeTwo->Time() - keyframeOne->Time()));
		XMVECTOR translation = XMVectorLerp(translationOne, translationTwo, lerpValue);
		XMVECTOR rotationQuaternion = XMQuaternionSlerp(rotationQuaternionOne, rotationQuaternionTwo, lerpValue);
		XMVECTOR scale = XMVectorLerp(scaleOne, scaleTwo, lerpValue);

		static XMVECTOR rotationOrigin = XMLoadFloat4(&Vector4Helper::Zero);
		XMStoreFloat4x4(&transform, XMMatrixAffineTransformation(scale, rotationOrigin, rotationQuaternion, translation));
	}
}

UINT BoneAnimation::FindKeyframeIndex(float time) const
{
	Keyframe* firstKeyframe = mKeyframes.front();
	if (time <= firstKeyframe->Time())
	{
		return 0;
	}

	Keyframe* lastKeyframe = mKeyframes.back();
	if (time >= lastKeyframe->Time())
	{
		return mKeyframes.size() - 1;
	}

	UINT keyframeIndex = 1;

	for (; keyframeIndex < mKeyframes.size() - 1 && time >= mKeyframes[keyframeIndex]->Time(); keyframeIndex++);

	return keyframeIndex - 1;
}

接下来，我们仔细分析一下BoneAnimation::GetInterpolatedTransform()函数的实现原理。首先，查找指定时间点的前后两个keyframes并获取对应的数据。然后使用如下的公式进行插值计算：


以下方法演示了该公式的计算过程：


在前面几章中我们已经讨论了线程插值的计算公式为：
lerp (x,y,s) = x * (1 - s) + (y * s)
因此，在上面的示例中，lerp value（插值因子）为0.2表示在最终的计算结果中keyframe1所占的比例为80%，而keyframe2所占的比例为20%。
在BoneAnimation::GetInterpolatedTransform()函数中使用这种方法插值计算translation，rotation以及scale值，并使用这些值计算指定时间点的bone transformation。
chenjinxian_3D
关注
专栏目录
ImportError: DLL load failed while importing _rust: 找不到指定的程序的解决方案
weixin_43178406的博客
08-09 6万+
 本文主要介绍了ImportError: DLL load failed while importing _rust: 找不到指定的程序的解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
ImportError: DLL load failed while importing _pydantic_core: 找不到指定的程序对应解决方案
热门推荐
weixin_43178406的博客
07-22 7万+
本文主要介绍了ImportError: DLL load failed while importing _pydantic_core: 找不到指定的程序对应解决方案，希望能对使用Python的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
Open Asset Import Library
weixin_33971205的博客
07-07 235
2019独角兽企业重金招聘Python工程师标准>>> ...
动画类型
熊小屁的专栏
04-09 838
载入动画模型本节你将创建一个叫做AnimatedModel的用于实时处理骨骼动画模型的类，这个类包含载入模型，播放和更新动画，绘制模型的方法，AnimatedModel类中开始时先声明变量。动画模型以XNA Model的形式被载入，它有一个dictionary，此dictionary包含一个可以通过Tag属性访问的AnimatedModelData对象。通过这种方式，Model类包含了
ASSIMP的数据结构
翻肚鱼儿的博客
07-20 905
ASSIMP的数据结构 博客分类： Assimp 数据结构是对文件的描述，也是我们想要获取的最终产物，一般来说我们会用这个结果映射到我们自己的模型里面去（这样做是为了降低对这个项目的依赖，如果你的模型都用别人的，还搞毛啊） 1.aiScene ：根节点 Java代码 structaiScene { unsignedintmFlags;//一个状态段 C_STRUCTaiNode*mRootNode;//根节点 ...
国外60个专业3D模型网站
wishchinYang的专栏
11-20 2万+
原始链接：http://blog.sina.com.cn/s/blog_4ba3c7950100jxkh.html   Today, 3D models are used in a wide variety of industries. The movie industry uses them as characters and objects for animated and real-
CMake Importing and Exporting Guide source
10-15
"CMake Importing and Exporting Guide source" 提供了关于如何在CMake项目之间共享依赖、库和构建配置的详细指导。下面我们将深入探讨这些知识点。 **1. CMake的导入（Importing）** 在CMake中，导入通常涉及到...
ImportError: DLL load failed while importing _iterative: 找不到指定的模块
最新发布
**My Coding Family**
08-18 1205
🏆本文收录于《CSDN问答解惑-专业版》专栏，主要记录项目实战过程中的Bug之前因后果及提供真实有效的解决方案，希望能够助你一臂之力，帮你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
Introduction to 3D Game Programming with DirectX 12 中文版 第四章至第十章
12-24
DirectX 12 3D 游戏开发实战 中文版 第四章至第十章 This book presents an introduction to programming interactive computer graphics, with an emphasis on game development, using Direct3D 12. It teaches the fundamentals of Direct3D and shader programming, after which the reader will be prepared to go on and learn more advanced techniques. The book is divided into three main parts. Part I explains the mathematical tools that will be used throughout this book. Part II shows how to implement fundamental tasks in Direct3D, such as initialization; defining 3D geometry; setting up cameras; creating vertex, pixel, geometry, and compute shaders; lighting; texturing; blending; stenciling; and tessellation. Part III is largely about applying Direct3D to implement a variety of interesting techniques and special effects, such as working with animated character meshes, picking, environment mapping, normal mapping, real-time shadows, and ambient occlusion.
OpenGL ES 学习教程(十一) Skin Mesh (骨骼动画)
Hello Captain
02-24 1万+
Skin Mesh (骨骼动画) 这个名字，多多少少让人产生误解。一开始我总以为要画出来几根骨头，然后再到骨头上去把顶点粘上去。 其实不是这样。事实上 是没有 骨骼 这个实体的，骨骼只是大家为了 形象的拟人表示 。
GLTF数据格式解析，自制模型转换工具
dukai392的博客
02-23 8554
GLTF是新的一种高效传输和加载3D场景和模型的格式。可以支持很多实现三维的引擎。GLTF是由Khronos Group设计和规定的。GLTF其实就是一个json文件，描述的就是3D场景数据的组成和构造。GLTF最外层的属性有：1.scenes,nodes,cameras,animations(这些属性描述的就是模型的基本结构）2.mesh,textures,images,samplers(这些属...
Models Genesis: Generic Autodidactic Models for 3D Medical Image Analysis精读
haribo的博客
03-25 2928
数据集 肺结节，PE肺栓塞，肝脏，PD肺部疾病 CIMT RoI: 脑肿瘤 LUNA16数据集是最大公用肺结节数据集LIDC-IDRI的子集，LIDC-IDRI它包括1018个低剂量的肺部CT影像。LIDC-IDRI删除了切片厚度大于3mm和肺结节小于3mm的CT影像，剩下的就是LUNA16数据集了。 奇怪数据集：来自“亚临床动脉粥样硬化发病率作为退役职业足球运动员心血管风险的指标”论文 ...
模型的骨骼动画技术讲解
海洋个人博客
03-23 9078
笔者介绍：姜雪伟，IT公司技术合伙人，IT高级讲师，CSDN社区专家，特邀编辑，畅销书作者，国家专利发明人;已出版书籍：《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。CSDN视频网址：http://edu.csdn.net/lecturer/144 骨骼动画实际上是两部分的过程。第一个由美术执行，第二个由程序员（或者你写的引擎）执行。第一部分发生
[OpenGL] 使用Assimp库的骨骼动画
(ง •̀_•́)ง
09-06 1万+
reference：http://ogldev.atspace.co.uk/www/tutorial38/tutorial38.html 你可以在主页找到教程全套的代码下载 Tutorial 38: Skeletal Animation With Assimp         最终，我们来到了这里。有数百万的读者都要求这一教程（我可能夸大了一些，但确实有不少）。
Cesium添加模型并设置各种属性
玖玖年的程序猿
12-21 3818
一、所需文件 css样式文件： Cesium-1.88\Apps\Sandcastle\templates\bucket.css js文件： Cesium-1.88\Build\Cesium\Cesium.js Cesium-1.88\Apps\Sandcastle\Sandcastle-header.js 二、HTML body <div id="cesiumContainer" class="fullSize"></div> 三、JavaScrip..
野猪写的《游戏程序中的骨骼插件》
lzpfmh的专栏
07-23 1103
我在《程序员》2008年2月刊上看到的（上），一搜果然搜到了。好文共分享！游戏程序中的骨骼插件（上）文/潘李亮引言　　在3D引擎中，骨骼动画系统是非常重要的一个组成部分，虽然在一个游戏的真正开发过程中，一个优秀的游戏引擎也许不需要用户去关心它的骨骼动画系统是如何实现的，但是还是有很多人希望了解这样的一个技术。本文将会介绍骨骼动画系统里的一个基础部件：3Ds MAX 的骨骼动画导出插件。3Ds
DLL load failed while importing
11-22
根据提供的引用内容，DLL load failed while importing 错误通常是由于缺少依赖库或依赖库版本不兼容导致的。解决此问题的方法如下： 1. 确保所有依赖库都已正确安装，并且版本兼容。可以使用pip list命令检查已...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值