@babylonjs/viewer
Version:
The Babylon Viewer aims to simplify a specific but common Babylon.js use case: loading, viewing, and interacting with a 3D model.
3,767 lines • 175 kB
JavaScript
import { bS as Decode, aY as Tools, O as Observable, bT as GLTFFileLoaderMetadata, y as Logger, bU as GLTFMagicBase64Encoded, bV as DecodeBase64UrlToBinary, bW as RuntimeError, bX as ErrorCodes, bn as RegisterSceneLoaderPlugin, bp as registerGLTFExtension, bo as unregisterGLTFExtension, v as RandomGUID, F as Material, bY as registeredGLTFExtensions, aV as Mesh, bh as AbstractMesh, bi as TransformNode, bZ as deepMerge, bJ as Geometry, V as Vector3, M as Matrix, aD as Quaternion, aU as Camera, b_ as Lazy, b$ as VertexBufferGetTypeByteLength, c0 as VertexBufferForEach, bk as Buffer, a7 as VertexBuffer, i as Color3, bv as Deferred, c1 as GetMimeType, m as Texture, c2 as IsBase64DataUrl, c3 as LoadFileError, c4 as GetTypedArrayConstructor, T as TmpVectors, bl as BoundingInfo } from './index-HyNDfLMI.esm.js';
import { M as MorphTargetManager, a as MorphTarget, F as FreeCamera } from './morphTargetManager-BcCzrruC.esm.js';
import { B as Bone } from './bone.pure-CwnvxLJv.esm.js';
import { S as Skeleton } from './skeleton-CK10BdK4.esm.js';
import { A as AssetContainer } from './assetContainer-BhW2gcI4.esm.js';
import { a as GetMappingForKey } from './objectModelMapping-OlchA9xj.esm.js';
/**
* Utility class for reading from a data buffer
*/
class DataReader {
/**
* Constructor
* @param buffer The buffer to read
*/
constructor(buffer) {
/**
* The current byte offset from the beginning of the data buffer.
*/
this.byteOffset = 0;
this.buffer = buffer;
}
/**
* Loads the given byte length.
* @param byteLength The byte length to load
* @returns A promise that resolves when the load is complete
*/
async loadAsync(byteLength) {
const data = await this.buffer.readAsync(this.byteOffset, byteLength);
this._dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
this._dataByteOffset = 0;
}
/**
* Read a unsigned 32-bit integer from the currently loaded data range.
* @returns The 32-bit integer read
*/
readUint32() {
const value = this._dataView.getUint32(this._dataByteOffset, true);
this._dataByteOffset += 4;
this.byteOffset += 4;
return value;
}
/**
* Read a byte array from the currently loaded data range.
* @param byteLength The byte length to read
* @returns The byte array read
*/
readUint8Array(byteLength) {
const value = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._dataByteOffset, byteLength);
this._dataByteOffset += byteLength;
this.byteOffset += byteLength;
return value;
}
/**
* Read a string from the currently loaded data range.
* @param byteLength The byte length to read
* @returns The string read
*/
readString(byteLength) {
return Decode(this.readUint8Array(byteLength));
}
/**
* Skips the given byte length the currently loaded data range.
* @param byteLength The byte length to skip
*/
skipBytes(byteLength) {
this._dataByteOffset += byteLength;
this.byteOffset += byteLength;
}
}
function ValidateAsync(data, rootUrl, fileName, getExternalResource) {
const options = {
externalResourceFunction: getExternalResource,
};
if (fileName) {
options.uri = rootUrl === "file:" ? fileName : rootUrl + fileName;
}
return ArrayBuffer.isView(data) ? GLTFValidator.validateBytes(data, options) : GLTFValidator.validateString(data, options);
}
/**
* The worker function that gets converted to a blob url to pass into a worker.
*/
function WorkerFunc() {
const pendingExternalResources = [];
onmessage = (message) => {
const data = message.data;
switch (data.id) {
case "init": {
importScripts(data.url);
break;
}
case "validate": {
ValidateAsync(data.data, data.rootUrl, data.fileName, (uri) => new Promise((resolve, reject) => {
const index = pendingExternalResources.length;
pendingExternalResources.push({ resolve, reject });
postMessage({ id: "getExternalResource", index: index, uri: uri });
})).then((value) => {
postMessage({ id: "validate.resolve", value: value });
}, (reason) => {
postMessage({ id: "validate.reject", reason: reason });
});
break;
}
case "getExternalResource.resolve": {
pendingExternalResources[data.index].resolve(data.value);
break;
}
case "getExternalResource.reject": {
pendingExternalResources[data.index].reject(data.reason);
break;
}
}
};
}
/**
* glTF validation
*/
class GLTFValidation {
/**
* Validate a glTF asset using the glTF-Validator.
* @param data The JSON of a glTF or the array buffer of a binary glTF
* @param rootUrl The root url for the glTF
* @param fileName The file name for the glTF
* @param getExternalResource The callback to get external resources for the glTF validator
* @returns A promise that resolves with the glTF validation results once complete
*/
static ValidateAsync(data, rootUrl, fileName, getExternalResource) {
if (typeof Worker === "function") {
return new Promise((resolve, reject) => {
const workerContent = `${ValidateAsync}(${WorkerFunc})()`;
const workerBlobUrl = URL.createObjectURL(new Blob([workerContent], { type: "application/javascript" }));
const worker = new Worker(workerBlobUrl);
const onError = (error) => {
worker.removeEventListener("error", onError);
worker.removeEventListener("message", onMessage);
// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
reject(error);
};
const onMessage = (message) => {
const data = message.data;
switch (data.id) {
case "getExternalResource": {
getExternalResource(data.uri).then((value) => {
worker.postMessage({ id: "getExternalResource.resolve", index: data.index, value: value }, [value.buffer]);
}, (reason) => {
worker.postMessage({ id: "getExternalResource.reject", index: data.index, reason: reason });
});
break;
}
case "validate.resolve": {
worker.removeEventListener("error", onError);
worker.removeEventListener("message", onMessage);
GLTFValidation._LastResults = data.value;
resolve(data.value);
worker.terminate();
break;
}
case "validate.reject": {
worker.removeEventListener("error", onError);
worker.removeEventListener("message", onMessage);
// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
reject(data.reason);
worker.terminate();
}
}
};
worker.addEventListener("error", onError);
worker.addEventListener("message", onMessage);
worker.postMessage({ id: "init", url: Tools.GetBabylonScriptURL(this.Configuration.url) });
if (ArrayBuffer.isView(data)) {
// Slice the data to avoid copying the whole array buffer.
const slicedData = data.slice();
worker.postMessage({ id: "validate", data: slicedData, rootUrl: rootUrl, fileName: fileName }, [slicedData.buffer]);
}
else {
worker.postMessage({ id: "validate", data: data, rootUrl: rootUrl, fileName: fileName });
}
});
}
else {
if (!this._LoadScriptPromise) {
this._LoadScriptPromise = Tools.LoadBabylonScriptAsync(this.Configuration.url);
}
return this._LoadScriptPromise.then(() => {
return ValidateAsync(data, rootUrl, fileName, getExternalResource);
});
}
}
}
/**
* The configuration. Defaults to `{ url: "https://cdn.babylonjs.com/gltf_validator.js" }`.
*/
GLTFValidation.Configuration = {
url: `${Tools._DefaultCdnUrl}/gltf_validator.js`,
};
/**
* The most recent validation results.
* @internal - Used for back-compat in Sandbox with Inspector V2.
*/
GLTFValidation._LastResults = null;
function readAsync(arrayBuffer, byteOffset, byteLength) {
try {
return Promise.resolve(new Uint8Array(arrayBuffer, byteOffset, byteLength));
}
catch (e) {
return Promise.reject(e);
}
}
function readViewAsync(arrayBufferView, byteOffset, byteLength) {
try {
if (byteOffset < 0 || byteOffset >= arrayBufferView.byteLength) {
throw new RangeError("Offset is out of range.");
}
if (byteOffset + byteLength > arrayBufferView.byteLength) {
throw new RangeError("Length is out of range.");
}
return Promise.resolve(new Uint8Array(arrayBufferView.buffer, arrayBufferView.byteOffset + byteOffset, byteLength));
}
catch (e) {
return Promise.reject(e);
}
}
/**
* Mode that determines the coordinate system to use.
*/
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 || (GLTFLoaderCoordinateSystemMode = {}));
/**
* Mode that determines what animations will start.
*/
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 || (GLTFLoaderAnimationStartMode = {}));
/**
* Loader 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 || (GLTFLoaderState = {}));
/**
* This class contains all the concrete (not abstract) glTF options, excluding callbacks.
* The purpose of this class is to make it easy to provide a way to mutate the default
* loader options (see the GLTFLoaderDefaultOptions instance below) without duplicating
* all the options in yet another object. Since this class is instantiated for the default
* options object, abstract properties and callbacks are not included, it's more just
* flag-type options.
*/
class GLTFLoaderBaseOptions {
constructor() {
/**
* Defines if the loader should always compute the bounding boxes of meshes and not use the min/max values from the position accessor. Defaults to false.
*/
this.alwaysComputeBoundingBox = false;
/**
* Defines if the loader should always compute the nearest common ancestor of the skeleton joints instead of using `skin.skeleton`. Defaults to false.
* Set this to true if loading assets with invalid `skin.skeleton` values.
*/
this.alwaysComputeSkeletonRootNode = false;
/**
* The animation start mode. Defaults to FIRST.
*/
this.animationStartMode = GLTFLoaderAnimationStartMode.FIRST;
/**
* Defines if the loader should compile materials before raising the success callback. Defaults to false.
*/
this.compileMaterials = false;
/**
* Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
*/
this.compileShadowGenerators = false;
/**
* The coordinate system mode. Defaults to AUTO.
*/
this.coordinateSystemMode = GLTFLoaderCoordinateSystemMode.AUTO;
/**
* Defines if the loader should create instances when multiple glTF nodes point to the same glTF mesh. Defaults to true.
*/
this.createInstances = true;
/**
* If true, load all materials defined in the file, even if not used by any mesh. Defaults to false.
*/
this.loadAllMaterials = false;
/**
* Defines if the loader should load morph targets. Defaults to true.
*/
this.loadMorphTargets = true;
/**
* When loading a mesh with morph targets, configure its MorphTargetManager so the morph shader is compiled
* once for all targets (`numMaxInfluencers = numTargets`, `optimizeInfluencers = false`). This prevents the
* shader from being recompiled (and the resulting one-frame visual glitch) when an animated morph target
* influence passes through zero and the active influencer count changes.
* Disable to restore the previous behavior, where only the currently active (non-zero) influencers drive the
* shader. That is cheaper per frame for meshes with very large morph target counts, but recompiles the shader
* during animation. Defaults to true.
*/
this.useMaxMorphTargetInfluencers = true;
/**
* Defines if the loader should load node animations. Defaults to true.
* NOTE: The animation of this node will still load if the node is also a joint of a skin and `loadSkins` is true.
*/
this.loadNodeAnimations = true;
/**
* If true, load only the materials defined in the file. Defaults to false.
*/
this.loadOnlyMaterials = false;
/**
* Defines if the loader should load skins. Defaults to true.
*/
this.loadSkins = true;
/**
* If true, do not load any materials defined in the file. Defaults to false.
*/
this.skipMaterials = false;
/**
* When loading glTF animations, which are defined in seconds, target them to this FPS. Defaults to 60.
*/
this.targetFps = 60;
/**
* Defines if the Alpha blended materials are only applied as coverage.
* If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
* If true, no extra effects are applied to transparent pixels.
*/
this.transparencyAsCoverage = false;
/**
* Defines if the loader should also compile materials with clip planes. Defaults to false.
*/
this.useClipPlane = false;
/**
* If true, the loader will derive the name for Babylon textures from the glTF texture name, image name, or image url. Defaults to false.
* Note that it is possible for multiple Babylon textures to share the same name when the Babylon textures load from the same glTF texture or image.
*/
this.useGltfTextureNames = false;
/**
* Defines if the loader should use range requests when load binary glTF files from HTTP.
* Enabling will disable offline support and glTF validator.
* Defaults to false.
*/
this.useRangeRequests = false;
/**
* If true, load the color (gamma encoded) textures into sRGB buffers (if supported by the GPU), which will yield more accurate results when sampling the texture. Defaults to true.
*/
this.useSRGBBuffers = true;
/**
* Defines if the loader should validate the asset.
*/
this.validate = false;
/**
* Load the glTF files using the OpenPBR material.
* @experimental
*/
this.useOpenPBR = false;
/**
* If true, the loader will not use the transmission helper when loading materials with transmission.
*/
this.dontUseTransmissionHelper = false;
}
}
/**
* The default GLTF loader options.
* Override the properties of this object to globally change the default loader options.
* To specify options for a specific load call, pass those options into the associated load function.
*/
const GLTFLoaderDefaultOptions = new GLTFLoaderBaseOptions();
/**
* Base class for glTF loader options that supports copying values from a partial options object.
*/
class GLTFLoaderOptions extends GLTFLoaderBaseOptions {
constructor() {
super(...arguments);
/**
* Defines options for glTF extensions.
*/
this.extensionOptions = {};
/**
* Function called before loading a url referenced by the asset.
* @param url url referenced by the asset
* @returns Async url to load
*/
this.preprocessUrlAsync = (url) => Promise.resolve(url);
}
// eslint-disable-next-line babylonjs/available
copyFrom(options) {
if (options) {
this.alwaysComputeBoundingBox = options.alwaysComputeBoundingBox ?? this.alwaysComputeBoundingBox;
this.alwaysComputeSkeletonRootNode = options.alwaysComputeSkeletonRootNode ?? this.alwaysComputeSkeletonRootNode;
this.animationStartMode = options.animationStartMode ?? this.animationStartMode;
this.capturePerformanceCounters = options.capturePerformanceCounters ?? this.capturePerformanceCounters;
this.compileMaterials = options.compileMaterials ?? this.compileMaterials;
this.compileShadowGenerators = options.compileShadowGenerators ?? this.compileShadowGenerators;
this.coordinateSystemMode = options.coordinateSystemMode ?? this.coordinateSystemMode;
this.createInstances = options.createInstances ?? this.createInstances;
this.customRootNode = options.customRootNode;
this.extensionOptions = options.extensionOptions ?? this.extensionOptions;
this.loadAllMaterials = options.loadAllMaterials ?? this.loadAllMaterials;
this.loadMorphTargets = options.loadMorphTargets ?? this.loadMorphTargets;
this.loadNodeAnimations = options.loadNodeAnimations ?? this.loadNodeAnimations;
this.loadOnlyMaterials = options.loadOnlyMaterials ?? this.loadOnlyMaterials;
this.loadSkins = options.loadSkins ?? this.loadSkins;
this.loggingEnabled = options.loggingEnabled ?? this.loggingEnabled;
this.onCameraLoaded = options.onCameraLoaded;
this.onMaterialLoaded = options.onMaterialLoaded;
this.onMeshLoaded = options.onMeshLoaded;
this.onParsed = options.onParsed;
this.onSkinLoaded = options.onSkinLoaded;
this.onTextureLoaded = options.onTextureLoaded;
this.onValidated = options.onValidated;
this.preprocessUrlAsync = options.preprocessUrlAsync ?? this.preprocessUrlAsync;
this.skipMaterials = options.skipMaterials ?? this.skipMaterials;
this.targetFps = options.targetFps ?? this.targetFps;
this.transparencyAsCoverage = options.transparencyAsCoverage ?? this.transparencyAsCoverage;
this.useClipPlane = options.useClipPlane ?? this.useClipPlane;
this.useGltfTextureNames = options.useGltfTextureNames ?? this.useGltfTextureNames;
this.useMaxMorphTargetInfluencers = options.useMaxMorphTargetInfluencers ?? this.useMaxMorphTargetInfluencers;
this.useOpenPBR = options.useOpenPBR ?? this.useOpenPBR;
this.useRangeRequests = options.useRangeRequests ?? this.useRangeRequests;
this.useSRGBBuffers = options.useSRGBBuffers ?? this.useSRGBBuffers;
this.validate = options.validate ?? this.validate;
this.dontUseTransmissionHelper = options.dontUseTransmissionHelper ?? this.dontUseTransmissionHelper;
}
}
}
/**
* File loader for loading glTF files into a scene.
*/
class GLTFFileLoader extends GLTFLoaderOptions {
/**
* Creates a new glTF file loader.
* @param options The options for the loader
*/
constructor(options) {
super();
// --------------------
// Begin Common options
// --------------------
/**
* Raised when the asset has been parsed
*/
this.onParsedObservable = new Observable();
// --------------
// End V1 options
// --------------
/**
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
* Note that the observable is raised as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
*/
this.onMeshLoadedObservable = new Observable();
/**
* Observable raised when the loader creates a skin after parsing the glTF properties of the skin node.
* @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh
* @param node - the transform node that corresponds to the original glTF skin node used for animations
* @param skinnedNode - the transform node that is the skinned mesh itself or the parent of the skinned meshes
*/
this.onSkinLoadedObservable = new Observable();
/**
* Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
this.onTextureLoadedObservable = new Observable();
/**
* Observable raised when the loader creates a material after parsing the glTF properties of the material.
*/
this.onMaterialLoadedObservable = new Observable();
/**
* Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
this.onCameraLoadedObservable = new Observable();
/**
* 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 Observable();
/**
* Observable raised when an error occurs.
*/
this.onErrorObservable = new Observable();
/**
* Observable raised after the loader is disposed.
*/
this.onDisposeObservable = new Observable();
/**
* Observable raised after a loader extension is created.
* Set additional options for a loader extension in this event.
*/
this.onExtensionLoadedObservable = new Observable();
/**
* Observable raised after validation when validate is set to true. The event data is the result of the validation.
*/
this.onValidatedObservable = new Observable();
this._loader = null;
this._state = null;
this._requests = new Array();
/**
* Name of the loader ("gltf")
*/
this.name = GLTFFileLoaderMetadata.name;
/** @internal */
this.extensions = GLTFFileLoaderMetadata.extensions;
/**
* Observable raised when the loader state changes.
*/
this.onLoaderStateChangedObservable = new Observable();
this._logIndentLevel = 0;
this._loggingEnabled = false;
/** @internal */
this._log = this._logDisabled;
this._capturePerformanceCounters = false;
/** @internal */
this._startPerformanceCounter = this._startPerformanceCounterDisabled;
/** @internal */
this._endPerformanceCounter = this._endPerformanceCounterDisabled;
this.copyFrom(Object.assign({ ...GLTFLoaderDefaultOptions }, options));
}
/**
* Raised when the asset has been parsed
*/
set onParsed(callback) {
if (this._onParsedObserver) {
this.onParsedObservable.remove(this._onParsedObserver);
}
if (callback) {
this._onParsedObserver = this.onParsedObservable.add(callback);
}
}
/**
* Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
* Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
*/
set onMeshLoaded(callback) {
if (this._onMeshLoadedObserver) {
this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
}
if (callback) {
this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
}
}
/**
* Callback raised when the loader creates a skin after parsing the glTF properties of the skin node.
* @see https://doc.babylonjs.com/features/featuresDeepDive/importers/glTF/glTFSkinning#ignoring-the-transform-of-the-skinned-mesh
*/
set onSkinLoaded(callback) {
if (this._onSkinLoadedObserver) {
this.onSkinLoadedObservable.remove(this._onSkinLoadedObserver);
}
if (callback) {
this._onSkinLoadedObserver = this.onSkinLoadedObservable.add((data) => callback(data.node, data.skinnedNode));
}
}
/**
* Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
*/
set onTextureLoaded(callback) {
if (this._onTextureLoadedObserver) {
this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);
}
if (callback) {
this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);
}
}
/**
* Callback raised when the loader creates a material after parsing the glTF properties of the material.
*/
set onMaterialLoaded(callback) {
if (this._onMaterialLoadedObserver) {
this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);
}
if (callback) {
this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);
}
}
/**
* Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
*/
set onCameraLoaded(callback) {
if (this._onCameraLoadedObserver) {
this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);
}
if (callback) {
this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);
}
}
/**
* Callback 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.
*/
set onComplete(callback) {
if (this._onCompleteObserver) {
this.onCompleteObservable.remove(this._onCompleteObserver);
}
this._onCompleteObserver = this.onCompleteObservable.add(callback);
}
/**
* Callback raised when an error occurs.
*/
set onError(callback) {
if (this._onErrorObserver) {
this.onErrorObservable.remove(this._onErrorObserver);
}
this._onErrorObserver = this.onErrorObservable.add(callback);
}
/**
* Callback raised after the loader is disposed.
*/
set onDispose(callback) {
if (this._onDisposeObserver) {
this.onDisposeObservable.remove(this._onDisposeObserver);
}
this._onDisposeObserver = this.onDisposeObservable.add(callback);
}
/**
* Callback raised after a loader extension is created.
*/
set onExtensionLoaded(callback) {
if (this._onExtensionLoadedObserver) {
this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);
}
this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);
}
/**
* Defines if the loader logging is enabled.
*/
get loggingEnabled() {
return this._loggingEnabled;
}
set loggingEnabled(value) {
if (this._loggingEnabled === value) {
return;
}
this._loggingEnabled = value;
if (this._loggingEnabled) {
this._log = this._logEnabled;
}
else {
this._log = this._logDisabled;
}
}
/**
* Defines if the loader should capture performance counters.
*/
get capturePerformanceCounters() {
return this._capturePerformanceCounters;
}
set capturePerformanceCounters(value) {
if (this._capturePerformanceCounters === value) {
return;
}
this._capturePerformanceCounters = value;
if (this._capturePerformanceCounters) {
this._startPerformanceCounter = this._startPerformanceCounterEnabled;
this._endPerformanceCounter = this._endPerformanceCounterEnabled;
}
else {
this._startPerformanceCounter = this._startPerformanceCounterDisabled;
this._endPerformanceCounter = this._endPerformanceCounterDisabled;
}
}
/**
* Callback raised after the asset is validated.
*/
set onValidated(callback) {
if (this._onValidatedObserver) {
this.onValidatedObservable.remove(this._onValidatedObserver);
}
this._onValidatedObserver = this.onValidatedObservable.add(callback);
}
/**
* Disposes the loader, releases resources during load, and cancels any outstanding requests.
*/
dispose() {
if (this._loader) {
this._loader.dispose();
this._loader = null;
}
for (const request of this._requests) {
request.abort();
}
this._requests.length = 0;
delete this._progressCallback;
this.preprocessUrlAsync = (url) => Promise.resolve(url);
this.onMeshLoadedObservable.clear();
this.onSkinLoadedObservable.clear();
this.onTextureLoadedObservable.clear();
this.onMaterialLoadedObservable.clear();
this.onCameraLoadedObservable.clear();
this.onCompleteObservable.clear();
this.onExtensionLoadedObservable.clear();
this.onDisposeObservable.notifyObservers(undefined);
this.onDisposeObservable.clear();
}
/**
* @internal
*/
loadFile(scene, fileOrUrl, rootUrl, onSuccess, onProgress, useArrayBuffer, onError, name) {
if (ArrayBuffer.isView(fileOrUrl)) {
this._loadBinary(scene, fileOrUrl, rootUrl, onSuccess, onError, name);
return null;
}
this._progressCallback = onProgress;
const fileName = fileOrUrl.name || Tools.GetFilename(fileOrUrl);
if (useArrayBuffer) {
if (this.useRangeRequests) {
if (this.validate) {
Logger.Warn("glTF validation is not supported when range requests are enabled");
}
const fileRequest = {
abort: () => { },
onCompleteObservable: new Observable(),
};
const dataBuffer = {
readAsync: (byteOffset, byteLength) => {
return new Promise((resolve, reject) => {
this._loadFile(scene, fileOrUrl, (data) => {
resolve(new Uint8Array(data));
}, true, (error) => {
reject(error);
}, (webRequest) => {
webRequest.setRequestHeader("Range", `bytes=${byteOffset}-${byteOffset + byteLength - 1}`);
});
});
},
byteLength: 0,
};
this._unpackBinaryAsync(new DataReader(dataBuffer)).then((loaderData) => {
fileRequest.onCompleteObservable.notifyObservers(fileRequest);
onSuccess(loaderData);
}, onError ? (error) => onError(undefined, error) : undefined);
return fileRequest;
}
return this._loadFile(scene, fileOrUrl, (data) => {
this._validate(scene, new Uint8Array(data, 0, data.byteLength), rootUrl, fileName);
this._unpackBinaryAsync(new DataReader({
readAsync: (byteOffset, byteLength) => readAsync(data, byteOffset, byteLength),
byteLength: data.byteLength,
})).then((loaderData) => {
onSuccess(loaderData);
}, onError ? (error) => onError(undefined, error) : undefined);
}, true, onError);
}
else {
return this._loadFile(scene, fileOrUrl, (data) => {
try {
this._validate(scene, data, rootUrl, fileName);
onSuccess({ json: this._parseJson(data) });
}
catch {
if (onError) {
onError();
}
}
}, false, onError);
}
}
_loadBinary(scene, data, rootUrl, onSuccess, onError, fileName) {
this._validate(scene, new Uint8Array(data.buffer, data.byteOffset, data.byteLength), rootUrl, fileName);
this._unpackBinaryAsync(new DataReader({
readAsync: (byteOffset, byteLength) => readViewAsync(data, byteOffset, byteLength),
byteLength: data.byteLength,
})).then((loaderData) => {
onSuccess(loaderData);
}, onError ? (error) => onError(undefined, error) : undefined);
}
/**
* @internal
*/
importMeshAsync(meshesNames, scene, data, rootUrl, onProgress, fileName) {
return Promise.resolve().then(() => {
this.onParsedObservable.notifyObservers(data);
this.onParsedObservable.clear();
this._log(`Loading ${fileName || ""}`);
this._loader = this._getLoader(data);
return this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);
});
}
/**
* @internal
*/
loadAsync(scene, data, rootUrl, onProgress, fileName) {
return Promise.resolve().then(() => {
this.onParsedObservable.notifyObservers(data);
this.onParsedObservable.clear();
this._log(`Loading ${fileName || ""}`);
this._loader = this._getLoader(data);
return this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);
});
}
/**
* @internal
*/
loadAssetContainerAsync(scene, data, rootUrl, onProgress, fileName) {
return Promise.resolve().then(() => {
this.onParsedObservable.notifyObservers(data);
this.onParsedObservable.clear();
this._log(`Loading ${fileName || ""}`);
this._loader = this._getLoader(data);
// Prepare the asset container.
const container = new AssetContainer(scene);
// Get materials/textures when loading to add to container
const materials = [];
this.onMaterialLoadedObservable.add((material) => {
materials.push(material);
});
const textures = [];
this.onTextureLoadedObservable.add((texture) => {
textures.push(texture);
});
const cameras = [];
this.onCameraLoadedObservable.add((camera) => {
cameras.push(camera);
});
const morphTargetManagers = [];
this.onMeshLoadedObservable.add((mesh) => {
if (mesh.morphTargetManager) {
morphTargetManagers.push(mesh.morphTargetManager);
}
});
return this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then((result) => {
Array.prototype.push.apply(container.geometries, result.geometries);
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);
Array.prototype.push.apply(container.materials, materials);
Array.prototype.push.apply(container.textures, textures);
Array.prototype.push.apply(container.lights, result.lights);
Array.prototype.push.apply(container.transformNodes, result.transformNodes);
Array.prototype.push.apply(container.cameras, cameras);
Array.prototype.push.apply(container.morphTargetManagers, morphTargetManagers);
return container;
});
});
}
/**
* @internal
*/
canDirectLoad(data) {
return GLTFFileLoaderMetadata.canDirectLoad(data);
}
/**
* @internal
*/
directLoad(scene, data) {
if (data.startsWith("base64," + GLTFMagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
data.startsWith(";base64," + GLTFMagicBase64Encoded) ||
data.startsWith("application/octet-stream;base64," + GLTFMagicBase64Encoded) ||
data.startsWith("model/gltf-binary;base64," + GLTFMagicBase64Encoded)) {
const arrayBuffer = DecodeBase64UrlToBinary(data);
this._validate(scene, new Uint8Array(arrayBuffer, 0, arrayBuffer.byteLength));
return this._unpackBinaryAsync(new DataReader({
readAsync: (byteOffset, byteLength) => readAsync(arrayBuffer, byteOffset, byteLength),
byteLength: arrayBuffer.byteLength,
}));
}
this._validate(scene, data);
return Promise.resolve({ json: this._parseJson(data) });
}
/** @internal */
createPlugin(options) {
return new GLTFFileLoader(options[GLTFFileLoaderMetadata.name]);
}
/**
* The loader state or null if the loader is not active.
*/
get loaderState() {
return this._state;
}
/**
* Returns a promise that resolves when the asset is completely loaded.
* @returns a promise that resolves when the asset is completely loaded.
*/
whenCompleteAsync() {
return new Promise((resolve, reject) => {
this.onCompleteObservable.addOnce(() => {
resolve();
});
this.onErrorObservable.addOnce((reason) => {
reject(reason);
});
});
}
/**
* @internal
*/
_setState(state) {
if (this._state === state) {
return;
}
this._state = state;
this.onLoaderStateChangedObservable.notifyObservers(this._state);
this._log(GLTFLoaderState[this._state]);
}
/**
* @internal
*/
_loadFile(scene, fileOrUrl, onSuccess, useArrayBuffer, onError, onOpened) {
const request = scene._loadFile(fileOrUrl, onSuccess, (event) => {
this._onProgress(event, request);
}, true, useArrayBuffer, onError, onOpened);
request.onCompleteObservable.add(() => {
// Force the length computable to be true since we can guarantee the data is loaded.
request._lengthComputable = true;
request._total = request._loaded;
});
this._requests.push(request);
return request;
}
_onProgress(event, request) {
if (!this._progressCallback) {
return;
}
request._lengthComputable = event.lengthComputable;
request._loaded = event.loaded;
request._total = event.total;
let lengthComputable = true;
let loaded = 0;
let total = 0;
for (const request of this._requests) {
if (request._lengthComputable === undefined || request._loaded === undefined || request._total === undefined) {
return;
}
lengthComputable = lengthComputable && request._lengthComputable;
loaded += request._loaded;
total += request._total;
}
this._progressCallback({
lengthComputable: lengthComputable,
loaded: loaded,
total: lengthComputable ? total : 0,
});
}
_validate(scene, data, rootUrl = "", fileName = "") {
if (!this.validate) {
return;
}
this._startPerformanceCounter("Validate JSON");
GLTFValidation.ValidateAsync(data, rootUrl, fileName, (uri) => {
return this.preprocessUrlAsync(rootUrl + uri).then((url) => {
return scene._loadFileAsync(url, undefined, true, true).then((data) => {
return new Uint8Array(data, 0, data.byteLength);
});
});
}).then((result) => {
this._endPerformanceCounter("Validate JSON");
this.onValidatedObservable.notifyObservers(result);
this.onValidatedObservable.clear();
}, (reason) => {
this._endPerformanceCounter("Validate JSON");
Tools.Warn(`Failed to validate: ${reason.message}`);
this.onValidatedObservable.clear();
});
}
_getLoader(loaderData) {
const asset = loaderData.json.asset || {};
this._log(`Asset version: ${asset.version}`);
asset.minVersion && this._log(`Asset minimum version: ${asset.minVersion}`);
asset.generator && this._log(`Asset generator: ${asset.generator}`);
const version = GLTFFileLoader._parseVersion(asset.version);
if (!version) {
throw new Error("Invalid version: " + asset.version);
}
if (asset.minVersion !== undefined) {
const minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
if (!minVersion) {
throw new Error("Invalid minimum version: " + asset.minVersion);
}
if (GLTFFileLoader._compareVersion(minVersion, { major: 2, minor: 0 }) > 0) {
throw new Error("Incompatible minimum version: " + asset.minVersion);
}
}
const createLoaders = {
1: GLTFFileLoader._CreateGLTF1Loader,
2: GLTFFileLoader._CreateGLTF2Loader,
};
const createLoader = createLoaders[version.major];
if (!createLoader) {
throw new Error("Unsupported version: " + asset.version);
}
return createLoader(this);
}
_parseJson(json) {
this._startPerformanceCounter("Parse JSON");
this._log(`JSON length: ${json.length}`);
const parsed = JSON.parse(json);
this._endPerformanceCounter("Parse JSON");
return parsed;
}
_unpackBinaryAsync(dataReader) {
this._startPerformanceCounter("Unpack Binary");
// Read magic + version + length + json length + json format
return dataReader.loadAsync(20).then(() => {
const Binary = {
Magic: 0x46546c67,
};
const magic = dataReader.readUint32();
if (magic !== Binary.Magic) {
throw new RuntimeError("Unexpected magic: " + magic, ErrorCodes.GLTFLoaderUnexpectedMagicError);
}
const version = dataReader.readUint32();
if (this.loggingEnabled) {
this._log(`Binary version: ${version}`);
}
const length = dataReader.readUint32();
if (!this.useRangeRequests && length !== dataReader.buffer.byteLength) {
Logger.Warn(`Length in header does not match actual data length: ${length} != ${dataReader.buffer.byteLength}`);
}
let unpacked;
switch (version) {
case 1: {
unpacked = this._unpackBinaryV1Async(dataReader, length);
break;
}
case 2: {
unpacked = this._unpackBinaryV2Async(dataReader, length);
break;
}
default: {
throw new Error("Unsupported version: " + version);
}
}
this._endPerformanceCounter("Unpack Binary");
return unpacked;
});
}
_unpackBinaryV1Async(dataReader, length) {
const ContentFormat = {
JSON: 0,
};
const contentLength = dataReader.readUint32();
const contentFormat = dataReader.readUint32();
if (contentFormat !== ContentFormat.JSON) {
throw new Error(`Unexpected content format: ${contentFormat}`);
}
const bodyLength = length - dataReader.byteOffset;
const data = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };
if (bodyLength !== 0) {
const startByteOffset = dataReader.byteOffset;
data.bin = {
readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),
byteLength: bodyLength,
};
}
return Promise.resolve(data);
}
_unpackBinaryV2Async(dataReader, length) {
const ChunkFormat = {
JSON: 0x4e4f534a,
BIN: 0x004e4942,
};
// Read the JSON chunk header.
const chunkLength = dataReader.readUint32();
const chunkFormat = dataReader.readUint32();
if (chunkFormat !== ChunkFormat.JSON) {
throw new Error("First chunk format is not JSON");
}
// Bail if there are no other chunks.
if (dataReader.byteOffset + chunkLength === length) {
return dataReader.loadAsync(chunkLength).then(() => {
return { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };
});
}
// Read the JSON chunk and the length and type of the next chunk.
return dataReader.loadAsync(chunkLength + 8).then(() => {
const data = { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };
const readAsync = () => {
const chunkLength = dataReader.readUint32();
const chunkFormat = dataReader.readUint32();
switch (chunkFormat) {
case ChunkFormat.JSON: {
throw new Error("Unexpected JSON chunk");
}
case ChunkFormat.BIN: {
const startByteOffset = dataReader.byteOffset;
data.bin = {
readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),
byteLength: chunkLength,
};
dataReader.skipBytes(chunkLength);
break;
}
default: {
// ignore unrecognized chunkFormat
dataReader.skipBytes(chunkLength);
break;
}
}
if (dataReader.byteOffset !== length) {
return dataReader.loadAsync(8).then(readAsync);
}
return Promise.resolve(data);
};
return readAsync();
});
}
static _parseVersion(version) {
if (version === "1.0" || version === "1.0.1") {
return {
major: 1,
minor: 0,
};
}
const match = (version + "").match(/^(\d+)\.(\d+)/);
if (!match) {
return null;
}
return {
major: parseInt(match[1]),
minor: parseInt(match[2]),
};
}
static _compareVersion(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;
}
/**
* @internal
*/
_logOpen(message) {
this._log(message);
this._logIndentLevel++;
}
/** @internal */
_logClose() {
--this._logIndentLevel;
}
_logEnabled(message) {
const spaces = GLTFFileLoader._logSpaces.substring(0, this._logIndentLevel * 2);
Logger.Log(`${spaces}${message}`);
}
_logDisabled(message) { }
_startPerformanceCounterEnabled(counterName) {
Tools.StartPerformanceCounter(counterName);
}
_startPerformanceCounterDisabled(counterName) { }
_endPerformanceCounterEnabled(counterName) {
Tools.EndPerformanceCounter(counterName);
}
_endPerformanceCounterDisabled(counterName) { }
}
// ------------------
// End Common options
// ------------------
// ----------------
// Begin 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.
* @internal
*/
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.
* @internal
*/
GLTFFileLoader.HomogeneousCoordinates = false;
GLTFFileLoader._logSpaces = " ";
let _Registered$1 = false;
/**
* Registers the GLTFFileLoader scene loader plugin.
* Safe to call multiple times; only the first call has an effect.
*/
function RegisterGLTFFileLoader() {
if (_Registered$1) {
return;
}
_Registered$1 = true;
RegisterSceneLoaderPlugin(new GLTFFileLoader());
}
// Caching these dynamic imports gives a surprising perf boost (compared to importing them directly each time).
const LazyAnimationGroupModulePromise = /*#__PURE__*/ new Lazy(() => import('./animationGroup-Cp7f8LUX.esm.js'));
const LazyLoaderAnimationModulePromise = /*#__PURE__*/ new Lazy(() => import('./glTFLoaderAnimation-BgUTPDiB.esm.js'));
/**
* Helper class for working with arrays when loading the glTF asset
*/
class ArrayItem {
/**
* Gets an item from the given array.
* @param context The context when loading the asset
* @param array The array to get the item from
* @param index The index to the array
* @returns The array item
*/
static Get(context, array, index) {
if (!array || index == undefined || !array[index]) {
throw new Error(`${context}: Failed to find index (${index})`);
}
return array[index];
}
/**
* Gets an item from the given array or returns null if not available.
* @param array The array to get the item from
* @param index The index to the array
* @returns The array item or null
*/
static TryGet(array, index) {
if (!array || index == undefined || !array[index]) {
return null;
}
return array[index];
}
/**
* Assign an `index` field to each item of the given array.
* @param array The array of items
*/
static Assign(array) {
if (array) {
for (let index = 0; index < array.length; index++) {
array[index].index = index;
}
}
}
}
/** @internal */
function LoadBoundingInfoFromPositionAccessor(accessor) {
if (accessor.min && accessor.max) {
const minArray = accessor.min;
const maxArray = accessor.max;
const minVector = TmpVectors.Vector3[0].copyFromFloats(minArray[0], minArray[1], minArray[2]);
const maxVector = TmpVectors.Vector3[1].copyFromFloats(maxArray[0], maxArray[1], maxArray[2]);
if (accessor.normalized && accessor.componentType !== 5126 /* AccessorComponentType.FLOAT */) {
let divider = 1;
switch (accessor.componentType) {
case 5120 /* AccessorComponentType.BYTE */:
divider = 127.0;
break;
case 5121 /* AccessorComponentType.UNSIGNED_BYTE */:
divider = 255.0;
break;
case 5122 /* AccessorComponentType.SHORT */:
divider = 32767.0;
break;
case 5123 /* AccessorComponentType.UNSIGNED_SHORT */:
divider = 65535.0;
break;
}
const oneOverDivider = 1 / divider;
minVector.scaleInPlace(oneOverDivider);
maxVector.scaleInPlace(oneOverDivider);
}
return new BoundingInfo(minVector, maxVector);
}
return null;
}
/**
* The glTF 2.0 loader
*/
class GLTFLoader {
/**
* Test if the given material is an instance of any PBR material type known to this loader.
* @param material The material to test
* @returns true if the material matches one of the loaded PBR implementations
*/
isMatchingMaterialType(material) {
if (!material) {
return false;
}
const materialImpls = Array.from(this._pbrMaterialImpls.values());
for (const impl of materialImpls) {
if (material instanceof impl.materialClass) {
return true;
}
}
return false;
}
/**
* Registers a loader extension.
* @param name The name of the loader extension.
* @param factory The factory function that creates the loader extension.
* @deprecated Please use registerGLTFExtension instead.
*/
static RegisterExtension(name, factory) {
registerGLTFExtension(name, false, factory);
}
/**
* Unregisters a loader extension.
* @param name The name of the loader extension.
* @returns A boolean indicating whether the extension has been unregistered
* @deprecated Please use unregisterGLTFExtension instead.
*/
static UnregisterExtension(name) {
return unregisterGLTFExtension(name);
}
/**
* The object that represents the glTF JSON.
*/
get gltf() {
if (!this._gltf) {
throw new Error("glTF JSON is not available");
}
return this._gltf;
}
/**
* The BIN chunk of a binary glTF.
*/
get bin() {
return this._bin;
}
/**
* The parent file loader.
*/
get parent() {
return this._parent;
}
/**
* The Babylon scene when loading the asset.
*/
get babylonScene() {
if (!this._babylonScene) {
throw new Error("Scene is not available");
}
return this._babylonScene;
}
/**
* The root Babylon node when loading the asset.
*/
get rootBabylonMesh() {
return this._rootBabylonMesh;
}
/**
* The root url when loading the asset.
*/
get rootUrl() {
return this._rootUrl;
}
/**
* @internal
*/
constructor(parent) {
/** @internal */
this._completePromises = new Array();
/** @internal */
this._assetContainer = null;
/** Storage */
this._babylonLights = [];
/** @internal */
this._disableInstancedMesh = 0;
/** @internal */
this._allMaterialsDirtyRequired = false;
/** @internal */
this._skipStartAnimationStep = false;
this._extensions = new Array();
/** @internal */
this._disposed = false;
this._rootUrl = null;
this._fileName = null;
this._uniqueRootUrl = null;
this._bin = null;
this._rootBabylonMesh = null;
this._defaultBabylonMaterialData = {};
this._postSceneLoadActions = new Array();
this._materialAdapterCache = new WeakMap();
this._materialAdapters = new Set();
/**
* Loaded PBR material implementations, keyed by their identifier (e.g. "pbr", "openpbr").
* Only populated after the load has started and only for the types actually needed by the asset.
* Empty when PBR materials are disabled (skipMaterials).
* @internal
*/
this._pbrMaterialImpls = new Map();
this._parent = parent;
}
/**
* Creates or gets a cached material loading adapter with dynamic imports
* @param material The material to adapt
* @returns Promise that resolves to the appropriate adapter
* @internal
*/
_getOrCreateMaterialAdapter(material) {
let adapter = this._materialAdapterCache.get(material);
if (!adapter) {
const materialImpls = Array.from(this._pbrMaterialImpls.values());
for (const impl of materialImpls) {
if (material instanceof impl.materialClass) {
adapter = new impl.adapterClass(material);
break;
}
}
if (!adapter) {
throw new Error(`Appropriate material adapter class not found`);
}
const createdAdapter = adapter;
this._materialAdapterCache.set(material, createdAdapter);
this._materialAdapters.add(createdAdapter);
}
return adapter;
}
/** @internal */
dispose() {
if (this._disposed) {
return;
}
this._disposed = true;
this._completePromises.length = 0;
this._extensions.forEach((extension) => extension.dispose && extension.dispose());
this._extensions.length = 0;
this._materialAdapters.clear();
this._gltf = null; // TODO
this._bin = null;
this._babylonScene = null; // TODO
this._rootBabylonMesh = null;
this._defaultBabylonMaterialData = {};
this._postSceneLoadActions.length = 0;
this._parent.dispose();
}
/**
* @internal
*/
async importMeshAsync(meshesNames, scene, container, data, rootUrl, onProgress, fileName = "") {
return await Promise.resolve().then(async () => {
this._babylonScene = scene;
this._assetContainer = container;
this._loadData(data);
let nodes = null;
if (meshesNames) {
const nodeMap = {};
if (this._gltf.nodes) {
for (const node of this._gltf.nodes) {
if (node.name) {
nodeMap[node.name] = node.index;
}
}
}
const names = meshesNames instanceof Array ? meshesNames : [meshesNames];
nodes = names.map((name) => {
const node = nodeMap[name];
if (node === undefined) {
throw new Error(`Failed to find node '${name}'`);
}
return node;
});
}
return await this._loadAsync(rootUrl, fileName, nodes, () => {
return {
meshes: this._getMeshes(),
particleSystems: [],
skeletons: this._getSkeletons(),
animationGroups: this._getAnimationGroups(),
lights: this._babylonLights,
transformNodes: this._getTransformNodes(),
geometries: this._getGeometries(),
spriteManagers: [],
};
});
});
}
/**
* @internal
*/
async loadAsync(scene, data, rootUrl, onProgress, fileName = "") {
this._babylonScene = scene;
this._loadData(data);
return await this._loadAsync(rootUrl, fileName, null, () => undefined);
}
async _loadAsync(rootUrl, fileName, nodes, resultFunc) {
return await Promise.resolve()
.then(async () => {
this._rootUrl = rootUrl;
this._uniqueRootUrl = !rootUrl.startsWith("file:") && fileName ? rootUrl : `${rootUrl}${RandomGUID()}/`;
this._fileName = fileName;
this._allMaterialsDirtyRequired = false;
await this._loadExtensionsAsync();
if (!this.parent.skipMaterials) {
const needsOpenPBR = this.parent.useOpenPBR || this.isExtensionUsed("KHR_materials_openpbr");
let needsPBR = false;
if (!this.parent.useOpenPBR) {
// PBR is needed when useOpenPBR is turned off.
needsPBR = true;
}
else if (this._gltf.materials?.length && this._gltf.materials.some((m) => !m.extensions?.["KHR_materials_openpbr"])) {
// PBR is needed if there is at least one material that does not use the KHR_materials_openpbr extension (i.e. relies on the default PBR implementation).
needsPBR = true;
}
const implPromises = [];
if (needsOpenPBR && !this._pbrMaterialImpls.has("openpbr")) {
implPromises.push(
// Import the .pure module (which directly declares the class and its registration
// function) rather than the side-effect wrapper. The wrapper re-exports the class via
// `export *`, and some bundlers fail to surface star-re-exported bindings on a dynamic
// import namespace across a chunk boundary (e.g. a Web Worker chunk), which would leave
// materialClass undefined and throw a cryptic "materialClass is not a constructor" later.
// A direct named export is reliable everywhere; we trigger registration explicitly.
Promise.all([import('./openpbrMaterial.pure-ChcQZB2S.esm.js'), import('./openpbrMaterialLoadingAdapter-DjWylswE.esm.js')]).then(([{ OpenPBRMaterial: openPBRMaterialClass, RegisterOpenpbrMaterial: registerOpenPBRMaterial }, { OpenPBRMaterialLoadingAdapter: openPBRAdapterClass },]) => {
registerOpenPBRMaterial();
this._pbrMaterialImpls.set("openpbr", {
materialClass: openPBRMaterialClass,
adapterClass: openPBRAdapterClass,
});
}));
}
if (needsPBR && !this._pbrMaterialImpls.has("pbr")) {
implPromises.push(
// See the openpbr note above: import the .pure module for a reliable class binding and
// register the class explicitly instead of relying on the wrapper's `export *` re-export.
Promise.all([import('./pbrMaterial.pure-BzpwJ0cY.esm.js'), import('./pbrMaterialLoadingAdapter-BJ5k5xoh.esm.js')]).then(([{ PBRMaterial: pbrMaterialClass, RegisterPbrMaterial: registerPBRMaterial }, { PBRMaterialLoadingAdapter: pbrAdapterClass }]) => {
registerPBRMaterial();
this._pbrMaterialImpls.set("pbr", {
materialClass: pbrMaterialClass,
adapterClass: pbrAdapterClass,
});
}));
}
await Promise.all(implPromises);
}
const loadingToReadyCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.READY]}`;
const loadingToCompleteCounterName = `${GLTFLoaderState[GLTFLoaderState.LOADING]} => ${GLTFLoaderState[GLTFLoaderState.COMPLETE]}`;
this._parent._startPerformanceCounter(loadingToReadyCounterName);
this._parent._startPerformanceCounter(loadingToCompleteCounterName);
this._parent._setState(GLTFLoaderState.LOADING);
this._extensionsOnLoading();
const promises = new Array();
// Block the marking of materials dirty until the scene is loaded.
const oldBlockMaterialDirtyMechanism = this._babylonScene.blockMaterialDirtyMechanism;
this._babylonScene.blockMaterialDirtyMechanism = true;
if (!this.parent.loadOnlyMaterials) {
if (nodes) {
promises.push(this.loadSceneAsync("/nodes", { nodes: nodes, index: -1 }));
}
else if (this._gltf.scene != undefined || (this._gltf.scenes && this._gltf.scenes[0])) {
const scene = ArrayItem.Get(`/scene`, this._gltf.scenes, this._gltf.scene || 0);
promises.push(this.loadSceneAsync(`/scenes/${scene.index}`, scene));
}
}
if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials) {
for (let m = 0; m < this._gltf.materials.length; ++m) {
const material = this._gltf.materials[m];
const context = "/materials/" + m;
const babylonDrawMode = Material.TriangleFillMode;
promises.push(this._loadMaterialAsync(context, material, null, babylonDrawMode, () => { }));
}
}
// Restore the blocking of material dirty.
if (this._allMaterialsDirtyRequired) {
// This can happen if we add a light for instance as it will impact the whole scene.
// This automatically resets everything if needed.
this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;
}
else {
// By default a newly created material is dirty so there is no need to flag the full scene as dirty.
// For perf reasons, we then bypass blockMaterialDirtyMechanism as this would "dirty" the entire scene.
this._babylonScene._forceBlockMaterialDirtyMechanism(oldBlockMaterialDirtyMechanism);
}
if (this._parent.compileMaterials) {
promises.push(this._compileMaterialsAsync());
}
if (this._parent.compileShadowGenerators) {
promises.push(this._compileShadowGeneratorsAsync());
}
const resultPromise = Promise.all(promises).then(() => {
if (this._rootBabylonMesh && this._rootBabylonMesh !== this._parent.customRootNode) {
this._rootBabylonMesh.setEnabled(true);
}
// Making sure we enable enough lights to have all lights together
for (const material of this._babylonScene.materials) {
const mat = material;
if (mat.maxSimultaneousLights !== undefined) {
mat.maxSimultaneousLights = Math.max(mat.maxSimultaneousLights, this._babylonScene.lights.length);
}
}
// Finalize all material adapters. finalizeAsync() may return a Promise for async
// work (e.g. GPU texture processing); any returned Promise is pushed into
// _completePromises so it is awaited before the COMPLETE state is reached.
for (const adapter of Array.from(this._materialAdapters)) {
this._completePromises.push(adapter.finalizeAsync(this));
}
this._extensionsOnReady();
this._parent._setState(GLTFLoaderState.READY);
if (!this._skipStartAnimationStep) {
this._startAnimations();
}
return resultFunc();
});
return await resultPromise.then((result) => {
this._parent._endPerformanceCounter(loadingToReadyCounterName);
Tools.SetImmediate(() => {
if (!this._disposed) {
Promise.all(this._completePromises).then(() => {
this._parent._endPerformanceCounter(loadingToCompleteCounterName);
this._parent._setState(GLTFLoaderState.COMPLETE);
this._parent.onCompleteObservable.notifyObservers(undefined);
this._parent.onCompleteObservable.clear();
this.dispose();
}, (error) => {
this._parent.onErrorObservable.notifyObservers(error);
this._parent.onErrorObservable.clear();
this.dispose();
});
}
});
return result;
});
})
.catch((error) => {
if (!this._disposed) {
this._parent.onErrorObservable.notifyObservers(error);
this._parent.onErrorObservable.clear();
this.dispose();
}
throw error;
});
}
_loadData(data) {
this._gltf = data.json;
this._setupData();
if (data.bin) {
const buffers = this._gltf.buffers;
if (buffers && buffers[0] && !buffers[0].uri) {
const binaryBuffer = buffers[0];
if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {
Logger.Warn(`Binary buffer length (${binaryBuffer.byteLength}) from JSON does not match chunk length (${data.bin.byteLength})`);
}
this._bin = data.bin;
}
else {
Logger.Warn("Unexpected BIN chunk");
}
}
}
_setupData() {
ArrayItem.Assign(this._gltf.accessors);
ArrayItem.Assign(this._gltf.animations);
ArrayItem.Assign(this._gltf.buffers);
ArrayItem.Assign(this._gltf.bufferViews);
ArrayItem.Assign(this._gltf.cameras);
ArrayItem.Assign(this._gltf.images);
ArrayItem.Assign(this._gltf.materials);
ArrayItem.Assign(this._gltf.meshes);
ArrayItem.Assign(this._gltf.nodes);
ArrayItem.Assign(this._gltf.samplers);
ArrayItem.Assign(this._gltf.scenes);
ArrayItem.Assign(this._gltf.skins);
ArrayItem.Assign(this._gltf.textures);
if (this._gltf.nodes) {
const nodeParents = {};
for (const node of this._gltf.nodes) {
if (node.children) {
for (const index of node.children) {
nodeParents[index] = node.index;
}
}
}
const rootNode = this._createRootNode();
for (const node of this._gltf.nodes) {
const parentIndex = nodeParents[node.index];
node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];
}
}
}
async _loadExtensionsAsync() {
const extensionPromises = [];
registeredGLTFExtensions.forEach((registeredExtension, name) => {
// Don't load explicitly disabled extensions.
if (this.parent.extensionOptions[name]?.enabled === false) {
// But warn if the disabled extension is used by the model.
if (registeredExtension.isGLTFExtension && this.isExtensionUsed(name)) {
Logger.Warn(`Extension ${name} is used but has been explicitly disabled.`);
}
}
// Load loader extensions that are not a glTF extension, as well as extensions that are glTF extensions and are used by the model.
else if (!registeredExtension.isGLTFExtension || this.isExtensionUsed(name)) {
extensionPromises.push((async () => {
const extension = await registeredExtension.factory(this);
if (extension.name !== name) {
Logger.Warn(`The name of the glTF loader extension instance does not match the registered name: ${extension.name} !== ${name}`);
}
this._parent.onExtensionLoadedObservable.notifyObservers(extension);
return extension;
})());
}
});
this._extensions.push(...(await Promise.all(extensionPromises)));
this._extensions.sort((a, b) => (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE));
this._parent.onExtensionLoadedObservable.clear();
if (this._gltf.extensionsRequired) {
for (const name of this._gltf.extensionsRequired) {
const available = this._extensions.some((extension) => extension.name === name && extension.enabled);
if (!available) {
if (this.parent.extensionOptions[name]?.enabled === false) {
throw new Error(`Required extension ${name} is disabled`);
}
throw new Error(`Required extension ${name} is not available`);
}
}
}
}
_createRootNode() {
if (this._parent.customRootNode !== undefined) {
this._rootBabylonMesh = this._parent.customRootNode;
return {
_babylonTransformNode: this._rootBabylonMesh === null ? undefined : this._rootBabylonMesh,
index: -1,
};
}
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const rootMesh = new Mesh("__root__", this._babylonScene);
this._rootBabylonMesh = rootMesh;
this._rootBabylonMesh._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
this._rootBabylonMesh.setEnabled(false);
const rootNode = {
_babylonTransformNode: this._rootBabylonMesh,
index: -1,
};
switch (this._parent.coordinateSystemMode) {
case GLTFLoaderCoordinateSystemMode.AUTO: {
if (!this._babylonScene.useRightHandedSystem) {
rootNode.rotation = [0, 1, 0, 0];
rootNode.scale = [1, 1, -1];
GLTFLoader._LoadTransform(rootNode, this._rootBabylonMesh);
}
break;
}
case GLTFLoaderCoordinateSystemMode.FORCE_RIGHT_HANDED: {
this._babylonScene.useRightHandedSystem = true;
break;
}
default: {
throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);
}
}
this._parent.onMeshLoadedObservable.notifyObservers(rootMesh);
return rootNode;
}
/**
* Loads a glTF scene.
* @param context The context when loading the asset
* @param scene The glTF scene property
* @returns A promise that resolves when the load is complete
*/
loadSceneAsync(context, scene) {
const extensionPromise = this._extensionsLoadSceneAsync(context, scene);
if (extensionPromise) {
return extensionPromise;
}
const promises = new Array();
this.logOpen(`${context} ${scene.name || ""}`);
if (scene.nodes) {
for (const index of scene.nodes) {
const node = ArrayItem.Get(`${context}/nodes/${index}`, this._gltf.nodes, index);
promises.push(this.loadNodeAsync(`/nodes/${node.index}`, node, (babylonMesh) => {
babylonMesh.parent = this._rootBabylonMesh;
}));
}
}
for (const action of this._postSceneLoadActions) {
action();
}
promises.push(this._loadAnimationsAsync());
this.logClose();
return Promise.all(promises).then(() => { });
}
_forEachPrimitive(node, callback) {
if (node._primitiveBabylonMeshes) {
for (const babylonMesh of node._primitiveBabylonMeshes) {
callback(babylonMesh);
}
}
}
_getGeometries() {
const geometries = [];
const nodes = this._gltf.nodes;
if (nodes) {
for (const node of nodes) {
this._forEachPrimitive(node, (babylonMesh) => {
const geometry = babylonMesh.geometry;
if (geometry && geometries.indexOf(geometry) === -1) {
geometries.push(geometry);
}
});
}
}
return geometries;
}
_getMeshes() {
const meshes = [];
// Root mesh is always first, if available.
if (this._rootBabylonMesh instanceof AbstractMesh) {
meshes.push(this._rootBabylonMesh);
}
const nodes = this._gltf.nodes;
if (nodes) {
for (const node of nodes) {
this._forEachPrimitive(node, (babylonMesh) => {
meshes.push(babylonMesh);
});
}
}
return meshes;
}
_getTransformNodes() {
const transformNodes = [];
const nodes = this._gltf.nodes;
if (nodes) {
for (const node of nodes) {
if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === "TransformNode") {
transformNodes.push(node._babylonTransformNode);
}
if (node._babylonTransformNodeForSkin) {
transformNodes.push(node._babylonTransformNodeForSkin);
}
}
}
return transformNodes;
}
_getSkeletons() {
const skeletons = [];
const skins = this._gltf.skins;
if (skins) {
for (const skin of skins) {
if (skin._data) {
skeletons.push(skin._data.babylonSkeleton);
}
}
}
return skeletons;
}
_getAnimationGroups() {
const animationGroups = [];
const animations = this._gltf.animations;
if (animations) {
for (const animation of animations) {
if (animation._babylonAnimationGroup) {
animationGroups.push(animation._babylonAnimationGroup);
}
}
}
return animationGroups;
}
_startAnimations() {
switch (this._parent.animationStartMode) {
case GLTFLoaderAnimationStartMode.NONE: {
// do nothing
break;
}
case GLTFLoaderAnimationStartMode.FIRST: {
const babylonAnimationGroups = this._getAnimationGroups();
if (babylonAnimationGroups.length !== 0) {
babylonAnimationGroups[0].start(true);
}
break;
}
case GLTFLoaderAnimationStartMode.ALL: {
const babylonAnimationGroups = this._getAnimationGroups();
for (const babylonAnimationGroup of babylonAnimationGroups) {
babylonAnimationGroup.start(true);
}
break;
}
default: {
Logger.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);
return;
}
}
}
/**
* Loads a glTF node.
* @param context The context when loading the asset
* @param node The glTF node property
* @param assign A function called synchronously after parsing the glTF properties
* @returns A promise that resolves with the loaded Babylon mesh when the load is complete
*/
loadNodeAsync(context, node, assign = () => { }) {
const extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
if (extensionPromise) {
return extensionPromise;
}
if (node._babylonTransformNode) {
throw new Error(`${context}: Invalid recursive node hierarchy`);
}
const promises = new Array();
this.logOpen(`${context} ${node.name || ""}`);
const loadNode = (babylonTransformNode) => {
GLTFLoader.AddPointerMetadata(babylonTransformNode, context);
GLTFLoader._LoadTransform(node, babylonTransformNode);
if (node.camera != undefined) {
const camera = ArrayItem.Get(`${context}/camera`, this._gltf.cameras, node.camera);
promises.push(this.loadCameraAsync(`/cameras/${camera.index}`, camera, (babylonCamera) => {
babylonCamera.parent = babylonTransformNode;
if (!this._babylonScene.useRightHandedSystem) {
babylonTransformNode.scaling.x = -1; // Cancelling root node scaling for handedness so the view matrix does not end up flipped.
}
}));
}
if (node.children) {
for (const index of node.children) {
const childNode = ArrayItem.Get(`${context}/children/${index}`, this._gltf.nodes, index);
promises.push(this.loadNodeAsync(`/nodes/${childNode.index}`, childNode, (childBabylonMesh) => {
childBabylonMesh.parent = babylonTransformNode;
}));
}
}
assign(babylonTransformNode);
};
const hasMesh = node.mesh != undefined;
const hasSkin = this._parent.loadSkins && node.skin != undefined;
if (!hasMesh || hasSkin) {
const nodeName = node.name || `node${node.index}`;
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const transformNode = new TransformNode(nodeName, this._babylonScene);
transformNode._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
if (node.mesh == undefined) {
node._babylonTransformNode = transformNode;
}
else {
node._babylonTransformNodeForSkin = transformNode;
}
loadNode(transformNode);
}
if (hasMesh) {
if (hasSkin) {
// See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
// This code path will place the skinned mesh as a sibling of the skeleton root node without loading the
// transform, which effectively ignores the transform of the skinned mesh, as per spec.
const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, (babylonTransformNode) => {
const babylonTransformNodeForSkin = node._babylonTransformNodeForSkin;
// Merge the metadata from the skin node to the skinned mesh in case a loader extension added metadata.
babylonTransformNode.metadata = deepMerge(babylonTransformNodeForSkin.metadata, babylonTransformNode.metadata || {});
const skin = ArrayItem.Get(`${context}/skin`, this._gltf.skins, node.skin);
promises.push(this._loadSkinAsync(`/skins/${skin.index}`, node, skin, (babylonSkeleton) => {
this._forEachPrimitive(node, (babylonMesh) => {
babylonMesh.skeleton = babylonSkeleton;
});
// Wait until all the nodes are parented before parenting the skinned mesh.
this._postSceneLoadActions.push(() => {
if (skin.skeleton != undefined) {
// Place the skinned mesh node as a sibling of the skeleton root node.
// Handle special case when the parent of the skeleton root is the skinned mesh.
const parentNode = ArrayItem.Get(`/skins/${skin.index}/skeleton`, this._gltf.nodes, skin.skeleton).parent;
if (node.index === parentNode.index) {
babylonTransformNode.parent = babylonTransformNodeForSkin.parent;
}
else {
babylonTransformNode.parent = parentNode._babylonTransformNode;
}
}
else {
babylonTransformNode.parent = this._rootBabylonMesh;
}
this._parent.onSkinLoadedObservable.notifyObservers({ node: babylonTransformNodeForSkin, skinnedNode: babylonTransformNode });
});
}));
}));
}
else {
const mesh = ArrayItem.Get(`${context}/mesh`, this._gltf.meshes, node.mesh);
promises.push(this._loadMeshAsync(`/meshes/${mesh.index}`, node, mesh, loadNode));
}
}
this.logClose();
return Promise.all(promises).then(() => {
this._forEachPrimitive(node, (babylonMesh) => {
const asMesh = babylonMesh;
if (!asMesh.isAnInstance && asMesh.geometry && asMesh.geometry.useBoundingInfoFromGeometry) {
// simply apply the world matrices to the bounding info - the extends are already ok
babylonMesh._updateBoundingInfo();
}
else {
babylonMesh.refreshBoundingInfo(true, true);
}
});
return node._babylonTransformNode;
});
}
_loadMeshAsync(context, node, mesh, assign) {
const primitives = mesh.primitives;
if (!primitives || !primitives.length) {
throw new Error(`${context}: Primitives are missing`);
}
if (primitives[0].index == undefined) {
ArrayItem.Assign(primitives);
}
const promises = new Array();
this.logOpen(`${context} ${mesh.name || ""}`);
const name = node.name || `node${node.index}`;
if (primitives.length === 1) {
const primitive = mesh.primitives[0];
promises.push(this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, name, node, mesh, primitive, (babylonMesh) => {
node._babylonTransformNode = babylonMesh;
node._primitiveBabylonMeshes = [babylonMesh];
}));
}
else {
this._babylonScene._blockEntityCollection = !!this._assetContainer;
node._babylonTransformNode = new TransformNode(name, this._babylonScene);
node._babylonTransformNode._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
node._primitiveBabylonMeshes = [];
for (const primitive of primitives) {
promises.push(this._loadMeshPrimitiveAsync(`${context}/primitives/${primitive.index}`, `${name}_primitive${primitive.index}`, node, mesh, primitive, (babylonMesh) => {
babylonMesh.parent = node._babylonTransformNode;
node._primitiveBabylonMeshes.push(babylonMesh);
}));
}
}
assign(node._babylonTransformNode);
this.logClose();
return Promise.all(promises).then(() => {
return node._babylonTransformNode;
});
}
/**
* @internal Define this method to modify the default behavior when loading data for mesh primitives.
* @param context The context when loading the asset
* @param name The mesh name when loading the asset
* @param node The glTF node when loading the asset
* @param mesh The glTF mesh when loading the asset
* @param primitive The glTF mesh primitive property
* @param assign A function called synchronously after parsing the glTF properties
* @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
*/
_loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
const extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
if (extensionPromise) {
return extensionPromise;
}
this.logOpen(`${context}`);
const shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;
let babylonAbstractMesh;
let promise;
if (shouldInstance && primitive._instanceData) {
this._babylonScene._blockEntityCollection = !!this._assetContainer;
babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);
babylonAbstractMesh._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
promise = primitive._instanceData.promise;
}
else {
const promises = new Array();
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const babylonMesh = new Mesh(name, this._babylonScene);
babylonMesh._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
babylonMesh.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
this._createMorphTargets(context, node, mesh, primitive, babylonMesh);
promises.push(this._loadVertexDataAsync(context, primitive, babylonMesh).then(async (babylonGeometry) => {
return await this._loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry).then(() => {
if (this._disposed) {
return;
}
this._babylonScene._blockEntityCollection = !!this._assetContainer;
babylonGeometry.applyToMesh(babylonMesh);
babylonGeometry._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
});
}));
if (!this.parent.skipMaterials) {
const babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
if (primitive.material == undefined) {
let babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
if (!babylonMaterial) {
babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode, this._getDefaultImpl());
this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
}
babylonMesh.material = babylonMaterial;
}
else {
const material = ArrayItem.Get(`${context}/material`, this._gltf.materials, primitive.material);
promises.push(this._loadMaterialAsync(`/materials/${material.index}`, material, babylonMesh, babylonDrawMode, (babylonMaterial) => {
babylonMesh.material = babylonMaterial;
}));
}
}
promise = Promise.all(promises);
if (shouldInstance) {
primitive._instanceData = {
babylonSourceMesh: babylonMesh,
promise: promise,
};
}
babylonAbstractMesh = babylonMesh;
}
GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);
this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);
assign(babylonAbstractMesh);
this.logClose();
return promise.then(() => {
return babylonAbstractMesh;
});
}
_loadVertexDataAsync(context, primitive, babylonMesh) {
const extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
if (extensionPromise) {
return extensionPromise;
}
const attributes = primitive.attributes;
if (!attributes) {
throw new Error(`${context}: Attributes are missing`);
}
const promises = new Array();
const babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);
if (primitive.indices == undefined) {
babylonMesh.isUnIndexed = true;
}
else {
const accessor = ArrayItem.Get(`${context}/indices`, this._gltf.accessors, primitive.indices);
promises.push(this._loadIndicesAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {
babylonGeometry.setIndices(data);
}));
}
const loadAttribute = (name, kind, callback) => {
if (attributes[name] == undefined) {
return;
}
babylonMesh._delayInfo = babylonMesh._delayInfo || [];
if (babylonMesh._delayInfo.indexOf(kind) === -1) {
babylonMesh._delayInfo.push(kind);
}
const accessor = ArrayItem.Get(`${context}/attributes/${name}`, this._gltf.accessors, attributes[name]);
promises.push(this._loadVertexAccessorAsync(`/accessors/${accessor.index}`, accessor, kind).then((babylonVertexBuffer) => {
if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {
const babylonBoundingInfo = LoadBoundingInfoFromPositionAccessor(accessor);
if (babylonBoundingInfo) {
babylonGeometry._boundingInfo = babylonBoundingInfo;
babylonGeometry.useBoundingInfoFromGeometry = true;
}
}
babylonGeometry.setVerticesBuffer(babylonVertexBuffer, accessor.count);
}));
if (kind == VertexBuffer.MatricesIndicesExtraKind) {
babylonMesh.numBoneInfluencers = 8;
}
if (callback) {
callback(accessor);
}
};
loadAttribute("POSITION", VertexBuffer.PositionKind);
loadAttribute("NORMAL", VertexBuffer.NormalKind);
loadAttribute("TANGENT", VertexBuffer.TangentKind);
loadAttribute("TEXCOORD_0", VertexBuffer.UVKind);
loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind);
loadAttribute("TEXCOORD_2", VertexBuffer.UV3Kind);
loadAttribute("TEXCOORD_3", VertexBuffer.UV4Kind);
loadAttribute("TEXCOORD_4", VertexBuffer.UV5Kind);
loadAttribute("TEXCOORD_5", VertexBuffer.UV6Kind);
loadAttribute("JOINTS_0", VertexBuffer.MatricesIndicesKind);
loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
loadAttribute("JOINTS_1", VertexBuffer.MatricesIndicesExtraKind);
loadAttribute("WEIGHTS_1", VertexBuffer.MatricesWeightsExtraKind);
loadAttribute("COLOR_0", VertexBuffer.ColorKind, (accessor) => {
if (accessor.type === "VEC4" /* AccessorType.VEC4 */) {
babylonMesh.hasVertexAlpha = true;
}
});
return Promise.all(promises).then(() => {
return babylonGeometry;
});
}
_createMorphTargets(context, node, mesh, primitive, babylonMesh) {
if (!primitive.targets || !this._parent.loadMorphTargets) {
return;
}
if (node._numMorphTargets == undefined) {
node._numMorphTargets = primitive.targets.length;
}
else if (primitive.targets.length !== node._numMorphTargets) {
throw new Error(`${context}: Primitives do not have the same number of targets`);
}
const targetNames = mesh.extras ? mesh.extras.targetNames : null;
this._babylonScene._blockEntityCollection = !!this._assetContainer;
babylonMesh.morphTargetManager = new MorphTargetManager(this._babylonScene);
babylonMesh.morphTargetManager._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
babylonMesh.morphTargetManager.areUpdatesFrozen = true;
for (let index = 0; index < primitive.targets.length; index++) {
const weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;
const name = targetNames ? targetNames[index] : `morphTarget${index}`;
babylonMesh.morphTargetManager.addTarget(new MorphTarget(name, weight, babylonMesh.getScene()));
// TODO: tell the target whether it has positions, normals, tangents
}
}
_loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry) {
if (!primitive.targets || !this._parent.loadMorphTargets) {
return Promise.resolve();
}
const promises = new Array();
const morphTargetManager = babylonMesh.morphTargetManager;
for (let index = 0; index < morphTargetManager.numTargets; index++) {
const babylonMorphTarget = morphTargetManager.getTarget(index);
promises.push(this._loadMorphTargetVertexDataAsync(`${context}/targets/${index}`, babylonGeometry, primitive.targets[index], babylonMorphTarget));
}
return Promise.all(promises).then(() => {
morphTargetManager.areUpdatesFrozen = false;
if (this._parent.useMaxMorphTargetInfluencers) {
// Compile the morph shader once for all targets so it is not recompiled (causing a one-frame visual
// glitch) when an animated influence passes through zero and the active influencer count changes.
// optimizeInfluencers is disabled too so the active influencer set - and thus the bound
// influences/attributes - matches NUM_MORPH_INFLUENCERS.
// In the vertex-attribute fallback path the active set is hard-capped at
// MaxActiveMorphTargetsInVertexAttributeMode, so only pin when texture storage is used or the target
// count fits within that cap; otherwise NUM_MORPH_INFLUENCERS would exceed the bound attributes.
if (morphTargetManager.isUsingTextureForTargets || morphTargetManager.numTargets <= MorphTargetManager.MaxActiveMorphTargetsInVertexAttributeMode) {
morphTargetManager.optimizeInfluencers = false;
morphTargetManager.numMaxInfluencers = morphTargetManager.numTargets;
}
}
});
}
async _loadMorphTargetVertexDataAsync(context, babylonGeometry, attributes, babylonMorphTarget) {
const promises = new Array();
const loadAttribute = (attribute, kind, setData) => {
if (attributes[attribute] == undefined) {
return;
}
const babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);
if (!babylonVertexBuffer) {
return;
}
const accessor = ArrayItem.Get(`${context}/${attribute}`, this._gltf.accessors, attributes[attribute]);
promises.push(this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor).then((data) => {
setData(babylonVertexBuffer, data);
}));
};
loadAttribute("POSITION", VertexBuffer.PositionKind, (babylonVertexBuffer, data) => {
const positions = new Float32Array(data.length);
babylonVertexBuffer.forEach(data.length, (value, index) => {
positions[index] = data[index] + value;
});
babylonMorphTarget.setPositions(positions);
});
loadAttribute("NORMAL", VertexBuffer.NormalKind, (babylonVertexBuffer, data) => {
const normals = new Float32Array(data.length);
babylonVertexBuffer.forEach(normals.length, (value, index) => {
normals[index] = data[index] + value;
});
babylonMorphTarget.setNormals(normals);
});
loadAttribute("TANGENT", VertexBuffer.TangentKind, (babylonVertexBuffer, data) => {
const tangents = new Float32Array((data.length / 3) * 4);
let dataIndex = 0;
babylonVertexBuffer.forEach((data.length / 3) * 4, (value, index) => {
// Tangent data for morph targets is stored as xyz delta.
// The vertexData.tangent is stored as xyzw.
// So we need to skip every fourth vertexData.tangent.
if ((index + 1) % 4 !== 0) {
tangents[dataIndex] = data[dataIndex] + value;
dataIndex++;
}
});
babylonMorphTarget.setTangents(tangents);
});
loadAttribute("TEXCOORD_0", VertexBuffer.UVKind, (babylonVertexBuffer, data) => {
const uvs = new Float32Array(data.length);
babylonVertexBuffer.forEach(data.length, (value, index) => {
uvs[index] = data[index] + value;
});
babylonMorphTarget.setUVs(uvs);
});
loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind, (babylonVertexBuffer, data) => {
const uvs = new Float32Array(data.length);
babylonVertexBuffer.forEach(data.length, (value, index) => {
uvs[index] = data[index] + value;
});
babylonMorphTarget.setUV2s(uvs);
});
loadAttribute("COLOR_0", VertexBuffer.ColorKind, (babylonVertexBuffer, data) => {
let colors = null;
const componentSize = babylonVertexBuffer.getSize();
if (componentSize === 3) {
colors = new Float32Array((data.length / 3) * 4);
babylonVertexBuffer.forEach(data.length, (value, index) => {
const pixid = Math.floor(index / 3);
const channel = index % 3;
colors[4 * pixid + channel] = data[3 * pixid + channel] + value;
});
for (let i = 0; i < data.length / 3; ++i) {
colors[4 * i + 3] = 1;
}
}
else if (componentSize === 4) {
colors = new Float32Array(data.length);
babylonVertexBuffer.forEach(data.length, (value, index) => {
colors[index] = data[index] + value;
});
}
else {
throw new Error(`${context}: Invalid number of components (${componentSize}) for COLOR_0 attribute`);
}
babylonMorphTarget.setColors(colors);
});
return await Promise.all(promises).then(() => { });
}
static _LoadTransform(node, babylonNode) {
// Ignore the TRS of skinned nodes.
// See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
if (node.skin != undefined) {
return;
}
let position = Vector3.Zero();
let rotation = Quaternion.Identity();
let scaling = Vector3.One();
if (node.matrix) {
const matrix = Matrix.FromArray(node.matrix);
matrix.decompose(scaling, rotation, position);
}
else {
if (node.translation) {
position = Vector3.FromArray(node.translation);
}
if (node.rotation) {
rotation = Quaternion.FromArray(node.rotation);
}
if (node.scale) {
scaling = Vector3.FromArray(node.scale);
}
}
babylonNode.position = position;
babylonNode.rotationQuaternion = rotation;
babylonNode.scaling = scaling;
}
_loadSkinAsync(context, node, skin, assign) {
if (!this._parent.loadSkins) {
return Promise.resolve();
}
const extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
if (extensionPromise) {
return extensionPromise;
}
if (skin._data) {
assign(skin._data.babylonSkeleton);
return skin._data.promise;
}
const skeletonId = `skeleton${skin.index}`;
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
babylonSkeleton._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
this._loadBones(context, skin, babylonSkeleton);
const promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then((inverseBindMatricesData) => {
this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
});
skin._data = {
babylonSkeleton: babylonSkeleton,
promise: promise,
};
assign(babylonSkeleton);
return promise;
}
_loadBones(context, skin, babylonSkeleton) {
if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {
const rootNode = this._findSkeletonRootNode(`${context}/joints`, skin.joints);
if (rootNode) {
if (skin.skeleton === undefined) {
skin.skeleton = rootNode.index;
}
else {
const isParent = (a, b) => {
for (; b.parent; b = b.parent) {
if (b.parent === a) {
return true;
}
}
return false;
};
const skeletonNode = ArrayItem.Get(`${context}/skeleton`, this._gltf.nodes, skin.skeleton);
if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {
Logger.Warn(`${context}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`);
skin.skeleton = rootNode.index;
}
}
}
else {
Logger.Warn(`${context}: Failed to find common root`);
}
}
const babylonBones = {};
for (const index of skin.joints) {
const node = ArrayItem.Get(`${context}/joints/${index}`, this._gltf.nodes, index);
this._loadBone(node, skin, babylonSkeleton, babylonBones);
}
}
_findSkeletonRootNode(context, joints) {
if (joints.length === 0) {
return null;
}
const paths = {};
for (const index of joints) {
const path = [];
let node = ArrayItem.Get(`${context}/${index}`, this._gltf.nodes, index);
while (node.index !== -1) {
path.unshift(node);
node = node.parent;
}
paths[index] = path;
}
let rootNode = null;
for (let i = 0;; ++i) {
let path = paths[joints[0]];
if (i >= path.length) {
return rootNode;
}
const node = path[i];
for (let j = 1; j < joints.length; ++j) {
path = paths[joints[j]];
if (i >= path.length || node !== path[i]) {
return rootNode;
}
}
rootNode = node;
}
}
_loadBone(node, skin, babylonSkeleton, babylonBones) {
node._isJoint = true;
let babylonBone = babylonBones[node.index];
if (babylonBone) {
return babylonBone;
}
let parentBabylonBone = null;
if (node.index !== skin.skeleton) {
if (node.parent && node.parent.index !== -1) {
parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);
}
else if (skin.skeleton !== undefined) {
Logger.Warn(`/skins/${skin.index}/skeleton: Skeleton node is not a common root`);
}
}
const boneIndex = skin.joints.indexOf(node.index);
babylonBone = new Bone(node.name || `joint${node.index}`, babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);
babylonBones[node.index] = babylonBone;
// Wait until the scene is loaded to ensure the transform nodes are loaded.
this._postSceneLoadActions.push(() => {
// Link the Babylon bone with the corresponding Babylon transform node.
// A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.
babylonBone.linkTransformNode(node._babylonTransformNode);
});
return babylonBone;
}
_loadSkinInverseBindMatricesDataAsync(context, skin) {
if (skin.inverseBindMatrices == undefined) {
return Promise.resolve(null);
}
const accessor = ArrayItem.Get(`${context}/inverseBindMatrices`, this._gltf.accessors, skin.inverseBindMatrices);
return this._loadFloatAccessorAsync(`/accessors/${accessor.index}`, accessor);
}
_updateBoneMatrices(babylonSkeleton, inverseBindMatricesData) {
for (const babylonBone of babylonSkeleton.bones) {
const baseMatrix = Matrix.Identity();
const boneIndex = babylonBone._index;
if (inverseBindMatricesData && boneIndex !== -1) {
Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);
baseMatrix.invertToRef(baseMatrix);
}
const babylonParentBone = babylonBone.getParent();
if (babylonParentBone) {
baseMatrix.multiplyToRef(babylonParentBone.getAbsoluteInverseBindMatrix(), baseMatrix);
}
babylonBone.updateMatrix(baseMatrix, false, false);
babylonBone._updateAbsoluteBindMatrices(undefined, false);
}
}
_getNodeMatrix(node) {
return node.matrix
? Matrix.FromArray(node.matrix)
: Matrix.Compose(node.scale ? Vector3.FromArray(node.scale) : Vector3.One(), node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(), node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero());
}
/**
* Loads a glTF camera.
* @param context The context when loading the asset
* @param camera The glTF camera property
* @param assign A function called synchronously after parsing the glTF properties
* @returns A promise that resolves with the loaded Babylon camera when the load is complete
*/
loadCameraAsync(context, camera, assign = () => { }) {
const extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);
if (extensionPromise) {
return extensionPromise;
}
const promises = new Array();
this.logOpen(`${context} ${camera.name || ""}`);
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const babylonCamera = new FreeCamera(camera.name || `camera${camera.index}`, Vector3.Zero(), this._babylonScene, false);
babylonCamera._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
camera._babylonCamera = babylonCamera;
// glTF cameras look towards the local -Z axis.
babylonCamera.setTarget(new Vector3(0, 0, -1));
switch (camera.type) {
case "perspective" /* CameraType.PERSPECTIVE */: {
const perspective = camera.perspective;
if (!perspective) {
throw new Error(`${context}: Camera perspective properties are missing`);
}
babylonCamera.fov = perspective.yfov;
babylonCamera.minZ = perspective.znear;
babylonCamera.maxZ = perspective.zfar || 0;
break;
}
case "orthographic" /* CameraType.ORTHOGRAPHIC */: {
if (!camera.orthographic) {
throw new Error(`${context}: Camera orthographic properties are missing`);
}
babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
babylonCamera.orthoLeft = -camera.orthographic.xmag;
babylonCamera.orthoRight = camera.orthographic.xmag;
babylonCamera.orthoBottom = -camera.orthographic.ymag;
babylonCamera.orthoTop = camera.orthographic.ymag;
babylonCamera.minZ = camera.orthographic.znear;
babylonCamera.maxZ = camera.orthographic.zfar;
break;
}
default: {
throw new Error(`${context}: Invalid camera type (${camera.type})`);
}
}
GLTFLoader.AddPointerMetadata(babylonCamera, context);
this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);
assign(babylonCamera);
this.logClose();
return Promise.all(promises).then(() => {
return babylonCamera;
});
}
_loadAnimationsAsync() {
this._parent._startPerformanceCounter("Load animations");
const animations = this._gltf.animations;
if (!animations) {
return Promise.resolve();
}
const promises = new Array();
for (let index = 0; index < animations.length; index++) {
const animation = animations[index];
promises.push(this.loadAnimationAsync(`/animations/${animation.index}`, animation).then((animationGroup) => {
// Delete the animation group if it ended up not having any animations in it.
if (animationGroup.targetedAnimations.length === 0) {
animationGroup.dispose();
}
}));
}
return Promise.all(promises).then(() => {
this._parent._endPerformanceCounter("Load animations");
});
}
/**
* Loads a glTF animation.
* @param context The context when loading the asset
* @param animation The glTF animation property
* @returns A promise that resolves with the loaded Babylon animation group when the load is complete
*/
loadAnimationAsync(context, animation) {
this._parent._startPerformanceCounter("Load animation");
const promise = this._extensionsLoadAnimationAsync(context, animation);
if (promise) {
return promise;
}
// eslint-disable-next-line @typescript-eslint/naming-convention
return LazyAnimationGroupModulePromise.value.then(({ AnimationGroup }) => {
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const babylonAnimationGroup = new AnimationGroup(animation.name || `animation${animation.index}`, this._babylonScene);
babylonAnimationGroup._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
animation._babylonAnimationGroup = babylonAnimationGroup;
const promises = new Array();
ArrayItem.Assign(animation.channels);
ArrayItem.Assign(animation.samplers);
for (const channel of animation.channels) {
promises.push(this._loadAnimationChannelAsync(`${context}/channels/${channel.index}`, context, animation, channel, (babylonTarget, babylonAnimation) => {
babylonTarget.animations = babylonTarget.animations || [];
babylonTarget.animations.push(babylonAnimation);
babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonTarget);
}));
}
this._parent._endPerformanceCounter("Load animation");
return Promise.all(promises).then(() => {
babylonAnimationGroup.normalize(0);
return babylonAnimationGroup;
});
});
}
/**
* @hidden
* Loads a glTF animation channel.
* @param context The context when loading the asset
* @param animationContext The context of the animation when loading the asset
* @param animation The glTF animation property
* @param channel The glTF animation channel property
* @param onLoad Called for each animation loaded
* @returns A void promise that resolves when the load is complete
*/
_loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
const promise = this._extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad);
if (promise) {
return promise;
}
if (channel.target.node == undefined) {
return Promise.resolve();
}
const targetNode = ArrayItem.Get(`${context}/target/node`, this._gltf.nodes, channel.target.node);
const channelTargetPath = channel.target.path;
const pathIsWeights = channelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */;
// Ignore animations that have no animation targets.
if ((pathIsWeights && !targetNode._numMorphTargets) || (!pathIsWeights && !targetNode._babylonTransformNode)) {
return Promise.resolve();
}
// Don't load node animations if disabled.
if (!this._parent.loadNodeAnimations && !pathIsWeights && !targetNode._isJoint) {
return Promise.resolve();
}
// async-load the animation sampler to provide the interpolation of the channelTargetPath
return LazyLoaderAnimationModulePromise.value.then(() => {
let properties;
switch (channelTargetPath) {
case "translation" /* AnimationChannelTargetPath.TRANSLATION */: {
properties = GetMappingForKey("/nodes/{}/translation")?.interpolation;
break;
}
case "rotation" /* AnimationChannelTargetPath.ROTATION */: {
properties = GetMappingForKey("/nodes/{}/rotation")?.interpolation;
break;
}
case "scale" /* AnimationChannelTargetPath.SCALE */: {
properties = GetMappingForKey("/nodes/{}/scale")?.interpolation;
break;
}
case "weights" /* AnimationChannelTargetPath.WEIGHTS */: {
properties = GetMappingForKey("/nodes/{}/weights")?.interpolation;
break;
}
default: {
throw new Error(`${context}/target/path: Invalid value (${channel.target.path})`);
}
}
// stay safe
if (!properties) {
throw new Error(`${context}/target/path: Could not find interpolation properties for target path (${channel.target.path})`);
}
const targetInfo = {
object: targetNode,
info: properties,
};
return this._loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad);
});
}
/**
* @hidden
* Loads a glTF animation channel.
* @param context The context when loading the asset
* @param animationContext The context of the animation when loading the asset
* @param animation The glTF animation property
* @param channel The glTF animation channel property
* @param targetInfo The glTF target and properties
* @param onLoad Called for each animation loaded
* @returns A void promise that resolves when the load is complete
*/
_loadAnimationChannelFromTargetInfoAsync(context, animationContext, animation, channel, targetInfo, onLoad) {
const fps = this.parent.targetFps;
const invfps = 1 / fps;
const sampler = ArrayItem.Get(`${context}/sampler`, animation.samplers, channel.sampler);
return this._loadAnimationSamplerAsync(`${animationContext}/samplers/${channel.sampler}`, sampler).then((data) => {
let numAnimations = 0;
const target = targetInfo.object;
const propertyInfos = targetInfo.info;
// Extract the corresponding values from the read value.
// GLTF values may be dispatched to several Babylon properties.
// For example, baseColorFactor [`r`, `g`, `b`, `a`] is dispatched to
// - albedoColor as Color3(`r`, `g`, `b`)
// - alpha as `a`
for (const propertyInfo of propertyInfos) {
const stride = propertyInfo.getStride(target);
const input = data.input;
const output = data.output;
const keys = new Array(input.length);
let outputOffset = 0;
switch (data.interpolation) {
case "STEP" /* AnimationSamplerInterpolation.STEP */: {
for (let index = 0; index < input.length; index++) {
const value = propertyInfo.getValue(target, output, outputOffset, 1);
outputOffset += stride;
keys[index] = {
frame: input[index] * fps,
value: value,
interpolation: 1 /* AnimationKeyInterpolation.STEP */,
};
}
break;
}
case "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */: {
for (let index = 0; index < input.length; index++) {
const inTangent = propertyInfo.getValue(target, output, outputOffset, invfps);
outputOffset += stride;
const value = propertyInfo.getValue(target, output, outputOffset, 1);
outputOffset += stride;
const outTangent = propertyInfo.getValue(target, output, outputOffset, invfps);
outputOffset += stride;
keys[index] = {
frame: input[index] * fps,
inTangent: inTangent,
value: value,
outTangent: outTangent,
};
}
break;
}
case "LINEAR" /* AnimationSamplerInterpolation.LINEAR */: {
for (let index = 0; index < input.length; index++) {
const value = propertyInfo.getValue(target, output, outputOffset, 1);
outputOffset += stride;
keys[index] = {
frame: input[index] * fps,
value: value,
};
}
break;
}
}
if (outputOffset > 0) {
const name = `${animation.name || `animation${animation.index}`}_channel${channel.index}_${numAnimations}`;
const babylonAnimations = propertyInfo.buildAnimations(target, name, fps, keys);
for (const babylonAnimation of babylonAnimations) {
numAnimations++;
onLoad(babylonAnimation.babylonAnimatable, babylonAnimation.babylonAnimation);
}
}
}
});
}
_loadAnimationSamplerAsync(context, sampler) {
if (sampler._data) {
return sampler._data;
}
const interpolation = sampler.interpolation || "LINEAR" /* AnimationSamplerInterpolation.LINEAR */;
switch (interpolation) {
case "STEP" /* AnimationSamplerInterpolation.STEP */:
case "LINEAR" /* AnimationSamplerInterpolation.LINEAR */:
case "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */: {
break;
}
default: {
throw new Error(`${context}/interpolation: Invalid value (${sampler.interpolation})`);
}
}
const inputAccessor = ArrayItem.Get(`${context}/input`, this._gltf.accessors, sampler.input);
const outputAccessor = ArrayItem.Get(`${context}/output`, this._gltf.accessors, sampler.output);
sampler._data = Promise.all([
this._loadFloatAccessorAsync(`/accessors/${inputAccessor.index}`, inputAccessor),
this._loadFloatAccessorAsync(`/accessors/${outputAccessor.index}`, outputAccessor),
]).then(([inputData, outputData]) => {
return {
input: inputData,
interpolation: interpolation,
output: outputData,
};
});
return sampler._data;
}
/**
* Loads a glTF buffer.
* @param context The context when loading the asset
* @param buffer The glTF buffer property
* @param byteOffset The byte offset to use
* @param byteLength The byte length to use
* @returns A promise that resolves with the loaded data when the load is complete
*/
loadBufferAsync(context, buffer, byteOffset, byteLength) {
const extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);
if (extensionPromise) {
return extensionPromise;
}
if (!buffer._data) {
if (buffer.uri) {
buffer._data = this.loadUriAsync(`${context}/uri`, buffer, buffer.uri);
}
else {
if (!this._bin) {
throw new Error(`${context}: Uri is missing or the binary glTF is missing its binary chunk`);
}
buffer._data = this._bin.readAsync(0, buffer.byteLength);
}
}
return buffer._data.then((data) => {
try {
return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);
}
catch (e) {
throw new Error(`${context}: ${e.message}`, { cause: e });
}
});
}
/**
* Loads a glTF buffer view.
* @param context The context when loading the asset
* @param bufferView The glTF buffer view property
* @returns A promise that resolves with the loaded data when the load is complete
*/
loadBufferViewAsync(context, bufferView) {
const extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);
if (extensionPromise) {
return extensionPromise;
}
if (bufferView._data) {
return bufferView._data;
}
const buffer = ArrayItem.Get(`${context}/buffer`, this._gltf.buffers, bufferView.buffer);
bufferView._data = this.loadBufferAsync(`/buffers/${buffer.index}`, buffer, bufferView.byteOffset || 0, bufferView.byteLength);
return bufferView._data;
}
_loadAccessorAsync(context, accessor, constructor) {
if (accessor._data) {
return accessor._data;
}
const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
const byteStride = numComponents * VertexBufferGetTypeByteLength(accessor.componentType);
const length = numComponents * accessor.count;
if (accessor.bufferView == undefined) {
accessor._data = Promise.resolve(new constructor(length));
}
else {
const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
if (accessor.componentType === 5126 /* AccessorComponentType.FLOAT */ && !accessor.normalized && (!bufferView.byteStride || bufferView.byteStride === byteStride)) {
return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);
}
else {
const typedArray = new constructor(length);
VertexBufferForEach(data, accessor.byteOffset || 0, bufferView.byteStride || byteStride, numComponents, accessor.componentType, typedArray.length, accessor.normalized || false, (value, index) => {
typedArray[index] = value;
});
return typedArray;
}
});
}
if (accessor.sparse) {
const sparse = accessor.sparse;
accessor._data = accessor._data.then((data) => {
const typedArray = data;
const indicesBufferView = ArrayItem.Get(`${context}/sparse/indices/bufferView`, this._gltf.bufferViews, sparse.indices.bufferView);
const valuesBufferView = ArrayItem.Get(`${context}/sparse/values/bufferView`, this._gltf.bufferViews, sparse.values.bufferView);
return Promise.all([
this.loadBufferViewAsync(`/bufferViews/${indicesBufferView.index}`, indicesBufferView),
this.loadBufferViewAsync(`/bufferViews/${valuesBufferView.index}`, valuesBufferView),
]).then(([indicesData, valuesData]) => {
const indices = GLTFLoader._GetTypedArray(`${context}/sparse/indices`, sparse.indices.componentType, indicesData, sparse.indices.byteOffset, sparse.count);
const sparseLength = numComponents * sparse.count;
let values;
if (accessor.componentType === 5126 /* AccessorComponentType.FLOAT */ && !accessor.normalized) {
values = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);
}
else {
const sparseData = GLTFLoader._GetTypedArray(`${context}/sparse/values`, accessor.componentType, valuesData, sparse.values.byteOffset, sparseLength);
values = new constructor(sparseLength);
VertexBufferForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, (value, index) => {
values[index] = value;
});
}
let valuesIndex = 0;
for (let indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {
let dataIndex = indices[indicesIndex] * numComponents;
for (let componentIndex = 0; componentIndex < numComponents; componentIndex++) {
typedArray[dataIndex++] = values[valuesIndex++];
}
}
return typedArray;
});
});
}
return accessor._data;
}
/**
* @internal
*/
_loadFloatAccessorAsync(context, accessor) {
return this._loadAccessorAsync(context, accessor, Float32Array);
}
/**
* @internal
*/
_loadIndicesAccessorAsync(context, accessor) {
if (accessor.type !== "SCALAR" /* AccessorType.SCALAR */) {
throw new Error(`${context}/type: Invalid value ${accessor.type}`);
}
if (accessor.componentType !== 5121 /* AccessorComponentType.UNSIGNED_BYTE */ &&
accessor.componentType !== 5123 /* AccessorComponentType.UNSIGNED_SHORT */ &&
accessor.componentType !== 5125 /* AccessorComponentType.UNSIGNED_INT */) {
throw new Error(`${context}/componentType: Invalid value ${accessor.componentType}`);
}
if (accessor._data) {
return accessor._data;
}
if (accessor.sparse) {
const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, accessor.componentType);
accessor._data = this._loadAccessorAsync(context, accessor, constructor);
}
else {
const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
accessor._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);
});
}
return accessor._data;
}
/**
* @internal
*/
_loadVertexBufferViewAsync(bufferView) {
if (bufferView._babylonBuffer) {
return bufferView._babylonBuffer;
}
const engine = this._babylonScene.getEngine();
bufferView._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView).then((data) => {
return new Buffer(engine, data, false);
});
return bufferView._babylonBuffer;
}
/**
* @internal
*/
_loadVertexAccessorAsync(context, accessor, kind) {
if (accessor._babylonVertexBuffer?.[kind]) {
return accessor._babylonVertexBuffer[kind];
}
if (!accessor._babylonVertexBuffer) {
accessor._babylonVertexBuffer = {};
}
const engine = this._babylonScene.getEngine();
if (accessor.sparse || accessor.bufferView == undefined) {
accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then((data) => {
return new VertexBuffer(engine, data, kind, false);
});
}
else {
const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, accessor.bufferView);
accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView).then((babylonBuffer) => {
const numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
return new VertexBuffer(engine, babylonBuffer, kind, false, undefined, bufferView.byteStride, undefined, accessor.byteOffset, numComponents, accessor.componentType, accessor.normalized, true, undefined, true);
});
}
return accessor._babylonVertexBuffer[kind];
}
_loadMaterialMetallicRoughnessPropertiesAsync(context, properties, babylonMaterial) {
const promises = new Array();
const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
if (properties) {
// Set base color and alpha using adapter
if (properties.baseColorFactor) {
adapter.baseColor = Color3.FromArray(properties.baseColorFactor);
adapter.geometryOpacity = properties.baseColorFactor[3];
}
else {
adapter.baseColor = Color3.White();
}
// Set metallic and roughness using adapter
adapter.baseMetalness = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;
adapter.specularRoughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;
if (properties.baseColorTexture) {
promises.push(this.loadTextureInfoAsync(`${context}/baseColorTexture`, properties.baseColorTexture, (texture) => {
texture.name = `${babylonMaterial.name} (Base Color)`;
adapter.baseColorTexture = texture;
}));
}
if (properties.metallicRoughnessTexture) {
properties.metallicRoughnessTexture.nonColorData = true;
promises.push(this.loadTextureInfoAsync(`${context}/metallicRoughnessTexture`, properties.metallicRoughnessTexture, (texture) => {
texture.name = `${babylonMaterial.name} (Metallic Roughness)`;
adapter.baseMetalnessTexture = texture;
adapter.specularRoughnessTexture = texture;
}));
// Configure texture channel usage using adapter
adapter.useRoughnessFromMetallicTextureGreen = true;
adapter.useMetallicFromMetallicTextureBlue = true;
}
}
return Promise.all(promises).then(() => { });
}
/**
* @internal
*/
_loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign = () => { }) {
const extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
if (extensionPromise) {
return extensionPromise;
}
material._data = material._data || {};
let babylonData = material._data[babylonDrawMode];
if (!babylonData) {
this.logOpen(`${context} ${material.name || ""}`);
const babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
babylonData = {
babylonMaterial: babylonMaterial,
babylonMeshes: [],
promise: this.loadMaterialPropertiesAsync(context, material, babylonMaterial),
};
material._data[babylonDrawMode] = babylonData;
GLTFLoader.AddPointerMetadata(babylonMaterial, context);
this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
this.logClose();
}
if (babylonMesh) {
babylonData.babylonMeshes.push(babylonMesh);
babylonMesh.onDisposeObservable.addOnce(() => {
const index = babylonData.babylonMeshes.indexOf(babylonMesh);
if (index !== -1) {
babylonData.babylonMeshes.splice(index, 1);
}
});
}
assign(babylonData.babylonMaterial);
return babylonData.promise.then(() => {
return babylonData.babylonMaterial;
});
}
/**
* Selects the appropriate PBR material implementation for a given glTF material.
* Uses OpenPBR when the material carries a "KHR_materials_openpbr" extension or when
* the loader-level `useOpenPBR` flag is set; falls back to standard PBR otherwise.
* @param material The glTF material
* @returns The matching loaded implementation
*/
_selectImplForGltfMaterial(material) {
if (this.parent.useOpenPBR || material.extensions?.["KHR_materials_openpbr"]) {
const impl = this._pbrMaterialImpls.get("openpbr");
if (impl) {
return impl;
}
}
const impl = this._pbrMaterialImpls.get("pbr");
if (impl) {
return impl;
}
throw new Error("No PBR material implementation loaded");
}
/**
* Returns the default PBR material implementation used when there is no per-material
* selection context (e.g. when creating the built-in default material for primitives
* that have no glTF material assigned). Prefers OpenPBR when `useOpenPBR` is set.
* @returns The default loaded implementation
*/
_getDefaultImpl() {
if (this.parent.useOpenPBR) {
const impl = this._pbrMaterialImpls.get("openpbr");
if (impl) {
return impl;
}
}
const impl = this._pbrMaterialImpls.get("pbr") ?? this._pbrMaterialImpls.values().next().value;
if (impl) {
return impl;
}
throw new Error("No PBR material implementation loaded");
}
_createDefaultMaterial(name, babylonDrawMode, impl) {
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const babylonMaterial = new impl.materialClass(name, this._babylonScene);
babylonMaterial._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
babylonMaterial.fillMode = babylonDrawMode;
babylonMaterial.transparencyMode = impl.materialClass.MATERIAL_OPAQUE;
// Create the material adapter and set some default properties.
// We don't need to wait for the promise to resolve here.
const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
adapter.transparencyAsAlphaCoverage = this._parent.transparencyAsCoverage;
// Set default metallic and roughness values
adapter.baseMetalness = 1.0;
adapter.specularRoughness = 1.0;
return babylonMaterial;
}
/**
* Creates a Babylon material from a glTF material.
* @param context The context when loading the asset
* @param material The glTF material property
* @param babylonDrawMode The draw mode for the Babylon material
* @returns The Babylon material
*/
createMaterial(context, material, babylonDrawMode) {
const extensionMaterial = this._extensionsCreateMaterial(context, material, babylonDrawMode);
if (extensionMaterial) {
return extensionMaterial;
}
const name = material.name || `material${material.index}`;
const babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode, this._selectImplForGltfMaterial(material));
return babylonMaterial;
}
/**
* Loads properties from a glTF material into a Babylon material.
* @param context The context when loading the asset
* @param material The glTF material property
* @param babylonMaterial The Babylon material
* @returns A promise that resolves when the load is complete
*/
loadMaterialPropertiesAsync(context, material, babylonMaterial) {
const extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);
if (extensionPromise) {
return extensionPromise;
}
const promises = new Array();
promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
if (material.pbrMetallicRoughness) {
promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${context}/pbrMetallicRoughness`, material.pbrMetallicRoughness, babylonMaterial));
}
this.loadMaterialAlphaProperties(context, material, babylonMaterial);
return Promise.all(promises).then(() => { });
}
/**
* Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
* @param context The context when loading the asset
* @param material The glTF material property
* @param babylonMaterial The Babylon material
* @returns A promise that resolves when the load is complete
*/
loadMaterialBasePropertiesAsync(context, material, babylonMaterial) {
const promises = new Array();
const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
// Set emission color using adapter
adapter.emissionColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);
// Set double-sided properties using adapter
if (material.doubleSided) {
adapter.backFaceCulling = false;
adapter.twoSidedLighting = true;
}
if (material.normalTexture) {
material.normalTexture.nonColorData = true;
promises.push(this.loadTextureInfoAsync(`${context}/normalTexture`, material.normalTexture, (texture) => {
texture.name = `${babylonMaterial.name} (Normal)`;
adapter.geometryNormalTexture = texture;
if (material.normalTexture?.scale != undefined) {
texture.level = material.normalTexture.scale;
}
}));
// Set normal map inversions using adapter
adapter.setNormalMapInversions(!this._babylonScene.useRightHandedSystem, this._babylonScene.useRightHandedSystem);
}
let aoTexture;
let aoStrength = 1.0;
let emissionTexture;
if (material.occlusionTexture) {
material.occlusionTexture.nonColorData = true;
promises.push(this.loadTextureInfoAsync(`${context}/occlusionTexture`, material.occlusionTexture, (texture) => {
texture.name = `${babylonMaterial.name} (Occlusion)`;
aoTexture = texture;
}));
if (material.occlusionTexture.strength != undefined) {
aoStrength = material.occlusionTexture.strength;
}
}
if (material.emissiveTexture) {
promises.push(this.loadTextureInfoAsync(`${context}/emissiveTexture`, material.emissiveTexture, (texture) => {
texture.name = `${babylonMaterial.name} (Emissive)`;
emissionTexture = texture;
}));
}
return Promise.all(promises).then(() => {
// Set ambient occlusion and emissive textures using adapter
if (aoTexture) {
adapter.ambientOcclusionTexture = aoTexture;
adapter.ambientOcclusionTextureStrength = aoStrength;
}
if (emissionTexture) {
adapter.emissionColorTexture = emissionTexture;
}
});
}
/**
* Loads the alpha properties from a glTF material into a Babylon material.
* Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
* @param context The context when loading the asset
* @param material The glTF material property
* @param babylonMaterial The Babylon material
*/
loadMaterialAlphaProperties(context, material, babylonMaterial) {
if (this._pbrMaterialImpls.size === 0) {
throw new Error(`${context}: Material type not supported`);
}
const adapter = this._getOrCreateMaterialAdapter(babylonMaterial);
const baseColorTexture = adapter.baseColorTexture;
const alphaMode = material.alphaMode || "OPAQUE" /* MaterialAlphaMode.OPAQUE */;
switch (alphaMode) {
case "OPAQUE" /* MaterialAlphaMode.OPAQUE */: {
babylonMaterial.transparencyMode = Material.MATERIAL_OPAQUE;
babylonMaterial.alpha = 1.0; // Force alpha to 1.0 for opaque mode.
break;
}
case "MASK" /* MaterialAlphaMode.MASK */: {
babylonMaterial.transparencyMode = Material.MATERIAL_ALPHATEST;
adapter.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;
if (baseColorTexture) {
baseColorTexture.hasAlpha = true;
adapter.useAlphaFromBaseColorTexture = true;
}
break;
}
case "BLEND" /* MaterialAlphaMode.BLEND */: {
babylonMaterial.transparencyMode = Material.MATERIAL_ALPHABLEND;
if (baseColorTexture) {
baseColorTexture.hasAlpha = true;
adapter.useAlphaFromBaseColorTexture = true;
}
break;
}
default: {
throw new Error(`${context}/alphaMode: Invalid value (${material.alphaMode})`);
}
}
}
/**
* Loads a glTF texture info.
* @param context The context when loading the asset
* @param textureInfo The glTF texture info property
* @param assign A function called synchronously after parsing the glTF properties
* @returns A promise that resolves with the loaded Babylon texture when the load is complete
*/
loadTextureInfoAsync(context, textureInfo, assign = () => { }) {
const extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
if (extensionPromise) {
return extensionPromise;
}
this.logOpen(`${context}`);
if (textureInfo.texCoord >= 6) {
throw new Error(`${context}/texCoord: Invalid value (${textureInfo.texCoord})`);
}
const texture = ArrayItem.Get(`${context}/index`, this._gltf.textures, textureInfo.index);
texture._textureInfo = textureInfo;
const promise = this._loadTextureAsync(`/textures/${textureInfo.index}`, texture, (babylonTexture) => {
babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;
GLTFLoader.AddPointerMetadata(babylonTexture, context);
this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);
assign(babylonTexture);
});
this.logClose();
return promise;
}
/**
* @internal
*/
_loadTextureAsync(context, texture, assign = () => { }) {
const extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
if (extensionPromise) {
return extensionPromise;
}
this.logOpen(`${context} ${texture.name || ""}`);
const sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get(`${context}/sampler`, this._gltf.samplers, texture.sampler);
const image = ArrayItem.Get(`${context}/source`, this._gltf.images, texture.source);
const promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
this.logClose();
return promise;
}
/**
* @internal
*/
_createTextureAsync(context, sampler, image, assign = () => { }, textureLoaderOptions, useSRGBBuffer) {
const samplerData = this._loadSampler(`/samplers/${sampler.index}`, sampler);
const promises = new Array();
const deferred = new Deferred();
this._babylonScene._blockEntityCollection = !!this._assetContainer;
const textureCreationOptions = {
noMipmap: samplerData.noMipMaps,
invertY: false,
samplingMode: samplerData.samplingMode,
onLoad: () => {
if (!this._disposed) {
deferred.resolve();
}
},
onError: (message, exception) => {
if (!this._disposed) {
deferred.reject(new Error(`${context}: ${exception && exception.message ? exception.message : message || "Failed to load texture"}`));
}
},
mimeType: image.mimeType ?? GetMimeType(image.uri ?? ""),
loaderOptions: textureLoaderOptions,
useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,
};
const babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
babylonTexture._parentContainer = this._assetContainer;
this._babylonScene._blockEntityCollection = false;
promises.push(deferred.promise);
const nonBase64Uri = image.uri && !IsBase64DataUrl(image.uri) ? image.uri : undefined;
const imageId = nonBase64Uri ?? `${this._fileName}#image${image.index}`;
promises.push(this.loadImageAsync(`/images/${image.index}`, image).then((data) => {
const dataUrl = `data:${this._uniqueRootUrl}${imageId}`;
babylonTexture.updateURL(dataUrl, data);
// Set the internal texture label.
const internalTexture = babylonTexture.getInternalTexture();
if (internalTexture) {
internalTexture.label = image.name;
}
}));
babylonTexture.wrapU = samplerData.wrapU;
babylonTexture.wrapV = samplerData.wrapV;
assign(babylonTexture);
if (this._parent.useGltfTextureNames) {
const textureName = image.name || nonBase64Uri || `image${image.index}`;
babylonTexture.name = textureName;
}
return Promise.all(promises).then(() => {
return babylonTexture;
});
}
_loadSampler(context, sampler) {
if (!sampler._data) {
sampler._data = {
noMipMaps: sampler.minFilter === 9728 /* TextureMinFilter.NEAREST */ || sampler.minFilter === 9729 /* TextureMinFilter.LINEAR */,
samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),
wrapU: GLTFLoader._GetTextureWrapMode(`${context}/wrapS`, sampler.wrapS),
wrapV: GLTFLoader._GetTextureWrapMode(`${context}/wrapT`, sampler.wrapT),
};
}
return sampler._data;
}
/**
* Loads a glTF image.
* @param context The context when loading the asset
* @param image The glTF image property
* @returns A promise that resolves with the loaded data when the load is complete
*/
loadImageAsync(context, image) {
if (!image._data) {
this.logOpen(`${context} ${image.name || ""}`);
if (image.uri) {
image._data = this.loadUriAsync(`${context}/uri`, image, image.uri);
}
else {
const bufferView = ArrayItem.Get(`${context}/bufferView`, this._gltf.bufferViews, image.bufferView);
image._data = this.loadBufferViewAsync(`/bufferViews/${bufferView.index}`, bufferView);
}
this.logClose();
}
return image._data;
}
/**
* Loads a glTF uri.
* @param context The context when loading the asset
* @param property The glTF property associated with the uri
* @param uri The base64 or relative uri
* @returns A promise that resolves with the loaded data when the load is complete
*/
loadUriAsync(context, property, uri) {
const extensionPromise = this._extensionsLoadUriAsync(context, property, uri);
if (extensionPromise) {
return extensionPromise;
}
if (!GLTFLoader._ValidateUri(uri)) {
throw new Error(`${context}: '${uri}' is invalid`);
}
if (IsBase64DataUrl(uri)) {
const data = new Uint8Array(DecodeBase64UrlToBinary(uri));
this.log(`${context}: Decoded ${uri.substring(0, 64)}... (${data.length} bytes)`);
return Promise.resolve(data);
}
this.log(`${context}: Loading ${uri}`);
return this._parent.preprocessUrlAsync(this._rootUrl + uri).then((url) => {
return new Promise((resolve, reject) => {
this._parent._loadFile(this._babylonScene, url, (data) => {
if (!this._disposed) {
this.log(`${context}: Loaded ${uri} (${data.byteLength} bytes)`);
resolve(new Uint8Array(data));
}
}, true, (request) => {
reject(new LoadFileError(`${context}: Failed to load '${uri}'${request ? ": " + request.status + " " + request.statusText : ""}`, request));
});
});
});
}
/**
* Adds a JSON pointer to the _internalMetadata of the Babylon object at `<object>._internalMetadata.gltf.pointers`.
* @param babylonObject the Babylon object with _internalMetadata
* @param pointer the JSON pointer
*/
static AddPointerMetadata(babylonObject, pointer) {
babylonObject.metadata = babylonObject.metadata || {};
const metadata = (babylonObject._internalMetadata = babylonObject._internalMetadata || {});
const gltf = (metadata.gltf = metadata.gltf || {});
const pointers = (gltf.pointers = gltf.pointers || []);
pointers.push(pointer);
}
static _GetTextureWrapMode(context, mode) {
// Set defaults if undefined
mode = mode == undefined ? 10497 /* TextureWrapMode.REPEAT */ : mode;
switch (mode) {
case 33071 /* TextureWrapMode.CLAMP_TO_EDGE */:
return Texture.CLAMP_ADDRESSMODE;
case 33648 /* TextureWrapMode.MIRRORED_REPEAT */:
return Texture.MIRROR_ADDRESSMODE;
case 10497 /* TextureWrapMode.REPEAT */:
return Texture.WRAP_ADDRESSMODE;
default:
Logger.Warn(`${context}: Invalid value (${mode})`);
return Texture.WRAP_ADDRESSMODE;
}
}
static _GetTextureSamplingMode(context, sampler) {
// Set defaults if undefined
const magFilter = sampler.magFilter == undefined ? 9729 /* TextureMagFilter.LINEAR */ : sampler.magFilter;
const minFilter = sampler.minFilter == undefined ? 9987 /* TextureMinFilter.LINEAR_MIPMAP_LINEAR */ : sampler.minFilter;
if (magFilter === 9729 /* TextureMagFilter.LINEAR */) {
switch (minFilter) {
case 9728 /* TextureMinFilter.NEAREST */:
return Texture.LINEAR_NEAREST;
case 9729 /* TextureMinFilter.LINEAR */:
return Texture.LINEAR_LINEAR;
case 9984 /* TextureMinFilter.NEAREST_MIPMAP_NEAREST */:
return Texture.LINEAR_NEAREST_MIPNEAREST;
case 9985 /* TextureMinFilter.LINEAR_MIPMAP_NEAREST */:
return Texture.LINEAR_LINEAR_MIPNEAREST;
case 9986 /* TextureMinFilter.NEAREST_MIPMAP_LINEAR */:
return Texture.LINEAR_NEAREST_MIPLINEAR;
case 9987 /* TextureMinFilter.LINEAR_MIPMAP_LINEAR */:
return Texture.LINEAR_LINEAR_MIPLINEAR;
default:
Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);
return Texture.LINEAR_LINEAR_MIPLINEAR;
}
}
else {
if (magFilter !== 9728 /* TextureMagFilter.NEAREST */) {
Logger.Warn(`${context}/magFilter: Invalid value (${magFilter})`);
}
switch (minFilter) {
case 9728 /* TextureMinFilter.NEAREST */:
return Texture.NEAREST_NEAREST;
case 9729 /* TextureMinFilter.LINEAR */:
return Texture.NEAREST_LINEAR;
case 9984 /* TextureMinFilter.NEAREST_MIPMAP_NEAREST */:
return Texture.NEAREST_NEAREST_MIPNEAREST;
case 9985 /* TextureMinFilter.LINEAR_MIPMAP_NEAREST */:
return Texture.NEAREST_LINEAR_MIPNEAREST;
case 9986 /* TextureMinFilter.NEAREST_MIPMAP_LINEAR */:
return Texture.NEAREST_NEAREST_MIPLINEAR;
case 9987 /* TextureMinFilter.LINEAR_MIPMAP_LINEAR */:
return Texture.NEAREST_LINEAR_MIPLINEAR;
default:
Logger.Warn(`${context}/minFilter: Invalid value (${minFilter})`);
return Texture.NEAREST_NEAREST_MIPNEAREST;
}
}
}
static _GetTypedArrayConstructor(context, componentType) {
try {
return GetTypedArrayConstructor(componentType);
}
catch (e) {
throw new Error(`${context}: ${e.message}`, { cause: e });
}
}
static _GetTypedArray(context, componentType, bufferView, byteOffset, length) {
const buffer = bufferView.buffer;
byteOffset = bufferView.byteOffset + (byteOffset || 0);
const constructor = GLTFLoader._GetTypedArrayConstructor(`${context}/componentType`, componentType);
const componentTypeLength = VertexBufferGetTypeByteLength(componentType);
if (byteOffset % componentTypeLength !== 0) {
// HACK: Copy the buffer if byte offset is not a multiple of component type byte length.
Logger.Warn(`${context}: Copying buffer as byte offset (${byteOffset}) is not a multiple of component type byte length (${componentTypeLength})`);
return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);
}
return new constructor(buffer, byteOffset, length);
}
static _GetNumComponents(context, type) {
switch (type) {
case "SCALAR":
return 1;
case "VEC2":
return 2;
case "VEC3":
return 3;
case "VEC4":
return 4;
case "MAT2":
return 4;
case "MAT3":
return 9;
case "MAT4":
return 16;
}
throw new Error(`${context}: Invalid type (${type})`);
}
static _ValidateUri(uri) {
return Tools.IsBase64(uri) || uri.indexOf("..") === -1;
}
/**
* @internal
*/
static _GetDrawMode(context, mode) {
if (mode == undefined) {
mode = 4 /* MeshPrimitiveMode.TRIANGLES */;
}
switch (mode) {
case 0 /* MeshPrimitiveMode.POINTS */:
return Material.PointListDrawMode;
case 1 /* MeshPrimitiveMode.LINES */:
return Material.LineListDrawMode;
case 2 /* MeshPrimitiveMode.LINE_LOOP */:
return Material.LineLoopDrawMode;
case 3 /* MeshPrimitiveMode.LINE_STRIP */:
return Material.LineStripDrawMode;
case 4 /* MeshPrimitiveMode.TRIANGLES */:
return Material.TriangleFillMode;
case 5 /* MeshPrimitiveMode.TRIANGLE_STRIP */:
return Material.TriangleStripDrawMode;
case 6 /* MeshPrimitiveMode.TRIANGLE_FAN */:
return Material.TriangleFanDrawMode;
}
throw new Error(`${context}: Invalid mesh primitive mode (${mode})`);
}
_compileMaterialsAsync() {
this._parent._startPerformanceCounter("Compile materials");
const promises = new Array();
if (this._gltf.materials) {
for (const material of this._gltf.materials) {
if (material._data) {
for (const babylonDrawMode in material._data) {
const babylonData = material._data[babylonDrawMode];
for (const babylonMesh of babylonData.babylonMeshes) {
// Ensure nonUniformScaling is set if necessary.
babylonMesh.computeWorldMatrix(true);
const babylonMaterial = babylonData.babylonMaterial;
promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));
if (this._parent.useClipPlane) {
promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));
promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true, useInstances: true }));
}
}
}
}
}
}
return Promise.all(promises).then(() => {
this._parent._endPerformanceCounter("Compile materials");
});
}
_compileShadowGeneratorsAsync() {
this._parent._startPerformanceCounter("Compile shadow generators");
const promises = new Array();
const lights = this._babylonScene.lights;
for (const light of lights) {
const generator = light.getShadowGenerator();
if (generator) {
promises.push(generator.forceCompilationAsync());
}
}
return Promise.all(promises).then(() => {
this._parent._endPerformanceCounter("Compile shadow generators");
});
}
_forEachExtensions(action) {
for (const extension of this._extensions) {
if (extension.enabled) {
action(extension);
}
}
}
_applyExtensions(property, functionName, actionAsync) {
for (const extension of this._extensions) {
if (extension.enabled) {
const id = `${extension.name}.${functionName}`;
const loaderProperty = property;
loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};
const activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;
if (!activeLoaderExtensionFunctions[id]) {
activeLoaderExtensionFunctions[id] = true;
try {
const result = actionAsync(extension);
if (result) {
return result;
}
}
finally {
delete activeLoaderExtensionFunctions[id];
}
}
}
}
return null;
}
_extensionsOnLoading() {
this._forEachExtensions((extension) => extension.onLoading && extension.onLoading());
}
_extensionsOnReady() {
this._forEachExtensions((extension) => extension.onReady && extension.onReady());
}
_extensionsLoadSceneAsync(context, scene) {
return this._applyExtensions(scene, "loadScene", (extension) => extension.loadSceneAsync && extension.loadSceneAsync(context, scene));
}
_extensionsLoadNodeAsync(context, node, assign) {
return this._applyExtensions(node, "loadNode", (extension) => extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign));
}
_extensionsLoadCameraAsync(context, camera, assign) {
return this._applyExtensions(camera, "loadCamera", (extension) => extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign));
}
_extensionsLoadVertexDataAsync(context, primitive, babylonMesh) {
return this._applyExtensions(primitive, "loadVertexData", (extension) => extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh));
}
_extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign) {
return this._applyExtensions(primitive, "loadMeshPrimitive", (extension) => extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign));
}
_extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign) {
return this._applyExtensions(material, "loadMaterial", (extension) => extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign));
}
_extensionsCreateMaterial(context, material, babylonDrawMode) {
return this._applyExtensions(material, "createMaterial", (extension) => extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode));
}
_extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial) {
return this._applyExtensions(material, "loadMaterialProperties", (extension) => extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial));
}
_extensionsLoadTextureInfoAsync(context, textureInfo, assign) {
return this._applyExtensions(textureInfo, "loadTextureInfo", (extension) => extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign));
}
_extensionsLoadTextureAsync(context, texture, assign) {
return this._applyExtensions(texture, "loadTexture", (extension) => extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign));
}
_extensionsLoadAnimationAsync(context, animation) {
return this._applyExtensions(animation, "loadAnimation", (extension) => extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation));
}
_extensionsLoadAnimationChannelAsync(context, animationContext, animation, channel, onLoad) {
return this._applyExtensions(animation, "loadAnimationChannel", (extension) => extension._loadAnimationChannelAsync && extension._loadAnimationChannelAsync(context, animationContext, animation, channel, onLoad));
}
_extensionsLoadSkinAsync(context, node, skin) {
return this._applyExtensions(skin, "loadSkin", (extension) => extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin));
}
_extensionsLoadUriAsync(context, property, uri) {
return this._applyExtensions(property, "loadUri", (extension) => extension._loadUriAsync && extension._loadUriAsync(context, property, uri));
}
_extensionsLoadBufferViewAsync(context, bufferView) {
return this._applyExtensions(bufferView, "loadBufferView", (extension) => extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView));
}
_extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength) {
return this._applyExtensions(buffer, "loadBuffer", (extension) => extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength));
}
/**
* Helper method called by a loader extension to load an glTF extension.
* @param context The context when loading the asset
* @param property The glTF property to load the extension from
* @param extensionName The name of the extension to load
* @param actionAsync The action to run
* @returns The promise returned by actionAsync or null if the extension does not exist
*/
// eslint-disable-next-line @typescript-eslint/naming-convention
static LoadExtensionAsync(context, property, extensionName, actionAsync) {
if (!property.extensions) {
return null;
}
const extensions = property.extensions;
const extension = extensions[extensionName];
if (!extension) {
return null;
}
return actionAsync(`${context}/extensions/${extensionName}`, extension);
}
/**
* Helper method called by a loader extension to load a glTF extra.
* @param context The context when loading the asset
* @param property The glTF property to load the extra from
* @param extensionName The name of the extension to load
* @param actionAsync The action to run
* @returns The promise returned by actionAsync or null if the extra does not exist
*/
// eslint-disable-next-line @typescript-eslint/naming-convention
static LoadExtraAsync(context, property, extensionName, actionAsync) {
if (!property.extras) {
return null;
}
const extras = property.extras;
const extra = extras[extensionName];
if (!extra) {
return null;
}
return actionAsync(`${context}/extras/${extensionName}`, extra);
}
/**
* Checks for presence of an extension.
* @param name The name of the extension to check
* @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
*/
isExtensionUsed(name) {
return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;
}
/**
* Increments the indentation level and logs a message.
* @param message The message to log
*/
logOpen(message) {
this._parent._logOpen(message);
}
/**
* Decrements the indentation level.
*/
logClose() {
this._parent._logClose();
}
/**
* Logs a message
* @param message The message to log
*/
log(message) {
this._parent._log(message);
}
/**
* Starts a performance counter.
* @param counterName The name of the performance counter
*/
startPerformanceCounter(counterName) {
this._parent._startPerformanceCounter(counterName);
}
/**
* Ends a performance counter.
* @param counterName The name of the performance counter
*/
endPerformanceCounter(counterName) {
this._parent._endPerformanceCounter(counterName);
}
}
/**
* The default glTF sampler.
*/
GLTFLoader.DefaultSampler = { index: -1 };
let _Registered = false;
/**
* Registers the GLTF 2.0 loader factory on the GLTFFileLoader. Idempotent.
* @internal
*/
function RegisterGLTF2Loader() {
if (_Registered) {
return;
}
_Registered = true;
GLTFFileLoader._CreateGLTF2Loader = (parent) => new GLTFLoader(parent);
}
export { ArrayItem as A, GLTFFileLoader as G, LoadBoundingInfoFromPositionAccessor as L, RegisterGLTF2Loader as R, RegisterGLTFFileLoader as a, GLTFLoader as b };
//# sourceMappingURL=glTFLoader.pure-qHOSg4KR.esm.js.map