Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | 1886x 1886x 1886x 1886x 1886x 2x 1884x 1884x 1884x 1884x 1884x 1x 1x 1x 1x 11978x 6911x 1x 8253x 6371x 1882x 1300x 1300x 582x 582x 582x 582x 582x 582x 566x 12x 554x 554x 554x 16x 6x 10x 10x 10x 1x 582x 1x 1881x | import Frozen from "../Core/Frozen.js";
import defined from "../Core/defined.js";
import DeveloperError from "../Core/DeveloperError.js";
import ResourceLoader from "./ResourceLoader.js";
import ResourceLoaderState from "./ResourceLoaderState.js";
/**
* Loads an embedded or external buffer.
* <p>
* Implements the {@link ResourceLoader} interface.
* </p>
*
* @alias BufferLoader
* @constructor
* @augments ResourceLoader
*
* @param {object} options Object with the following properties:
* @param {Uint8Array} [options.typedArray] The typed array containing the embedded buffer contents. Mutually exclusive with options.resource.
* @param {Resource} [options.resource] The {@link Resource} pointing to the external buffer. Mutually exclusive with options.typedArray.
* @param {string} [options.cacheKey] The cache key of the resource.
*
* @exception {DeveloperError} One of options.typedArray and options.resource must be defined.
*
* @private
*/
function BufferLoader(options) {
options = options ?? Frozen.EMPTY_OBJECT;
const typedArray = options.typedArray;
const resource = options.resource;
const cacheKey = options.cacheKey;
//>>includeStart('debug', pragmas.debug);
if (defined(typedArray) === defined(resource)) {
throw new DeveloperError(
"One of options.typedArray and options.resource must be defined.",
);
}
//>>includeEnd('debug');
this._typedArray = typedArray;
this._resource = resource;
this._cacheKey = cacheKey;
this._state = ResourceLoaderState.UNLOADED;
this._promise = undefined;
}
Eif (defined(Object.create)) {
BufferLoader.prototype = Object.create(ResourceLoader.prototype);
BufferLoader.prototype.constructor = BufferLoader;
}
Object.defineProperties(BufferLoader.prototype, {
/**
* The cache key of the resource.
*
* @memberof BufferLoader.prototype
*
* @type {string}
* @readonly
* @private
*/
cacheKey: {
get: function () {
return this._cacheKey;
},
},
/**
* The typed array containing the embedded buffer contents.
*
* @memberof BufferLoader.prototype
*
* @type {Uint8Array}
* @readonly
* @private
*/
typedArray: {
get: function () {
return this._typedArray;
},
},
});
/**
* Loads the resource.
* @returns {Promise<BufferLoader>} A promise which resolves to the loader when the resource loading is completed.
* @private
*/
BufferLoader.prototype.load = async function () {
if (defined(this._promise)) {
return this._promise;
}
if (defined(this._typedArray)) {
this._promise = Promise.resolve(this);
return this._promise;
}
this._promise = loadExternalBuffer(this);
return this._promise;
};
async function loadExternalBuffer(bufferLoader) {
const resource = bufferLoader._resource;
bufferLoader._state = ResourceLoaderState.LOADING;
try {
const arrayBuffer = await BufferLoader._fetchArrayBuffer(resource);
if (bufferLoader.isDestroyed()) {
return;
}
bufferLoader._typedArray = new Uint8Array(arrayBuffer);
bufferLoader._state = ResourceLoaderState.READY;
return bufferLoader;
} catch (error) {
if (bufferLoader.isDestroyed()) {
return;
}
bufferLoader._state = ResourceLoaderState.FAILED;
const errorMessage = `Failed to load external buffer: ${resource.url}`;
throw bufferLoader.getError(errorMessage, error);
}
}
/**
* Exposed for testing
* @private
*/
BufferLoader._fetchArrayBuffer = function (resource) {
return resource.fetchArrayBuffer();
};
/**
* Unloads the resource.
* @private
*/
BufferLoader.prototype.unload = function () {
this._typedArray = undefined;
};
export default BufferLoader;
|