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 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 | 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 1x 1x 1x 1x 126x 114x 6x 6x 6x 6x 6x 6x 6x 6x 6x 1x 114x 108x 6x 6x 6x 6x 6x 6x 6x 6x 6x 6x 1x 285x 285x 114x 171x 171x 171x 171x 165x 6x 6x 6x 1x 12x 6x 12x 12x 12x 12x 12x | import Check from "../Core/Check.js";
import Frozen from "../Core/Frozen.js";
import defined from "../Core/defined.js";
import ResourceLoader from "./ResourceLoader.js";
import ResourceLoaderState from "./ResourceLoaderState.js";
import { loadSpz } from "@spz-loader/core";
/**
* Load a SPZ buffer from a glTF.
* <p>
* Implements the {@link ResourceLoader} interface.
* </p>
* @alias GltfSpzLoader
* @constructor
* @augments ResourceLoader
* @param {object} options Object with the following properties:
* @param {ResourceCache} options.resourceCache The {@link ResourceCache} (to avoid circular dependencies).
* @param {object} options.gltf The glTF JSON.
* @param {object} options.primitive The primitive containing the SPZ extension.
* @param {object} options.spz The SPZ extension object.
* @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 {string} [options.cacheKey] The cache key of the resource.
*
* @private
*/
function GltfSpzLoader(options) {
options = options ?? Frozen.EMPTY_OBJECT;
const resourceCache = options.resourceCache;
const gltf = options.gltf;
const primitive = options.primitive;
const spz = options.spz;
const gltfResource = options.gltfResource;
const baseResource = options.baseResource;
const cacheKey = options.cacheKey;
//>>includeStart('debug', pragmas.debug);
Check.typeOf.func("options.resourceCache", resourceCache);
Check.typeOf.object("options.gltf", gltf);
Check.typeOf.object("options.primitive", primitive);
Check.typeOf.object("options.spz", spz);
Check.typeOf.object("options.gltfResource", gltfResource);
Check.typeOf.object("options.baseResource", baseResource);
//>>includeEnd('debug');
this._resourceCache = resourceCache;
this._gltfResource = gltfResource;
this._baseResource = baseResource;
this._gltf = gltf;
this._primitive = primitive;
this._spz = spz;
this._cacheKey = cacheKey;
this._bufferViewLoader = undefined;
this._bufferViewTypedArray = undefined;
this._decodePromise = undefined;
this._decodedData = undefined;
this._state = ResourceLoaderState.UNLOADED;
this._promise = undefined;
this._spzError = undefined;
}
Eif (defined(Object.create)) {
GltfSpzLoader.prototype = Object.create(ResourceLoader.prototype);
GltfSpzLoader.prototype.constructor = GltfSpzLoader;
}
Object.defineProperties(GltfSpzLoader.prototype, {
/**
* The cache key of the resource.
* @memberof GltfSpzLoader.prototype
* @type {string}
* @readonly
* @private
*/
cacheKey: {
get: function () {
return this._cacheKey;
},
},
/**
* The decoded SPZ data.
* @memberof GltfSpzLoader.prototype
* @type {object}
* @readonly
* @private
*/
decodedData: {
get: function () {
return this._decodedData;
},
},
});
async function loadResources(loader) {
const resourceCache = loader._resourceCache;
try {
const bufferViewLoader = resourceCache.getBufferViewLoader({
gltf: loader._gltf,
bufferViewId: 0,
gltfResource: loader._gltfResource,
baseResource: loader._baseResource,
});
loader._bufferViewLoader = bufferViewLoader;
await bufferViewLoader.load();
Iif (loader.isDestroyed()) {
return;
}
loader._bufferViewTypedArray = bufferViewLoader.typedArray;
loader._state = ResourceLoaderState.PROCESSING;
return loader;
} catch (error) {
if (loader.isDestroyed()) {
return;
}
handleError(loader, error);
}
}
/**
* Loads the SPZ resource.
* @returns {Promise<Resource>} A promise that resolves to the resource when the SPZ is loaded.
* @private
*/
GltfSpzLoader.prototype.load = async function () {
if (defined(this._promise)) {
return this._promise;
}
this._state = ResourceLoaderState.LOADING;
this._promise = loadResources(this);
return this._promise;
};
function handleError(spzLoader, error) {
spzLoader.unload();
spzLoader._state = ResourceLoaderState.FAILED;
const errorMessage = "Failed to load SPZ";
throw spzLoader.getError(errorMessage, error);
}
async function processDecode(loader, decodePromise) {
try {
const gcloud = await decodePromise;
Iif (loader.isDestroyed()) {
return;
}
loader.unload();
loader._decodedData = {
gcloud: gcloud,
};
loader._state = ResourceLoaderState.READY;
return loader._baseResource;
} catch (error) {
if (loader.isDestroyed()) {
return;
}
loader._spzError = error;
}
}
/**
* Processes the SPZ resource.
* @param {FrameState} frameState The frame state.
* @private
*/
GltfSpzLoader.prototype.process = function (frameState) {
//>>includeStart('debug', pragmas.debug);
Check.typeOf.object("frameState", frameState);
//>>includeEnd('debug');
if (this._state === ResourceLoaderState.READY) {
return true;
}
Iif (this._state !== ResourceLoaderState.PROCESSING) {
return false;
}
Iif (defined(this._spzError)) {
handleError(this, this._spzError);
}
Iif (!defined(this._bufferViewTypedArray)) {
return false;
}
if (defined(this._decodePromise)) {
return false;
}
const decodePromise = loadSpz(this._bufferViewTypedArray, {
unpackOptions: { coordinateSystem: "UNSPECIFIED" },
});
Iif (!defined(decodePromise)) {
return false;
}
this._decodePromise = processDecode(this, decodePromise);
};
/**
* Unloads the SPZ resource and frees associated resources.
* @private
*/
GltfSpzLoader.prototype.unload = function () {
if (defined(this._bufferViewLoader)) {
this._resourceCache.unload(this._bufferViewLoader);
}
this._bufferViewLoader = undefined;
this._bufferViewTypedArray = undefined;
this._decodedData = undefined;
this._gltf = undefined;
this._primitive = undefined;
};
export default GltfSpzLoader;
|