Add existing to tracked
This commit is contained in:
+624
@@ -0,0 +1,624 @@
|
||||
import Check from "../Core/Check.js";
|
||||
import Frozen from "../Core/Frozen.js";
|
||||
import defined from "../Core/defined.js";
|
||||
import DeveloperError from "../Core/DeveloperError.js";
|
||||
import Buffer from "../Renderer/Buffer.js";
|
||||
import BufferUsage from "../Renderer/BufferUsage.js";
|
||||
import AttributeType from "./AttributeType.js";
|
||||
import JobType from "./JobType.js";
|
||||
import ModelComponents from "./ModelComponents.js";
|
||||
import ResourceLoader from "./ResourceLoader.js";
|
||||
import ResourceLoaderState from "./ResourceLoaderState.js";
|
||||
import CesiumMath from "../Core/Math.js";
|
||||
|
||||
/**
|
||||
* Loads a vertex buffer from a glTF buffer view.
|
||||
* <p>
|
||||
* Implements the {@link ResourceLoader} interface.
|
||||
* </p>
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
class GltfVertexBufferLoader extends 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 {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 {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
|
||||
* @param {object} [options.primitive] The primitive containing the Draco extension.
|
||||
* @param {object} [options.draco] The Draco extension object.
|
||||
* @param {object} [options.spz] The SPZ extension object.
|
||||
* @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
|
||||
* @param {number} [options.accessorId] The accessor id.
|
||||
* @param {string} [options.cacheKey] The cache key of the resource.
|
||||
* @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
|
||||
* @param {boolean} [options.loadBuffer=false] Load vertex buffer as a GPU vertex buffer.
|
||||
* @param {boolean} [options.loadTypedArray=false] Load vertex buffer as a typed array.
|
||||
*
|
||||
* @exception {DeveloperError} Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.
|
||||
* @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
|
||||
* @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
|
||||
*/
|
||||
constructor(options) {
|
||||
super();
|
||||
|
||||
options = options ?? Frozen.EMPTY_OBJECT;
|
||||
const resourceCache = options.resourceCache;
|
||||
const gltf = options.gltf;
|
||||
const gltfResource = options.gltfResource;
|
||||
const baseResource = options.baseResource;
|
||||
const bufferViewId = options.bufferViewId;
|
||||
const primitive = options.primitive;
|
||||
const draco = options.draco;
|
||||
const attributeSemantic = options.attributeSemantic;
|
||||
const accessorId = options.accessorId;
|
||||
const cacheKey = options.cacheKey;
|
||||
const spz = options.spz;
|
||||
const asynchronous = options.asynchronous ?? true;
|
||||
const loadBuffer = options.loadBuffer ?? false;
|
||||
const loadTypedArray = options.loadTypedArray ?? false;
|
||||
|
||||
//>>includeStart('debug', pragmas.debug);
|
||||
Check.typeOf.func("options.resourceCache", resourceCache);
|
||||
Check.typeOf.object("options.gltf", gltf);
|
||||
Check.typeOf.object("options.gltfResource", gltfResource);
|
||||
Check.typeOf.object("options.baseResource", baseResource);
|
||||
if (!loadBuffer && !loadTypedArray) {
|
||||
throw new DeveloperError(
|
||||
"At least one of loadBuffer and loadTypedArray must be true.",
|
||||
);
|
||||
}
|
||||
|
||||
const hasBufferViewId = defined(bufferViewId);
|
||||
const hasPrimitive = defined(primitive);
|
||||
const hasDraco = hasDracoCompression(draco, attributeSemantic);
|
||||
const hasAttributeSemantic = defined(attributeSemantic);
|
||||
const hasAccessorId = defined(accessorId);
|
||||
const hasSpz = defined(spz);
|
||||
const sourceCount =
|
||||
Number(hasBufferViewId) + Number(hasDraco) + Number(hasSpz);
|
||||
if (sourceCount !== 1) {
|
||||
throw new DeveloperError(
|
||||
"Exactly one vertex buffer source must be effective: options.bufferViewId, options.spz, or options.draco for options.attributeSemantic.",
|
||||
);
|
||||
}
|
||||
|
||||
if (hasDraco && !hasAttributeSemantic) {
|
||||
throw new DeveloperError(
|
||||
"When options.draco is defined options.attributeSemantic must also be defined.",
|
||||
);
|
||||
}
|
||||
|
||||
if (hasDraco && !hasAccessorId) {
|
||||
throw new DeveloperError(
|
||||
"When options.draco is defined options.accessorId must also be defined.",
|
||||
);
|
||||
}
|
||||
|
||||
if (hasDraco && !hasPrimitive) {
|
||||
throw new DeveloperError(
|
||||
"When options.draco is defined options.primitive must also be defined.",
|
||||
);
|
||||
}
|
||||
|
||||
if (hasDraco) {
|
||||
Check.typeOf.object("options.primitive", primitive);
|
||||
Check.typeOf.object("options.draco", draco);
|
||||
Check.typeOf.string("options.attributeSemantic", attributeSemantic);
|
||||
Check.typeOf.number("options.accessorId", accessorId);
|
||||
}
|
||||
|
||||
//>>includeEnd('debug');
|
||||
|
||||
this._resourceCache = resourceCache;
|
||||
this._gltfResource = gltfResource;
|
||||
this._baseResource = baseResource;
|
||||
this._gltf = gltf;
|
||||
this._bufferViewId = bufferViewId;
|
||||
this._primitive = primitive;
|
||||
this._draco = draco;
|
||||
this._spz = spz;
|
||||
this._attributeSemantic = attributeSemantic;
|
||||
this._accessorId = accessorId;
|
||||
this._cacheKey = cacheKey;
|
||||
this._asynchronous = asynchronous;
|
||||
this._loadBuffer = loadBuffer;
|
||||
this._loadTypedArray = loadTypedArray;
|
||||
this._bufferViewLoader = undefined;
|
||||
this._dracoLoader = undefined;
|
||||
this._quantization = undefined;
|
||||
this._typedArray = undefined;
|
||||
this._buffer = undefined;
|
||||
this._state = ResourceLoaderState.UNLOADED;
|
||||
this._promise = undefined;
|
||||
}
|
||||
|
||||
/**
|
||||
* The cache key of the resource.
|
||||
*
|
||||
*
|
||||
* @type {string}
|
||||
* @readonly
|
||||
* @private
|
||||
*/
|
||||
get cacheKey() {
|
||||
return this._cacheKey;
|
||||
}
|
||||
|
||||
/**
|
||||
* The vertex buffer. This is only defined when <code>loadAsTypedArray</code> is false.
|
||||
*
|
||||
*
|
||||
* @type {Buffer}
|
||||
* @readonly
|
||||
* @private
|
||||
*/
|
||||
get buffer() {
|
||||
return this._buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* The typed array containing vertex buffer data. This is only defined when <code>loadAsTypedArray</code> is true.
|
||||
*
|
||||
*
|
||||
* @type {Uint8Array}
|
||||
* @readonly
|
||||
* @private
|
||||
*/
|
||||
get typedArray() {
|
||||
return this._typedArray;
|
||||
}
|
||||
|
||||
/**
|
||||
* Information about the quantized vertex attribute after Draco decode.
|
||||
*
|
||||
*
|
||||
* @type {ModelComponents.Quantization}
|
||||
* @readonly
|
||||
* @private
|
||||
*/
|
||||
get quantization() {
|
||||
return this._quantization;
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the resource.
|
||||
* @returns {Promise<GltfVertexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
|
||||
* @private
|
||||
*/
|
||||
async load() {
|
||||
if (defined(this._promise)) {
|
||||
return this._promise;
|
||||
}
|
||||
|
||||
if (defined(this._spz)) {
|
||||
this._promise = loadFromSpz(this);
|
||||
return this._promise;
|
||||
}
|
||||
|
||||
if (hasDracoCompression(this._draco, this._attributeSemantic)) {
|
||||
this._promise = loadFromDraco(this);
|
||||
return this._promise;
|
||||
}
|
||||
|
||||
this._promise = loadFromBufferView(this);
|
||||
return this._promise;
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes the resource until it becomes ready.
|
||||
*
|
||||
* @param {FrameState} frameState The frame state.
|
||||
* @private
|
||||
*/
|
||||
process(frameState) {
|
||||
//>>includeStart('debug', pragmas.debug);
|
||||
Check.typeOf.object("frameState", frameState);
|
||||
//>>includeEnd('debug');
|
||||
|
||||
if (this._state === ResourceLoaderState.READY) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (
|
||||
this._state !== ResourceLoaderState.LOADED &&
|
||||
this._state !== ResourceLoaderState.PROCESSING
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (defined(this._dracoLoader)) {
|
||||
try {
|
||||
const ready = this._dracoLoader.process(frameState);
|
||||
if (!ready) {
|
||||
return false;
|
||||
}
|
||||
} catch (error) {
|
||||
handleError(this, error);
|
||||
}
|
||||
|
||||
processDraco(this);
|
||||
}
|
||||
|
||||
if (defined(this._spzLoader)) {
|
||||
try {
|
||||
const ready = this._spzLoader.process(frameState);
|
||||
if (!ready) {
|
||||
return false;
|
||||
}
|
||||
} catch (error) {
|
||||
handleError(this, error);
|
||||
}
|
||||
|
||||
processSpz(this);
|
||||
}
|
||||
|
||||
let buffer;
|
||||
const typedArray = this._typedArray;
|
||||
if (this._loadBuffer && this._asynchronous) {
|
||||
const vertexBufferJob = scratchVertexBufferJob;
|
||||
vertexBufferJob.set(typedArray, frameState.context);
|
||||
const jobScheduler = frameState.jobScheduler;
|
||||
if (!jobScheduler.execute(vertexBufferJob, JobType.BUFFER)) {
|
||||
// Job scheduler is full. Try again next frame.
|
||||
return false;
|
||||
}
|
||||
buffer = vertexBufferJob.buffer;
|
||||
} else if (this._loadBuffer) {
|
||||
buffer = createVertexBuffer(typedArray, frameState.context);
|
||||
}
|
||||
|
||||
// Unload everything except the vertex buffer
|
||||
this.unload();
|
||||
|
||||
this._buffer = buffer;
|
||||
this._typedArray = this._loadTypedArray ? typedArray : undefined;
|
||||
this._state = ResourceLoaderState.READY;
|
||||
this._resourceCache.statistics.addGeometryLoader(this);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unloads the resource.
|
||||
* @private
|
||||
*/
|
||||
unload() {
|
||||
if (defined(this._buffer)) {
|
||||
this._buffer.destroy();
|
||||
}
|
||||
|
||||
const resourceCache = this._resourceCache;
|
||||
|
||||
if (
|
||||
defined(this._bufferViewLoader) &&
|
||||
!this._bufferViewLoader.isDestroyed()
|
||||
) {
|
||||
resourceCache.unload(this._bufferViewLoader);
|
||||
}
|
||||
|
||||
if (defined(this._dracoLoader)) {
|
||||
resourceCache.unload(this._dracoLoader);
|
||||
}
|
||||
|
||||
if (defined(this._spzLoader)) {
|
||||
resourceCache.unload(this._spzLoader);
|
||||
}
|
||||
|
||||
this._bufferViewLoader = undefined;
|
||||
this._dracoLoader = undefined;
|
||||
this._spzLoader = undefined;
|
||||
this._typedArray = undefined;
|
||||
this._buffer = undefined;
|
||||
this._gltf = undefined;
|
||||
this._primitive = undefined;
|
||||
}
|
||||
}
|
||||
|
||||
function hasDracoCompression(draco, semantic) {
|
||||
return (
|
||||
defined(draco) &&
|
||||
defined(draco.attributes) &&
|
||||
defined(draco.attributes[semantic])
|
||||
);
|
||||
}
|
||||
|
||||
function getQuantizationInformation(
|
||||
dracoQuantization,
|
||||
componentDatatype,
|
||||
componentCount,
|
||||
type,
|
||||
) {
|
||||
const quantizationBits = dracoQuantization.quantizationBits;
|
||||
const normalizationRange = (1 << quantizationBits) - 1;
|
||||
const normalizationDivisor = 1.0 / normalizationRange;
|
||||
|
||||
const quantization = new ModelComponents.Quantization();
|
||||
quantization.componentDatatype = componentDatatype;
|
||||
quantization.octEncoded = dracoQuantization.octEncoded;
|
||||
quantization.octEncodedZXY = true;
|
||||
quantization.type = type;
|
||||
|
||||
if (quantization.octEncoded) {
|
||||
quantization.type = AttributeType.VEC2;
|
||||
quantization.normalizationRange = normalizationRange;
|
||||
} else {
|
||||
const MathType = AttributeType.getMathType(type);
|
||||
if (MathType === Number) {
|
||||
const dimensions = dracoQuantization.range;
|
||||
quantization.quantizedVolumeOffset = dracoQuantization.minValues[0];
|
||||
quantization.quantizedVolumeDimensions = dimensions;
|
||||
quantization.normalizationRange = normalizationRange;
|
||||
quantization.quantizedVolumeStepSize = dimensions * normalizationDivisor;
|
||||
} else {
|
||||
quantization.quantizedVolumeOffset = MathType.unpack(
|
||||
dracoQuantization.minValues,
|
||||
);
|
||||
quantization.normalizationRange = MathType.unpack(
|
||||
new Array(componentCount).fill(normalizationRange),
|
||||
);
|
||||
const packedDimensions = new Array(componentCount).fill(
|
||||
dracoQuantization.range,
|
||||
);
|
||||
quantization.quantizedVolumeDimensions =
|
||||
MathType.unpack(packedDimensions);
|
||||
|
||||
// Computing the step size
|
||||
const packedSteps = packedDimensions.map(function (dimension) {
|
||||
return dimension * normalizationDivisor;
|
||||
});
|
||||
quantization.quantizedVolumeStepSize = MathType.unpack(packedSteps);
|
||||
}
|
||||
}
|
||||
|
||||
return quantization;
|
||||
}
|
||||
|
||||
async function loadFromSpz(vertexBufferLoader) {
|
||||
vertexBufferLoader._state = ResourceLoaderState.LOADING;
|
||||
const resourceCache = vertexBufferLoader._resourceCache;
|
||||
try {
|
||||
const spzLoader = resourceCache.getSpzLoader({
|
||||
gltf: vertexBufferLoader._gltf,
|
||||
primitive: vertexBufferLoader._primitive,
|
||||
spz: vertexBufferLoader._spz,
|
||||
gltfResource: vertexBufferLoader._gltfResource,
|
||||
baseResource: vertexBufferLoader._baseResource,
|
||||
});
|
||||
vertexBufferLoader._spzLoader = spzLoader;
|
||||
await spzLoader.load();
|
||||
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
vertexBufferLoader._state = ResourceLoaderState.LOADED;
|
||||
return vertexBufferLoader;
|
||||
} catch {
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getShAttributePrefix(attribute) {
|
||||
const prefix = attribute.startsWith("KHR_gaussian_splatting:")
|
||||
? "KHR_gaussian_splatting:"
|
||||
: "_";
|
||||
return `${prefix}SH_DEGREE_`;
|
||||
}
|
||||
|
||||
function extractSHDegreeAndCoef(attribute) {
|
||||
const prefix = getShAttributePrefix(attribute);
|
||||
const separator = "_COEF_";
|
||||
|
||||
const lStart = prefix.length;
|
||||
const coefIndex = attribute.indexOf(separator, lStart);
|
||||
|
||||
const l = parseInt(attribute.slice(lStart, coefIndex), 10);
|
||||
const n = parseInt(attribute.slice(coefIndex + separator.length), 10);
|
||||
|
||||
return { l, n };
|
||||
}
|
||||
|
||||
function processSpz(vertexBufferLoader) {
|
||||
vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
|
||||
const spzLoader = vertexBufferLoader._spzLoader;
|
||||
|
||||
const gcloudData = spzLoader.decodedData.gcloud;
|
||||
|
||||
if (vertexBufferLoader._attributeSemantic === "POSITION") {
|
||||
vertexBufferLoader._typedArray = gcloudData.positions;
|
||||
} else if (
|
||||
vertexBufferLoader._attributeSemantic === "KHR_gaussian_splatting:SCALE" ||
|
||||
vertexBufferLoader._attributeSemantic === "_SCALE"
|
||||
) {
|
||||
vertexBufferLoader._typedArray = gcloudData.scales;
|
||||
} else if (
|
||||
vertexBufferLoader._attributeSemantic ===
|
||||
"KHR_gaussian_splatting:ROTATION" ||
|
||||
vertexBufferLoader._attributeSemantic === "_ROTATION"
|
||||
) {
|
||||
vertexBufferLoader._typedArray = gcloudData.rotations;
|
||||
} else if (vertexBufferLoader._attributeSemantic === "COLOR_0") {
|
||||
const colors = gcloudData.colors;
|
||||
const alphas = gcloudData.alphas;
|
||||
vertexBufferLoader._typedArray = new Uint8Array((colors.length / 3) * 4);
|
||||
for (let i = 0; i < colors.length / 3; i++) {
|
||||
vertexBufferLoader._typedArray[i * 4] = CesiumMath.clamp(
|
||||
colors[i * 3] * 255.0,
|
||||
0.0,
|
||||
255.0,
|
||||
);
|
||||
vertexBufferLoader._typedArray[i * 4 + 1] = CesiumMath.clamp(
|
||||
colors[i * 3 + 1] * 255.0,
|
||||
0.0,
|
||||
255.0,
|
||||
);
|
||||
vertexBufferLoader._typedArray[i * 4 + 2] = CesiumMath.clamp(
|
||||
colors[i * 3 + 2] * 255.0,
|
||||
0.0,
|
||||
255.0,
|
||||
);
|
||||
vertexBufferLoader._typedArray[i * 4 + 3] = CesiumMath.clamp(
|
||||
alphas[i] * 255.0,
|
||||
0.0,
|
||||
255.0,
|
||||
);
|
||||
}
|
||||
} else if (vertexBufferLoader._attributeSemantic.includes("SH_DEGREE_")) {
|
||||
const { l, n } = extractSHDegreeAndCoef(
|
||||
vertexBufferLoader._attributeSemantic,
|
||||
);
|
||||
const sphericalHarmonicDegree = gcloudData.shDegree;
|
||||
let stride = 0;
|
||||
const base = [0, 9, 24];
|
||||
switch (sphericalHarmonicDegree) {
|
||||
case 1:
|
||||
stride = 9;
|
||||
break;
|
||||
case 2:
|
||||
stride = 24;
|
||||
break;
|
||||
case 3:
|
||||
stride = 45;
|
||||
break;
|
||||
}
|
||||
const count = gcloudData.numPoints;
|
||||
const sh = gcloudData.sh;
|
||||
vertexBufferLoader._typedArray = new Float32Array(count * 3);
|
||||
for (let i = 0; i < count; i++) {
|
||||
const idx = i * stride + base[l - 1] + n * 3;
|
||||
vertexBufferLoader._typedArray[i * 3] = sh[idx];
|
||||
vertexBufferLoader._typedArray[i * 3 + 1] = sh[idx + 1];
|
||||
vertexBufferLoader._typedArray[i * 3 + 2] = sh[idx + 2];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function loadFromDraco(vertexBufferLoader) {
|
||||
vertexBufferLoader._state = ResourceLoaderState.LOADING;
|
||||
const resourceCache = vertexBufferLoader._resourceCache;
|
||||
try {
|
||||
const dracoLoader = resourceCache.getDracoLoader({
|
||||
gltf: vertexBufferLoader._gltf,
|
||||
primitive: vertexBufferLoader._primitive,
|
||||
draco: vertexBufferLoader._draco,
|
||||
gltfResource: vertexBufferLoader._gltfResource,
|
||||
baseResource: vertexBufferLoader._baseResource,
|
||||
});
|
||||
vertexBufferLoader._dracoLoader = dracoLoader;
|
||||
await dracoLoader.load();
|
||||
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Now wait for process() to run to finish loading
|
||||
vertexBufferLoader._state = ResourceLoaderState.LOADED;
|
||||
return vertexBufferLoader;
|
||||
} catch {
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleError(vertexBufferLoader);
|
||||
}
|
||||
}
|
||||
|
||||
function processDraco(vertexBufferLoader) {
|
||||
vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
|
||||
const dracoLoader = vertexBufferLoader._dracoLoader;
|
||||
|
||||
// Get the typed array and quantization information
|
||||
const decodedVertexAttributes = dracoLoader.decodedData.vertexAttributes;
|
||||
const attributeSemantic = vertexBufferLoader._attributeSemantic;
|
||||
const dracoAttribute = decodedVertexAttributes[attributeSemantic];
|
||||
const accessorId = vertexBufferLoader._accessorId;
|
||||
const accessor = vertexBufferLoader._gltf.accessors[accessorId];
|
||||
const type = accessor.type;
|
||||
const typedArray = dracoAttribute.array;
|
||||
const dracoQuantization = dracoAttribute.data.quantization;
|
||||
if (defined(dracoQuantization)) {
|
||||
vertexBufferLoader._quantization = getQuantizationInformation(
|
||||
dracoQuantization,
|
||||
dracoAttribute.data.componentDatatype,
|
||||
dracoAttribute.data.componentsPerAttribute,
|
||||
type,
|
||||
);
|
||||
}
|
||||
|
||||
vertexBufferLoader._typedArray = new Uint8Array(
|
||||
typedArray.buffer,
|
||||
typedArray.byteOffset,
|
||||
typedArray.byteLength,
|
||||
);
|
||||
}
|
||||
|
||||
async function loadFromBufferView(vertexBufferLoader) {
|
||||
vertexBufferLoader._state = ResourceLoaderState.LOADING;
|
||||
const resourceCache = vertexBufferLoader._resourceCache;
|
||||
try {
|
||||
const bufferViewLoader = resourceCache.getBufferViewLoader({
|
||||
gltf: vertexBufferLoader._gltf,
|
||||
bufferViewId: vertexBufferLoader._bufferViewId,
|
||||
gltfResource: vertexBufferLoader._gltfResource,
|
||||
baseResource: vertexBufferLoader._baseResource,
|
||||
});
|
||||
vertexBufferLoader._bufferViewLoader = bufferViewLoader;
|
||||
await bufferViewLoader.load();
|
||||
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
vertexBufferLoader._typedArray = bufferViewLoader.typedArray;
|
||||
vertexBufferLoader._state = ResourceLoaderState.PROCESSING;
|
||||
return vertexBufferLoader;
|
||||
} catch (error) {
|
||||
if (vertexBufferLoader.isDestroyed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleError(vertexBufferLoader, error);
|
||||
}
|
||||
}
|
||||
|
||||
function handleError(vertexBufferLoader, error) {
|
||||
vertexBufferLoader.unload();
|
||||
vertexBufferLoader._state = ResourceLoaderState.FAILED;
|
||||
const errorMessage = "Failed to load vertex buffer";
|
||||
throw vertexBufferLoader.getError(errorMessage, error);
|
||||
}
|
||||
|
||||
class CreateVertexBufferJob {
|
||||
constructor() {
|
||||
this.typedArray = undefined;
|
||||
this.context = undefined;
|
||||
this.buffer = undefined;
|
||||
}
|
||||
|
||||
set(typedArray, context) {
|
||||
this.typedArray = typedArray;
|
||||
this.context = context;
|
||||
}
|
||||
|
||||
execute() {
|
||||
this.buffer = createVertexBuffer(this.typedArray, this.context);
|
||||
}
|
||||
}
|
||||
|
||||
function createVertexBuffer(typedArray, context) {
|
||||
const buffer = Buffer.createVertexBuffer({
|
||||
typedArray: typedArray,
|
||||
context: context,
|
||||
usage: BufferUsage.STATIC_DRAW,
|
||||
});
|
||||
buffer.vertexArrayDestroyable = false;
|
||||
return buffer;
|
||||
}
|
||||
|
||||
const scratchVertexBufferJob = new CreateVertexBufferJob();
|
||||
|
||||
export default GltfVertexBufferLoader;
|
||||
Reference in New Issue
Block a user