public static void UpdateMinMaxAccessor(GLTFAccessor accessor, float[] values)
{
for (int indexComponent = 0; indexComponent < values.Length; indexComponent++)
{
UpdateMinMaxAccessor(accessor, values[indexComponent], indexComponent);
}
}
private void AddElementsToAccessor(GLTFAccessor accessor, int count)
{
GLTFBufferView bufferView = accessor.BufferView;
GLTFBuffer buffer = bufferView.Buffer;
accessor.byteOffset = bufferView.byteLength;
accessor.count += count;
bufferView.byteLength += accessor.getByteLength();
buffer.byteLength += accessor.getByteLength();
}
public static void UpdateMinMaxAccessor(GLTFAccessor accessor, float value, int indexComponent = 0)
{
if (value < accessor.min[indexComponent])
{
accessor.min[indexComponent] = value;
}
if (value > accessor.max[indexComponent])
{
accessor.max[indexComponent] = value;
}
}
public GLTFAccessor _createAccessorOfPath(string path, GLTF gltf)
{
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
GLTFAccessor accessorOutput = null;
switch (path)
{
case "translation":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec3(gltf, buffer),
"accessorAnimationPositions",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC3
);
break;
case "rotation":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec4(gltf, buffer),
"accessorAnimationRotations",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC4
);
break;
case "scale":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec3(gltf, buffer),
"accessorAnimationScales",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC3
);
break;
case "fov":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationFovs",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
}
return(accessorOutput);
}
public GLTFAccessor CreateAccessor(GLTF gltf, GLTFBufferView bufferView, string name, GLTFAccessor.ComponentType componentType, GLTFAccessor.TypeEnum type)
{
var accessor = new GLTFAccessor
{
name = name,
bufferView = bufferView.index,
BufferView = bufferView,
componentType = componentType,
type = type.ToString()
};
accessor.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessor);
bufferView.Accessors.Add(accessor);
return(accessor);
}
private GLTFNode ExportMesh(BabylonMesh babylonMesh, GLTF gltf, GLTFNode gltfParentNode, BabylonScene babylonScene)
{
RaiseMessage("GLTFExporter.Mesh | Export mesh named: " + babylonMesh.name, 1);
// --------------------------
// ---------- Node ----------
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Node", 2);
// Node
var gltfNode = new GLTFNode();
gltfNode.name = babylonMesh.name;
gltfNode.index = gltf.NodesList.Count;
gltf.NodesList.Add(gltfNode);
// Hierarchy
if (gltfParentNode != null)
{
RaiseMessage("GLTFExporter.Mesh | Add " + babylonMesh.name + " as child to " + gltfParentNode.name, 3);
gltfParentNode.ChildrenList.Add(gltfNode.index);
}
else
{
// It's a root node
// Only root nodes are listed in a gltf scene
RaiseMessage("GLTFExporter.Mesh | Add " + babylonMesh.name + " as root node to scene", 3);
gltf.scenes[0].NodesList.Add(gltfNode.index);
}
// Transform
gltfNode.translation = babylonMesh.position;
// TODO - Choose between this method and the extra root node
// Switch from left to right handed coordinate system
//gltfNode.translation[0] *= -1;
if (babylonMesh.rotationQuaternion != null)
{
gltfNode.rotation = babylonMesh.rotationQuaternion;
}
else
{
// Convert rotation vector to quaternion
BabylonVector3 rotationVector3 = new BabylonVector3
{
X = babylonMesh.rotation[0],
Y = babylonMesh.rotation[1],
Z = babylonMesh.rotation[2]
};
gltfNode.rotation = rotationVector3.toQuaternionGltf().ToArray();
}
gltfNode.scale = babylonMesh.scaling;
// --------------------------
// --- Mesh from babylon ----
// --------------------------
if (babylonMesh.positions == null)
{
RaiseMessage("GLTFExporter.Mesh | Mesh is a dummy", 2);
return(gltfNode);
}
RaiseMessage("GLTFExporter.Mesh | Mesh from babylon", 2);
// Retreive general data from babylon mesh
int nbVertices = babylonMesh.positions.Length / 3;
bool hasUV = babylonMesh.uvs != null && babylonMesh.uvs.Length > 0;
bool hasUV2 = babylonMesh.uvs2 != null && babylonMesh.uvs2.Length > 0;
bool hasColor = babylonMesh.colors != null && babylonMesh.colors.Length > 0;
RaiseMessage("GLTFExporter.Mesh | nbVertices=" + nbVertices, 3);
RaiseMessage("GLTFExporter.Mesh | hasUV=" + hasUV, 3);
RaiseMessage("GLTFExporter.Mesh | hasUV2=" + hasUV2, 3);
RaiseMessage("GLTFExporter.Mesh | hasColor=" + hasColor, 3);
// Retreive vertices data from babylon mesh
List <GLTFGlobalVertex> globalVertices = new List <GLTFGlobalVertex>();
for (int indexVertex = 0; indexVertex < nbVertices; indexVertex++)
{
GLTFGlobalVertex globalVertex = new GLTFGlobalVertex();
globalVertex.Position = createIPoint3(babylonMesh.positions, indexVertex);
// Switch from left to right handed coordinate system
//globalVertex.Position.X *= -1;
globalVertex.Normal = createIPoint3(babylonMesh.normals, indexVertex);
if (hasUV)
{
globalVertex.UV = createIPoint2(babylonMesh.uvs, indexVertex);
// For glTF, the origin of the UV coordinates (0, 0) corresponds to the upper left corner of a texture image
// While for Babylon, it corresponds to the lower left corner of a texture image
globalVertex.UV.Y = 1 - globalVertex.UV.Y;
}
if (hasUV2)
{
globalVertex.UV2 = createIPoint2(babylonMesh.uvs2, indexVertex);
// For glTF, the origin of the UV coordinates (0, 0) corresponds to the upper left corner of a texture image
// While for Babylon, it corresponds to the lower left corner of a texture image
globalVertex.UV2.Y = 1 - globalVertex.UV2.Y;
}
if (hasColor)
{
globalVertex.Color = createIPoint4(babylonMesh.colors, indexVertex).ToArray();
}
globalVertices.Add(globalVertex);
}
// Retreive indices from babylon mesh
List <ushort> babylonIndices = new List <ushort>();
babylonIndices = babylonMesh.indices.ToList().ConvertAll(new Converter <int, ushort>(n => (ushort)n));
// For triangle primitives in gltf, the front face has a counter-clockwise (CCW) winding order
// Swap face side
//for (int i = 0; i < babylonIndices.Count; i += 3)
//{
// var tmp = babylonIndices[i];
// babylonIndices[i] = babylonIndices[i + 2];
// babylonIndices[i + 2] = tmp;
//}
// --------------------------
// ------- Init glTF --------
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Init glTF", 2);
// Mesh
var gltfMesh = new GLTFMesh {
name = babylonMesh.name
};
gltfMesh.index = gltf.MeshesList.Count;
gltf.MeshesList.Add(gltfMesh);
gltfNode.mesh = gltfMesh.index;
gltfMesh.gltfNode = gltfNode;
// Buffer
var buffer = new GLTFBuffer
{
uri = gltfMesh.name + ".bin"
};
buffer.index = gltf.BuffersList.Count;
gltf.BuffersList.Add(buffer);
// BufferView - Scalar
var bufferViewScalar = new GLTFBufferView
{
name = "bufferViewScalar",
buffer = buffer.index,
Buffer = buffer
};
bufferViewScalar.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewScalar);
// BufferView - Vector3
var bufferViewFloatVec3 = new GLTFBufferView
{
name = "bufferViewFloatVec3",
buffer = buffer.index,
Buffer = buffer,
byteOffset = 0,
byteStride = 12 // Field only defined for buffer views that contain vertex attributes. A vertex needs 3 * 4 bytes
};
bufferViewFloatVec3.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec3);
// BufferView - Vector4
GLTFBufferView bufferViewFloatVec4 = null;
if (hasColor)
{
bufferViewFloatVec4 = new GLTFBufferView
{
name = "bufferViewFloatVec4",
buffer = buffer.index,
Buffer = buffer,
byteOffset = 0,
byteStride = 16 // Field only defined for buffer views that contain vertex attributes. A vertex needs 4 * 4 bytes
};
bufferViewFloatVec4.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec4);
}
// BufferView - Vector2
GLTFBufferView bufferViewFloatVec2 = null;
if (hasUV || hasUV2)
{
bufferViewFloatVec2 = new GLTFBufferView
{
name = "bufferViewFloatVec2",
buffer = buffer.index,
Buffer = buffer,
byteStride = 8 // Field only defined for buffer views that contain vertex attributes. A vertex needs 2 * 4 bytes
};
bufferViewFloatVec2.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec2);
}
// --------------------------
// ---- glTF primitives -----
// --------------------------
RaiseMessage("GLTFExporter.Mesh | glTF primitives", 2);
var meshPrimitives = new List <GLTFMeshPrimitive>();
// Global vertices are sorted per submesh
var globalVerticesSubMeshes = new List <List <GLTFGlobalVertex> >();
// In gltf, indices of each mesh primitive are 0-based (ie: min value is 0)
// Thus, the gltf indices list is a concatenation of sub lists all 0-based
// Example for 2 triangles, each being a submesh:
// babylonIndices = {0,1,2, 3,4,5} gives as result gltfIndicies = {0,1,2, 0,1,2}
var gltfIndices = new List <ushort>();
foreach (BabylonSubMesh babylonSubMesh in babylonMesh.subMeshes)
{
// --------------------------
// ------ SubMesh data ------
// --------------------------
List <GLTFGlobalVertex> globalVerticesSubMesh = globalVertices.GetRange(babylonSubMesh.verticesStart, babylonSubMesh.verticesCount);
globalVerticesSubMeshes.Add(globalVerticesSubMesh);
List <ushort> _indices = babylonIndices.GetRange(babylonSubMesh.indexStart, babylonSubMesh.indexCount);
// Indices of this submesh / primitive are updated to be 0-based
var minIndiceValue = _indices.Min(); // Should be equal to babylonSubMesh.indexStart
for (int indexIndice = 0; indexIndice < _indices.Count; indexIndice++)
{
_indices[indexIndice] -= minIndiceValue;
}
gltfIndices.AddRange(_indices);
// --------------------------
// -- Init glTF primitive ---
// --------------------------
// MeshPrimitive
var meshPrimitive = new GLTFMeshPrimitive
{
attributes = new Dictionary <string, int>()
};
meshPrimitives.Add(meshPrimitive);
// Accessor - Indices
var accessorIndices = new GLTFAccessor
{
name = "accessorIndices",
bufferView = bufferViewScalar.index,
BufferView = bufferViewScalar,
componentType = GLTFAccessor.ComponentType.UNSIGNED_SHORT,
type = GLTFAccessor.TypeEnum.SCALAR.ToString()
};
accessorIndices.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorIndices);
meshPrimitive.indices = accessorIndices.index;
// Accessor - Positions
var accessorPositions = new GLTFAccessor
{
name = "accessorPositions",
bufferView = bufferViewFloatVec3.index,
BufferView = bufferViewFloatVec3,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC3.ToString(),
min = new float[] { float.MaxValue, float.MaxValue, float.MaxValue },
max = new float[] { float.MinValue, float.MinValue, float.MinValue }
};
accessorPositions.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorPositions);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.POSITION.ToString(), accessorPositions.index);
// Accessor - Normals
var accessorNormals = new GLTFAccessor
{
name = "accessorNormals",
bufferView = bufferViewFloatVec3.index,
BufferView = bufferViewFloatVec3,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC3.ToString()
};
accessorNormals.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorNormals);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.NORMAL.ToString(), accessorNormals.index);
// Accessor - Colors
GLTFAccessor accessorColors = null;
if (hasColor)
{
accessorColors = new GLTFAccessor
{
name = "accessorColors",
bufferView = bufferViewFloatVec4.index,
BufferView = bufferViewFloatVec4,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC4.ToString()
};
accessorColors.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorColors);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.COLOR_0.ToString(), accessorColors.index);
}
// Accessor - UV
GLTFAccessor accessorUVs = null;
if (hasUV)
{
accessorUVs = new GLTFAccessor
{
name = "accessorUVs",
bufferView = bufferViewFloatVec2.index,
BufferView = bufferViewFloatVec2,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC2.ToString()
};
accessorUVs.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorUVs);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.TEXCOORD_0.ToString(), accessorUVs.index);
}
// Accessor - UV2
GLTFAccessor accessorUV2s = null;
if (hasUV2)
{
accessorUV2s = new GLTFAccessor
{
name = "accessorUV2s",
bufferView = bufferViewFloatVec2.index,
BufferView = bufferViewFloatVec2,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC2.ToString()
};
accessorUV2s.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorUV2s);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.TEXCOORD_1.ToString(), accessorUV2s.index);
}
// --------------------------
// - Update glTF primitive --
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Mesh as glTF", 3);
// Material
if (babylonMesh.materialId != null)
{
// Retreive the babylon material
var babylonMaterialId = babylonMesh.materialId;
var babylonMaterials = new List <BabylonMaterial>(babylonScene.materials);
var babylonMaterial = babylonMaterials.Find(_babylonMaterial => _babylonMaterial.id == babylonMaterialId);
if (babylonMaterial == null)
{
// It's a multi material
var babylonMultiMaterials = new List <BabylonMultiMaterial>(babylonScene.multiMaterials);
var babylonMultiMaterial = babylonMultiMaterials.Find(_babylonMultiMaterial => _babylonMultiMaterial.id == babylonMesh.materialId);
babylonMaterialId = babylonMultiMaterial.materials[babylonSubMesh.materialIndex];
babylonMaterial = babylonMaterials.Find(_babylonMaterial => _babylonMaterial.id == babylonMaterialId);
}
// Update primitive material index
var indexMaterial = babylonMaterialsToExport.FindIndex(_babylonMaterial => _babylonMaterial == babylonMaterial);
if (indexMaterial == -1)
{
// Store material for exportation
indexMaterial = babylonMaterialsToExport.Count;
babylonMaterialsToExport.Add(babylonMaterial);
}
meshPrimitive.material = indexMaterial;
// TODO - Add and retreive info from babylon material
meshPrimitive.mode = GLTFMeshPrimitive.FillMode.TRIANGLES;
}
// Update min and max vertex position for each component (X, Y, Z)
globalVerticesSubMesh.ForEach((globalVertex) =>
{
var positionArray = new float[] { globalVertex.Position.X, globalVertex.Position.Y, globalVertex.Position.Z };
for (int indexComponent = 0; indexComponent < positionArray.Length; indexComponent++)
{
if (positionArray[indexComponent] < accessorPositions.min[indexComponent])
{
accessorPositions.min[indexComponent] = positionArray[indexComponent];
}
if (positionArray[indexComponent] > accessorPositions.max[indexComponent])
{
accessorPositions.max[indexComponent] = positionArray[indexComponent];
}
}
});
// Update byte length and count of accessors, bufferViews and buffers
// Scalar
AddElementsToAccessor(accessorIndices, _indices.Count);
// Vector3
AddElementsToAccessor(accessorPositions, globalVerticesSubMesh.Count);
AddElementsToAccessor(accessorNormals, globalVerticesSubMesh.Count);
// Vector4
if (hasColor)
{
AddElementsToAccessor(accessorColors, globalVerticesSubMesh.Count);
}
// Vector2
if (hasUV)
{
AddElementsToAccessor(accessorUVs, globalVerticesSubMesh.Count);
}
if (hasUV2)
{
AddElementsToAccessor(accessorUV2s, globalVerticesSubMesh.Count);
}
}
gltfMesh.primitives = meshPrimitives.ToArray();
// Update byte offset of bufferViews
GLTFBufferView lastBufferView = null;
gltf.BufferViewsList.FindAll(bufferView => bufferView.buffer == buffer.index).ForEach(bufferView =>
{
if (lastBufferView != null)
{
bufferView.byteOffset = lastBufferView.byteOffset + lastBufferView.byteLength;
}
lastBufferView = bufferView;
});
// --------------------------
// --------- Saving ---------
// --------------------------
string outputBinaryFile = Path.Combine(gltf.OutputPath, gltfMesh.name + ".bin");
RaiseMessage("GLTFExporter.Mesh | Saving " + outputBinaryFile, 2);
// Write data to binary file
using (BinaryWriter writer = new BinaryWriter(File.Open(outputBinaryFile, FileMode.Create)))
{
// BufferView - Scalar
gltfIndices.ForEach(n => writer.Write(n));
// BufferView - Vector3
globalVerticesSubMeshes.ForEach(globalVerticesSubMesh =>
{
List <float> vertices = globalVerticesSubMesh.SelectMany(v => new[] { v.Position.X, v.Position.Y, v.Position.Z }).ToList();
vertices.ForEach(n => writer.Write(n));
List <float> normals = globalVerticesSubMesh.SelectMany(v => new[] { v.Normal.X, v.Normal.Y, v.Normal.Z }).ToList();
normals.ForEach(n => writer.Write(n));
});
// BufferView - Vector4
globalVerticesSubMeshes.ForEach(globalVerticesSubMesh =>
{
if (hasColor)
{
List <float> colors = globalVerticesSubMesh.SelectMany(v => new[] { v.Color[0], v.Color[1], v.Color[2], v.Color[3] }).ToList();
colors.ForEach(n => writer.Write(n));
}
});
// BufferView - Vector2
globalVerticesSubMeshes.ForEach(globalVerticesSubMesh =>
{
if (hasUV)
{
List <float> uvs = globalVerticesSubMesh.SelectMany(v => new[] { v.UV.X, v.UV.Y }).ToList();
uvs.ForEach(n => writer.Write(n));
}
if (hasUV2)
{
List <float> uvs2 = globalVerticesSubMesh.SelectMany(v => new[] { v.UV2.X, v.UV2.Y }).ToList();
uvs2.ForEach(n => writer.Write(n));
}
});
}
return(gltfNode);
}
private GLTFAnimation ExportBoneAnimation(BabylonBone babylonBone, GLTF gltf, GLTFNode gltfNode)
{
GLTFAnimation gltfAnimation = null;
if (gltf.AnimationsList.Count > 0)
{
gltfAnimation = gltf.AnimationsList[0];
}
else
{
gltfAnimation = new GLTFAnimation();
gltf.AnimationsList.Add(gltfAnimation);
}
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
if (babylonBone.animation != null && babylonBone.animation.property == "_matrix")
{
RaiseMessage("GLTFExporter.Animation | Export animation of bone named: " + babylonBone.name, 2);
var babylonAnimation = babylonBone.animation;
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation);
// --- 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)
{
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);
translationBabylon.Z *= -1;
BabylonVector3 rotationVector3 = rotationQuatBabylon.toEulerAngles();
rotationVector3.X *= -1;
rotationVector3.Y *= -1;
rotationQuatBabylon = rotationVector3.toQuaternion();
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);
}
}
return(gltfAnimation);
}
private GLTFMesh ExportMesh(BabylonMesh babylonMesh, GLTF gltf, GLTFNode gltfParentNode)
{
RaiseMessage("GLTFExporter.Mesh | ExportMesh babylonMesh.name=" + babylonMesh.name, 1);
// --------------------------
// ---------- Node ----------
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Node", 1);
// Node
var gltfNode = new GLTFNode();
gltfNode.name = babylonMesh.name;
gltfNode.index = gltf.NodesList.Count;
gltf.NodesList.Add(gltfNode);
// Hierarchy
if (gltfParentNode != null)
{
RaiseMessage("GLTFExporter.Mesh | Add " + babylonMesh.name + " as child to " + gltfParentNode.name, 2);
gltfParentNode.ChildrenList.Add(gltfNode.index);
}
else
{
// It's a root node
// Only root nodes are listed in a gltf scene
RaiseMessage("GLTFExporter.Mesh | Add " + babylonMesh.name + " as root node to scene", 2);
gltf.scenes[0].NodesList.Add(gltfNode.index);
}
// Transform
gltfNode.translation = babylonMesh.position;
if (babylonMesh.rotationQuaternion != null)
{
gltfNode.rotation = babylonMesh.rotationQuaternion;
}
else
{
// Convert rotation vector to quaternion
// TODO - Fix it
BabylonVector3 rotationVector3 = new BabylonVector3
{
X = babylonMesh.rotation[0],
Y = babylonMesh.rotation[1],
Z = babylonMesh.rotation[2]
};
gltfNode.rotation = rotationVector3.toQuaternion().ToArray();
RaiseMessage("GLTFExporter.Mesh | rotationVector3=[" + rotationVector3.X + "; " + rotationVector3.Y + "; " + rotationVector3.Z + "]", 2);
RaiseMessage("GLTFExporter.Mesh | gltfNode.rotation=[" + gltfNode.rotation[0] + "; " + gltfNode.rotation[1] + "; " + gltfNode.rotation[2] + "; " + gltfNode.rotation[3] + "]", 2);
}
gltfNode.scale = babylonMesh.scaling;
// --------------------------
// --- Mesh from babylon ----
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Mesh from babylon", 1);
// Retreive general data from babylon mesh
int nbVertices = babylonMesh.positions.Length / 3;
bool hasUV = babylonMesh.uvs != null && babylonMesh.uvs.Length > 0;
bool hasUV2 = babylonMesh.uvs2 != null && babylonMesh.uvs2.Length > 0;
bool hasColor = babylonMesh.colors != null && babylonMesh.colors.Length > 0;
RaiseMessage("GLTFExporter.Mesh | nbVertices=" + nbVertices, 2);
RaiseMessage("GLTFExporter.Mesh | hasUV=" + hasUV, 2);
RaiseMessage("GLTFExporter.Mesh | hasUV2=" + hasUV2, 2);
RaiseMessage("GLTFExporter.Mesh | hasColor=" + hasColor, 2);
// Retreive vertices data from babylon mesh
List <GLTFGlobalVertex> globalVertices = new List <GLTFGlobalVertex>();
for (int i = 0; i < nbVertices; i++)
{
GLTFGlobalVertex globalVertex = new GLTFGlobalVertex();
globalVertex.Position = createIPoint3(babylonMesh.positions, i);
globalVertex.Normal = createIPoint3(babylonMesh.normals, i);
if (hasUV)
{
globalVertex.UV = createIPoint2(babylonMesh.uvs, i);
// For glTF, the origin of the UV coordinates (0, 0) corresponds to the upper left corner of a texture image
// While for Babylon, it corresponds to the lower left corner of a texture image
globalVertex.UV.Y = 1 - globalVertex.UV.Y;
}
if (hasUV2)
{
globalVertex.UV2 = createIPoint2(babylonMesh.uvs2, i);
// For glTF, the origin of the UV coordinates (0, 0) corresponds to the upper left corner of a texture image
// While for Babylon, it corresponds to the lower left corner of a texture image
globalVertex.UV2.Y = 1 - globalVertex.UV2.Y;
}
if (hasColor)
{
globalVertex.Color = createIPoint4(babylonMesh.colors, i).ToArray();
}
globalVertices.Add(globalVertex);
}
// Retreive indices from babylon mesh
List <ushort> indices = new List <ushort>();
indices = babylonMesh.indices.ToList().ConvertAll(new Converter <int, ushort>(n => (ushort)n));
// Swap face side
for (int i = 0; i < indices.Count; i += 3)
{
var tmp = indices[i];
indices[i] = indices[i + 2];
indices[i + 2] = tmp;
}
// --------------------------
// ------- Init glTF --------
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Init glTF", 1);
// Mesh
var gltfMesh = new GLTFMesh {
name = babylonMesh.name
};
gltfMesh.index = gltf.MeshesList.Count;
gltf.MeshesList.Add(gltfMesh);
gltfNode.mesh = gltfMesh.index;
gltfMesh.gltfNode = gltfNode;
// MeshPrimitive
var meshPrimitives = new List <GLTFMeshPrimitive>();
var meshPrimitive = new GLTFMeshPrimitive
{
attributes = new Dictionary <string, int>(),
mode = GLTFMeshPrimitive.FillMode.TRIANGLES // TODO reteive info from babylon material
};
meshPrimitives.Add(meshPrimitive);
// Buffer
var buffer = new GLTFBuffer
{
uri = gltfMesh.name + ".bin"
};
buffer.index = gltf.BuffersList.Count;
gltf.BuffersList.Add(buffer);
// BufferView - Scalar
var bufferViewScalar = new GLTFBufferView
{
name = "bufferViewScalar",
buffer = buffer.index,
Buffer = buffer
};
bufferViewScalar.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewScalar);
// BufferView - Vector3
var bufferViewFloatVec3 = new GLTFBufferView
{
name = "bufferViewFloatVec3",
buffer = buffer.index,
Buffer = buffer,
byteOffset = 0,
byteStride = 12 // Field only defined for buffer views that contain vertex attributes. A vertex needs 3 * 4 bytes
};
bufferViewFloatVec3.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec3);
// Accessor - Indices
var accessorIndices = new GLTFAccessor
{
name = "accessorIndices",
bufferView = bufferViewScalar.index,
BufferView = bufferViewScalar,
componentType = GLTFAccessor.ComponentType.UNSIGNED_SHORT,
type = GLTFAccessor.TypeEnum.SCALAR.ToString()
};
accessorIndices.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorIndices);
meshPrimitive.indices = accessorIndices.index;
// Accessor - Positions
var accessorPositions = new GLTFAccessor
{
name = "accessorPositions",
bufferView = bufferViewFloatVec3.index,
BufferView = bufferViewFloatVec3,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC3.ToString(),
min = new float[] { float.MaxValue, float.MaxValue, float.MaxValue },
max = new float[] { float.MinValue, float.MinValue, float.MinValue }
};
accessorPositions.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorPositions);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.POSITION.ToString(), accessorPositions.index);
// Accessor - Normals
var accessorNormals = new GLTFAccessor
{
name = "accessorNormals",
bufferView = bufferViewFloatVec3.index,
BufferView = bufferViewFloatVec3,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC3.ToString()
};
accessorNormals.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorNormals);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.NORMAL.ToString(), accessorNormals.index);
// BufferView - Vector4
GLTFBufferView bufferViewFloatVec4 = null;
// Accessor - Colors
GLTFAccessor accessorColors = null;
if (hasColor)
{
bufferViewFloatVec4 = new GLTFBufferView
{
name = "bufferViewFloatVec4",
buffer = buffer.index,
Buffer = buffer,
byteOffset = 0,
byteStride = 16 // Field only defined for buffer views that contain vertex attributes. A vertex needs 4 * 4 bytes
};
bufferViewFloatVec4.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec4);
accessorColors = new GLTFAccessor
{
name = "accessorColors",
bufferView = bufferViewFloatVec4.index,
BufferView = bufferViewFloatVec4,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC4.ToString()
};
accessorColors.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorColors);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.COLOR_0.ToString(), accessorColors.index);
}
// BufferView - Vector2
GLTFBufferView bufferViewFloatVec2 = null;
if (hasUV || hasUV2)
{
bufferViewFloatVec2 = new GLTFBufferView
{
name = "bufferViewFloatVec2",
buffer = buffer.index,
Buffer = buffer,
byteStride = 8 // Field only defined for buffer views that contain vertex attributes. A vertex needs 2 * 4 bytes
};
bufferViewFloatVec2.index = gltf.BufferViewsList.Count;
gltf.BufferViewsList.Add(bufferViewFloatVec2);
}
// Accessor - UV
GLTFAccessor accessorUVs = null;
if (hasUV)
{
accessorUVs = new GLTFAccessor
{
name = "accessorUVs",
bufferView = bufferViewFloatVec2.index,
BufferView = bufferViewFloatVec2,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC2.ToString()
};
accessorUVs.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorUVs);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.TEXCOORD_0.ToString(), accessorUVs.index);
}
// Accessor - UV2
GLTFAccessor accessorUV2s = null;
if (hasUV2)
{
accessorUV2s = new GLTFAccessor
{
name = "accessorUV2s",
bufferView = bufferViewFloatVec2.index,
BufferView = bufferViewFloatVec2,
componentType = GLTFAccessor.ComponentType.FLOAT,
type = GLTFAccessor.TypeEnum.VEC2.ToString()
};
accessorUV2s.index = gltf.AccessorsList.Count;
gltf.AccessorsList.Add(accessorUV2s);
meshPrimitive.attributes.Add(GLTFMeshPrimitive.Attribute.TEXCOORD_1.ToString(), accessorUV2s.index);
}
// --------------------------
// ------ Mesh as glTF ------
// --------------------------
RaiseMessage("GLTFExporter.Mesh | Mesh as glTF", 1);
// Material
//TODO - Handle multimaterials
GLTFMaterial gltfMaterial = gltf.MaterialsList.Find(material => material.id == babylonMesh.materialId);
if (gltfMaterial != null)
{
meshPrimitive.material = gltfMaterial.index;
}
// Update min and max vertex position for each component (X, Y, Z)
globalVertices.ForEach((globalVertex) =>
{
var positionArray = new float[] { globalVertex.Position.X, globalVertex.Position.Y, globalVertex.Position.Z };
for (int indexComponent = 0; indexComponent < positionArray.Length; indexComponent++)
{
if (positionArray[indexComponent] < accessorPositions.min[indexComponent])
{
accessorPositions.min[indexComponent] = positionArray[indexComponent];
}
if (positionArray[indexComponent] > accessorPositions.max[indexComponent])
{
accessorPositions.max[indexComponent] = positionArray[indexComponent];
}
}
});
// Update byte length and count of accessors, bufferViews and buffers
// Scalar
AddElementsToAccessor(accessorIndices, indices.Count);
// Vector3
bufferViewFloatVec3.byteOffset = buffer.byteLength;
AddElementsToAccessor(accessorPositions, globalVertices.Count);
AddElementsToAccessor(accessorNormals, globalVertices.Count);
// Vector4
if (hasColor)
{
bufferViewFloatVec4.byteOffset = buffer.byteLength;
AddElementsToAccessor(accessorColors, globalVertices.Count);
}
// Vector2
if (hasUV || hasUV2)
{
bufferViewFloatVec2.byteOffset = buffer.byteLength;
if (hasUV)
{
AddElementsToAccessor(accessorUVs, globalVertices.Count);
}
if (hasUV2)
{
AddElementsToAccessor(accessorUV2s, globalVertices.Count);
}
}
// --------------------------
// --------- Saving ---------
// --------------------------
string outputBinaryFile = Path.Combine(gltf.OutputPath, gltfMesh.name + ".bin");
RaiseMessage("GLTFExporter.Mesh | Saving " + outputBinaryFile, 1);
using (BinaryWriter writer = new BinaryWriter(File.Open(outputBinaryFile, FileMode.Create)))
{
// Binary arrays
List <float> vertices = globalVertices.SelectMany(v => new[] { v.Position.X, v.Position.Y, v.Position.Z }).ToList();
List <float> normals = globalVertices.SelectMany(v => new[] { v.Normal.X, v.Normal.Y, v.Normal.Z }).ToList();
List <float> colors = new List <float>();
if (hasColor)
{
colors = globalVertices.SelectMany(v => new[] { v.Color[0], v.Color[1], v.Color[2], v.Color[3] }).ToList();
}
List <float> uvs = new List <float>();
if (hasUV)
{
uvs = globalVertices.SelectMany(v => new[] { v.UV.X, v.UV.Y }).ToList(); // No symetry required to perform 3dsMax => gltf conversion
}
List <float> uvs2 = new List <float>();
if (hasUV2)
{
uvs2 = globalVertices.SelectMany(v => new[] { v.UV2.X, v.UV2.Y }).ToList(); // No symetry required to perform 3dsMax => gltf conversion
}
// Write data to binary file
indices.ForEach(n => writer.Write(n));
vertices.ForEach(n => writer.Write(n));
normals.ForEach(n => writer.Write(n));
colors.ForEach(n => writer.Write(n));
uvs.ForEach(n => writer.Write(n));
}
gltfMesh.primitives = meshPrimitives.ToArray();
return(gltfMesh);
}
private static float FPS_FACTOR = 60.0f; // TODO - Which FPS factor ?
private GLTFAnimation ExportNodeAnimation(BabylonNode babylonNode, GLTF gltf, GLTFNode gltfNode, BabylonScene babylonScene = null)
{
var channelList = new List <GLTFChannel>();
var samplerList = new List <GLTFAnimationSampler>();
if (babylonNode.animations != null && babylonNode.animations.Length > 0)
{
RaiseMessage("GLTFExporter.Animation | Export animation of node named: " + babylonNode.name, 2);
foreach (BabylonAnimation babylonAnimation in babylonNode.animations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
if (gltfTarget.path == null)
{
// Unkown babylon animation property
RaiseWarning("GLTFExporter.Animation | Unkown animation property '" + babylonAnimation.property + "'", 3);
// Ignore this babylon animation
continue;
}
// Buffer
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
// --- Input ---
var accessorInput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationInput",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
accessorInput.min = new float[] { float.MaxValue };
accessorInput.max = new float[] { float.MinValue };
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
var inputValue = babylonAnimationKey.frame / FPS_FACTOR;
// Store values as bytes
accessorInput.bytesList.AddRange(BitConverter.GetBytes(inputValue));
// Update min and max values
GLTFBufferService.UpdateMinMaxAccessor(accessorInput, inputValue);
}
;
accessorInput.count = babylonAnimation.keys.Length;
// --- Output ---
GLTFAccessor accessorOutput = null;
switch (gltfTarget.path)
{
case "translation":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec3(gltf, buffer),
"accessorAnimationPositions",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC3
);
break;
case "rotation":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec4(gltf, buffer),
"accessorAnimationRotations",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC4
);
break;
case "scale":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec3(gltf, buffer),
"accessorAnimationScales",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC3
);
break;
}
// Populate accessor
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
var outputValues = babylonAnimationKey.values;
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = babylonAnimation.keys.Length;
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList);
}
}
// Do not export empty arrays
if (channelList.Count > 0)
{
// Animation
var gltfAnimation = new GLTFAnimation
{
channels = channelList.ToArray(),
samplers = samplerList.ToArray()
};
gltf.AnimationsList.Add(gltfAnimation);
return(gltfAnimation);
}
else
{
return(null);
}
}
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")
{
RaiseMessage("GLTFExporter.Animation | Export animation of bone named: " + babylonBone.name, 2);
var babylonAnimation = babylonBone.animation;
// Optimize animation
var optimizeAnimations = !Loader.Core.RootNode.GetBoolProperty("babylonjs_donotoptimizeanimations"); // reverse negation for clarity
if (optimizeAnimations)
{
// Filter animation keys to only keep frames between start and end
List <BabylonAnimationKey> keysInRangeFull = babylonAnimation.keysFull.FindAll(babylonAnimationKey => babylonAnimationKey.frame >= startFrame && babylonAnimationKey.frame <= endFrame);
// Optimization process always keeps first and last frames
OptimizeAnimations(keysInRangeFull, false);
if (IsAnimationKeysRelevant(keysInRangeFull))
{
// From now, use optimized animation instead
// Override animation keys
babylonAnimation.keys = keysInRangeFull.ToArray();
}
}
// --- 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
QuatCorrection quatCorr = new QuatCorrection(); // restart correction for each curve
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);
translationBabylon.Z *= -1;
if (exportParameters.kuesaContQuats)
{
quatCorr.Quat = rotationQuatBabylon;
rotationQuatBabylon = quatCorr.Quat;
}
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 bool ExportMorphTargetWeightAnimation(BabylonMorphTargetManager babylonMorphTargetManager, GLTF gltf, GLTFNode gltfNode, List <GLTFChannel> channelList, List <GLTFAnimationSampler> samplerList, int startFrame, int endFrame, BabylonScene babylonScene, bool offsetToStartAtFrameZero = true)
{
if (exportedMorphTargets.Contains(babylonMorphTargetManager) || !_isBabylonMorphTargetManagerAnimationValid(babylonMorphTargetManager))
{
return(false);
}
var influencesPerFrame = _getTargetManagerAnimationsData(babylonMorphTargetManager);
var frames = new List <float>(influencesPerFrame.Keys);
var framesInRange = frames.Where(frame => frame >= startFrame && frame <= endFrame).ToList();
framesInRange.Sort(); // Mandatory to sort otherwise gltf loader of babylon doesn't understand
if (framesInRange.Count() <= 0)
{
return(false);
}
logger.RaiseMessage("GLTFExporter.Animation | Export animation of morph target manager with id: " + babylonMorphTargetManager.id, 2);
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = "weights";
// Buffer
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
// --- Input ---
var accessorInput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationInput",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
accessorInput.min = new float[] { float.MaxValue };
accessorInput.max = new float[] { float.MinValue };
int numKeys = 0;
foreach (var frame in framesInRange)
{
numKeys++;
float inputValue = frame;
if (offsetToStartAtFrameZero)
{
inputValue -= startFrame;
}
inputValue /= (float)babylonScene.TimelineFramesPerSecond;
// Store values as bytes
accessorInput.bytesList.AddRange(BitConverter.GetBytes(inputValue));
// Update min and max values
GLTFBufferService.UpdateMinMaxAccessor(accessorInput, inputValue);
}
accessorInput.count = numKeys;
if (accessorInput.count == 0)
{
logger.RaiseWarning(String.Format("GLTFExporter.Animation | No frames to export in morph target animation \"weight\" for mesh named \"{0}\". This will cause an error in the output gltf.", babylonMorphTargetManager.sourceMesh.name));
}
// --- Output ---
GLTFAccessor accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationWeights",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
foreach (var frame in framesInRange)
{
var outputValues = influencesPerFrame[frame];
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.count++;
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
// Mark this morph target as exported.
exportedMorphTargets.Add(babylonMorphTargetManager);
return(true);
}
private static float FPS_FACTOR = 30.0f; // TODO - Which FPS factor ?
private GLTFAnimation ExportNodeAnimation(BabylonNode babylonNode, GLTF gltf, GLTFNode gltfNode, BabylonScene babylonScene = null)
{
var channelList = new List <GLTFChannel>();
var samplerList = new List <GLTFAnimationSampler>();
if (babylonNode.animations != null && babylonNode.animations.Length > 0)
{
RaiseMessage("GLTFExporter.Animation | Export animation of node named: " + babylonNode.name, 2);
foreach (BabylonAnimation babylonAnimation in babylonNode.animations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
if (gltfTarget.path == null)
{
// Unkown babylon animation property
RaiseWarning("GLTFExporter.Animation | Unkown animation property '" + babylonAnimation.property + "'", 3);
// Ignore this babylon animation
continue;
}
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation);
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
var outputValues = babylonAnimationKey.values;
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = babylonAnimation.keys.Length;
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList);
}
}
// Do not export empty arrays
if (channelList.Count > 0)
{
// Animation
var gltfAnimation = new GLTFAnimation
{
channels = channelList.ToArray(),
samplers = samplerList.ToArray()
};
gltf.AnimationsList.Add(gltfAnimation);
return(gltfAnimation);
}
else
{
return(null);
}
}
private void ExportNodeAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonNode babylonNode, GLTFNode gltfNode, BabylonScene babylonScene)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
bool exportNonAnimated = Loader.Core.RootNode.GetBoolProperty("babylonjs_animgroup_exportnonanimated");
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (babylonNode.animations != null)
{
babylonAnimations.AddRange(babylonNode.animations);
}
if (babylonNode.extraAnimations != null)
{
babylonAnimations.AddRange(babylonNode.extraAnimations);
}
// Filter animations to only keep TRS ones
babylonAnimations = babylonAnimations.FindAll(babylonAnimation => _getTargetPath(babylonAnimation.property) != null);
if (babylonAnimations.Count > 0 || exportNonAnimated)
{
if (babylonAnimations.Count > 0)
{
RaiseMessage("GLTFExporter.Animation | Export animations of node named: " + babylonNode.name, 2);
}
else if (exportNonAnimated)
{
RaiseMessage("GLTFExporter.Animation | Export dummy animation for node named: " + babylonNode.name, 2);
// Export a dummy animation
babylonAnimations.Add(GetDummyAnimation(gltfNode, startFrame, endFrame));
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
continue;
}
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
int numKeys = 0;
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
if (babylonAnimationKey.frame < startFrame)
{
continue;
}
if (babylonAnimationKey.frame > endFrame)
{
continue;
}
numKeys++;
// copy data before changing it in case animation groups overlap
float[] outputValues = new float[babylonAnimationKey.values.Length];
babylonAnimationKey.values.CopyTo(outputValues, 0);
// Switch coordinate system at object level
if (babylonAnimation.property == "position")
{
outputValues[2] *= -1;
}
else if (babylonAnimation.property == "rotationQuaternion")
{
outputValues[0] *= -1;
outputValues[1] *= -1;
}
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = numKeys;
// bail out if no keyframes to export (?)
// todo [KeyInterpolation]: bail out only when there are no keyframes at all (?) and otherwise add the appropriate (interpolated) keyframes
if (numKeys == 0)
{
continue;
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList, startFrame, endFrame);
}
}
}
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 void ExportNodeAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonNode babylonNode, GLTFNode gltfNode, BabylonScene babylonScene, BabylonAnimationGroup animationGroup = null)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
bool exportNonAnimated = exportParameters.animgroupExportNonAnimated;
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (animationGroup != null)
{
var targetedAnimations = animationGroup.targetedAnimations.Where(animation => animation.targetId == babylonNode.id);
foreach (var targetedAnimation in targetedAnimations)
{
babylonAnimations.Add(targetedAnimation.animation);
}
}
// Do not include the node animations if a provided animation group already includes them.
if (babylonAnimations.Count <= 0)
{
if (babylonNode.animations != null)
{
babylonAnimations.AddRange(babylonNode.animations);
}
if (babylonNode.extraAnimations != null)
{
babylonAnimations.AddRange(babylonNode.extraAnimations);
}
}
// Filter animations to only keep TRS ones
babylonAnimations = babylonAnimations.FindAll(babylonAnimation => _getTargetPath(babylonAnimation.property) != null);
if (babylonAnimations.Count > 0 || exportNonAnimated)
{
if (babylonAnimations.Count > 0)
{
logger.RaiseMessage("GLTFExporter.Animation | Export animations of node named: " + babylonNode.name, 2);
}
else if (exportNonAnimated)
{
logger.RaiseMessage("GLTFExporter.Animation | Export dummy animation for node named: " + babylonNode.name, 2);
// Export a dummy animation
babylonAnimations.Add(GetDummyAnimation(gltfNode, startFrame, endFrame, babylonScene));
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
var babylonAnimationKeysInRange = babylonAnimation.keys.Where(key => key.frame >= startFrame && key.frame <= endFrame);
if (babylonAnimationKeysInRange.Count() <= 0)
{
continue;
}
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
continue;
}
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
int numKeys = 0;
foreach (var babylonAnimationKey in babylonAnimationKeysInRange)
{
numKeys++;
// copy data before changing it in case animation groups overlap
float[] outputValues = new float[babylonAnimationKey.values.Length];
babylonAnimationKey.values.CopyTo(outputValues, 0);
// Switch coordinate system at object level
if (babylonAnimation.property == "position")
{
outputValues[2] *= -1;
}
else if (babylonAnimation.property == "rotationQuaternion")
{
outputValues[0] *= -1;
outputValues[1] *= -1;
}
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = numKeys;
if (accessorOutput.count == 0)
{
logger.RaiseWarning(String.Format("GLTFExporter.Animation | No frames to export in node animation \"{1}\" of node named \"{0}\". This will cause an error in the output gltf.", babylonNode.name, babylonAnimation.name));
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
ExportGLTFExtension(babylonNode, ref gltfAnimation, gltf);
}
private void ExportBoneAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonNode babylonNode, GLTFNode gltfNode, BabylonAnimationGroup animationGroup = null)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
if (babylonNode.animations != null && babylonNode.animations[0].property == "_matrix")
{
logger.RaiseMessage("GLTFExporter.Animation | Export animation of bone named: " + babylonNode.name, 2);
BabylonAnimation babylonAnimation = null;
if (animationGroup != null)
{
var targetedAnimation = animationGroup.targetedAnimations.FirstOrDefault(animation => animation.targetId == babylonNode.id);
if (targetedAnimation != null)
{
babylonAnimation = targetedAnimation.animation;
}
}
// otherwise fall back to the full animation track on the node.
if (babylonAnimation == null)
{
babylonAnimation = babylonNode.animations[0];
}
var babylonAnimationKeysInRange = babylonAnimation.keys.Where(key => key.frame >= startFrame && key.frame <= endFrame);
if (babylonAnimationKeysInRange.Count() <= 0)
{
return;
}
// --- 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 babylonAnimationKeysInRange)
{
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;
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);
}
}
ExportGLTFExtension(babylonNode, ref gltfAnimation, gltf);
}
private void ExportNodeAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonNode babylonNode, GLTFNode gltfNode, BabylonScene babylonScene)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
if ((babylonNode.animations != null && babylonNode.animations.Length > 0) ||
(babylonNode.extraAnimations != null && babylonNode.extraAnimations.Count > 0))
{
RaiseMessage("GLTFExporter.Animation | Export animation of node named: " + babylonNode.name, 2);
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (babylonNode.animations != null)
{
babylonAnimations.AddRange(babylonNode.animations);
}
if (babylonNode.extraAnimations != null)
{
babylonAnimations.AddRange(babylonNode.extraAnimations);
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
if (gltfTarget.path == null)
{
// Unkown babylon animation property
//RaiseWarning("GLTFExporter.Animation | Unkown animation property '" + babylonAnimation.property + "'", 3);
// Ignore this babylon animation
continue;
}
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
continue;
}
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
int numKeys = 0;
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
if (babylonAnimationKey.frame < startFrame)
{
continue;
}
if (babylonAnimationKey.frame > endFrame)
{
continue;
}
numKeys++;
var outputValues = babylonAnimationKey.values;
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = numKeys;
// bail out if no keyframes to export (?)
// todo [KeyInterpolation]: bail out only when there are no keyframes at all (?) and otherwise add the appropriate (interpolated) keyframes
if (numKeys == 0)
{
continue;
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList, startFrame, endFrame);
}
}
}
private void ExportNodeAnimation(GLTFAnimation gltfAnimation, int startFrame, int endFrame, GLTF gltf, BabylonNode babylonNode, GLTFNode gltfNode, BabylonScene babylonScene)
{
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
bool exportNonAnimated = Loader.Core.RootNode.GetBoolProperty("babylonjs_animgroup_exportnonanimated");
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (babylonNode.animations != null)
{
babylonAnimations.AddRange(babylonNode.animations);
}
if (babylonNode.extraAnimations != null)
{
babylonAnimations.AddRange(babylonNode.extraAnimations);
}
// Filter animations to only keep TRS ones
babylonAnimations = babylonAnimations.FindAll(babylonAnimation => _getTargetPath(babylonAnimation.property) != null);
// Optimize animations to only keep ones animated between start and end frames
var optimizeAnimations = !Loader.Core.RootNode.GetBoolProperty("babylonjs_donotoptimizeanimations"); // reverse negation for clarity
if (optimizeAnimations)
{
List <BabylonAnimation> babylonAnimationsOptimized = new List <BabylonAnimation>();
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
// Filter animation keys to only keep frames between start and end
List <BabylonAnimationKey> keysInRangeFull = babylonAnimation.keysFull.FindAll(babylonAnimationKey => babylonAnimationKey.frame >= startFrame && babylonAnimationKey.frame <= endFrame);
// Optimization process always keeps first and last frames
OptimizeAnimations(keysInRangeFull, true);
if (IsAnimationKeysRelevant(keysInRangeFull))
{
// Override animation keys
babylonAnimation.keys = keysInRangeFull.ToArray();
babylonAnimationsOptimized.Add(babylonAnimation);
}
}
// From now, use optimized animations instead
babylonAnimations = babylonAnimationsOptimized;
}
if (babylonAnimations.Count > 0 || exportNonAnimated)
{
if (babylonAnimations.Count > 0)
{
RaiseMessage("GLTFExporter.Animation | Export animations of node named: " + babylonNode.name, 2);
}
else if (exportNonAnimated)
{
RaiseMessage("GLTFExporter.Animation | Export dummy animation for node named: " + babylonNode.name, 2);
// Export a dummy animation
babylonAnimations.Add(GetDummyAnimation(gltfNode, startFrame, endFrame));
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
continue;
}
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
int numKeys = 0;
QuatCorrection quatCorr = new QuatCorrection(); // restart correction for each curve
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
if (babylonAnimationKey.frame < startFrame)
{
continue;
}
if (babylonAnimationKey.frame > endFrame)
{
continue;
}
numKeys++;
// copy data before changing it in case animation groups overlap
float[] outputValues = new float[babylonAnimationKey.values.Length];
babylonAnimationKey.values.CopyTo(outputValues, 0);
// Switch coordinate system at object level
if (babylonAnimation.property == "position")
{
outputValues[2] *= -1;
}
else if (babylonAnimation.property == "rotationQuaternion")
{
quatCorr.Quat = new BabylonQuaternion(outputValues[0], outputValues[1], outputValues[2], outputValues[3]);
if (exportParameters.kuesaContQuats)
{
quatCorr.Quat = new BabylonQuaternion(outputValues[0], outputValues[1], outputValues[2], outputValues[3]);
outputValues[0] = quatCorr.Quat.X;
outputValues[1] = quatCorr.Quat.Y;
outputValues[2] = quatCorr.Quat.Z;
outputValues[3] = quatCorr.Quat.W;
}
outputValues[0] *= -1;
outputValues[1] *= -1;
}
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = numKeys;
// bail out if no keyframes to export (?)
// todo [KeyInterpolation]: bail out only when there are no keyframes at all (?) and otherwise add the appropriate (interpolated) keyframes
if (numKeys == 0)
{
continue;
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList, startFrame, endFrame);
}
}
}
private int AddParameterSamplerAnimation(BabylonCamera babylonCamera, GLTFAnimation gltfAnimation, GLTFExporter exporter, GLTF gltf, int startFrame, int endFrame)
{
var samplerList = gltfAnimation.SamplerList;
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (babylonCamera.animations != null)
{
IEnumerable <BabylonAnimation> extendedAnimations = babylonCamera.animations.Where(anim => anim.name == "fov animation");
babylonAnimations.AddRange(extendedAnimations);
}
if (babylonAnimations.Count > 0)
{
if (babylonAnimations.Count > 0)
{
exporter.logger.RaiseMessage("GLTFExporter.Animation | Export animations of node named: " + babylonCamera.name, 2);
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
var babylonAnimationKeysInRange = babylonAnimation.keys.Where(key => key.frame >= startFrame && key.frame <= endFrame);
if (babylonAnimationKeysInRange.Count() <= 0)
{
continue;
}
string target_path = babylonAnimation.property;
// --- Input ---
var accessorInput = exporter._createAndPopulateInput(gltf, babylonAnimation, startFrame, endFrame);
if (accessorInput == null)
{
continue;
}
// --- Output ---
GLTFAccessor accessorOutput = FlightSimAsoboPropertyAnimationExtension._createAccessorOfProperty(target_path, gltf);
if (accessorOutput == null)
{
continue;
}
// Populate accessor
int numKeys = 0;
foreach (var babylonAnimationKey in babylonAnimationKeysInRange)
{
numKeys++;
// copy data before changing it in case animation groups overlap
float[] outputValues = new float[babylonAnimationKey.values.Length];
babylonAnimationKey.values.CopyTo(outputValues, 0);
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = numKeys;
if (accessorOutput.count == 0)
{
exporter.logger.RaiseWarning(String.Format("GLTFExporter.Animation | No frames to export in material animation \"{1}\" of node named \"{0}\". This will cause an error in the output gltf.", babylonCamera.name, babylonAnimation.name));
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
}
}
else
{
return(-1);
}
return(samplerList.Count - 1);
}
private bool ExportMorphTargetWeightAnimation(BabylonMorphTargetManager babylonMorphTargetManager, GLTF gltf, GLTFNode gltfNode, List <GLTFChannel> channelList, List <GLTFAnimationSampler> samplerList, int startFrame, int endFrame)
{
if (!_isBabylonMorphTargetManagerAnimationValid(babylonMorphTargetManager))
{
return(false);
}
RaiseMessage("GLTFExporter.Animation | Export animation of morph target manager with id: " + babylonMorphTargetManager.id, 2);
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = "weights";
// Buffer
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
// --- Input ---
var accessorInput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationInput",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
accessorInput.min = new float[] { float.MaxValue };
accessorInput.max = new float[] { float.MinValue };
var influencesPerFrame = _getTargetManagerAnimationsData(babylonMorphTargetManager);
var frames = new List <int>(influencesPerFrame.Keys);
frames.Sort(); // Mandatory otherwise gltf loader of babylon doesn't understand
int numKeys = 0;
foreach (var frame in frames)
{
if (frame < startFrame)
{
continue;
}
if (frame > endFrame)
{
continue;
}
numKeys++;
var inputValue = frame / (float)Loader.Global.FrameRate;
// Store values as bytes
accessorInput.bytesList.AddRange(BitConverter.GetBytes(inputValue));
// Update min and max values
GLTFBufferService.UpdateMinMaxAccessor(accessorInput, inputValue);
}
accessorInput.count = numKeys;
// bail out if we have no keys to export (?)
// todo [KeyInterpolation]: bail out only when there are no keyframes at all (?) and otherwise add the appropriate (interpolated) keyframes
if (numKeys == 0)
{
return(false);
}
// --- Output ---
GLTFAccessor accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationWeights",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
foreach (var frame in frames)
{
if (frame < startFrame)
{
continue;
}
if (frame > endFrame)
{
continue;
}
var outputValues = influencesPerFrame[frame];
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.count++;
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
return(true);
}
private static float FPS_FACTOR = 30.0f; // TODO - Which FPS factor ?
private GLTFAnimation ExportNodeAnimation(BabylonNode babylonNode, GLTF gltf, GLTFNode gltfNode, BabylonScene babylonScene = null)
{
GLTFAnimation gltfAnimation = null;
if (gltf.AnimationsList.Count > 0)
{
gltfAnimation = gltf.AnimationsList[0];
}
else
{
gltfAnimation = new GLTFAnimation();
gltf.AnimationsList.Add(gltfAnimation);
}
var channelList = gltfAnimation.ChannelList;
var samplerList = gltfAnimation.SamplerList;
if ((babylonNode.animations != null && babylonNode.animations.Length > 0) ||
(babylonNode.extraAnimations != null && babylonNode.extraAnimations.Count > 0))
{
RaiseMessage("GLTFExporter.Animation | Export animation of node named: " + babylonNode.name, 2);
// Combine babylon animations from .babylon file and cached ones
var babylonAnimations = new List <BabylonAnimation>();
if (babylonNode.animations != null)
{
babylonAnimations.AddRange(babylonNode.animations);
}
if (babylonNode.extraAnimations != null)
{
babylonAnimations.AddRange(babylonNode.extraAnimations);
}
foreach (BabylonAnimation babylonAnimation in babylonAnimations)
{
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = _getTargetPath(babylonAnimation.property);
if (gltfTarget.path == null)
{
// Unkown babylon animation property
//RaiseWarning("GLTFExporter.Animation | Unkown animation property '" + babylonAnimation.property + "'", 3);
// Ignore this babylon animation
continue;
}
// --- Input ---
var accessorInput = _createAndPopulateInput(gltf, babylonAnimation);
// --- Output ---
GLTFAccessor accessorOutput = _createAccessorOfPath(gltfTarget.path, gltf);
// Populate accessor
foreach (var babylonAnimationKey in babylonAnimation.keys)
{
var outputValues = babylonAnimationKey.values;
// Switch coordinate system at object level
if (babylonAnimation.property == "position")
{
outputValues[2] *= -1;
}
else if (babylonAnimation.property == "rotationQuaternion")
{
outputValues[0] *= -1;
outputValues[1] *= -1;
}
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
;
accessorOutput.count = babylonAnimation.keys.Length;
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
}
}
if (babylonNode.GetType() == typeof(BabylonMesh))
{
var babylonMesh = babylonNode as BabylonMesh;
// Morph targets
var babylonMorphTargetManager = GetBabylonMorphTargetManager(babylonScene, babylonMesh);
if (babylonMorphTargetManager != null)
{
ExportMorphTargetWeightAnimation(babylonMorphTargetManager, gltf, gltfNode, channelList, samplerList);
}
}
return(gltfAnimation);
}
private bool ExportMorphTargetWeightAnimation(BabylonMorphTargetManager babylonMorphTargetManager, GLTF gltf, GLTFNode gltfNode, List <GLTFChannel> channelList, List <GLTFAnimationSampler> samplerList)
{
if (!_isBabylonMorphTargetManagerAnimationValid(babylonMorphTargetManager))
{
return(false);
}
RaiseMessage("GLTFExporter.Animation | Export animation of morph target manager with id: " + babylonMorphTargetManager.id, 2);
var influencesPerFrame = _getTargetManagerAnimationsData(babylonMorphTargetManager);
var frames = new List <int>(influencesPerFrame.Keys);
frames.Sort(); // Mandatory otherwise gltf loader of babylon doesn't understand
// Target
var gltfTarget = new GLTFChannelTarget
{
node = gltfNode.index
};
gltfTarget.path = "weights";
// Buffer
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
// --- Input ---
var accessorInput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationInput",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
accessorInput.min = new float[] { float.MaxValue };
accessorInput.max = new float[] { float.MinValue };
foreach (var frame in frames)
{
var inputValue = frame / FPS_FACTOR;
// Store values as bytes
accessorInput.bytesList.AddRange(BitConverter.GetBytes(inputValue));
// Update min and max values
GLTFBufferService.UpdateMinMaxAccessor(accessorInput, inputValue);
}
accessorInput.count = influencesPerFrame.Count;
// --- Output ---
GLTFAccessor accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationWeights",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
// Populate accessor
foreach (var frame in frames)
{
var outputValues = influencesPerFrame[frame];
// Store values as bytes
foreach (var outputValue in outputValues)
{
accessorOutput.count++;
accessorOutput.bytesList.AddRange(BitConverter.GetBytes(outputValue));
}
}
// Animation sampler
var gltfAnimationSampler = new GLTFAnimationSampler
{
input = accessorInput.index,
output = accessorOutput.index
};
gltfAnimationSampler.index = samplerList.Count;
samplerList.Add(gltfAnimationSampler);
// Channel
var gltfChannel = new GLTFChannel
{
sampler = gltfAnimationSampler.index,
target = gltfTarget
};
channelList.Add(gltfChannel);
return(true);
}
public static GLTFAccessor _createAccessorOfProperty(string path, GLTF gltf)
{
var buffer = GLTFBufferService.Instance.GetBuffer(gltf);
GLTFAccessor accessorOutput = null;
switch (path.ToUpperInvariant())
{
case "WIPERANIMSTATE1":
case "WIPERANIMSTATE2":
case "WIPERANIMSTATE3":
case "WIPERANIMSTATE4":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
$"accessorAnimation{path}",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "BASECOLOR":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec4(gltf, buffer),
"accessorAnimationBaseColor",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC4
);
break;
case "EMISSIVE":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatVec3(gltf, buffer),
"accessorAnimationEmissiveColor",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.VEC3
);
break;
case "ROUGHNESS":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationRoughnessFactor",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "METALLIC":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationMetallicFactor",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "FOV":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationFOV",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "UVOFFSETU":
case "UVOFFSETV":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationUVOffset",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "UVTILINGU":
case "UVTILINGV":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationUVTiling",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
case "UVROTATION":
accessorOutput = GLTFBufferService.Instance.CreateAccessor(
gltf,
GLTFBufferService.Instance.GetBufferViewAnimationFloatScalar(gltf, buffer),
"accessorAnimationUVRotation",
GLTFAccessor.ComponentType.FLOAT,
GLTFAccessor.TypeEnum.SCALAR
);
break;
}
return(accessorOutput);
}
