private void ExportBoneAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonBone babylonBone, GLTFNode gltfNode)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
if (babylonBone.animation != null && babylonBone.animation.property == "_matrix")
{
logger.RaiseMessage("GLTFExporter.Animation | Export animation of bone named: " + babylonBone.name, 2);
var babylonAnimation = babylonBone.animation;
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
return;
}
// --- Output ---
var paths = new string[] { "translation", "rotation", "scale" };
var accessorOutputByPath = new Dictionary <string, GLTFAccessor>();
foreach (string path in paths)
{
GLTFAccessor accessorOutput = _createAccessorOfPath(path, gltf);
accessorOutputByPath.Add(path, accessorOutput);
}
// Populate accessors
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
if (babylonAnimationKey.frame < startFrame)
{
continue;
}
if (babylonAnimationKey.frame > endFrame)
{
continue;
}
var matrix = new BabylonMatrix();
matrix.m = babylonAnimationKey.values;
var translationBabylon = new BabylonVector3();
var rotationQuatBabylon = new BabylonQuaternion();
var scaleBabylon = new BabylonVector3();
matrix.decompose(scaleBabylon, rotationQuatBabylon, translationBabylon);
// Switch coordinate system at object level
translationBabylon.Z *= -1;
translationBabylon *= exportParameters.scaleFactor;
rotationQuatBabylon.X *= -1;
rotationQuatBabylon.Y *= -1;
var outputValuesByPath = new Dictionary <string, float[]>();
outputValuesByPath.Add("translation", translationBabylon.ToArray());
outputValuesByPath.Add("rotation", rotationQuatBabylon.ToArray());
outputValuesByPath.Add("scale", scaleBabylon.ToArray());
// Store values as bytes
foreach (string path in paths)
{
var accessorOutput = accessorOutputByPath[path];
var outputValues = outputValuesByPath[path];
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
accessorOutput.count++;
}
}
;
foreach (string path in paths)
{
var accessorOutput = accessorOutputByPath[path];
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = path;
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
}
private GLTFSkin ExportSkin(BabylonSkeleton babylonSkeleton, GLTF gltf, GLTFNode gltfNode)
{
// Skin
GLTFSkin gltfSkin = new GLTFSkin
{
name = babylonSkeleton.name
};
gltfSkin.index = gltf.SkinsList.Count;
gltf.SkinsList.Add(gltfSkin);
var bones = new List <BabylonBone>(babylonSkeleton.bones);
// Compute and store world matrix of each bone
var bonesWorldMatrices = new Dictionary <int, BabylonMatrix>();
foreach (var babylonBone in babylonSkeleton.bones)
{
if (!bonesWorldMatrices.ContainsKey(babylonBone.index))
{
BabylonMatrix boneWorldMatrix = _getBoneWorldMatrix(babylonBone, bones);
bonesWorldMatrices.Add(babylonBone.index, boneWorldMatrix);
}
}
// Buffer
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
// Accessor - InverseBindMatrices
var accessorInverseBindMatrices = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewFloatMat4(gltf, buffer),
"accessorInverseBindMatrices",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.MAT4
);
gltfSkin.inverseBindMatrices = accessorInverseBindMatrices.index;
// World matrix of the node
var invNodeWorldMatrix = BabylonMatrix.Invert(_getNodeWorldMatrix(gltfNode)); // inverted
var gltfJoints = new List <int>();
alreadyExportedBones = new Dictionary <BabylonBone, GLTFNode>();
foreach (var babylonBone in babylonSkeleton.bones)
{
// Export bone as a new node
var gltfBoneNode = _exportBone(babylonBone, gltf, babylonSkeleton, bones);
gltfJoints.Add(gltfBoneNode.index);
// Set this bone as skeleton if it is a root
if (babylonBone.parentBoneIndex == -1)
{
gltfSkin.skeleton = gltfBoneNode.index;
}
// Compute inverseBindMatrice for this bone when attached to this node
var boneLocalMatrix = new BabylonMatrix();
boneLocalMatrix.m = babylonBone.matrix;
BabylonMatrix boneWorldMatrix = null;
if (babylonBone.parentBoneIndex == -1)
{
boneWorldMatrix = boneLocalMatrix;
}
else
{
var parentWorldMatrix = bonesWorldMatrices[babylonBone.parentBoneIndex];
// Remove scale of parent
// This actually enable to take into account the scale of the bones, except for the root one
parentWorldMatrix = _removeScale(parentWorldMatrix);
boneWorldMatrix = boneLocalMatrix * parentWorldMatrix;
}
var inverseBindMatrices = BabylonMatrix.Invert(boneWorldMatrix * invNodeWorldMatrix);
// Populate accessor
List <float> matrix = new List <float>(inverseBindMatrices.m);
matrix.ForEach(n => accessorInverseBindMatrices.bytesList.AddRange(BitConverter.GetBytes(n)));
accessorInverseBindMatrices.count++;
}
gltfSkin.joints = gltfJoints.ToArray();
return(gltfSkin);
}
