Unigine.ObjectMeshSkinned Class

To add the animation to the ObjectMeshSkinned and play it, do the following:

1. Set the number of animation layers with NumLayers. There is only one layer by default.
2. Enable the layer and set the animation weight for blending by calling the SetLayer() function.

3. Add the animation *.anim file by using the SetLayerAnimationFilePath() function.

4. Play the added animation by calling the SetLayerFrame() function for each animation layer.

Blending is performed between all layers. The contribution of each layer depends on its weight. Also, you can optionally define single bone transformations by hand, if needed, using either SetBoneTransform() or SetBoneTransformWithChildren().

Usage Example

using Unigine;

[Component(PropertyGuid = "_______________(generated automatically)__________________")]
public class SkinnedMeshController : Component
{
	public AssetLink meshAsset;
	public AssetLink animAsset1;
	public AssetLink animAsset2;

	private ObjectMeshSkinned skinnedMesh;

	void Init()
	{
		// create the new ObjectMeshSkinned mesh based on an existing mesh
		skinnedMesh = new ObjectMeshSkinned(meshAsset.Path);

		// set the number of animation layers
		skinnedMesh.NumLayers = 2;

		// load animations from the files
		skinnedMesh.SetLayerAnimationFilePath(0, animAsset1.Path);
		skinnedMesh.SetLayerAnimationFilePath(1, animAsset2.Path);

		// enable each layer and set an animation weight
		skinnedMesh.SetLayer(0, true, 0.7f);
		skinnedMesh.SetLayer(1, true, 0.3f);
	}
	
	void Update()
	{
		// play each animation
		skinnedMesh.SetLayerFrame(0, Game.Time * 25.0f);
		skinnedMesh.SetLayerFrame(1, Game.Time * 25.0f);
	}
}

Usage Example

using System;
using System.Collections;
using System.Collections.Generic;
using Unigine;

[Component(PropertyGuid = "_______________(generated automatically)__________________")]
public class Blend2D : Component
{
	private ObjectMeshSkinned meshSkinned = null;

	public struct Animation
	{
		public string name;

		[ParameterAsset(Filter = "anim")]
		public AssetLink asset;

		public vec2 point;
	}

	[ShowInEditor]
	[ParameterSlider(Min = MathLib.EPSILON)]
	private float targetDuration = 2.0f;

	[ShowInEditor]
	private List<Animation> animations = new List<Animation>()
	{
		new Animation() { name = "Idle", point = new vec2(0, 0) },
		new Animation() { name = "Forward", point = new vec2(0, 1) },
		new Animation() { name = "Backward", point = new vec2(0, -1) },
		new Animation() { name = "Right", point = new vec2(1, 0) },
		new Animation() { name = "Left", point = new vec2(-1, 0) },
	};

	// for playback
	private float time = 0.0f;
	private List<float> speeds = new List<float>();

	// for blending
	private List<vec2> points = new List<vec2>();
	private List<float> weights = new List<float>();
	private vec2 targetPoint = new vec2(0, 0);

	private void Init()
	{
		meshSkinned = node as ObjectMeshSkinned;
		if (!meshSkinned)
			return;

		// remove default layer
		meshSkinned.RemoveLayer(0);

		for (int i = 0; i < animations.Count; i++)
		{
			if (animations[i].asset.IsNull || !animations[i].asset.IsFileExist)
				continue;

			// create layer for each animation
			int id = meshSkinned.AddAnimation(animations[i].asset.Path);
			meshSkinned.AddLayer();
			meshSkinned.SetAnimation(meshSkinned.NumLayers - 1, id);

			// enable new layer and set default weight to 1.0
			meshSkinned.SetLayer(meshSkinned.NumLayers - 1, true, 1.0f);

			// calculate animation speed to play with fixed duration
			int numFrames = meshSkinned.GetNumAnimationFrames(id);
			float speed = numFrames / targetDuration;
			speeds.Add(speed);

			// add point and weight for blending
			points.Add(animations[i].point);
			weights.Add(1.0f);
		}
	}
	
	private void Update()
	{
		if (!meshSkinned)
			return;

		// update weight for each layer
		UpdateWeights();

		// update layer frames and layer weights
		for (int i = 0; i < meshSkinned.NumLayers; i++)
		{
			float frame = time * speeds[i];
			meshSkinned.setLayerFrame(i, frame);
			meshSkinned.SetLayerWeight(i, weights[i]);
		}

		time += Game.IFps;
		if (time > targetDuration)
			time -= targetDuration;

		// update target point for blending
		ivec2 movement = new ivec2();
		if (Input.IsKeyPressed(Input.KEY.T))
			movement += new ivec2(0, 1);

		if (Input.IsKeyPressed(Input.KEY.G))
			movement -= new ivec2(0, 1);

		if (Input.IsKeyPressed(Input.KEY.H))
			movement += new ivec2(1, 0);

		if (Input.IsKeyPressed(Input.KEY.F))
			movement -= new ivec2(1, 0);

		if (movement.x != 0)
			targetPoint.x += movement.x * Game.IFps * 2.0f;
		else
			targetPoint.x *= MathLib.Exp(-Game.IFps * 3.0f);

		if (movement.y != 0)
			targetPoint.y += movement.y * Game.IFps * 2.0f;
		else
			targetPoint.y *= MathLib.Exp(-Game.IFps * 3.0f);

		targetPoint = MathLib.Clamp(targetPoint, new vec2(-1, -1), new vec2(1, 1));
	}

	private void UpdateWeights()
	{
		// gradient band interpolation

		float totalWeight = 0.0f;
		for (int i = 0; i < points.Count; i++)
		{
			vec2 pi = points[i];
			vec2 targetVector = targetPoint - pi;

			float weight = 1.0f;
			for (int j = 0; j < points.Count; j++)
			{
				if (j == i)
					continue;

				vec2 jVector = points[j] - pi;

				float newWeight = 1.0f - MathLib.Dot(targetVector, jVector) / jVector.Length2;
				newWeight = MathLib.Clamp(newWeight, 0.0f, 1.0f);

				weight = MathLib.Min(weight, newWeight);
			}

			weights[i] = weight;
			totalWeight += weight;
		}

		for (int i = 0; i < weights.Count; i++)
			weights[i] = weights[i] / totalWeight;
	}
}

Some of the methods require to update the animation data before the renderer makes its update and actually draws the skinned mesh. Such update allows to get the correct result of blending between the frames and layers.

The execution sequence of updating bone transformations is the following:

1. Call the method, which sets the update flag. This flag shows that the instance should be updated.
2. Update the bone transformations by calling proper functions. These functions check the flag and if the flag is set, they calculate the transformations and set the flag to the default value.
3. During the rendering, the engine performs animations and transformations which were calculated on the previous step or recalculates them, if the update flag has been set. If calculations have been performed, the flag is set to the default value.

If you try to update bone transformations before you set the flag to update, functions will not calculate new transformations and the engine doesn't perform them.

When you change the transformation of the bone, you should notify all skinned meshes which use these bone about these transformations to update the mesh. When you change transformations of a bone, skinned mesh instances get the flag to update. When you use the setLayerFrame() function, you set necessary transformations for the specified skinned mesh.

Surfaces of identical skinned meshes which have the same materials assigned to them and the same number of bones attached to their vertices are automatically instanced and drawn in one draw call.

The data buffers for instanced objects that store bones transformations are limited in size; therefore, if skinned meshes have many bones, only a few meshes can populate the instance data buffer to be drawn in one draw call.

Animations from one character can be used for another.

Animation Frame Masks#

Retargeting#

ObjectMeshSkinned supports inverse kinematics (IK) for bone chains (IK chains). Inverse kinematics provide a way to handle joint rotation from the location of an end-effector rather than via direct joint rotation. You provide a location of the effector and the IK Solver attempts to find a rotation so that the final joint coincides with that location as best it can. This can be used to position a character's feet properly on uneven ground, and ensure believable interactions with the world. The tolerance value sets a threshold where the target is considered to have reached its destination position, and when the IK Solver stops iterating.

An IK chain can have an arbitrary length (contain an arbitrary number of bones), it has an auxiliary vector enabling you to control bending direction. You can also set rotation for the last joint of the chain.

Each IK chain has a weight value that can be used to control the impact of the target on the last joint of the chain. This enables you to make smooth transitions from the source animation to required target position of the limb.

To visualize IK chains you can use the following methods: AddVisualizeIKChain(), RemoveVisualizeIKChain(), and ClearVisualizeIKChain().

• Mesh class
• Article on Mesh File Formats
• Animation sample in C# Component Samples suite
• Samples located in the <UnigineSDK>/data/samples/animation folder