holes-in
Version:
Generates a 3D mesh from a 2D outer path and 2D inner paths
1,060 lines (1,055 loc) • 193 kB
JavaScript
/// <reference path="../../../dist/preview release/babylon.d.ts"/>
var BABYLON = require("babylonjs");
(function (BABYLON) {
var GLTFFileLoader = (function () {
function GLTFFileLoader() {
this.extensions = {
".gltf": { isBinary: false },
".glb": { isBinary: true }
};
}
GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onSuccess, onError) {
var loaderData = GLTFFileLoader._parse(data);
var loader = this._getLoader(loaderData);
if (!loader) {
onError();
return;
}
loader.importMeshAsync(meshesNames, scene, loaderData, rootUrl, onSuccess, onError);
};
GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onSuccess, onError) {
var loaderData = GLTFFileLoader._parse(data);
var loader = this._getLoader(loaderData);
if (!loader) {
onError();
return;
}
return loader.loadAsync(scene, loaderData, rootUrl, onSuccess, onError);
};
GLTFFileLoader._parse = function (data) {
if (data instanceof ArrayBuffer) {
return GLTFFileLoader._parseBinary(data);
}
return {
json: JSON.parse(data),
bin: null
};
};
GLTFFileLoader.prototype._getLoader = function (loaderData) {
var loaderVersion = { major: 2, minor: 0 };
var asset = loaderData.json.asset || {};
var version = GLTFFileLoader._parseVersion(asset.version);
if (!version) {
BABYLON.Tools.Error("Invalid version");
return null;
}
var minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
if (minVersion) {
if (GLTFFileLoader._compareVersion(minVersion, loaderVersion) > 0) {
BABYLON.Tools.Error("Incompatible version");
return null;
}
}
var loaders = {
1: GLTFFileLoader.GLTFLoaderV1,
2: GLTFFileLoader.GLTFLoaderV2
};
var loader = loaders[version.major];
if (loader === undefined) {
BABYLON.Tools.Error("Unsupported version");
return null;
}
if (loader === null) {
BABYLON.Tools.Error("v" + version.major + " loader is not available");
return null;
}
return loader;
};
GLTFFileLoader._parseBinary = function (data) {
var Binary = {
Magic: 0x46546C67
};
var binaryReader = new BinaryReader(data);
var magic = binaryReader.readUint32();
if (magic !== Binary.Magic) {
BABYLON.Tools.Error("Unexpected magic: " + magic);
return null;
}
var version = binaryReader.readUint32();
switch (version) {
case 1: return GLTFFileLoader._parseV1(binaryReader);
case 2: return GLTFFileLoader._parseV2(binaryReader);
}
BABYLON.Tools.Error("Unsupported version: " + version);
return null;
};
GLTFFileLoader._parseV1 = function (binaryReader) {
var ContentFormat = {
JSON: 0
};
var length = binaryReader.readUint32();
if (length != binaryReader.getLength()) {
BABYLON.Tools.Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
return null;
}
var contentLength = binaryReader.readUint32();
var contentFormat = binaryReader.readUint32();
var content;
switch (contentFormat) {
case ContentFormat.JSON:
content = JSON.parse(GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(contentLength)));
break;
default:
BABYLON.Tools.Error("Unexpected content format: " + contentFormat);
return null;
}
var bytesRemaining = binaryReader.getLength() - binaryReader.getPosition();
var body = binaryReader.readUint8Array(bytesRemaining);
return {
json: content,
bin: body
};
};
GLTFFileLoader._parseV2 = function (binaryReader) {
var ChunkFormat = {
JSON: 0x4E4F534A,
BIN: 0x004E4942
};
var length = binaryReader.readUint32();
if (length !== binaryReader.getLength()) {
BABYLON.Tools.Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
return null;
}
// JSON chunk
var chunkLength = binaryReader.readUint32();
var chunkFormat = binaryReader.readUint32();
if (chunkFormat !== ChunkFormat.JSON) {
BABYLON.Tools.Error("First chunk format is not JSON");
return null;
}
var json = JSON.parse(GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(chunkLength)));
// Look for BIN chunk
var bin = null;
while (binaryReader.getPosition() < binaryReader.getLength()) {
chunkLength = binaryReader.readUint32();
chunkFormat = binaryReader.readUint32();
switch (chunkFormat) {
case ChunkFormat.JSON:
BABYLON.Tools.Error("Unexpected JSON chunk");
return null;
case ChunkFormat.BIN:
bin = binaryReader.readUint8Array(chunkLength);
break;
default:
// ignore unrecognized chunkFormat
binaryReader.skipBytes(chunkLength);
break;
}
}
return {
json: json,
bin: bin
};
};
GLTFFileLoader._parseVersion = function (version) {
if (!version) {
return null;
}
var parts = version.split(".");
if (parts.length === 0) {
return null;
}
var major = parseInt(parts[0]);
if (major > 1 && parts.length != 2) {
return null;
}
var minor = parseInt(parts[1]);
return {
major: major,
minor: parseInt(parts[0])
};
};
GLTFFileLoader._compareVersion = function (a, b) {
if (a.major > b.major)
return 1;
if (a.major < b.major)
return -1;
if (a.minor > b.minor)
return 1;
if (a.minor < b.minor)
return -1;
return 0;
};
GLTFFileLoader._decodeBufferToText = function (view) {
var result = "";
var length = view.byteLength;
for (var i = 0; i < length; ++i) {
result += String.fromCharCode(view[i]);
}
return result;
};
return GLTFFileLoader;
}());
GLTFFileLoader.GLTFLoaderV1 = null;
GLTFFileLoader.GLTFLoaderV2 = null;
GLTFFileLoader.HomogeneousCoordinates = false;
GLTFFileLoader.IncrementalLoading = true;
BABYLON.GLTFFileLoader = GLTFFileLoader;
var BinaryReader = (function () {
function BinaryReader(arrayBuffer) {
this._arrayBuffer = arrayBuffer;
this._dataView = new DataView(arrayBuffer);
this._byteOffset = 0;
}
BinaryReader.prototype.getPosition = function () {
return this._byteOffset;
};
BinaryReader.prototype.getLength = function () {
return this._arrayBuffer.byteLength;
};
BinaryReader.prototype.readUint32 = function () {
var value = this._dataView.getUint32(this._byteOffset, true);
this._byteOffset += 4;
return value;
};
BinaryReader.prototype.readUint8Array = function (length) {
var value = new Uint8Array(this._arrayBuffer, this._byteOffset, length);
this._byteOffset += length;
return value;
};
BinaryReader.prototype.skipBytes = function (length) {
this._byteOffset += length;
};
return BinaryReader;
}());
BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
})(BABYLON || (BABYLON = {}));
//# sourceMappingURL=babylon.glTFFileLoader.js.map
/// <reference path="../../../../dist/preview release/babylon.d.ts"/>
var BABYLON;
(function (BABYLON) {
var GLTF1;
(function (GLTF1) {
/**
* Enums
*/
var EComponentType;
(function (EComponentType) {
EComponentType[EComponentType["BYTE"] = 5120] = "BYTE";
EComponentType[EComponentType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
EComponentType[EComponentType["SHORT"] = 5122] = "SHORT";
EComponentType[EComponentType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
EComponentType[EComponentType["FLOAT"] = 5126] = "FLOAT";
})(EComponentType = GLTF1.EComponentType || (GLTF1.EComponentType = {}));
var EShaderType;
(function (EShaderType) {
EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
})(EShaderType = GLTF1.EShaderType || (GLTF1.EShaderType = {}));
var EParameterType;
(function (EParameterType) {
EParameterType[EParameterType["BYTE"] = 5120] = "BYTE";
EParameterType[EParameterType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
EParameterType[EParameterType["SHORT"] = 5122] = "SHORT";
EParameterType[EParameterType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
EParameterType[EParameterType["INT"] = 5124] = "INT";
EParameterType[EParameterType["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
EParameterType[EParameterType["FLOAT"] = 5126] = "FLOAT";
EParameterType[EParameterType["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
EParameterType[EParameterType["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
EParameterType[EParameterType["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
EParameterType[EParameterType["INT_VEC2"] = 35667] = "INT_VEC2";
EParameterType[EParameterType["INT_VEC3"] = 35668] = "INT_VEC3";
EParameterType[EParameterType["INT_VEC4"] = 35669] = "INT_VEC4";
EParameterType[EParameterType["BOOL"] = 35670] = "BOOL";
EParameterType[EParameterType["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
EParameterType[EParameterType["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
EParameterType[EParameterType["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
EParameterType[EParameterType["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
EParameterType[EParameterType["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
EParameterType[EParameterType["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
EParameterType[EParameterType["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
})(EParameterType = GLTF1.EParameterType || (GLTF1.EParameterType = {}));
var ETextureWrapMode;
(function (ETextureWrapMode) {
ETextureWrapMode[ETextureWrapMode["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
ETextureWrapMode[ETextureWrapMode["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
ETextureWrapMode[ETextureWrapMode["REPEAT"] = 10497] = "REPEAT";
})(ETextureWrapMode = GLTF1.ETextureWrapMode || (GLTF1.ETextureWrapMode = {}));
var ETextureFilterType;
(function (ETextureFilterType) {
ETextureFilterType[ETextureFilterType["NEAREST"] = 9728] = "NEAREST";
ETextureFilterType[ETextureFilterType["LINEAR"] = 9728] = "LINEAR";
ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
})(ETextureFilterType = GLTF1.ETextureFilterType || (GLTF1.ETextureFilterType = {}));
var ETextureFormat;
(function (ETextureFormat) {
ETextureFormat[ETextureFormat["ALPHA"] = 6406] = "ALPHA";
ETextureFormat[ETextureFormat["RGB"] = 6407] = "RGB";
ETextureFormat[ETextureFormat["RGBA"] = 6408] = "RGBA";
ETextureFormat[ETextureFormat["LUMINANCE"] = 6409] = "LUMINANCE";
ETextureFormat[ETextureFormat["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
})(ETextureFormat = GLTF1.ETextureFormat || (GLTF1.ETextureFormat = {}));
var ECullingType;
(function (ECullingType) {
ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
ECullingType[ECullingType["BACK"] = 1029] = "BACK";
ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
})(ECullingType = GLTF1.ECullingType || (GLTF1.ECullingType = {}));
var EBlendingFunction;
(function (EBlendingFunction) {
EBlendingFunction[EBlendingFunction["ZERO"] = 0] = "ZERO";
EBlendingFunction[EBlendingFunction["ONE"] = 1] = "ONE";
EBlendingFunction[EBlendingFunction["SRC_COLOR"] = 768] = "SRC_COLOR";
EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
EBlendingFunction[EBlendingFunction["DST_COLOR"] = 774] = "DST_COLOR";
EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
EBlendingFunction[EBlendingFunction["SRC_ALPHA"] = 770] = "SRC_ALPHA";
EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
EBlendingFunction[EBlendingFunction["DST_ALPHA"] = 772] = "DST_ALPHA";
EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
EBlendingFunction[EBlendingFunction["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
EBlendingFunction[EBlendingFunction["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
EBlendingFunction[EBlendingFunction["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
})(EBlendingFunction = GLTF1.EBlendingFunction || (GLTF1.EBlendingFunction = {}));
})(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
})(BABYLON || (BABYLON = {}));
//# sourceMappingURL=babylon.glTFLoaderInterfaces.js.map
/// <reference path="../../../../dist/preview release/babylon.d.ts"/>
var BABYLON;
(function (BABYLON) {
var GLTF1;
(function (GLTF1) {
/**
* Tokenizer. Used for shaders compatibility
* Automatically map world, view, projection, worldViewProjection, attributes and so on
*/
var ETokenType;
(function (ETokenType) {
ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
})(ETokenType || (ETokenType = {}));
var Tokenizer = (function () {
function Tokenizer(toParse) {
this._pos = 0;
this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
this._toParse = toParse;
this._maxPos = toParse.length;
}
Tokenizer.prototype.getNextToken = function () {
if (this.isEnd())
return ETokenType.END_OF_INPUT;
this.currentString = this.read();
this.currentToken = ETokenType.UNKNOWN;
if (this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString)) {
this.currentToken = ETokenType.IDENTIFIER;
this.currentIdentifier = this.currentString;
while (!this.isEnd() && (this.isLetterOrDigitPattern.test(this.currentString = this.peek()) || this.currentString === "_")) {
this.currentIdentifier += this.currentString;
this.forward();
}
}
return this.currentToken;
};
Tokenizer.prototype.peek = function () {
return this._toParse[this._pos];
};
Tokenizer.prototype.read = function () {
return this._toParse[this._pos++];
};
Tokenizer.prototype.forward = function () {
this._pos++;
};
Tokenizer.prototype.isEnd = function () {
return this._pos >= this._maxPos;
};
return Tokenizer;
}());
/**
* Values
*/
var glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
var babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
var glTFAnimationPaths = ["translation", "rotation", "scale"];
var babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
/**
* Parse
*/
var parseBuffers = function (parsedBuffers, gltfRuntime) {
for (var buf in parsedBuffers) {
var parsedBuffer = parsedBuffers[buf];
gltfRuntime.buffers[buf] = parsedBuffer;
gltfRuntime.buffersCount++;
}
};
var parseShaders = function (parsedShaders, gltfRuntime) {
for (var sha in parsedShaders) {
var parsedShader = parsedShaders[sha];
gltfRuntime.shaders[sha] = parsedShader;
gltfRuntime.shaderscount++;
}
};
var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
for (var object in parsedObjects) {
var parsedObject = parsedObjects[object];
gltfRuntime[runtimeProperty][object] = parsedObject;
}
};
/**
* Utils
*/
var normalizeUVs = function (buffer) {
if (!buffer) {
return;
}
for (var i = 0; i < buffer.length / 2; i++) {
buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
}
};
var replaceInString = function (str, searchValue, replaceValue) {
while (str.indexOf(searchValue) !== -1) {
str = str.replace(searchValue, replaceValue);
}
return str;
};
var getAttribute = function (attributeParameter) {
if (attributeParameter.semantic === "NORMAL") {
return "normal";
}
else if (attributeParameter.semantic === "POSITION") {
return "position";
}
else if (attributeParameter.semantic === "JOINT") {
return "matricesIndices";
}
else if (attributeParameter.semantic === "WEIGHT") {
return "matricesWeights";
}
else if (attributeParameter.semantic === "COLOR") {
return "color";
}
else if (attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
var channel = Number(attributeParameter.semantic.split("_")[1]);
return "uv" + (channel === 0 ? "" : channel + 1);
}
};
/**
* Returns the animation path (glTF -> Babylon)
*/
var getAnimationPath = function (path) {
var index = glTFAnimationPaths.indexOf(path);
if (index !== -1) {
return babylonAnimationPaths[index];
}
return path;
};
/**
* Loads and creates animations
*/
var loadAnimations = function (gltfRuntime) {
for (var anim in gltfRuntime.animations) {
var animation = gltfRuntime.animations[anim];
var lastAnimation = null;
for (var i = 0; i < animation.channels.length; i++) {
// Get parameters and load buffers
var channel = animation.channels[i];
var sampler = animation.samplers[channel.sampler];
if (!sampler) {
continue;
}
var inputData = null;
var outputData = null;
if (animation.parameters) {
inputData = animation.parameters[sampler.input];
outputData = animation.parameters[sampler.output];
}
else {
inputData = sampler.input;
outputData = sampler.output;
}
var bufferInput = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
var bufferOutput = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
var targetID = channel.target.id;
var targetNode = gltfRuntime.scene.getNodeByID(targetID);
if (targetNode === null) {
targetNode = gltfRuntime.scene.getNodeByName(targetID);
}
if (targetNode === null) {
BABYLON.Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetID + " to attach to");
continue;
}
var isBone = targetNode instanceof BABYLON.Bone;
// Get target path (position, rotation or scaling)
var targetPath = channel.target.path;
var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
if (targetPathIndex !== -1) {
targetPath = babylonAnimationPaths[targetPathIndex];
}
// Determine animation type
var animationType = BABYLON.Animation.ANIMATIONTYPE_MATRIX;
if (!isBone) {
if (targetPath === "rotationQuaternion") {
animationType = BABYLON.Animation.ANIMATIONTYPE_QUATERNION;
targetNode.rotationQuaternion = new BABYLON.Quaternion();
}
else {
animationType = BABYLON.Animation.ANIMATIONTYPE_VECTOR3;
}
}
// Create animation and key frames
var babylonAnimation = null;
var keys = [];
var arrayOffset = 0;
var modifyKey = false;
if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
babylonAnimation = lastAnimation;
modifyKey = true;
}
if (!modifyKey) {
babylonAnimation = new BABYLON.Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, BABYLON.Animation.ANIMATIONLOOPMODE_CYCLE);
}
// For each frame
for (var j = 0; j < bufferInput.length; j++) {
var value = null;
if (targetPath === "rotationQuaternion") {
value = BABYLON.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
arrayOffset += 4;
}
else {
value = BABYLON.Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
arrayOffset += 3;
}
if (isBone) {
var bone = targetNode;
var translation = BABYLON.Vector3.Zero();
var rotationQuaternion = new BABYLON.Quaternion();
var scaling = BABYLON.Vector3.Zero();
// Warning on decompose
var mat = bone.getBaseMatrix();
if (modifyKey) {
mat = lastAnimation.getKeys()[j].value;
}
mat.decompose(scaling, rotationQuaternion, translation);
if (targetPath === "position") {
translation = value;
}
else if (targetPath === "rotationQuaternion") {
rotationQuaternion = value;
}
else {
scaling = value;
}
value = BABYLON.Matrix.Compose(scaling, rotationQuaternion, translation);
}
if (!modifyKey) {
keys.push({
frame: bufferInput[j],
value: value
});
}
else {
lastAnimation.getKeys()[j].value = value;
}
}
// Finish
if (!modifyKey) {
babylonAnimation.setKeys(keys);
targetNode.animations.push(babylonAnimation);
}
lastAnimation = babylonAnimation;
gltfRuntime.scene.stopAnimation(targetNode);
gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
}
}
};
/**
* Returns the bones transformation matrix
*/
var configureBoneTransformation = function (node) {
var mat = null;
if (node.translation || node.rotation || node.scale) {
var scale = BABYLON.Vector3.FromArray(node.scale || [1, 1, 1]);
var rotation = BABYLON.Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
var position = BABYLON.Vector3.FromArray(node.translation || [0, 0, 0]);
mat = BABYLON.Matrix.Compose(scale, rotation, position);
}
else {
mat = BABYLON.Matrix.FromArray(node.matrix);
}
return mat;
};
/**
* Returns the parent bone
*/
var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
// Try to find
for (var i = 0; i < newSkeleton.bones.length; i++) {
if (newSkeleton.bones[i].name === jointName) {
return newSkeleton.bones[i];
}
}
// Not found, search in gltf nodes
var nodes = gltfRuntime.nodes;
for (var nde in nodes) {
var node = nodes[nde];
if (!node.jointName) {
continue;
}
var children = node.children;
for (var i = 0; i < children.length; i++) {
var child = gltfRuntime.nodes[children[i]];
if (!child.jointName) {
continue;
}
if (child.jointName === jointName) {
var mat = configureBoneTransformation(node);
var bone = new BABYLON.Bone(node.name, newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
bone.id = nde;
return bone;
}
}
}
return null;
};
/**
* Returns the appropriate root node
*/
var getNodeToRoot = function (nodesToRoot, id) {
for (var i = 0; i < nodesToRoot.length; i++) {
var nodeToRoot = nodesToRoot[i];
for (var j = 0; j < nodeToRoot.node.children.length; j++) {
var child = nodeToRoot.node.children[j];
if (child === id) {
return nodeToRoot.bone;
}
}
}
return null;
};
/**
* Returns the node with the joint name
*/
var getJointNode = function (gltfRuntime, jointName) {
var nodes = gltfRuntime.nodes;
var node = nodes[jointName];
if (node) {
return {
node: node,
id: jointName
};
}
for (var nde in nodes) {
node = nodes[nde];
if (node.jointName === jointName) {
return {
node: node,
id: nde
};
}
}
return null;
};
/**
* Checks if a nodes is in joints
*/
var nodeIsInJoints = function (skins, id) {
for (var i = 0; i < skins.jointNames.length; i++) {
if (skins.jointNames[i] === id) {
return true;
}
}
return false;
};
/**
* Fills the nodes to root for bones and builds hierarchy
*/
var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
// Creates nodes for root
for (var nde in gltfRuntime.nodes) {
var node = gltfRuntime.nodes[nde];
var id = nde;
if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
continue;
}
// Create node to root bone
var mat = configureBoneTransformation(node);
var bone = new BABYLON.Bone(node.name, newSkeleton, null, mat);
bone.id = id;
nodesToRoot.push({ bone: bone, node: node, id: id });
}
// Parenting
for (var i = 0; i < nodesToRoot.length; i++) {
var nodeToRoot = nodesToRoot[i];
var children = nodeToRoot.node.children;
for (var j = 0; j < children.length; j++) {
var child = null;
for (var k = 0; k < nodesToRoot.length; k++) {
if (nodesToRoot[k].id === children[j]) {
child = nodesToRoot[k];
break;
}
}
if (child) {
child.bone._parent = nodeToRoot.bone;
nodeToRoot.bone.children.push(child.bone);
}
}
}
};
var printMat = function (m) {
console.log(m[0] + "\t" + m[1] + "\t" + m[2] + "\t" + m[3] + "\n" +
m[4] + "\t" + m[5] + "\t" + m[6] + "\t" + m[7] + "\n" +
m[8] + "\t" + m[9] + "\t" + m[10] + "\t" + m[11] + "\n" +
m[12] + "\t" + m[13] + "\t" + m[14] + "\t" + m[15] + "\n");
};
/**
* Imports a skeleton
*/
var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton, id) {
if (!newSkeleton) {
newSkeleton = new BABYLON.Skeleton(skins.name, "", gltfRuntime.scene);
}
if (!skins.babylonSkeleton) {
return newSkeleton;
}
// Matrices
var accessor = gltfRuntime.accessors[skins.inverseBindMatrices];
var buffer = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
var bindShapeMatrix = BABYLON.Matrix.FromArray(skins.bindShapeMatrix);
// Find the root bones
var nodesToRoot = [];
var nodesToRootToAdd = [];
getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
newSkeleton.bones = [];
// Joints
for (var i = 0; i < skins.jointNames.length; i++) {
var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
var node = jointNode.node;
if (!node) {
BABYLON.Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
continue;
}
var id = jointNode.id;
// Optimize, if the bone already exists...
var existingBone = gltfRuntime.scene.getBoneByID(id);
if (existingBone) {
newSkeleton.bones.push(existingBone);
continue;
}
// Search for parent bone
var foundBone = false;
var parentBone = null;
for (var j = 0; j < i; j++) {
var joint = getJointNode(gltfRuntime, skins.jointNames[j]).node;
if (!joint) {
BABYLON.Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
continue;
}
var children = joint.children;
foundBone = false;
for (var k = 0; k < children.length; k++) {
if (children[k] === id) {
parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
foundBone = true;
break;
}
}
if (foundBone) {
break;
}
}
// Create bone
var mat = configureBoneTransformation(node);
if (!parentBone && nodesToRoot.length > 0) {
parentBone = getNodeToRoot(nodesToRoot, id);
if (parentBone) {
if (nodesToRootToAdd.indexOf(parentBone) === -1) {
nodesToRootToAdd.push(parentBone);
}
}
}
var bone = new BABYLON.Bone(node.jointName, newSkeleton, parentBone, mat);
bone.id = id;
}
// Polish
var bones = newSkeleton.bones;
newSkeleton.bones = [];
for (var i = 0; i < skins.jointNames.length; i++) {
var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
if (!jointNode) {
continue;
}
for (var j = 0; j < bones.length; j++) {
if (bones[j].id === jointNode.id) {
newSkeleton.bones.push(bones[j]);
break;
}
}
}
newSkeleton.prepare();
// Finish
for (var i = 0; i < nodesToRootToAdd.length; i++) {
newSkeleton.bones.push(nodesToRootToAdd[i]);
}
return newSkeleton;
};
/**
* Imports a mesh and its geometries
*/
var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
if (!newMesh) {
newMesh = new BABYLON.Mesh(node.name, gltfRuntime.scene);
newMesh.id = id;
}
if (!node.babylonNode) {
return newMesh;
}
var multiMat = new BABYLON.MultiMaterial("multimat" + id, gltfRuntime.scene);
if (!newMesh.material) {
newMesh.material = multiMat;
}
var vertexData = new BABYLON.VertexData();
var geometry = new BABYLON.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
var verticesStarts = [];
var verticesCounts = [];
var indexStarts = [];
var indexCounts = [];
for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
var meshID = meshes[meshIndex];
var mesh = gltfRuntime.meshes[meshID];
if (!mesh) {
continue;
}
// Positions, normals and UVs
for (var i = 0; i < mesh.primitives.length; i++) {
// Temporary vertex data
var tempVertexData = new BABYLON.VertexData();
var primitive = mesh.primitives[i];
if (primitive.mode !== 4) {
// continue;
}
var attributes = primitive.attributes;
var accessor = null;
var buffer = null;
// Set positions, normal and uvs
for (var semantic in attributes) {
// Link accessor and buffer view
accessor = gltfRuntime.accessors[attributes[semantic]];
buffer = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
if (semantic === "NORMAL") {
tempVertexData.normals = new Float32Array(buffer.length);
tempVertexData.normals.set(buffer);
}
else if (semantic === "POSITION") {
if (BABYLON.GLTFFileLoader.HomogeneousCoordinates) {
tempVertexData.positions = new Float32Array(buffer.length - buffer.length / 4);
for (var j = 0; j < buffer.length; j += 4) {
tempVertexData.positions[j] = buffer[j];
tempVertexData.positions[j + 1] = buffer[j + 1];
tempVertexData.positions[j + 2] = buffer[j + 2];
}
}
else {
tempVertexData.positions = new Float32Array(buffer.length);
tempVertexData.positions.set(buffer);
}
verticesCounts.push(tempVertexData.positions.length);
}
else if (semantic.indexOf("TEXCOORD_") !== -1) {
var channel = Number(semantic.split("_")[1]);
var uvKind = BABYLON.VertexBuffer.UVKind + (channel === 0 ? "" : (channel + 1));
var uvs = new Float32Array(buffer.length);
uvs.set(buffer);
normalizeUVs(uvs);
tempVertexData.set(uvs, uvKind);
}
else if (semantic === "JOINT") {
tempVertexData.matricesIndices = new Float32Array(buffer.length);
tempVertexData.matricesIndices.set(buffer);
}
else if (semantic === "WEIGHT") {
tempVertexData.matricesWeights = new Float32Array(buffer.length);
tempVertexData.matricesWeights.set(buffer);
}
else if (semantic === "COLOR") {
tempVertexData.colors = new Float32Array(buffer.length);
tempVertexData.colors.set(buffer);
}
}
// Indices
accessor = gltfRuntime.accessors[primitive.indices];
if (accessor) {
buffer = GLTF1.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
tempVertexData.indices = new Int32Array(buffer.length);
tempVertexData.indices.set(buffer);
indexCounts.push(tempVertexData.indices.length);
}
else {
// Set indices on the fly
var indices = [];
for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
indices.push(j);
}
tempVertexData.indices = new Int32Array(indices);
indexCounts.push(tempVertexData.indices.length);
}
vertexData.merge(tempVertexData);
tempVertexData = undefined;
// Sub material
var material = gltfRuntime.scene.getMaterialByID(primitive.material);
multiMat.subMaterials.push(material === null ? GLTF1.GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material);
// Update vertices start and index start
verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
indexStarts.push(indexStarts.length === 0 ? 0 : indexStarts[indexStarts.length - 1] + indexCounts[indexCounts.length - 2]);
}
}
// Apply geometry
geometry.setAllVerticesData(vertexData, false);
newMesh.computeWorldMatrix(true);
// Apply submeshes
newMesh.subMeshes = [];
var index = 0;
for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
var meshID = meshes[meshIndex];
var mesh = gltfRuntime.meshes[meshID];
if (!mesh) {
continue;
}
for (var i = 0; i < mesh.primitives.length; i++) {
if (mesh.primitives[i].mode !== 4) {
//continue;
}
var subMesh = new BABYLON.SubMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
index++;
}
}
// Finish
return newMesh;
};
/**
* Configure node transformation from position, rotation and scaling
*/
var configureNode = function (newNode, position, rotation, scaling) {
if (newNode.position) {
newNode.position = position;
}
if (newNode.rotationQuaternion || newNode.rotation) {
newNode.rotationQuaternion = rotation;
}
if (newNode.scaling) {
newNode.scaling = scaling;
}
};
/**
* Configures node from transformation matrix
*/
var configureNodeFromMatrix = function (newNode, node, parent) {
if (node.matrix) {
var position = new BABYLON.Vector3(0, 0, 0);
var rotation = new BABYLON.Quaternion();
var scaling = new BABYLON.Vector3(0, 0, 0);
var mat = BABYLON.Matrix.FromArray(node.matrix);
mat.decompose(scaling, rotation, position);
configureNode(newNode, position, rotation, scaling);
}
else {
configureNode(newNode, BABYLON.Vector3.FromArray(node.translation), BABYLON.Quaternion.FromArray(node.rotation), BABYLON.Vector3.FromArray(node.scale));
}
newNode.computeWorldMatrix(true);
};
/**
* Imports a node
*/
var importNode = function (gltfRuntime, node, id, parent) {
var lastNode = null;
if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
if (gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name) === -1) {
return null;
}
}
// Meshes
if (node.skin) {
if (node.meshes) {
var skin = gltfRuntime.skins[node.skin];
var newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
newMesh.skeleton = gltfRuntime.scene.getLastSkeletonByID(node.skin);
if (newMesh.skeleton === null) {
newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton, node.skin);
if (!skin.babylonSkeleton) {
skin.babylonSkeleton = newMesh.skeleton;
}
}
lastNode = newMesh;
}
}
else if (node.meshes) {
/**
* Improve meshes property
*/
var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
lastNode = newMesh;
}
else if (node.light && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
var light = gltfRuntime.lights[node.light];
if (light) {
if (light.type === "ambient") {
var ambienLight = light[light.type];
var hemiLight = new BABYLON.HemisphericLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
hemiLight.name = node.name;
if (ambienLight.color) {
hemiLight.diffuse = BABYLON.Color3.FromArray(ambienLight.color);
}
lastNode = hemiLight;
}
else if (light.type === "directional") {
var directionalLight = light[light.type];
var dirLight = new BABYLON.DirectionalLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
dirLight.name = node.name;
if (directionalLight.color) {
dirLight.diffuse = BABYLON.Color3.FromArray(directionalLight.color);
}
lastNode = dirLight;
}
else if (light.type === "point") {
var pointLight = light[light.type];
var ptLight = new BABYLON.PointLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
ptLight.name = node.name;
if (pointLight.color) {
ptLight.diffuse = BABYLON.Color3.FromArray(pointLight.color);
}
lastNode = ptLight;
}
else if (light.type === "spot") {
var spotLight = light[light.type];
var spLight = new BABYLON.SpotLight(node.light, BABYLON.Vector3.Zero(), BABYLON.Vector3.Zero(), 0, 0, gltfRuntime.scene);
spLight.name = node.name;
if (spotLight.color) {
spLight.diffuse = BABYLON.Color3.FromArray(spotLight.color);
}
if (spotLight.fallOfAngle) {
spLight.angle = spotLight.fallOfAngle;
}
if (spotLight.fallOffExponent) {
spLight.exponent = spotLight.fallOffExponent;
}
lastNode = spLight;
}
}
}
else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
var camera = gltfRuntime.cameras[node.camera];
if (camera) {
if (camera.type === "orthographic") {
var orthographicCamera = camera[camera.type];
var orthoCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene);
orthoCamera.name = node.name;
orthoCamera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
orthoCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
lastNode = orthoCamera;
}