|
|
@@ -11298,6 +11298,10 @@ var BABYLON;
|
|
|
**/
|
|
|
this.enableOfflineSupport = false;
|
|
|
/**
|
|
|
+ * Gets or sets a boolean to enable/disable checking manifest if IndexedDB support is enabled (Babylon.js will always consider the database is up to date)
|
|
|
+ **/
|
|
|
+ this.disableManifestCheck = false;
|
|
|
+ /**
|
|
|
* Gets the list of created scenes
|
|
|
*/
|
|
|
this.scenes = new Array();
|
|
|
@@ -67282,7 +67286,8 @@ var BABYLON;
|
|
|
return plugin;
|
|
|
}
|
|
|
if (rootUrl.indexOf("file:") === -1) {
|
|
|
- var canUseOfflineSupport = scene.getEngine().enableOfflineSupport;
|
|
|
+ var engine = scene.getEngine();
|
|
|
+ var canUseOfflineSupport = engine.enableOfflineSupport;
|
|
|
if (canUseOfflineSupport) {
|
|
|
// Also check for exceptions
|
|
|
var exceptionFound = false;
|
|
|
@@ -67297,7 +67302,7 @@ var BABYLON;
|
|
|
}
|
|
|
if (canUseOfflineSupport) {
|
|
|
// Checking if a manifest file has been set for this scene and if offline mode has been requested
|
|
|
- database = new BABYLON.Database(rootUrl + sceneFilename, manifestChecked);
|
|
|
+ database = new BABYLON.Database(rootUrl + sceneFilename, manifestChecked, engine.disableManifestCheck);
|
|
|
}
|
|
|
else {
|
|
|
manifestChecked();
|
|
|
@@ -68991,12 +68996,24 @@ var BABYLON;
|
|
|
|
|
|
var BABYLON;
|
|
|
(function (BABYLON) {
|
|
|
+ /**
|
|
|
+ * Class used to enable access to IndexedDB
|
|
|
+ * @see @https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API
|
|
|
+ */
|
|
|
var Database = /** @class */ (function () {
|
|
|
- function Database(urlToScene, callbackManifestChecked) {
|
|
|
+ /**
|
|
|
+ * Creates a new Database
|
|
|
+ * @param urlToScene defines the url to load the scene
|
|
|
+ * @param callbackManifestChecked defines the callback to use when manifest is checked
|
|
|
+ * @param disableManifestCheck defines a boolean indicating that we want to skip the manifest validation (it will be considered validated and up to date)
|
|
|
+ */
|
|
|
+ function Database(urlToScene, callbackManifestChecked, disableManifestCheck) {
|
|
|
+ if (disableManifestCheck === void 0) { disableManifestCheck = false; }
|
|
|
+ var _this = this;
|
|
|
// Handling various flavors of prefixed version of IndexedDB
|
|
|
this.idbFactory = (window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB);
|
|
|
this.callbackManifestChecked = callbackManifestChecked;
|
|
|
- this.currentSceneUrl = Database.ReturnFullUrlLocation(urlToScene);
|
|
|
+ this.currentSceneUrl = Database._ReturnFullUrlLocation(urlToScene);
|
|
|
this.db = null;
|
|
|
this._enableSceneOffline = false;
|
|
|
this._enableTexturesOffline = false;
|
|
|
@@ -69007,10 +69024,23 @@ var BABYLON;
|
|
|
this.callbackManifestChecked(true);
|
|
|
}
|
|
|
else {
|
|
|
- this.checkManifestFile();
|
|
|
+ if (disableManifestCheck) {
|
|
|
+ this._enableSceneOffline = true;
|
|
|
+ this._enableTexturesOffline = true;
|
|
|
+ this.manifestVersionFound = 1;
|
|
|
+ BABYLON.Tools.SetImmediate(function () {
|
|
|
+ _this.callbackManifestChecked(true);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ this._checkManifestFile();
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
Object.defineProperty(Database.prototype, "enableSceneOffline", {
|
|
|
+ /**
|
|
|
+ * Gets a boolean indicating if scene must be saved in the database
|
|
|
+ */
|
|
|
get: function () {
|
|
|
return this._enableSceneOffline;
|
|
|
},
|
|
|
@@ -69018,13 +69048,16 @@ var BABYLON;
|
|
|
configurable: true
|
|
|
});
|
|
|
Object.defineProperty(Database.prototype, "enableTexturesOffline", {
|
|
|
+ /**
|
|
|
+ * Gets a boolean indicating if textures must be saved in the database
|
|
|
+ */
|
|
|
get: function () {
|
|
|
return this._enableTexturesOffline;
|
|
|
},
|
|
|
enumerable: true,
|
|
|
configurable: true
|
|
|
});
|
|
|
- Database.prototype.checkManifestFile = function () {
|
|
|
+ Database.prototype._checkManifestFile = function () {
|
|
|
var _this = this;
|
|
|
var noManifestFile = function () {
|
|
|
_this._enableSceneOffline = false;
|
|
|
@@ -69082,6 +69115,11 @@ var BABYLON;
|
|
|
this.callbackManifestChecked(false);
|
|
|
}
|
|
|
};
|
|
|
+ /**
|
|
|
+ * Open the database and make it available
|
|
|
+ * @param successCallback defines the callback to call on success
|
|
|
+ * @param errorCallback defines the callback to call on error
|
|
|
+ */
|
|
|
Database.prototype.openAsync = function (successCallback, errorCallback) {
|
|
|
var _this = this;
|
|
|
var handleError = function () {
|
|
|
@@ -69138,9 +69176,14 @@ var BABYLON;
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
+ /**
|
|
|
+ * Loads an image from the database
|
|
|
+ * @param url defines the url to load from
|
|
|
+ * @param image defines the target DOM image
|
|
|
+ */
|
|
|
Database.prototype.loadImageFromDB = function (url, image) {
|
|
|
var _this = this;
|
|
|
- var completeURL = Database.ReturnFullUrlLocation(url);
|
|
|
+ var completeURL = Database._ReturnFullUrlLocation(url);
|
|
|
var saveAndLoadImage = function () {
|
|
|
if (!_this.hasReachedQuota && _this.db !== null) {
|
|
|
// the texture is not yet in the DB, let's try to save it
|
|
|
@@ -69369,9 +69412,17 @@ var BABYLON;
|
|
|
callback(-1);
|
|
|
}
|
|
|
};
|
|
|
+ /**
|
|
|
+ * Loads a file from database
|
|
|
+ * @param url defines the URL to load from
|
|
|
+ * @param sceneLoaded defines a callback to call on success
|
|
|
+ * @param progressCallBack defines a callback to call when progress changed
|
|
|
+ * @param errorCallback defines a callback to call on error
|
|
|
+ * @param useArrayBuffer defines a boolean to use array buffer instead of text string
|
|
|
+ */
|
|
|
Database.prototype.loadFileFromDB = function (url, sceneLoaded, progressCallBack, errorCallback, useArrayBuffer) {
|
|
|
var _this = this;
|
|
|
- var completeUrl = Database.ReturnFullUrlLocation(url);
|
|
|
+ var completeUrl = Database._ReturnFullUrlLocation(url);
|
|
|
var saveAndLoadFile = function () {
|
|
|
// the scene is not yet in the DB, let's try to save it
|
|
|
_this._saveFileIntoDBAsync(completeUrl, sceneLoaded, progressCallBack);
|
|
|
@@ -69511,9 +69562,11 @@ var BABYLON;
|
|
|
callback();
|
|
|
}
|
|
|
};
|
|
|
+ /** Gets a boolean indicating if the user agent supports blob storage (this value will be updated after creating the first Database object) */
|
|
|
Database.IsUASupportingBlobStorage = true;
|
|
|
+ /** Gets a boolean indicating if Database storate is enabled */
|
|
|
Database.IDBStorageEnabled = true;
|
|
|
- Database.parseURL = function (url) {
|
|
|
+ Database._ParseURL = function (url) {
|
|
|
var a = document.createElement('a');
|
|
|
a.href = url;
|
|
|
var urlWithoutHash = url.substring(0, url.lastIndexOf("#"));
|
|
|
@@ -69521,9 +69574,9 @@ var BABYLON;
|
|
|
var absLocation = url.substring(0, url.indexOf(fileName, 0));
|
|
|
return absLocation;
|
|
|
};
|
|
|
- Database.ReturnFullUrlLocation = function (url) {
|
|
|
+ Database._ReturnFullUrlLocation = function (url) {
|
|
|
if (url.indexOf("http:/") === -1 && url.indexOf("https:/") === -1) {
|
|
|
- return (Database.parseURL(window.location.href) + url);
|
|
|
+ return (Database._ParseURL(window.location.href) + url);
|
|
|
}
|
|
|
else {
|
|
|
return url;
|
|
|
@@ -102803,6 +102856,10 @@ var BABYLON;
|
|
|
*/
|
|
|
this.compileShadowGenerators = false;
|
|
|
/**
|
|
|
+ * Function called before loading a url referenced by the asset.
|
|
|
+ */
|
|
|
+ this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
|
|
|
+ /**
|
|
|
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
|
|
|
*/
|
|
|
this.onMeshLoadedObservable = new BABYLON.Observable();
|
|
|
@@ -102981,6 +103038,7 @@ var BABYLON;
|
|
|
this._loader.dispose();
|
|
|
this._loader = null;
|
|
|
}
|
|
|
+ this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
|
|
|
this.onMeshLoadedObservable.clear();
|
|
|
this.onTextureLoadedObservable.clear();
|
|
|
this.onMaterialLoadedObservable.clear();
|
|
|
@@ -103108,6 +103166,7 @@ var BABYLON;
|
|
|
loader.compileMaterials = this.compileMaterials;
|
|
|
loader.useClipPlane = this.useClipPlane;
|
|
|
loader.compileShadowGenerators = this.compileShadowGenerators;
|
|
|
+ loader.preprocessUrlAsync = this.preprocessUrlAsync;
|
|
|
loader.onMeshLoadedObservable.add(function (mesh) { return _this.onMeshLoadedObservable.notifyObservers(mesh); });
|
|
|
loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); });
|
|
|
loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); });
|
|
|
@@ -104687,16 +104746,14 @@ var BABYLON;
|
|
|
this.compileMaterials = false;
|
|
|
this.useClipPlane = false;
|
|
|
this.compileShadowGenerators = false;
|
|
|
- this.onDisposeObservable = new BABYLON.Observable();
|
|
|
+ this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
|
|
|
this.onMeshLoadedObservable = new BABYLON.Observable();
|
|
|
this.onTextureLoadedObservable = new BABYLON.Observable();
|
|
|
this.onMaterialLoadedObservable = new BABYLON.Observable();
|
|
|
this.onCameraLoadedObservable = new BABYLON.Observable();
|
|
|
this.onCompleteObservable = new BABYLON.Observable();
|
|
|
+ this.onDisposeObservable = new BABYLON.Observable();
|
|
|
this.onExtensionLoadedObservable = new BABYLON.Observable();
|
|
|
- /**
|
|
|
- * State of the loader
|
|
|
- */
|
|
|
this.state = null;
|
|
|
}
|
|
|
GLTFLoader.RegisterExtension = function (extension) {
|
|
|
@@ -105565,6 +105622,10 @@ var BABYLON;
|
|
|
*/
|
|
|
this.compileShadowGenerators = false;
|
|
|
/**
|
|
|
+ * Function called before loading a url referenced by the asset.
|
|
|
+ */
|
|
|
+ this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
|
|
|
+ /**
|
|
|
* Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
|
|
|
*/
|
|
|
this.onMeshLoadedObservable = new BABYLON.Observable();
|
|
|
@@ -105598,13 +105659,13 @@ var BABYLON;
|
|
|
}
|
|
|
/** @hidden */
|
|
|
GLTFLoader._Register = function (name, factory) {
|
|
|
- if (GLTFLoader._Factories[name]) {
|
|
|
+ if (GLTFLoader._ExtensionFactories[name]) {
|
|
|
BABYLON.Tools.Error("Extension with the name '" + name + "' already exists");
|
|
|
return;
|
|
|
}
|
|
|
- GLTFLoader._Factories[name] = factory;
|
|
|
+ GLTFLoader._ExtensionFactories[name] = factory;
|
|
|
// Keep the order of registration so that extensions registered first are called first.
|
|
|
- GLTFLoader._Names.push(name);
|
|
|
+ GLTFLoader._ExtensionNames.push(name);
|
|
|
};
|
|
|
Object.defineProperty(GLTFLoader.prototype, "state", {
|
|
|
/**
|
|
|
@@ -105727,15 +105788,17 @@ var BABYLON;
|
|
|
});
|
|
|
return resultPromise;
|
|
|
}).catch(function (error) {
|
|
|
- BABYLON.Tools.Error("glTF Loader: " + error.message);
|
|
|
- _this._clear();
|
|
|
- throw error;
|
|
|
+ if (!_this._disposed) {
|
|
|
+ BABYLON.Tools.Error("glTF Loader: " + error.message);
|
|
|
+ _this._clear();
|
|
|
+ throw error;
|
|
|
+ }
|
|
|
});
|
|
|
};
|
|
|
GLTFLoader.prototype._loadExtensions = function () {
|
|
|
- for (var _i = 0, _a = GLTFLoader._Names; _i < _a.length; _i++) {
|
|
|
+ for (var _i = 0, _a = GLTFLoader._ExtensionNames; _i < _a.length; _i++) {
|
|
|
var name_1 = _a[_i];
|
|
|
- var extension = GLTFLoader._Factories[name_1](this);
|
|
|
+ var extension = GLTFLoader._ExtensionFactories[name_1](this);
|
|
|
this._extensions[name_1] = extension;
|
|
|
this.onExtensionLoadedObservable.notifyObservers(extension);
|
|
|
}
|
|
|
@@ -106814,31 +106877,35 @@ var BABYLON;
|
|
|
if (BABYLON.Tools.IsBase64(uri)) {
|
|
|
return Promise.resolve(new Uint8Array(BABYLON.Tools.DecodeBase64(uri)));
|
|
|
}
|
|
|
- return new Promise(function (resolve, reject) {
|
|
|
- var request = BABYLON.Tools.LoadFile(_this._rootUrl + uri, function (data) {
|
|
|
- if (!_this._disposed) {
|
|
|
- resolve(new Uint8Array(data));
|
|
|
- }
|
|
|
- }, function (event) {
|
|
|
+ return this.preprocessUrlAsync(this._rootUrl + uri).then(function (url) {
|
|
|
+ return new Promise(function (resolve, reject) {
|
|
|
if (!_this._disposed) {
|
|
|
- try {
|
|
|
- if (request && _this._state === BABYLON.GLTFLoaderState.LOADING) {
|
|
|
- request._lengthComputable = event.lengthComputable;
|
|
|
- request._loaded = event.loaded;
|
|
|
- request._total = event.total;
|
|
|
- _this._onProgress();
|
|
|
+ var request_1 = BABYLON.Tools.LoadFile(url, function (data) {
|
|
|
+ if (!_this._disposed) {
|
|
|
+ resolve(new Uint8Array(data));
|
|
|
}
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- reject(e);
|
|
|
- }
|
|
|
- }
|
|
|
- }, _this._babylonScene.database, true, function (request, exception) {
|
|
|
- if (!_this._disposed) {
|
|
|
- reject(new BABYLON.LoadFileError(context + ": Failed to load '" + uri + "'" + (request ? ": " + request.status + " " + request.statusText : ""), request));
|
|
|
+ }, function (event) {
|
|
|
+ if (!_this._disposed) {
|
|
|
+ try {
|
|
|
+ if (request_1 && _this._state === BABYLON.GLTFLoaderState.LOADING) {
|
|
|
+ request_1._lengthComputable = event.lengthComputable;
|
|
|
+ request_1._loaded = event.loaded;
|
|
|
+ request_1._total = event.total;
|
|
|
+ _this._onProgress();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ catch (e) {
|
|
|
+ reject(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }, _this._babylonScene.database, true, function (request, exception) {
|
|
|
+ if (!_this._disposed) {
|
|
|
+ reject(new BABYLON.LoadFileError(context + ": Failed to load '" + uri + "'" + (request ? ": " + request.status + " " + request.statusText : ""), request));
|
|
|
+ }
|
|
|
+ });
|
|
|
+ _this._requests.push(request_1);
|
|
|
}
|
|
|
});
|
|
|
- _this._requests.push(request);
|
|
|
});
|
|
|
};
|
|
|
GLTFLoader.prototype._onProgress = function () {
|
|
|
@@ -107029,7 +107096,7 @@ var BABYLON;
|
|
|
};
|
|
|
/** @hidden */
|
|
|
GLTFLoader.prototype._applyExtensions = function (actionAsync) {
|
|
|
- for (var _i = 0, _a = GLTFLoader._Names; _i < _a.length; _i++) {
|
|
|
+ for (var _i = 0, _a = GLTFLoader._ExtensionNames; _i < _a.length; _i++) {
|
|
|
var name_5 = _a[_i];
|
|
|
var extension = this._extensions[name_5];
|
|
|
if (extension.enabled) {
|
|
|
@@ -107041,8 +107108,8 @@ var BABYLON;
|
|
|
}
|
|
|
return null;
|
|
|
};
|
|
|
- GLTFLoader._Names = new Array();
|
|
|
- GLTFLoader._Factories = {};
|
|
|
+ GLTFLoader._ExtensionNames = new Array();
|
|
|
+ GLTFLoader._ExtensionFactories = {};
|
|
|
return GLTFLoader;
|
|
|
}());
|
|
|
GLTF2.GLTFLoader = GLTFLoader;
|
David Catuhe