315 lines
8.9 KiB
JavaScript
315 lines
8.9 KiB
JavaScript
import Check from "../Core/Check.js";
|
|
import defaultValue from "../Core/defaultValue.js";
|
|
import defined from "../Core/defined.js";
|
|
import getJsonFromTypedArray from "../Core/getJsonFromTypedArray.js";
|
|
import getMagic from "../Core/getMagic.js";
|
|
import isDataUri from "../Core/isDataUri.js";
|
|
import Resource from "../Core/Resource.js";
|
|
import RuntimeError from "../Core/RuntimeError.js";
|
|
import addDefaults from "./GltfPipeline/addDefaults.js";
|
|
import addPipelineExtras from "./GltfPipeline/addPipelineExtras.js";
|
|
import ForEach from "./GltfPipeline/ForEach.js";
|
|
import parseGlb from "./GltfPipeline/parseGlb.js";
|
|
import removePipelineExtras from "./GltfPipeline/removePipelineExtras.js";
|
|
import updateVersion from "./GltfPipeline/updateVersion.js";
|
|
import usesExtension from "./GltfPipeline/usesExtension.js";
|
|
import ResourceLoader from "./ResourceLoader.js";
|
|
import ResourceLoaderState from "./ResourceLoaderState.js";
|
|
import ModelUtility from "./Model/ModelUtility.js";
|
|
|
|
/**
|
|
* Loads a glTF JSON from a glTF or glb.
|
|
* <p>
|
|
* Implements the {@link ResourceLoader} interface.
|
|
* </p>
|
|
*
|
|
* @alias GltfJsonLoader
|
|
* @constructor
|
|
* @augments ResourceLoader
|
|
*
|
|
* @param {object} options Object with the following properties:
|
|
* @param {ResourceCache} options.resourceCache The {@link ResourceCache} (to avoid circular dependencies).
|
|
* @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
|
|
* @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
|
|
* @param {Uint8Array} [options.typedArray] The typed array containing the glTF contents.
|
|
* @param {object} [options.gltfJson] The parsed glTF JSON contents.
|
|
* @param {string} [options.cacheKey] The cache key of the resource.
|
|
*
|
|
* @private
|
|
*/
|
|
function GltfJsonLoader(options) {
|
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
const resourceCache = options.resourceCache;
|
|
const gltfResource = options.gltfResource;
|
|
const baseResource = options.baseResource;
|
|
const typedArray = options.typedArray;
|
|
const gltfJson = options.gltfJson;
|
|
const cacheKey = options.cacheKey;
|
|
|
|
//>>includeStart('debug', pragmas.debug);
|
|
Check.typeOf.func("options.resourceCache", resourceCache);
|
|
Check.typeOf.object("options.gltfResource", gltfResource);
|
|
Check.typeOf.object("options.baseResource", baseResource);
|
|
//>>includeEnd('debug');
|
|
|
|
this._resourceCache = resourceCache;
|
|
this._gltfResource = gltfResource;
|
|
this._baseResource = baseResource;
|
|
this._typedArray = typedArray;
|
|
this._gltfJson = gltfJson;
|
|
this._cacheKey = cacheKey;
|
|
this._gltf = undefined;
|
|
this._bufferLoaders = [];
|
|
this._state = ResourceLoaderState.UNLOADED;
|
|
this._promise = undefined;
|
|
}
|
|
|
|
if (defined(Object.create)) {
|
|
GltfJsonLoader.prototype = Object.create(ResourceLoader.prototype);
|
|
GltfJsonLoader.prototype.constructor = GltfJsonLoader;
|
|
}
|
|
|
|
Object.defineProperties(GltfJsonLoader.prototype, {
|
|
/**
|
|
* The cache key of the resource.
|
|
*
|
|
* @memberof GltfJsonLoader.prototype
|
|
*
|
|
* @type {string}
|
|
* @readonly
|
|
* @private
|
|
*/
|
|
cacheKey: {
|
|
get: function () {
|
|
return this._cacheKey;
|
|
},
|
|
},
|
|
/**
|
|
* The glTF JSON.
|
|
*
|
|
* @memberof GltfJsonLoader.prototype
|
|
*
|
|
* @type {object}
|
|
* @readonly
|
|
* @private
|
|
*/
|
|
gltf: {
|
|
get: function () {
|
|
return this._gltf;
|
|
},
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Loads the resource.
|
|
* @returns {Promise<GltfJsonLoader>} A promise which resolves to the loader when the resource loading is completed.
|
|
* @private
|
|
*/
|
|
GltfJsonLoader.prototype.load = async function () {
|
|
if (defined(this._promise)) {
|
|
return this._promise;
|
|
}
|
|
|
|
this._state = ResourceLoaderState.LOADING;
|
|
|
|
if (defined(this._gltfJson)) {
|
|
this._promise = processGltfJson(this, this._gltfJson);
|
|
return this._promise;
|
|
}
|
|
|
|
if (defined(this._typedArray)) {
|
|
this._promise = processGltfTypedArray(this, this._typedArray);
|
|
return this._promise;
|
|
}
|
|
|
|
this._promise = loadFromUri(this);
|
|
return this._promise;
|
|
};
|
|
|
|
async function loadFromUri(gltfJsonLoader) {
|
|
let typedArray;
|
|
try {
|
|
const arrayBuffer = await gltfJsonLoader._fetchGltf();
|
|
if (gltfJsonLoader.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
typedArray = new Uint8Array(arrayBuffer);
|
|
} catch (error) {
|
|
if (gltfJsonLoader.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
handleError(gltfJsonLoader, error);
|
|
}
|
|
|
|
return processGltfTypedArray(gltfJsonLoader, typedArray);
|
|
}
|
|
|
|
function handleError(gltfJsonLoader, error) {
|
|
gltfJsonLoader.unload();
|
|
gltfJsonLoader._state = ResourceLoaderState.FAILED;
|
|
const errorMessage = `Failed to load glTF: ${gltfJsonLoader._gltfResource.url}`;
|
|
throw gltfJsonLoader.getError(errorMessage, error);
|
|
}
|
|
|
|
async function upgradeVersion(gltfJsonLoader, gltf) {
|
|
if (
|
|
defined(gltf.asset) &&
|
|
gltf.asset.version === "2.0" &&
|
|
!usesExtension(gltf, "KHR_techniques_webgl") &&
|
|
!usesExtension(gltf, "KHR_materials_common")
|
|
) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
// Load all buffers into memory. updateVersion will read and in some cases modify
|
|
// the buffer data, which it accesses from buffer.extras._pipeline.source
|
|
const promises = [];
|
|
ForEach.buffer(gltf, function (buffer) {
|
|
if (
|
|
!defined(buffer.extras._pipeline.source) && // Ignore uri if this buffer uses the glTF 1.0 KHR_binary_glTF extension
|
|
defined(buffer.uri)
|
|
) {
|
|
const resource = gltfJsonLoader._baseResource.getDerivedResource({
|
|
url: buffer.uri,
|
|
});
|
|
const resourceCache = gltfJsonLoader._resourceCache;
|
|
const bufferLoader = resourceCache.getExternalBufferLoader({
|
|
resource: resource,
|
|
});
|
|
gltfJsonLoader._bufferLoaders.push(bufferLoader);
|
|
|
|
promises.push(
|
|
bufferLoader.load().then(function () {
|
|
if (bufferLoader.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
buffer.extras._pipeline.source = bufferLoader.typedArray;
|
|
})
|
|
);
|
|
}
|
|
});
|
|
|
|
await Promise.all(promises);
|
|
updateVersion(gltf);
|
|
}
|
|
|
|
function decodeDataUris(gltf) {
|
|
const promises = [];
|
|
ForEach.buffer(gltf, function (buffer) {
|
|
const bufferUri = buffer.uri;
|
|
if (
|
|
!defined(buffer.extras._pipeline.source) && // Ignore uri if this buffer uses the glTF 1.0 KHR_binary_glTF extension
|
|
defined(bufferUri) &&
|
|
isDataUri(bufferUri)
|
|
) {
|
|
delete buffer.uri; // Delete the data URI to keep the cached glTF JSON small
|
|
promises.push(
|
|
Resource.fetchArrayBuffer(bufferUri).then(function (arrayBuffer) {
|
|
buffer.extras._pipeline.source = new Uint8Array(arrayBuffer);
|
|
})
|
|
);
|
|
}
|
|
});
|
|
return Promise.all(promises);
|
|
}
|
|
|
|
function loadEmbeddedBuffers(gltfJsonLoader, gltf) {
|
|
const promises = [];
|
|
ForEach.buffer(gltf, function (buffer, bufferId) {
|
|
const source = buffer.extras._pipeline.source;
|
|
if (defined(source) && !defined(buffer.uri)) {
|
|
const resourceCache = gltfJsonLoader._resourceCache;
|
|
const bufferLoader = resourceCache.getEmbeddedBufferLoader({
|
|
parentResource: gltfJsonLoader._gltfResource,
|
|
bufferId: bufferId,
|
|
typedArray: source,
|
|
});
|
|
gltfJsonLoader._bufferLoaders.push(bufferLoader);
|
|
promises.push(bufferLoader.load());
|
|
}
|
|
});
|
|
return Promise.all(promises);
|
|
}
|
|
|
|
async function processGltfJson(gltfJsonLoader, gltf) {
|
|
try {
|
|
addPipelineExtras(gltf);
|
|
|
|
await decodeDataUris(gltf);
|
|
await upgradeVersion(gltfJsonLoader, gltf);
|
|
addDefaults(gltf);
|
|
await loadEmbeddedBuffers(gltfJsonLoader, gltf);
|
|
removePipelineExtras(gltf);
|
|
|
|
const version = gltf.asset.version;
|
|
if (version !== "1.0" && version !== "2.0") {
|
|
throw new RuntimeError(`Unsupported glTF version: ${version}`);
|
|
}
|
|
|
|
const extensionsRequired = gltf.extensionsRequired;
|
|
if (defined(extensionsRequired)) {
|
|
ModelUtility.checkSupportedExtensions(extensionsRequired);
|
|
}
|
|
|
|
gltfJsonLoader._gltf = gltf;
|
|
gltfJsonLoader._state = ResourceLoaderState.READY;
|
|
return gltfJsonLoader;
|
|
} catch (error) {
|
|
if (gltfJsonLoader.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
handleError(gltfJsonLoader, error);
|
|
}
|
|
}
|
|
|
|
async function processGltfTypedArray(gltfJsonLoader, typedArray) {
|
|
let gltf;
|
|
try {
|
|
if (getMagic(typedArray) === "glTF") {
|
|
gltf = parseGlb(typedArray);
|
|
} else {
|
|
gltf = getJsonFromTypedArray(typedArray);
|
|
}
|
|
} catch (error) {
|
|
if (gltfJsonLoader.isDestroyed()) {
|
|
return;
|
|
}
|
|
|
|
handleError(gltfJsonLoader, error);
|
|
}
|
|
|
|
return processGltfJson(gltfJsonLoader, gltf);
|
|
}
|
|
|
|
/**
|
|
* Unloads the resource.
|
|
* @private
|
|
*/
|
|
GltfJsonLoader.prototype.unload = function () {
|
|
const bufferLoaders = this._bufferLoaders;
|
|
const bufferLoadersLength = bufferLoaders.length;
|
|
for (let i = 0; i < bufferLoadersLength; ++i) {
|
|
bufferLoaders[i] =
|
|
!bufferLoaders[i].isDestroyed() &&
|
|
this._resourceCache.unload(bufferLoaders[i]);
|
|
}
|
|
this._bufferLoaders.length = 0;
|
|
|
|
this._gltf = undefined;
|
|
};
|
|
|
|
/**
|
|
* Exposed for testing
|
|
*
|
|
* @private
|
|
*/
|
|
GltfJsonLoader.prototype._fetchGltf = function () {
|
|
return this._gltfResource.fetchArrayBuffer();
|
|
};
|
|
|
|
export default GltfJsonLoader;
|