babylonjs-loaders
Version:
Babylon.js Loaders module =====================
1,183 lines (1,143 loc) • 1.45 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("babylonjs"));
else if(typeof define === 'function' && define.amd)
define("babylonjs-loaders", ["babylonjs"], factory);
else if(typeof exports === 'object')
exports["babylonjs-loaders"] = factory(require("babylonjs"));
else
root["LOADERS"] = factory(root["BABYLON"]);
})((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), (__WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_tools__) => {
return /******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ "../../../dev/loaders/src/glTF/1.0/glTFBinaryExtension.ts":
/*!****************************************************************!*\
!*** ../../../dev/loaders/src/glTF/1.0/glTFBinaryExtension.ts ***!
\****************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ GLTFBinaryExtension: () => (/* binding */ GLTFBinaryExtension)
/* harmony export */ });
/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! tslib */ "../../../../node_modules/tslib/tslib.es6.mjs");
/* harmony import */ var _glTFLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoader */ "../../../dev/loaders/src/glTF/1.0/glTFLoader.ts");
/* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./glTFLoaderUtils */ "../../../dev/loaders/src/glTF/1.0/glTFLoaderUtils.ts");
/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../dev/loaders/src/glTF/1.0/glTFLoaderInterfaces.ts");
var BinaryExtensionBufferName = "binary_glTF";
/**
* @internal
* @deprecated
*/
var GLTFBinaryExtension = /** @class */ (function (_super) {
(0,tslib__WEBPACK_IMPORTED_MODULE_3__.__extends)(GLTFBinaryExtension, _super);
function GLTFBinaryExtension() {
return _super.call(this, "KHR_binary_glTF") || this;
}
GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess) {
var extensionsUsed = data.json.extensionsUsed;
if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) {
return false;
}
this._bin = data.bin;
onSuccess(_glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
return true;
};
GLTFBinaryExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
if (gltfRuntime.extensionsUsed.indexOf(this.name) === -1) {
return false;
}
if (id !== BinaryExtensionBufferName) {
return false;
}
this._bin.readAsync(0, this._bin.byteLength).then(onSuccess, function (error) { return onError(error.message); });
return true;
};
GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess) {
var texture = gltfRuntime.textures[id];
var source = gltfRuntime.images[texture.source];
if (!source.extensions || !(this.name in source.extensions)) {
return false;
}
var sourceExt = source.extensions[this.name];
var bufferView = gltfRuntime.bufferViews[sourceExt.bufferView];
var buffer = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_1__.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EComponentType.UNSIGNED_BYTE);
onSuccess(buffer);
return true;
};
GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess) {
var shader = gltfRuntime.shaders[id];
if (!shader.extensions || !(this.name in shader.extensions)) {
return false;
}
var binaryExtensionShader = shader.extensions[this.name];
var bufferView = gltfRuntime.bufferViews[binaryExtensionShader.bufferView];
var shaderBytes = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_1__.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_2__.EComponentType.UNSIGNED_BYTE);
setTimeout(function () {
var shaderString = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_1__.GLTFUtils.DecodeBufferToText(shaderBytes);
onSuccess(shaderString);
});
return true;
};
return GLTFBinaryExtension;
}(_glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoaderExtension));
_glTFLoader__WEBPACK_IMPORTED_MODULE_0__.GLTFLoader.RegisterExtension(new GLTFBinaryExtension());
/***/ }),
/***/ "../../../dev/loaders/src/glTF/1.0/glTFLoader.ts":
/*!*******************************************************!*\
!*** ../../../dev/loaders/src/glTF/1.0/glTFLoader.ts ***!
\*******************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ GLTFLoader: () => (/* binding */ GLTFLoader),
/* harmony export */ GLTFLoaderBase: () => (/* binding */ GLTFLoaderBase),
/* harmony export */ GLTFLoaderExtension: () => (/* binding */ GLTFLoaderExtension)
/* harmony export */ });
/* harmony import */ var _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./glTFLoaderInterfaces */ "../../../dev/loaders/src/glTF/1.0/glTFLoaderInterfaces.ts");
/* harmony import */ var babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! babylonjs/Engines/constants */ "babylonjs/Misc/tools");
/* harmony import */ var babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./glTFLoaderUtils */ "../../../dev/loaders/src/glTF/1.0/glTFLoaderUtils.ts");
/* harmony import */ var _glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../glTFFileLoader */ "../../../dev/loaders/src/glTF/glTFFileLoader.ts");
/**
* 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 = /** @class */ (function () {
function Tokenizer(toParse) {
this._pos = 0;
this.currentToken = ETokenType.UNKNOWN;
this.currentIdentifier = "";
this.currentString = "";
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
* @param parsedBuffers
* @param gltfRuntime
*/
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
* @param buffer
*/
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 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 && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
var channel = Number(attributeParameter.semantic.split("_")[1]);
return "uv" + (channel === 0 ? "" : channel + 1);
}
return null;
};
/**
* Loads and creates animations
* @param gltfRuntime
*/
var loadAnimations = function (gltfRuntime) {
for (var anim in gltfRuntime.animations) {
var animation = gltfRuntime.animations[anim];
if (!animation.channels || !animation.samplers) {
continue;
}
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 = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
var bufferOutput = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.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) {
babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetId + " to attach to");
continue;
}
var isBone = targetNode instanceof babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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 = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_MATRIX;
if (!isBone) {
if (targetPath === "rotationQuaternion") {
animationType = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONTYPE_QUATERNION;
targetNode.rotationQuaternion = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
}
else {
animationType = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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) {
gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
babylonAnimation = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Animation.ANIMATIONLOOPMODE_CYCLE);
gltfRuntime.scene._blockEntityCollection = false;
}
// For each frame
for (var j = 0; j < bufferInput.length; j++) {
var value = null;
if (targetPath === "rotationQuaternion") {
// VEC4
value = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
arrayOffset += 4;
}
else {
// Position and scaling are VEC3
value = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
arrayOffset += 3;
}
if (isBone) {
var bone = targetNode;
var translation = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero();
var rotationQuaternion = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
var scaling = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero();
// Warning on decompose
var mat = bone.getBaseMatrix();
if (modifyKey && lastAnimation) {
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 = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Compose(scaling, rotationQuaternion, translation);
}
if (!modifyKey) {
keys.push({
frame: bufferInput[j],
value: value,
});
}
else if (lastAnimation) {
lastAnimation.getKeys()[j].value = value;
}
}
// Finish
if (!modifyKey && babylonAnimation) {
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
* @param node
*/
var configureBoneTransformation = function (node) {
var mat = null;
if (node.translation || node.rotation || node.scale) {
var scale = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.scale || [1, 1, 1]);
var rotation = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
var position = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.translation || [0, 0, 0]);
mat = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.Compose(scale, rotation, position);
}
else {
mat = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(node.matrix);
}
return mat;
};
/**
* Returns the parent bone
* @param gltfRuntime
* @param skins
* @param jointName
* @param newSkeleton
* @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 babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Bone(node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
bone.id = nde;
return bone;
}
}
}
return null;
};
/**
* Returns the appropriate root node
* @param nodesToRoot
* @param id
* @returns the 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
* @param gltfRuntime
* @param jointName
* @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
* @param skins
* @param id
* @returns true if the node is in joints, else false
*/
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
* @param gltfRuntime
* @param newSkeleton
* @param skins
* @param nodesToRoot
*/
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 babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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);
}
}
}
};
/**
* Imports a skeleton
* @param gltfRuntime
* @param skins
* @param mesh
* @param newSkeleton
* @returns the bone name
*/
var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
if (!newSkeleton) {
newSkeleton = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Skeleton(skins.name || "", "", gltfRuntime.scene);
}
if (!skins.babylonSkeleton) {
return newSkeleton;
}
// 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]);
if (!jointNode) {
continue;
}
var node = jointNode.node;
if (!node) {
babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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 jointNode_1 = getJointNode(gltfRuntime, skins.jointNames[j]);
if (!jointNode_1) {
continue;
}
var joint = jointNode_1.node;
if (!joint) {
babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
continue;
}
var children = joint.children;
if (!children) {
continue;
}
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 babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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
* @param gltfRuntime
* @param node
* @param meshes
* @param id
* @param newMesh
* @returns the new mesh
*/
var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
if (!newMesh) {
gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
newMesh = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh(node.name || "", gltfRuntime.scene);
newMesh._parentContainer = gltfRuntime.assetContainer;
gltfRuntime.scene._blockEntityCollection = false;
newMesh.id = id;
}
if (!node.babylonNode) {
return newMesh;
}
var subMaterials = [];
var vertexData = null;
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 babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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 = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
if (semantic === "NORMAL") {
tempVertexData.normals = new Float32Array(buffer.length);
tempVertexData.normals.set(buffer);
}
else if (semantic === "POSITION") {
if (_glTFFileLoader__WEBPACK_IMPORTED_MODULE_3__.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 = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.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 = _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.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);
}
if (!vertexData) {
vertexData = tempVertexData;
}
else {
vertexData.merge(tempVertexData);
}
// Sub material
var material_1 = gltfRuntime.scene.getMaterialById(primitive.material);
subMaterials.push(material_1 === null ? _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material_1);
// 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]);
}
}
var material;
gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
if (subMaterials.length > 1) {
material = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.MultiMaterial("multimat" + id, gltfRuntime.scene);
material.subMaterials = subMaterials;
}
else {
material = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.StandardMaterial("multimat" + id, gltfRuntime.scene);
}
if (subMaterials.length === 1) {
material = subMaterials[0];
}
material._parentContainer = gltfRuntime.assetContainer;
if (!newMesh.material) {
newMesh.material = material;
}
// Apply geometry
new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
newMesh.computeWorldMatrix(true);
gltfRuntime.scene._blockEntityCollection = false;
// 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;
}
babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.SubMesh.AddToMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
index++;
}
}
// Finish
return newMesh;
};
/**
* Configure node transformation from position, rotation and scaling
* @param newNode
* @param position
* @param rotation
* @param 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
* @param newNode
* @param node
*/
var configureNodeFromMatrix = function (newNode, node) {
if (node.matrix) {
var position = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3(0, 0, 0);
var rotation = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion();
var scaling = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3(0, 0, 0);
var mat = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Matrix.FromArray(node.matrix);
mat.decompose(scaling, rotation, position);
configureNode(newNode, position, rotation, scaling);
}
else if (node.translation && node.rotation && node.scale) {
configureNode(newNode, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.translation), babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(node.rotation), babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(node.scale));
}
newNode.computeWorldMatrix(true);
};
/**
* Imports a node
* @param gltfRuntime
* @param node
* @param id
* @returns the newly imported node
*/
var importNode = function (gltfRuntime, node, id) {
var lastNode = null;
if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
if (gltfRuntime.importMeshesNames && 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);
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;
}
// Lights
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 babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.HemisphericLight(node.light, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
hemiLight.name = node.name || "";
if (ambienLight.color) {
hemiLight.diffuse = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(ambienLight.color);
}
lastNode = hemiLight;
}
else if (light.type === "directional") {
var directionalLight = light[light.type];
var dirLight = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.DirectionalLight(node.light, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
dirLight.name = node.name || "";
if (directionalLight.color) {
dirLight.diffuse = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(directionalLight.color);
}
lastNode = dirLight;
}
else if (light.type === "point") {
var pointLight = light[light.type];
var ptLight = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.PointLight(node.light, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene);
ptLight.name = node.name || "";
if (pointLight.color) {
ptLight.diffuse = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(pointLight.color);
}
lastNode = ptLight;
}
else if (light.type === "spot") {
var spotLight = light[light.type];
var spLight = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.SpotLight(node.light, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), 0, 0, gltfRuntime.scene);
spLight.name = node.name || "";
if (spotLight.color) {
spLight.diffuse = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Color3.FromArray(spotLight.color);
}
if (spotLight.fallOfAngle) {
spLight.angle = spotLight.fallOfAngle;
}
if (spotLight.fallOffExponent) {
spLight.exponent = spotLight.fallOffExponent;
}
lastNode = spLight;
}
}
}
// Cameras
else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
var camera = gltfRuntime.cameras[node.camera];
if (camera) {
gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
if (camera.type === "orthographic") {
var orthoCamera = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.FreeCamera(node.camera, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene, false);
orthoCamera.name = node.name || "";
orthoCamera.mode = babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Camera.ORTHOGRAPHIC_CAMERA;
orthoCamera.attachControl();
lastNode = orthoCamera;
orthoCamera._parentContainer = gltfRuntime.assetContainer;
}
else if (camera.type === "perspective") {
var perspectiveCamera = camera[camera.type];
var persCamera = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.FreeCamera(node.camera, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.Zero(), gltfRuntime.scene, false);
persCamera.name = node.name || "";
persCamera.attachControl();
if (!perspectiveCamera.aspectRatio) {
perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
}
if (perspectiveCamera.znear && perspectiveCamera.zfar) {
persCamera.maxZ = perspectiveCamera.zfar;
persCamera.minZ = perspectiveCamera.znear;
}
lastNode = persCamera;
persCamera._parentContainer = gltfRuntime.assetContainer;
}
gltfRuntime.scene._blockEntityCollection = false;
}
}
// Empty node
if (!node.jointName) {
if (node.babylonNode) {
return node.babylonNode;
}
else if (lastNode === null) {
gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
var dummy = new babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh(node.name || "", gltfRuntime.scene);
dummy._parentContainer = gltfRuntime.assetContainer;
gltfRuntime.scene._blockEntityCollection = false;
node.babylonNode = dummy;
lastNode = dummy;
}
}
if (lastNode !== null) {
if (node.matrix && lastNode instanceof babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Mesh) {
configureNodeFromMatrix(lastNode, node);
}
else {
var translation = node.translation || [0, 0, 0];
var rotation = node.rotation || [0, 0, 0, 1];
var scale = node.scale || [1, 1, 1];
configureNode(lastNode, babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(translation), babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Quaternion.FromArray(rotation), babylonjs_Maths_math_vector__WEBPACK_IMPORTED_MODULE_1__.Vector3.FromArray(scale));
}
lastNode.updateCache(true);
node.babylonNode = lastNode;
}
return lastNode;
};
/**
* Traverses nodes and creates them
* @param gltfRuntime
* @param id
* @param parent
* @param meshIncluded
*/
var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
if (meshIncluded === void 0) { meshIncluded = false; }
var node = gltfRuntime.nodes[id];
var newNode = null;
if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
meshIncluded = true;
}
else {
meshIncluded = false;
}
}
else {
meshIncluded = true;
}
if (!node.jointName && meshIncluded) {
newNode = importNode(gltfRuntime, node, id);
if (newNode !== null) {
newNode.id = id;
newNode.parent = parent;
}
}
if (node.children) {
for (var i = 0; i < node.children.length; i++) {
traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
}
}
};
/**
* do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
* @param gltfRuntime
*/
var postLoad = function (gltfRuntime) {
// Nodes
var currentScene = gltfRuntime.currentScene;
if (currentScene) {
for (var i = 0; i < currentScene.nodes.length; i++) {
traverseNodes(gltfRuntime, currentScene.nodes[i], null);
}
}
else {
for (var thing in gltfRuntime.scenes) {
currentScene = gltfRuntime.scenes[thing];
for (var i = 0; i < currentScene.nodes.length; i++) {
traverseNodes(gltfRuntime, currentScene.nodes[i], null);
}
}
}
// Set animations
loadAnimations(gltfRuntime);
for (var i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
var skeleton = gltfRuntime.scene.skeletons[i];
gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
}
};
/**
* onBind shaderrs callback to set uniforms and matrices
* @param mesh
* @param gltfRuntime
* @param unTreatedUniforms
* @param shaderMaterial
* @param technique
* @param material
* @param onSuccess
*/
var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) {
var materialValues = material.values || technique.parameters;
for (var unif in unTreatedUniforms) {
var uniform = unTreatedUniforms[unif];
var type = uniform.type;
if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT2 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT3 || type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.FLOAT_MAT4) {
if (uniform.semantic && !uniform.source && !uniform.node) {
_glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetMatrix(gltfRuntime.scene, mesh, uniform, unif, shaderMaterial.getEffect());
}
else if (uniform.semantic && (uniform.source || uniform.node)) {
var source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node || "");
if (source === null) {
source = gltfRuntime.scene.getNodeById(uniform.source || uniform.node || "");
}
if (source === null) {
continue;
}
_glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
}
}
else {
var value = materialValues[technique.uniforms[unif]];
if (!value) {
continue;
}
if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.SAMPLER_2D) {
var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
if (texture === null || texture === undefined) {
continue;
}
shaderMaterial.getEffect().setTexture(unif, texture);
}
else {
_glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetUniform(shaderMaterial.getEffect(), unif, value, type);
}
}
}
onSuccess(shaderMaterial);
};
/**
* Prepare uniforms to send the only one time
* Loads the appropriate textures
* @param gltfRuntime
* @param shaderMaterial
* @param technique
* @param material
*/
var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
var materialValues = material.values || technique.parameters;
var techniqueUniforms = technique.uniforms;
var _loop_1 = function (unif) {
var uniform = unTreatedUniforms[unif];
var type = uniform.type;
var value = materialValues[techniqueUniforms[unif]];
if (value === undefined) {
// In case the value is the same for all materials
value = uniform.value;
}
if (!value) {
return "continue";
}
var onLoadTexture = function (uniformName) {
return function (texture) {
if (uniform.value && uniformName) {
// Static uniform
shaderMaterial.setTexture(uniformName, texture);
delete unTreatedUniforms[uniformName];
}
};
};
// Texture (sampler2D)
if (type === _glTFLoaderInterfaces__WEBPACK_IMPORTED_MODULE_0__.EParameterType.SAMPLER_2D) {
GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
}
// Others
else {
if (uniform.value && _glTFLoaderUtils__WEBPACK_IMPORTED_MODULE_2__.GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
// Static uniform
delete unTreatedUniforms[unif];
}
}
};
/**
* Prepare values here (not matrices)
*/
for (var unif in unTreatedUniforms) {
_loop_1(unif);
}
};
/**
* Shader compilation failed
* @param program
* @param shaderMaterial
* @param onError
* @returns callback when shader is compiled
*/
var onShaderCompileError = function (program, shaderMaterial, onError) {
return function (effect, error) {
shaderMaterial.dispose(true);
onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
};
};
/**
* Shader compilation success
* @param gltfRuntime
* @param shaderMaterial
* @param technique
* @param material
* @param unTreatedUniforms
* @param onSuccess
* @returns callback when shader is compiled
*/
var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) {
return function (_) {
prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
shaderMaterial.onBind = function (mesh) {
onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
};
};
};
/**
* Returns the appropriate uniform if already handled by babylon
* @param tokenizer
* @param technique
* @param unTreatedUniforms
* @returns the name of the uniform handled by babylon
*/
var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
for (var unif in technique.uniforms) {
var uniform = technique.uniforms[unif];
var uniformParameter = technique.parameters[uniform];
if (tokenizer.currentIdentifier === unif) {