/// var BABYLON; (function (BABYLON) { /** * Coordinate system mode that will be used when loading from the gltf file */ var GLTFLoaderCoordinateSystemMode; (function (GLTFLoaderCoordinateSystemMode) { /** * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene. */ GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["AUTO"] = 0] = "AUTO"; /** * Sets the useRightHandedSystem flag on the scene. */ GLTFLoaderCoordinateSystemMode[GLTFLoaderCoordinateSystemMode["FORCE_RIGHT_HANDED"] = 1] = "FORCE_RIGHT_HANDED"; })(GLTFLoaderCoordinateSystemMode = BABYLON.GLTFLoaderCoordinateSystemMode || (BABYLON.GLTFLoaderCoordinateSystemMode = {})); /** * Animation mode that determines which animations should be started when a file is loaded */ var GLTFLoaderAnimationStartMode; (function (GLTFLoaderAnimationStartMode) { /** * No animation will start. */ GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["NONE"] = 0] = "NONE"; /** * The first animation will start. */ GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["FIRST"] = 1] = "FIRST"; /** * All animations will start. */ GLTFLoaderAnimationStartMode[GLTFLoaderAnimationStartMode["ALL"] = 2] = "ALL"; })(GLTFLoaderAnimationStartMode = BABYLON.GLTFLoaderAnimationStartMode || (BABYLON.GLTFLoaderAnimationStartMode = {})); /** * Loading state */ var GLTFLoaderState; (function (GLTFLoaderState) { /** * The asset is loading. */ GLTFLoaderState[GLTFLoaderState["LOADING"] = 0] = "LOADING"; /** * The asset is ready for rendering. */ GLTFLoaderState[GLTFLoaderState["READY"] = 1] = "READY"; /** * The asset is completely loaded. */ GLTFLoaderState[GLTFLoaderState["COMPLETE"] = 2] = "COMPLETE"; })(GLTFLoaderState = BABYLON.GLTFLoaderState || (BABYLON.GLTFLoaderState = {})); /** File loader to load gltf files into a babylon scene */ var GLTFFileLoader = /** @class */ (function () { function GLTFFileLoader() { // #region Common options /** * Raised when the asset has been parsed. * The data.json property stores the glTF JSON. * The data.bin property stores the BIN chunk from a glTF binary or null if the input is not a glTF binary. */ this.onParsedObservable = new BABYLON.Observable(); // #endregion // #region V2 options /** * The coordinate system mode (AUTO, FORCE_RIGHT_HANDED). Defaults to AUTO. * - AUTO - Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene. * - FORCE_RIGHT_HANDED - Sets the useRightHandedSystem flag on the scene. */ this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO; /** * The animation start mode (NONE, FIRST, ALL). Defaults to FIRST. * - NONE - No animation will start. * - FIRST - The first animation will start. * - ALL - All animations will start. */ this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST; /** * Set to true to compile materials before raising the success callback. Defaults to false. */ this.compileMaterials = false; /** * Set to true to also compile materials with clip planes. Defaults to false. */ this.useClipPlane = false; /** * Set to true to compile shadow generators before raising the success callback. Defaults to false. */ this.compileShadowGenerators = false; /** * Raised when the loader creates a mesh after parsing the glTF properties of the mesh. */ this.onMeshLoadedObservable = new BABYLON.Observable(); /** * Raised when the loader creates a texture after parsing the glTF properties of the texture. */ this.onTextureLoadedObservable = new BABYLON.Observable(); /** * Raised when the loader creates a material after parsing the glTF properties of the material. */ this.onMaterialLoadedObservable = new BABYLON.Observable(); /** * Raised when the asset is completely loaded, immediately before the loader is disposed. * For assets with LODs, raised when all of the LODs are complete. * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise. */ this.onCompleteObservable = new BABYLON.Observable(); /** * Raised after the loader is disposed. */ this.onDisposeObservable = new BABYLON.Observable(); /** * Raised after a loader extension is created. * Set additional options for a loader extension in this event. */ this.onExtensionLoadedObservable = new BABYLON.Observable(); // #endregion this._loader = null; /** * Name of the loader ("gltf") */ this.name = "gltf"; /** * Supported file extensions of the loader (.gltf, .glb) */ this.extensions = { ".gltf": { isBinary: false }, ".glb": { isBinary: true } }; } Object.defineProperty(GLTFFileLoader.prototype, "onParsed", { /** Raised when the asset has been parsed. */ set: function (callback) { if (this._onParsedObserver) { this.onParsedObservable.remove(this._onParsedObserver); } this._onParsedObserver = this.onParsedObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onMeshLoaded", { /** * Raised when the loader creates a mesh after parsing the glTF properties of the mesh. (onMeshLoadedObservable is likely desired instead.) */ set: function (callback) { if (this._onMeshLoadedObserver) { this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver); } this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onTextureLoaded", { /** * Method called when a texture has been loaded (onTextureLoadedObservable is likely desired instead.) */ set: function (callback) { if (this._onTextureLoadedObserver) { this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver); } this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onMaterialLoaded", { /** * Method when the loader creates a material after parsing the glTF properties of the material. (onMaterialLoadedObservable is likely desired instead.) */ set: function (callback) { if (this._onMaterialLoadedObserver) { this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver); } this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onComplete", { /** * Raised when the asset is completely loaded, immediately before the loader is disposed. (onCompleteObservable is likely desired instead.) */ set: function (callback) { if (this._onCompleteObserver) { this.onCompleteObservable.remove(this._onCompleteObserver); } this._onCompleteObserver = this.onCompleteObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onDispose", { /** * Raised after the loader is disposed. (onDisposeObservable is likely desired instead.) */ set: function (callback) { if (this._onDisposeObserver) { this.onDisposeObservable.remove(this._onDisposeObserver); } this._onDisposeObserver = this.onDisposeObservable.add(callback); }, enumerable: true, configurable: true }); Object.defineProperty(GLTFFileLoader.prototype, "onExtensionLoaded", { /** * Raised after a loader extension is created. (onExtensionLoadedObservable is likely desired instead.) */ set: function (callback) { if (this._onExtensionLoadedObserver) { this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver); } this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback); }, enumerable: true, configurable: true }); /** * Returns a promise that resolves when the asset is completely loaded. * @returns A promise that resolves when the asset is completely loaded. */ GLTFFileLoader.prototype.whenCompleteAsync = function () { var _this = this; return new Promise(function (resolve) { _this.onCompleteObservable.add(function () { resolve(); }, undefined, undefined, undefined, true); }); }; Object.defineProperty(GLTFFileLoader.prototype, "loaderState", { /** * The loader state (LOADING, READY, COMPLETE) or null if the loader is not active. */ get: function () { return this._loader ? this._loader.state : null; }, enumerable: true, configurable: true }); /** * Disposes the loader, releases resources during load, and cancels any outstanding requests. */ GLTFFileLoader.prototype.dispose = function () { if (this._loader) { this._loader.dispose(); this._loader = null; } this.onMeshLoadedObservable.clear(); this.onTextureLoadedObservable.clear(); this.onMaterialLoadedObservable.clear(); this.onDisposeObservable.notifyObservers(this); this.onDisposeObservable.clear(); }; /** * Imports one or more meshes from a loaded gltf file and adds them to the scene * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file * @param scene the scene the meshes should be added to * @param data gltf data containing information of the meshes in a loaded file * @param rootUrl root url to load from * @param onProgress event that fires when loading progress has occured * @returns a promise containg the loaded meshes, particles, skeletons and animations */ GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress) { var _this = this; return Promise.resolve().then(function () { var loaderData = _this._parse(data); _this._loader = _this._getLoader(loaderData); return _this._loader.importMeshAsync(meshesNames, scene, loaderData, rootUrl, onProgress); }); }; /** * Imports all objects from a loaded gltf file and adds them to the scene * @param scene the scene the objects should be added to * @param data gltf data containing information of the meshes in a loaded file * @param rootUrl root url to load from * @param onProgress event that fires when loading progress has occured * @returns a promise which completes when objects have been loaded to the scene */ GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress) { var _this = this; return Promise.resolve().then(function () { var loaderData = _this._parse(data); _this._loader = _this._getLoader(loaderData); return _this._loader.loadAsync(scene, loaderData, rootUrl, onProgress); }); }; /** * Load into an asset container. * @param scene The scene to load into * @param data The data to import * @param rootUrl The root url for scene and resources * @param onProgress The callback when the load progresses * @returns The loaded asset container */ GLTFFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress) { var _this = this; return Promise.resolve().then(function () { var loaderData = _this._parse(data); _this._loader = _this._getLoader(loaderData); return _this._loader.importMeshAsync(null, scene, loaderData, rootUrl, onProgress).then(function (result) { var container = new BABYLON.AssetContainer(scene); Array.prototype.push.apply(container.meshes, result.meshes); Array.prototype.push.apply(container.particleSystems, result.particleSystems); Array.prototype.push.apply(container.skeletons, result.skeletons); Array.prototype.push.apply(container.animationGroups, result.animationGroups); container.removeAllFromScene(); return container; }); }); }; /** * If the data string can be loaded directly * @param data string contianing the file data * @returns if the data can be loaded directly */ GLTFFileLoader.prototype.canDirectLoad = function (data) { return ((data.indexOf("scene") !== -1) && (data.indexOf("node") !== -1)); }; /** * Instantiates a gltf file loader plugin * @returns the created plugin */ GLTFFileLoader.prototype.createPlugin = function () { return new GLTFFileLoader(); }; GLTFFileLoader.prototype._parse = function (data) { var parsedData; if (data instanceof ArrayBuffer) { parsedData = GLTFFileLoader._parseBinary(data); } else { parsedData = { json: JSON.parse(data), bin: null }; } this.onParsedObservable.notifyObservers(parsedData); this.onParsedObservable.clear(); return parsedData; }; GLTFFileLoader.prototype._getLoader = function (loaderData) { var _this = this; var loaderVersion = { major: 2, minor: 0 }; var asset = loaderData.json.asset || {}; var version = GLTFFileLoader._parseVersion(asset.version); if (!version) { throw new Error("Invalid version: " + asset.version); } if (asset.minVersion !== undefined) { var minVersion = GLTFFileLoader._parseVersion(asset.minVersion); if (!minVersion) { throw new Error("Invalid minimum version: " + asset.minVersion); } if (GLTFFileLoader._compareVersion(minVersion, loaderVersion) > 0) { throw new Error("Incompatible minimum version: " + asset.minVersion); } } var createLoaders = { 1: GLTFFileLoader.CreateGLTFLoaderV1, 2: GLTFFileLoader.CreateGLTFLoaderV2 }; var createLoader = createLoaders[version.major]; if (!createLoader) { throw new Error("Unsupported version: " + asset.version); } var loader = createLoader(); loader.coordinateSystemMode = this.coordinateSystemMode; loader.animationStartMode = this.animationStartMode; loader.compileMaterials = this.compileMaterials; loader.useClipPlane = this.useClipPlane; loader.compileShadowGenerators = this.compileShadowGenerators; loader.onMeshLoadedObservable.add(function (mesh) { return _this.onMeshLoadedObservable.notifyObservers(mesh); }); loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); }); loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); }); loader.onExtensionLoadedObservable.add(function (extension) { return _this.onExtensionLoadedObservable.notifyObservers(extension); }); loader.onCompleteObservable.add(function () { _this.onMeshLoadedObservable.clear(); _this.onTextureLoadedObservable.clear(); _this.onMaterialLoadedObservable.clear(); _this.onCompleteObservable.notifyObservers(_this); _this.onCompleteObservable.clear(); }); return loader; }; GLTFFileLoader._parseBinary = function (data) { var Binary = { Magic: 0x46546C67 }; var binaryReader = new BinaryReader(data); var magic = binaryReader.readUint32(); if (magic !== Binary.Magic) { throw new Error("Unexpected magic: " + magic); } var version = binaryReader.readUint32(); switch (version) { case 1: return GLTFFileLoader._parseV1(binaryReader); case 2: return GLTFFileLoader._parseV2(binaryReader); } throw new Error("Unsupported version: " + version); }; GLTFFileLoader._parseV1 = function (binaryReader) { var ContentFormat = { JSON: 0 }; var length = binaryReader.readUint32(); if (length != binaryReader.getLength()) { throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength()); } 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: { throw new Error("Unexpected content format: " + contentFormat); } } 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()) { throw new Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength()); } // JSON chunk var chunkLength = binaryReader.readUint32(); var chunkFormat = binaryReader.readUint32(); if (chunkFormat !== ChunkFormat.JSON) { throw new Error("First chunk format is not JSON"); } var json = JSON.parse(GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(chunkLength))); // Look for BIN chunk var bin = null; while (binaryReader.getPosition() < binaryReader.getLength()) { var chunkLength_1 = binaryReader.readUint32(); var chunkFormat_1 = binaryReader.readUint32(); switch (chunkFormat_1) { case ChunkFormat.JSON: { throw new Error("Unexpected JSON chunk"); } case ChunkFormat.BIN: { bin = binaryReader.readUint8Array(chunkLength_1); break; } default: { // ignore unrecognized chunkFormat binaryReader.skipBytes(chunkLength_1); break; } } } return { json: json, bin: bin }; }; GLTFFileLoader._parseVersion = function (version) { if (version === "1.0" || version === "1.0.1") { return { major: 1, minor: 0 }; } var match = (version + "").match(/^(\d+)\.(\d+)/); if (!match) { return null; } return { major: parseInt(match[1]), minor: parseInt(match[2]) }; }; 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 (buffer) { var result = ""; var length = buffer.byteLength; for (var i = 0; i < length; i++) { result += String.fromCharCode(buffer[i]); } return result; }; // #endregion // #region V1 options /** * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders. Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled. Defaults to true. */ GLTFFileLoader.IncrementalLoading = true; /** * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters. Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates */ GLTFFileLoader.HomogeneousCoordinates = false; return GLTFFileLoader; }()); BABYLON.GLTFFileLoader = GLTFFileLoader; var BinaryReader = /** @class */ (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; }()); if (BABYLON.SceneLoader) { BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader()); } })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFFileLoader.js.map /// 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 /// 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 = /** @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 */ 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 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 */ 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 = 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") { // VEC4 value = BABYLON.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]); arrayOffset += 4; } else { // Position and scaling are VEC3 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 && 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 = BABYLON.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 */ 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); } } } }; /** * 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; } // 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) { 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 jointNode_1 = getJointNode(gltfRuntime, skins.jointNames[j]); if (!jointNode_1) { continue; } var joint = jointNode_1.node; if (!joint) { BABYLON.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 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 subMaterials = []; var vertexData = null; var verticesStarts = new Array(); var verticesCounts = new Array(); var indexStarts = new Array(); var indexCounts = new Array(); 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); } if (!vertexData) { vertexData = tempVertexData; } else { vertexData.merge(tempVertexData); } // Sub material var material_1 = gltfRuntime.scene.getMaterialByID(primitive.material); subMaterials.push(material_1 === null ? GLTF1.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; if (subMaterials.length > 1) { material = new BABYLON.MultiMaterial("multimat" + id, gltfRuntime.scene); material.subMaterials = subMaterials; } else { material = new BABYLON.StandardMaterial("multimat" + id, gltfRuntime.scene); } if (subMaterials.length === 1) { material = subMaterials[0]; } if (!newMesh.material) { newMesh.material = material; } // Apply geometry new BABYLON.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh); 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; } BABYLON.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 */ 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 if (node.translation && node.rotation && node.scale) { 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 && 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; } // 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 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; } } } // Cameras else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) { var camera = gltfRuntime.cameras[node.camera]; if (camera) { if (camera.type === "orthographic") { 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; } else if (camera.type === "perspective") { var perspectiveCamera = camera[camera.type]; var persCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene); persCamera.name = node.name || ""; persCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas()); 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; } } } // Empty node if (!node.jointName) { if (node.babylonNode) { return node.babylonNode; } else if (lastNode === null) { var dummy = new BABYLON.Mesh(node.name || "", gltfRuntime.scene); node.babylonNode = dummy; lastNode = dummy; } } if (lastNode !== null) { if (node.matrix && lastNode instanceof BABYLON.Mesh) { configureNodeFromMatrix(lastNode, node, parent); } 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, BABYLON.Vector3.FromArray(translation), BABYLON.Quaternion.FromArray(rotation), BABYLON.Vector3.FromArray(scale)); } lastNode.updateCache(true); node.babylonNode = lastNode; } return lastNode; }; /** * Traverses nodes and creates them */ 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, parent); 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.) */ 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 */ 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 === GLTF1.EParameterType.FLOAT_MAT2 || type === GLTF1.EParameterType.FLOAT_MAT3 || type === GLTF1.EParameterType.FLOAT_MAT4) { if (uniform.semantic && !uniform.source && !uniform.node) { GLTF1.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; } GLTF1.GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect()); } } else { var value = materialValues[technique.uniforms[unif]]; if (!value) { continue; } if (type === GLTF1.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 { GLTF1.GLTFUtils.SetUniform((shaderMaterial.getEffect()), unif, value, type); } } } onSuccess(shaderMaterial); }; /** * Prepare uniforms to send the only one time * Loads the appropriate textures */ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) { var materialValues = material.values || technique.parameters; var techniqueUniforms = technique.uniforms; /** * Prepare values here (not matrices) */ for (var unif in unTreatedUniforms) { 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) { 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 === GLTF1.EParameterType.SAMPLER_2D) { GLTF1.GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); }); } // Others else { if (uniform.value && GLTF1.GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) { // Static uniform delete unTreatedUniforms[unif]; } } } }; /** * Shader compilation failed */ 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 */ 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 */ 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) { if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) { var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic); if (transformIndex !== -1) { delete unTreatedUniforms[unif]; return babylonTransforms[transformIndex]; } } } } return tokenizer.currentIdentifier; }; /** * All shaders loaded. Create materials one by one */ var importMaterials = function (gltfRuntime) { // Create materials for (var mat in gltfRuntime.materials) { GLTF1.GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function (material) { }, function () { }); } }; /** * Implementation of the base glTF spec */ var GLTFLoaderBase = /** @class */ (function () { function GLTFLoaderBase() { } GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) { var gltfRuntime = { extensions: {}, accessors: {}, buffers: {}, bufferViews: {}, meshes: {}, lights: {}, cameras: {}, nodes: {}, images: {}, textures: {}, shaders: {}, programs: {}, samplers: {}, techniques: {}, materials: {}, animations: {}, skins: {}, extensionsUsed: [], scenes: {}, buffersCount: 0, shaderscount: 0, scene: scene, rootUrl: rootUrl, loadedBufferCount: 0, loadedBufferViews: {}, loadedShaderCount: 0, importOnlyMeshes: false, dummyNodes: [] }; // Parse if (parsedData.extensions) { parseObject(parsedData.extensions, "extensions", gltfRuntime); } if (parsedData.extensionsUsed) { parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime); } if (parsedData.buffers) { parseBuffers(parsedData.buffers, gltfRuntime); } if (parsedData.bufferViews) { parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime); } if (parsedData.accessors) { parseObject(parsedData.accessors, "accessors", gltfRuntime); } if (parsedData.meshes) { parseObject(parsedData.meshes, "meshes", gltfRuntime); } if (parsedData.lights) { parseObject(parsedData.lights, "lights", gltfRuntime); } if (parsedData.cameras) { parseObject(parsedData.cameras, "cameras", gltfRuntime); } if (parsedData.nodes) { parseObject(parsedData.nodes, "nodes", gltfRuntime); } if (parsedData.images) { parseObject(parsedData.images, "images", gltfRuntime); } if (parsedData.textures) { parseObject(parsedData.textures, "textures", gltfRuntime); } if (parsedData.shaders) { parseShaders(parsedData.shaders, gltfRuntime); } if (parsedData.programs) { parseObject(parsedData.programs, "programs", gltfRuntime); } if (parsedData.samplers) { parseObject(parsedData.samplers, "samplers", gltfRuntime); } if (parsedData.techniques) { parseObject(parsedData.techniques, "techniques", gltfRuntime); } if (parsedData.materials) { parseObject(parsedData.materials, "materials", gltfRuntime); } if (parsedData.animations) { parseObject(parsedData.animations, "animations", gltfRuntime); } if (parsedData.skins) { parseObject(parsedData.skins, "skins", gltfRuntime); } if (parsedData.scenes) { gltfRuntime.scenes = parsedData.scenes; } if (parsedData.scene && parsedData.scenes) { gltfRuntime.currentScene = parsedData.scenes[parsedData.scene]; } return gltfRuntime; }; GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) { var buffer = gltfRuntime.buffers[id]; if (BABYLON.Tools.IsBase64(buffer.uri)) { setTimeout(function () { return onSuccess(new Uint8Array(BABYLON.Tools.DecodeBase64(buffer.uri))); }); } else { BABYLON.Tools.LoadFile(gltfRuntime.rootUrl + buffer.uri, function (data) { return onSuccess(new Uint8Array(data)); }, onProgress, undefined, true, function (request) { if (request) { onError(request.status + " " + request.statusText); } }); } }; GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) { var texture = gltfRuntime.textures[id]; if (!texture || !texture.source) { onError(""); return; } if (texture.babylonTexture) { onSuccess(null); return; } var source = gltfRuntime.images[texture.source]; if (BABYLON.Tools.IsBase64(source.uri)) { setTimeout(function () { return onSuccess(new Uint8Array(BABYLON.Tools.DecodeBase64(source.uri))); }); } else { BABYLON.Tools.LoadFile(gltfRuntime.rootUrl + source.uri, function (data) { return onSuccess(new Uint8Array(data)); }, undefined, undefined, true, function (request) { if (request) { onError(request.status + " " + request.statusText); } }); } }; GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) { var texture = gltfRuntime.textures[id]; if (texture.babylonTexture) { onSuccess(texture.babylonTexture); return; } var sampler = gltfRuntime.samplers[texture.sampler]; var createMipMaps = (sampler.minFilter === GLTF1.ETextureFilterType.NEAREST_MIPMAP_NEAREST) || (sampler.minFilter === GLTF1.ETextureFilterType.NEAREST_MIPMAP_LINEAR) || (sampler.minFilter === GLTF1.ETextureFilterType.LINEAR_MIPMAP_NEAREST) || (sampler.minFilter === GLTF1.ETextureFilterType.LINEAR_MIPMAP_LINEAR); var samplingMode = BABYLON.Texture.BILINEAR_SAMPLINGMODE; var blob = new Blob([buffer]); var blobURL = URL.createObjectURL(blob); var revokeBlobURL = function () { return URL.revokeObjectURL(blobURL); }; var newTexture = new BABYLON.Texture(blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL); if (sampler.wrapS !== undefined) { newTexture.wrapU = GLTF1.GLTFUtils.GetWrapMode(sampler.wrapS); } if (sampler.wrapT !== undefined) { newTexture.wrapV = GLTF1.GLTFUtils.GetWrapMode(sampler.wrapT); } newTexture.name = id; texture.babylonTexture = newTexture; onSuccess(newTexture); }; GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) { var shader = gltfRuntime.shaders[id]; if (BABYLON.Tools.IsBase64(shader.uri)) { var shaderString = atob(shader.uri.split(",")[1]); if (onSuccess) { onSuccess(shaderString); } } else { BABYLON.Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) { if (request && onError) { onError(request.status + " " + request.statusText); } }); } }; GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) { var material = gltfRuntime.materials[id]; if (!material.technique) { if (onError) { onError("No technique found."); } return; } var technique = gltfRuntime.techniques[material.technique]; if (!technique) { var defaultMaterial = new BABYLON.StandardMaterial(id, gltfRuntime.scene); defaultMaterial.diffuseColor = new BABYLON.Color3(0.5, 0.5, 0.5); defaultMaterial.sideOrientation = BABYLON.Material.CounterClockWiseSideOrientation; onSuccess(defaultMaterial); return; } var program = gltfRuntime.programs[technique.program]; var states = technique.states; var vertexShader = BABYLON.Effect.ShadersStore[program.vertexShader + "VertexShader"]; var pixelShader = BABYLON.Effect.ShadersStore[program.fragmentShader + "PixelShader"]; var newVertexShader = ""; var newPixelShader = ""; var vertexTokenizer = new Tokenizer(vertexShader); var pixelTokenizer = new Tokenizer(pixelShader); var unTreatedUniforms = {}; var uniforms = []; var attributes = []; var samplers = []; // Fill uniform, sampler2D and attributes for (var unif in technique.uniforms) { var uniform = technique.uniforms[unif]; var uniformParameter = technique.parameters[uniform]; unTreatedUniforms[unif] = uniformParameter; if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) { var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic); if (transformIndex !== -1) { uniforms.push(babylonTransforms[transformIndex]); delete unTreatedUniforms[unif]; } else { uniforms.push(unif); } } else if (uniformParameter.type === GLTF1.EParameterType.SAMPLER_2D) { samplers.push(unif); } else { uniforms.push(unif); } } for (var attr in technique.attributes) { var attribute = technique.attributes[attr]; var attributeParameter = technique.parameters[attribute]; if (attributeParameter.semantic) { attributes.push(getAttribute(attributeParameter)); } } // Configure vertex shader while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) { var tokenType = vertexTokenizer.currentToken; if (tokenType !== ETokenType.IDENTIFIER) { newVertexShader += vertexTokenizer.currentString; continue; } var foundAttribute = false; for (var attr in technique.attributes) { var attribute = technique.attributes[attr]; var attributeParameter = technique.parameters[attribute]; if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) { newVertexShader += getAttribute(attributeParameter); foundAttribute = true; break; } } if (foundAttribute) { continue; } newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms); } // Configure pixel shader while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) { var tokenType = pixelTokenizer.currentToken; if (tokenType !== ETokenType.IDENTIFIER) { newPixelShader += pixelTokenizer.currentString; continue; } newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms); } // Create shader material var shaderPath = { vertex: program.vertexShader + id, fragment: program.fragmentShader + id }; var options = { attributes: attributes, uniforms: uniforms, samplers: samplers, needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1 }; BABYLON.Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader; BABYLON.Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader; var shaderMaterial = new BABYLON.ShaderMaterial(id, gltfRuntime.scene, shaderPath, options); shaderMaterial.onError = onShaderCompileError(program, shaderMaterial, onError); shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess); shaderMaterial.sideOrientation = BABYLON.Material.CounterClockWiseSideOrientation; if (states && states.functions) { var functions = states.functions; if (functions.cullFace && functions.cullFace[0] !== GLTF1.ECullingType.BACK) { shaderMaterial.backFaceCulling = false; } var blendFunc = functions.blendFuncSeparate; if (blendFunc) { if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_ALPHA && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_COMBINE; } else if (blendFunc[0] === GLTF1.EBlendingFunction.ONE && blendFunc[1] === GLTF1.EBlendingFunction.ONE && blendFunc[2] === GLTF1.EBlendingFunction.ZERO && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ONEONE; } else if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE && blendFunc[2] === GLTF1.EBlendingFunction.ZERO && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ADD; } else if (blendFunc[0] === GLTF1.EBlendingFunction.ZERO && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_SUBTRACT; } else if (blendFunc[0] === GLTF1.EBlendingFunction.DST_COLOR && blendFunc[1] === GLTF1.EBlendingFunction.ZERO && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MULTIPLY; } else if (blendFunc[0] === GLTF1.EBlendingFunction.SRC_ALPHA && blendFunc[1] === GLTF1.EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === GLTF1.EBlendingFunction.ONE && blendFunc[3] === GLTF1.EBlendingFunction.ONE) { shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MAXIMIZED; } } } }; return GLTFLoaderBase; }()); GLTF1.GLTFLoaderBase = GLTFLoaderBase; /** * glTF V1 Loader */ var GLTFLoader = /** @class */ (function () { function GLTFLoader() { // #region Stubs for IGLTFLoader interface this.coordinateSystemMode = BABYLON.GLTFLoaderCoordinateSystemMode.AUTO; this.animationStartMode = BABYLON.GLTFLoaderAnimationStartMode.FIRST; this.compileMaterials = false; this.useClipPlane = false; this.compileShadowGenerators = false; this.onDisposeObservable = new BABYLON.Observable(); this.onMeshLoadedObservable = new BABYLON.Observable(); this.onTextureLoadedObservable = new BABYLON.Observable(); this.onMaterialLoadedObservable = new BABYLON.Observable(); this.onCompleteObservable = new BABYLON.Observable(); this.onExtensionLoadedObservable = new BABYLON.Observable(); /** * State of the loader */ this.state = null; } GLTFLoader.RegisterExtension = function (extension) { if (GLTFLoader.Extensions[extension.name]) { BABYLON.Tools.Error("Tool with the same name \"" + extension.name + "\" already exists"); return; } GLTFLoader.Extensions[extension.name] = extension; }; GLTFLoader.prototype.dispose = function () { }; // #endregion GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, onSuccess, onProgress, onError) { var _this = this; scene.useRightHandedSystem = true; GLTF1.GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) { gltfRuntime.importOnlyMeshes = true; if (meshesNames === "") { gltfRuntime.importMeshesNames = []; } else if (typeof meshesNames === "string") { gltfRuntime.importMeshesNames = [meshesNames]; } else if (meshesNames && !(meshesNames instanceof Array)) { gltfRuntime.importMeshesNames = [meshesNames]; } else { gltfRuntime.importMeshesNames = []; BABYLON.Tools.Warn("Argument meshesNames must be of type string or string[]"); } // Create nodes _this._createNodes(gltfRuntime); var meshes = new Array(); var skeletons = new Array(); // Fill arrays of meshes and skeletons for (var nde in gltfRuntime.nodes) { var node = gltfRuntime.nodes[nde]; if (node.babylonNode instanceof BABYLON.AbstractMesh) { meshes.push(node.babylonNode); } } for (var skl in gltfRuntime.skins) { var skin = gltfRuntime.skins[skl]; if (skin.babylonSkeleton instanceof BABYLON.Skeleton) { skeletons.push(skin.babylonSkeleton); } } // Load buffers, shaders, materials, etc. _this._loadBuffersAsync(gltfRuntime, function () { _this._loadShadersAsync(gltfRuntime, function () { importMaterials(gltfRuntime); postLoad(gltfRuntime); if (!BABYLON.GLTFFileLoader.IncrementalLoading && onSuccess) { onSuccess(meshes, skeletons); } }); }, onProgress); if (BABYLON.GLTFFileLoader.IncrementalLoading && onSuccess) { onSuccess(meshes, skeletons); } }, onError); return true; }; /** * Imports one or more meshes from a loaded gltf file and adds them to the scene * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file * @param scene the scene the meshes should be added to * @param data gltf data containing information of the meshes in a loaded file * @param rootUrl root url to load from * @param onProgress event that fires when loading progress has occured * @returns a promise containg the loaded meshes, particles, skeletons and animations */ GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress) { var _this = this; return new Promise(function (resolve, reject) { _this._importMeshAsync(meshesNames, scene, data, rootUrl, function (meshes, skeletons) { resolve({ meshes: meshes, particleSystems: [], skeletons: skeletons, animationGroups: [] }); }, onProgress, function (message) { reject(new Error(message)); }); }); }; GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) { var _this = this; scene.useRightHandedSystem = true; GLTF1.GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) { // Load runtime extensios GLTF1.GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () { // Create nodes _this._createNodes(gltfRuntime); // Load buffers, shaders, materials, etc. _this._loadBuffersAsync(gltfRuntime, function () { _this._loadShadersAsync(gltfRuntime, function () { importMaterials(gltfRuntime); postLoad(gltfRuntime); if (!BABYLON.GLTFFileLoader.IncrementalLoading) { onSuccess(); } }); }); if (BABYLON.GLTFFileLoader.IncrementalLoading) { onSuccess(); } }, onError); }, onError); }; /** * Imports all objects from a loaded gltf file and adds them to the scene * @param scene the scene the objects should be added to * @param data gltf data containing information of the meshes in a loaded file * @param rootUrl root url to load from * @param onProgress event that fires when loading progress has occured * @returns a promise which completes when objects have been loaded to the scene */ GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress) { var _this = this; return new Promise(function (resolve, reject) { _this._loadAsync(scene, data, rootUrl, function () { resolve(); }, onProgress, function (message) { reject(new Error(message)); }); }); }; GLTFLoader.prototype._loadShadersAsync = function (gltfRuntime, onload) { var hasShaders = false; var processShader = function (sha, shader) { GLTF1.GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, function (shaderString) { if (shaderString instanceof ArrayBuffer) { return; } gltfRuntime.loadedShaderCount++; if (shaderString) { BABYLON.Effect.ShadersStore[sha + (shader.type === GLTF1.EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = shaderString; } if (gltfRuntime.loadedShaderCount === gltfRuntime.shaderscount) { onload(); } }, function () { BABYLON.Tools.Error("Error when loading shader program named " + sha + " located at " + shader.uri); }); }; for (var sha in gltfRuntime.shaders) { hasShaders = true; var shader = gltfRuntime.shaders[sha]; if (shader) { processShader.bind(this, sha, shader)(); } else { BABYLON.Tools.Error("No shader named: " + sha); } } if (!hasShaders) { onload(); } }; ; GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad, onProgress) { var hasBuffers = false; var processBuffer = function (buf, buffer) { GLTF1.GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) { gltfRuntime.loadedBufferCount++; if (bufferView) { if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) { BABYLON.Tools.Error("Buffer named " + buf + " is length " + bufferView.byteLength + ". Expected: " + buffer.byteLength); // Improve error message } gltfRuntime.loadedBufferViews[buf] = bufferView; } if (gltfRuntime.loadedBufferCount === gltfRuntime.buffersCount) { onLoad(); } }, function () { BABYLON.Tools.Error("Error when loading buffer named " + buf + " located at " + buffer.uri); }); }; for (var buf in gltfRuntime.buffers) { hasBuffers = true; var buffer = gltfRuntime.buffers[buf]; if (buffer) { processBuffer.bind(this, buf, buffer)(); } else { BABYLON.Tools.Error("No buffer named: " + buf); } } if (!hasBuffers) { onLoad(); } }; GLTFLoader.prototype._createNodes = function (gltfRuntime) { var currentScene = gltfRuntime.currentScene; if (currentScene) { // Only one scene even if multiple scenes are defined for (var i = 0; i < currentScene.nodes.length; i++) { traverseNodes(gltfRuntime, currentScene.nodes[i], null); } } else { // Load all scenes 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); } } } }; GLTFLoader.Extensions = {}; return GLTFLoader; }()); GLTF1.GLTFLoader = GLTFLoader; ; BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); }; })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {})); })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFLoader.js.map /// var BABYLON; (function (BABYLON) { var GLTF1; (function (GLTF1) { /** * Utils functions for GLTF */ var GLTFUtils = /** @class */ (function () { function GLTFUtils() { } /** * Sets the given "parameter" matrix * @param scene: the {BABYLON.Scene} object * @param source: the source node where to pick the matrix * @param parameter: the GLTF technique parameter * @param uniformName: the name of the shader's uniform * @param shaderMaterial: the shader material */ GLTFUtils.SetMatrix = function (scene, source, parameter, uniformName, shaderMaterial) { var mat = null; if (parameter.semantic === "MODEL") { mat = source.getWorldMatrix(); } else if (parameter.semantic === "PROJECTION") { mat = scene.getProjectionMatrix(); } else if (parameter.semantic === "VIEW") { mat = scene.getViewMatrix(); } else if (parameter.semantic === "MODELVIEWINVERSETRANSPOSE") { mat = BABYLON.Matrix.Transpose(source.getWorldMatrix().multiply(scene.getViewMatrix()).invert()); } else if (parameter.semantic === "MODELVIEW") { mat = source.getWorldMatrix().multiply(scene.getViewMatrix()); } else if (parameter.semantic === "MODELVIEWPROJECTION") { mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()); } else if (parameter.semantic === "MODELINVERSE") { mat = source.getWorldMatrix().invert(); } else if (parameter.semantic === "VIEWINVERSE") { mat = scene.getViewMatrix().invert(); } else if (parameter.semantic === "PROJECTIONINVERSE") { mat = scene.getProjectionMatrix().invert(); } else if (parameter.semantic === "MODELVIEWINVERSE") { mat = source.getWorldMatrix().multiply(scene.getViewMatrix()).invert(); } else if (parameter.semantic === "MODELVIEWPROJECTIONINVERSE") { mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()).invert(); } else if (parameter.semantic === "MODELINVERSETRANSPOSE") { mat = BABYLON.Matrix.Transpose(source.getWorldMatrix().invert()); } else { debugger; } if (mat) { switch (parameter.type) { case GLTF1.EParameterType.FLOAT_MAT2: shaderMaterial.setMatrix2x2(uniformName, BABYLON.Matrix.GetAsMatrix2x2(mat)); break; case GLTF1.EParameterType.FLOAT_MAT3: shaderMaterial.setMatrix3x3(uniformName, BABYLON.Matrix.GetAsMatrix3x3(mat)); break; case GLTF1.EParameterType.FLOAT_MAT4: shaderMaterial.setMatrix(uniformName, mat); break; default: break; } } }; /** * Sets the given "parameter" matrix * @param shaderMaterial: the shader material * @param uniform: the name of the shader's uniform * @param value: the value of the uniform * @param type: the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4) */ GLTFUtils.SetUniform = function (shaderMaterial, uniform, value, type) { switch (type) { case GLTF1.EParameterType.FLOAT: shaderMaterial.setFloat(uniform, value); return true; case GLTF1.EParameterType.FLOAT_VEC2: shaderMaterial.setVector2(uniform, BABYLON.Vector2.FromArray(value)); return true; case GLTF1.EParameterType.FLOAT_VEC3: shaderMaterial.setVector3(uniform, BABYLON.Vector3.FromArray(value)); return true; case GLTF1.EParameterType.FLOAT_VEC4: shaderMaterial.setVector4(uniform, BABYLON.Vector4.FromArray(value)); return true; default: return false; } }; /** * Returns the wrap mode of the texture * @param mode: the mode value */ GLTFUtils.GetWrapMode = function (mode) { switch (mode) { case GLTF1.ETextureWrapMode.CLAMP_TO_EDGE: return BABYLON.Texture.CLAMP_ADDRESSMODE; case GLTF1.ETextureWrapMode.MIRRORED_REPEAT: return BABYLON.Texture.MIRROR_ADDRESSMODE; case GLTF1.ETextureWrapMode.REPEAT: return BABYLON.Texture.WRAP_ADDRESSMODE; default: return BABYLON.Texture.WRAP_ADDRESSMODE; } }; /** * Returns the byte stride giving an accessor * @param accessor: the GLTF accessor objet */ GLTFUtils.GetByteStrideFromType = function (accessor) { // Needs this function since "byteStride" isn't requiered in glTF format var type = accessor.type; switch (type) { case "VEC2": return 2; case "VEC3": return 3; case "VEC4": return 4; case "MAT2": return 4; case "MAT3": return 9; case "MAT4": return 16; default: return 1; } }; /** * Returns the texture filter mode giving a mode value * @param mode: the filter mode value */ GLTFUtils.GetTextureFilterMode = function (mode) { switch (mode) { case GLTF1.ETextureFilterType.LINEAR: case GLTF1.ETextureFilterType.LINEAR_MIPMAP_NEAREST: case GLTF1.ETextureFilterType.LINEAR_MIPMAP_LINEAR: return BABYLON.Texture.TRILINEAR_SAMPLINGMODE; case GLTF1.ETextureFilterType.NEAREST: case GLTF1.ETextureFilterType.NEAREST_MIPMAP_NEAREST: return BABYLON.Texture.NEAREST_SAMPLINGMODE; default: return BABYLON.Texture.BILINEAR_SAMPLINGMODE; } }; GLTFUtils.GetBufferFromBufferView = function (gltfRuntime, bufferView, byteOffset, byteLength, componentType) { var byteOffset = bufferView.byteOffset + byteOffset; var loadedBufferView = gltfRuntime.loadedBufferViews[bufferView.buffer]; if (byteOffset + byteLength > loadedBufferView.byteLength) { throw new Error("Buffer access is out of range"); } var buffer = loadedBufferView.buffer; byteOffset += loadedBufferView.byteOffset; switch (componentType) { case GLTF1.EComponentType.BYTE: return new Int8Array(buffer, byteOffset, byteLength); case GLTF1.EComponentType.UNSIGNED_BYTE: return new Uint8Array(buffer, byteOffset, byteLength); case GLTF1.EComponentType.SHORT: return new Int16Array(buffer, byteOffset, byteLength); case GLTF1.EComponentType.UNSIGNED_SHORT: return new Uint16Array(buffer, byteOffset, byteLength); default: return new Float32Array(buffer, byteOffset, byteLength); } }; /** * Returns a buffer from its accessor * @param gltfRuntime: the GLTF runtime * @param accessor: the GLTF accessor */ GLTFUtils.GetBufferFromAccessor = function (gltfRuntime, accessor) { var bufferView = gltfRuntime.bufferViews[accessor.bufferView]; var byteLength = accessor.count * GLTFUtils.GetByteStrideFromType(accessor); return GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, accessor.byteOffset, byteLength, accessor.componentType); }; /** * Decodes a buffer view into a string * @param view: the buffer view */ GLTFUtils.DecodeBufferToText = function (view) { var result = ""; var length = view.byteLength; for (var i = 0; i < length; ++i) { result += String.fromCharCode(view[i]); } return result; }; /** * Returns the default material of gltf. Related to * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material * @param scene: the Babylon.js scene */ GLTFUtils.GetDefaultMaterial = function (scene) { if (!GLTFUtils._DefaultMaterial) { BABYLON.Effect.ShadersStore["GLTFDefaultMaterialVertexShader"] = [ "precision highp float;", "", "uniform mat4 worldView;", "uniform mat4 projection;", "", "attribute vec3 position;", "", "void main(void)", "{", " gl_Position = projection * worldView * vec4(position, 1.0);", "}" ].join("\n"); BABYLON.Effect.ShadersStore["GLTFDefaultMaterialPixelShader"] = [ "precision highp float;", "", "uniform vec4 u_emission;", "", "void main(void)", "{", " gl_FragColor = u_emission;", "}" ].join("\n"); var shaderPath = { vertex: "GLTFDefaultMaterial", fragment: "GLTFDefaultMaterial" }; var options = { attributes: ["position"], uniforms: ["worldView", "projection", "u_emission"], samplers: new Array(), needAlphaBlending: false }; GLTFUtils._DefaultMaterial = new BABYLON.ShaderMaterial("GLTFDefaultMaterial", scene, shaderPath, options); GLTFUtils._DefaultMaterial.setColor4("u_emission", new BABYLON.Color4(0.5, 0.5, 0.5, 1.0)); } return GLTFUtils._DefaultMaterial; }; // The GLTF default material GLTFUtils._DefaultMaterial = null; return GLTFUtils; }()); GLTF1.GLTFUtils = GLTFUtils; })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {})); })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFLoaderUtils.js.map /// var BABYLON; (function (BABYLON) { var GLTF1; (function (GLTF1) { var GLTFLoaderExtension = /** @class */ (function () { function GLTFLoaderExtension(name) { this._name = name; } Object.defineProperty(GLTFLoaderExtension.prototype, "name", { get: function () { return this._name; }, enumerable: true, configurable: true }); /** * Defines an override for loading the runtime * Return true to stop further extensions from loading the runtime */ GLTFLoaderExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) { return false; }; /** * Defines an onverride for creating gltf runtime * Return true to stop further extensions from creating the runtime */ GLTFLoaderExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) { return false; }; /** * Defines an override for loading buffers * Return true to stop further extensions from loading this buffer */ GLTFLoaderExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) { return false; }; /** * Defines an override for loading texture buffers * Return true to stop further extensions from loading this texture data */ GLTFLoaderExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) { return false; }; /** * Defines an override for creating textures * Return true to stop further extensions from loading this texture */ GLTFLoaderExtension.prototype.createTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) { return false; }; /** * Defines an override for loading shader strings * Return true to stop further extensions from loading this shader data */ GLTFLoaderExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) { return false; }; /** * Defines an override for loading materials * Return true to stop further extensions from loading this material */ GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) { return false; }; // --------- // Utilities // --------- GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError); }, function () { setTimeout(function () { if (!onSuccess) { return; } onSuccess(GLTF1.GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl)); }); }); }; GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError); }, function () { setTimeout(function () { onSuccess(); }); }); }; GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress); }, function () { GLTF1.GLTFLoaderBase.LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress); }); }; GLTFLoaderExtension.LoadTextureAsync = function (gltfRuntime, id, onSuccess, onError) { GLTFLoaderExtension.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) { if (buffer) { GLTFLoaderExtension.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError); } }, onError); }; GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadShaderStringAsync(gltfRuntime, id, onSuccess, onError); }, function () { GLTF1.GLTFLoaderBase.LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError); }); }; GLTFLoaderExtension.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadMaterialAsync(gltfRuntime, id, onSuccess, onError); }, function () { GLTF1.GLTFLoaderBase.LoadMaterialAsync(gltfRuntime, id, onSuccess, onError); }); }; GLTFLoaderExtension.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError); }, function () { GLTF1.GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError); }); }; GLTFLoaderExtension.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) { GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) { return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError); }, function () { GLTF1.GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError); }); }; GLTFLoaderExtension.ApplyExtensions = function (func, defaultFunc) { for (var extensionName in GLTF1.GLTFLoader.Extensions) { var loaderExtension = GLTF1.GLTFLoader.Extensions[extensionName]; if (func(loaderExtension)) { return; } } defaultFunc(); }; return GLTFLoaderExtension; }()); GLTF1.GLTFLoaderExtension = GLTFLoaderExtension; })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {})); })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFLoaderExtension.js.map /// var __extends = (this && this.__extends) || (function () { var extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; return function (d, b) { extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); var BABYLON; (function (BABYLON) { var GLTF1; (function (GLTF1) { var BinaryExtensionBufferName = "binary_glTF"; ; ; var GLTFBinaryExtension = /** @class */ (function (_super) { __extends(GLTFBinaryExtension, _super); function GLTFBinaryExtension() { return _super.call(this, "KHR_binary_glTF") || this; } GLTFBinaryExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) { var extensionsUsed = data.json.extensionsUsed; if (!extensionsUsed || extensionsUsed.indexOf(this.name) === -1 || !data.bin) { return false; } this._bin = data.bin; onSuccess(GLTF1.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; } onSuccess(this._bin); return true; }; GLTFBinaryExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) { 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 = GLTF1.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, GLTF1.EComponentType.UNSIGNED_BYTE); onSuccess(buffer); return true; }; GLTFBinaryExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) { 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 = GLTF1.GLTFUtils.GetBufferFromBufferView(gltfRuntime, bufferView, 0, bufferView.byteLength, GLTF1.EComponentType.UNSIGNED_BYTE); setTimeout(function () { var shaderString = GLTF1.GLTFUtils.DecodeBufferToText(shaderBytes); onSuccess(shaderString); }); return true; }; return GLTFBinaryExtension; }(GLTF1.GLTFLoaderExtension)); GLTF1.GLTFBinaryExtension = GLTFBinaryExtension; GLTF1.GLTFLoader.RegisterExtension(new GLTFBinaryExtension()); })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {})); })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFBinaryExtension.js.map /// var __extends = (this && this.__extends) || (function () { var extendStatics = Object.setPrototypeOf || ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; return function (d, b) { extendStatics(d, b); function __() { this.constructor = d; } d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; })(); var BABYLON; (function (BABYLON) { var GLTF1; (function (GLTF1) { ; ; ; var GLTFMaterialsCommonExtension = /** @class */ (function (_super) { __extends(GLTFMaterialsCommonExtension, _super); function GLTFMaterialsCommonExtension() { return _super.call(this, "KHR_materials_common") || this; } GLTFMaterialsCommonExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) { if (!gltfRuntime.extensions) return false; var extension = gltfRuntime.extensions[this.name]; if (!extension) return false; // Create lights var lights = extension.lights; if (lights) { for (var thing in lights) { var light = lights[thing]; switch (light.type) { case "ambient": var ambientLight = new BABYLON.HemisphericLight(light.name, new BABYLON.Vector3(0, 1, 0), gltfRuntime.scene); var ambient = light.ambient; if (ambient) { ambientLight.diffuse = BABYLON.Color3.FromArray(ambient.color || [1, 1, 1]); } break; case "point": var pointLight = new BABYLON.PointLight(light.name, new BABYLON.Vector3(10, 10, 10), gltfRuntime.scene); var point = light.point; if (point) { pointLight.diffuse = BABYLON.Color3.FromArray(point.color || [1, 1, 1]); } break; case "directional": var dirLight = new BABYLON.DirectionalLight(light.name, new BABYLON.Vector3(0, -1, 0), gltfRuntime.scene); var directional = light.directional; if (directional) { dirLight.diffuse = BABYLON.Color3.FromArray(directional.color || [1, 1, 1]); } break; case "spot": var spot = light.spot; if (spot) { var spotLight = new BABYLON.SpotLight(light.name, new BABYLON.Vector3(0, 10, 0), new BABYLON.Vector3(0, -1, 0), spot.fallOffAngle || Math.PI, spot.fallOffExponent || 0.0, gltfRuntime.scene); spotLight.diffuse = BABYLON.Color3.FromArray(spot.color || [1, 1, 1]); } break; default: BABYLON.Tools.Warn("GLTF Material Common extension: light type \"" + light.type + "\” not supported"); break; } } } return false; }; GLTFMaterialsCommonExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) { var material = gltfRuntime.materials[id]; if (!material || !material.extensions) return false; var extension = material.extensions[this.name]; if (!extension) return false; var standardMaterial = new BABYLON.StandardMaterial(id, gltfRuntime.scene); standardMaterial.sideOrientation = BABYLON.Material.CounterClockWiseSideOrientation; if (extension.technique === "CONSTANT") { standardMaterial.disableLighting = true; } standardMaterial.backFaceCulling = extension.doubleSided === undefined ? false : !extension.doubleSided; standardMaterial.alpha = extension.values.transparency === undefined ? 1.0 : extension.values.transparency; standardMaterial.specularPower = extension.values.shininess === undefined ? 0.0 : extension.values.shininess; // Ambient if (typeof extension.values.ambient === "string") { this._loadTexture(gltfRuntime, extension.values.ambient, standardMaterial, "ambientTexture", onError); } else { standardMaterial.ambientColor = BABYLON.Color3.FromArray(extension.values.ambient || [0, 0, 0]); } // Diffuse if (typeof extension.values.diffuse === "string") { this._loadTexture(gltfRuntime, extension.values.diffuse, standardMaterial, "diffuseTexture", onError); } else { standardMaterial.diffuseColor = BABYLON.Color3.FromArray(extension.values.diffuse || [0, 0, 0]); } // Emission if (typeof extension.values.emission === "string") { this._loadTexture(gltfRuntime, extension.values.emission, standardMaterial, "emissiveTexture", onError); } else { standardMaterial.emissiveColor = BABYLON.Color3.FromArray(extension.values.emission || [0, 0, 0]); } // Specular if (typeof extension.values.specular === "string") { this._loadTexture(gltfRuntime, extension.values.specular, standardMaterial, "specularTexture", onError); } else { standardMaterial.specularColor = BABYLON.Color3.FromArray(extension.values.specular || [0, 0, 0]); } return true; }; GLTFMaterialsCommonExtension.prototype._loadTexture = function (gltfRuntime, id, material, propertyPath, onError) { // Create buffer from texture url GLTF1.GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, function (buffer) { // Create texture from buffer GLTF1.GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, function (texture) { return material[propertyPath] = texture; }, onError); }, onError); }; return GLTFMaterialsCommonExtension; }(GLTF1.GLTFLoaderExtension)); GLTF1.GLTFMaterialsCommonExtension = GLTFMaterialsCommonExtension; GLTF1.GLTFLoader.RegisterExtension(new GLTFMaterialsCommonExtension()); })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {})); })(BABYLON || (BABYLON = {})); //# sourceMappingURL=babylon.glTFMaterialsCommonExtension.js.map