You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
511 lines
12 KiB
511 lines
12 KiB
( function () {
|
|
|
|
const _taskCache = new WeakMap();
|
|
class DRACOLoader extends THREE.Loader {
|
|
|
|
constructor( manager ) {
|
|
|
|
super( manager );
|
|
this.decoderPath = '';
|
|
this.decoderConfig = {};
|
|
this.decoderBinary = null;
|
|
this.decoderPending = null;
|
|
this.workerLimit = 4;
|
|
this.workerPool = [];
|
|
this.workerNextTaskID = 1;
|
|
this.workerSourceURL = '';
|
|
this.defaultAttributeIDs = {
|
|
position: 'POSITION',
|
|
normal: 'NORMAL',
|
|
color: 'COLOR',
|
|
uv: 'TEX_COORD'
|
|
};
|
|
this.defaultAttributeTypes = {
|
|
position: 'Float32Array',
|
|
normal: 'Float32Array',
|
|
color: 'Float32Array',
|
|
uv: 'Float32Array'
|
|
};
|
|
|
|
}
|
|
setDecoderPath( path ) {
|
|
|
|
this.decoderPath = path;
|
|
return this;
|
|
|
|
}
|
|
setDecoderConfig( config ) {
|
|
|
|
this.decoderConfig = config;
|
|
return this;
|
|
|
|
}
|
|
setWorkerLimit( workerLimit ) {
|
|
|
|
this.workerLimit = workerLimit;
|
|
return this;
|
|
|
|
}
|
|
load( url, onLoad, onProgress, onError ) {
|
|
|
|
const loader = new THREE.FileLoader( this.manager );
|
|
loader.setPath( this.path );
|
|
loader.setResponseType( 'arraybuffer' );
|
|
loader.setRequestHeader( this.requestHeader );
|
|
loader.setWithCredentials( this.withCredentials );
|
|
loader.load( url, buffer => {
|
|
|
|
this.decodeDracoFile( buffer, onLoad ).catch( onError );
|
|
|
|
}, onProgress, onError );
|
|
|
|
}
|
|
decodeDracoFile( buffer, callback, attributeIDs, attributeTypes ) {
|
|
|
|
const taskConfig = {
|
|
attributeIDs: attributeIDs || this.defaultAttributeIDs,
|
|
attributeTypes: attributeTypes || this.defaultAttributeTypes,
|
|
useUniqueIDs: !! attributeIDs
|
|
};
|
|
return this.decodeGeometry( buffer, taskConfig ).then( callback );
|
|
|
|
}
|
|
decodeGeometry( buffer, taskConfig ) {
|
|
|
|
const taskKey = JSON.stringify( taskConfig );
|
|
|
|
// Check for an existing task using this buffer. A transferred buffer cannot be transferred
|
|
// again from this thread.
|
|
if ( _taskCache.has( buffer ) ) {
|
|
|
|
const cachedTask = _taskCache.get( buffer );
|
|
if ( cachedTask.key === taskKey ) {
|
|
|
|
return cachedTask.promise;
|
|
|
|
} else if ( buffer.byteLength === 0 ) {
|
|
|
|
// Technically, it would be possible to wait for the previous task to complete,
|
|
// transfer the buffer back, and decode again with the second configuration. That
|
|
// is complex, and I don't know of any reason to decode a Draco buffer twice in
|
|
// different ways, so this is left unimplemented.
|
|
throw new Error( 'THREE.DRACOLoader: Unable to re-decode a buffer with different ' + 'settings. Buffer has already been transferred.' );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
|
|
let worker;
|
|
const taskID = this.workerNextTaskID ++;
|
|
const taskCost = buffer.byteLength;
|
|
|
|
// Obtain a worker and assign a task, and construct a geometry instance
|
|
// when the task completes.
|
|
const geometryPending = this._getWorker( taskID, taskCost ).then( _worker => {
|
|
|
|
worker = _worker;
|
|
return new Promise( ( resolve, reject ) => {
|
|
|
|
worker._callbacks[ taskID ] = {
|
|
resolve,
|
|
reject
|
|
};
|
|
worker.postMessage( {
|
|
type: 'decode',
|
|
id: taskID,
|
|
taskConfig,
|
|
buffer
|
|
}, [ buffer ] );
|
|
|
|
// this.debug();
|
|
|
|
} );
|
|
|
|
} ).then( message => this._createGeometry( message.geometry ) );
|
|
|
|
// Remove task from the task list.
|
|
// Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
|
|
geometryPending.catch( () => true ).then( () => {
|
|
|
|
if ( worker && taskID ) {
|
|
|
|
this._releaseTask( worker, taskID );
|
|
|
|
// this.debug();
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
// Cache the task result.
|
|
_taskCache.set( buffer, {
|
|
key: taskKey,
|
|
promise: geometryPending
|
|
} );
|
|
return geometryPending;
|
|
|
|
}
|
|
_createGeometry( geometryData ) {
|
|
|
|
const geometry = new THREE.BufferGeometry();
|
|
if ( geometryData.index ) {
|
|
|
|
geometry.setIndex( new THREE.BufferAttribute( geometryData.index.array, 1 ) );
|
|
|
|
}
|
|
|
|
for ( let i = 0; i < geometryData.attributes.length; i ++ ) {
|
|
|
|
const attribute = geometryData.attributes[ i ];
|
|
const name = attribute.name;
|
|
const array = attribute.array;
|
|
const itemSize = attribute.itemSize;
|
|
geometry.setAttribute( name, new THREE.BufferAttribute( array, itemSize ) );
|
|
|
|
}
|
|
|
|
return geometry;
|
|
|
|
}
|
|
_loadLibrary( url, responseType ) {
|
|
|
|
const loader = new THREE.FileLoader( this.manager );
|
|
loader.setPath( this.decoderPath );
|
|
loader.setResponseType( responseType );
|
|
loader.setWithCredentials( this.withCredentials );
|
|
return new Promise( ( resolve, reject ) => {
|
|
|
|
loader.load( url, resolve, undefined, reject );
|
|
|
|
} );
|
|
|
|
}
|
|
preload() {
|
|
|
|
this._initDecoder();
|
|
return this;
|
|
|
|
}
|
|
_initDecoder() {
|
|
|
|
if ( this.decoderPending ) return this.decoderPending;
|
|
const useJS = typeof WebAssembly !== 'object' || this.decoderConfig.type === 'js';
|
|
const librariesPending = [];
|
|
if ( useJS ) {
|
|
|
|
librariesPending.push( this._loadLibrary( 'draco_decoder.js', 'text' ) );
|
|
|
|
} else {
|
|
|
|
librariesPending.push( this._loadLibrary( 'draco_wasm_wrapper.js', 'text' ) );
|
|
librariesPending.push( this._loadLibrary( 'draco_decoder.wasm', 'arraybuffer' ) );
|
|
|
|
}
|
|
|
|
this.decoderPending = Promise.all( librariesPending ).then( libraries => {
|
|
|
|
const jsContent = libraries[ 0 ];
|
|
if ( ! useJS ) {
|
|
|
|
this.decoderConfig.wasmBinary = libraries[ 1 ];
|
|
|
|
}
|
|
|
|
const fn = DRACOWorker.toString();
|
|
const body = [ '/* draco decoder */', jsContent, '', '/* worker */', fn.substring( fn.indexOf( '{' ) + 1, fn.lastIndexOf( '}' ) ) ].join( '\n' );
|
|
this.workerSourceURL = URL.createObjectURL( new Blob( [ body ] ) );
|
|
|
|
} );
|
|
return this.decoderPending;
|
|
|
|
}
|
|
_getWorker( taskID, taskCost ) {
|
|
|
|
return this._initDecoder().then( () => {
|
|
|
|
if ( this.workerPool.length < this.workerLimit ) {
|
|
|
|
const worker = new Worker( this.workerSourceURL );
|
|
worker._callbacks = {};
|
|
worker._taskCosts = {};
|
|
worker._taskLoad = 0;
|
|
worker.postMessage( {
|
|
type: 'init',
|
|
decoderConfig: this.decoderConfig
|
|
} );
|
|
worker.onmessage = function ( e ) {
|
|
|
|
const message = e.data;
|
|
switch ( message.type ) {
|
|
|
|
case 'decode':
|
|
worker._callbacks[ message.id ].resolve( message );
|
|
break;
|
|
case 'error':
|
|
worker._callbacks[ message.id ].reject( message );
|
|
break;
|
|
default:
|
|
console.error( 'THREE.DRACOLoader: Unexpected message, "' + message.type + '"' );
|
|
|
|
}
|
|
|
|
};
|
|
|
|
this.workerPool.push( worker );
|
|
|
|
} else {
|
|
|
|
this.workerPool.sort( function ( a, b ) {
|
|
|
|
return a._taskLoad > b._taskLoad ? - 1 : 1;
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
const worker = this.workerPool[ this.workerPool.length - 1 ];
|
|
worker._taskCosts[ taskID ] = taskCost;
|
|
worker._taskLoad += taskCost;
|
|
return worker;
|
|
|
|
} );
|
|
|
|
}
|
|
_releaseTask( worker, taskID ) {
|
|
|
|
worker._taskLoad -= worker._taskCosts[ taskID ];
|
|
delete worker._callbacks[ taskID ];
|
|
delete worker._taskCosts[ taskID ];
|
|
|
|
}
|
|
debug() {
|
|
|
|
console.log( 'Task load: ', this.workerPool.map( worker => worker._taskLoad ) );
|
|
|
|
}
|
|
dispose() {
|
|
|
|
for ( let i = 0; i < this.workerPool.length; ++ i ) {
|
|
|
|
this.workerPool[ i ].terminate();
|
|
|
|
}
|
|
|
|
this.workerPool.length = 0;
|
|
return this;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* WEB WORKER */
|
|
|
|
function DRACOWorker() {
|
|
|
|
let decoderConfig;
|
|
let decoderPending;
|
|
onmessage = function ( e ) {
|
|
|
|
const message = e.data;
|
|
switch ( message.type ) {
|
|
|
|
case 'init':
|
|
decoderConfig = message.decoderConfig;
|
|
decoderPending = new Promise( function ( resolve /*, reject*/ ) {
|
|
|
|
decoderConfig.onModuleLoaded = function ( draco ) {
|
|
|
|
// Module is Promise-like. Wrap before resolving to avoid loop.
|
|
resolve( {
|
|
draco: draco
|
|
} );
|
|
|
|
};
|
|
|
|
DracoDecoderModule( decoderConfig ); // eslint-disable-line no-undef
|
|
|
|
} );
|
|
|
|
break;
|
|
case 'decode':
|
|
const buffer = message.buffer;
|
|
const taskConfig = message.taskConfig;
|
|
decoderPending.then( module => {
|
|
|
|
const draco = module.draco;
|
|
const decoder = new draco.Decoder();
|
|
const decoderBuffer = new draco.DecoderBuffer();
|
|
decoderBuffer.Init( new Int8Array( buffer ), buffer.byteLength );
|
|
try {
|
|
|
|
const geometry = decodeGeometry( draco, decoder, decoderBuffer, taskConfig );
|
|
const buffers = geometry.attributes.map( attr => attr.array.buffer );
|
|
if ( geometry.index ) buffers.push( geometry.index.array.buffer );
|
|
self.postMessage( {
|
|
type: 'decode',
|
|
id: message.id,
|
|
geometry
|
|
}, buffers );
|
|
|
|
} catch ( error ) {
|
|
|
|
console.error( error );
|
|
self.postMessage( {
|
|
type: 'error',
|
|
id: message.id,
|
|
error: error.message
|
|
} );
|
|
|
|
} finally {
|
|
|
|
draco.destroy( decoderBuffer );
|
|
draco.destroy( decoder );
|
|
|
|
}
|
|
|
|
} );
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function decodeGeometry( draco, decoder, decoderBuffer, taskConfig ) {
|
|
|
|
const attributeIDs = taskConfig.attributeIDs;
|
|
const attributeTypes = taskConfig.attributeTypes;
|
|
let dracoGeometry;
|
|
let decodingStatus;
|
|
const geometryType = decoder.GetEncodedGeometryType( decoderBuffer );
|
|
if ( geometryType === draco.TRIANGULAR_MESH ) {
|
|
|
|
dracoGeometry = new draco.Mesh();
|
|
decodingStatus = decoder.DecodeBufferToMesh( decoderBuffer, dracoGeometry );
|
|
|
|
} else if ( geometryType === draco.POINT_CLOUD ) {
|
|
|
|
dracoGeometry = new draco.PointCloud();
|
|
decodingStatus = decoder.DecodeBufferToPointCloud( decoderBuffer, dracoGeometry );
|
|
|
|
} else {
|
|
|
|
throw new Error( 'THREE.DRACOLoader: Unexpected geometry type.' );
|
|
|
|
}
|
|
|
|
if ( ! decodingStatus.ok() || dracoGeometry.ptr === 0 ) {
|
|
|
|
throw new Error( 'THREE.DRACOLoader: Decoding failed: ' + decodingStatus.error_msg() );
|
|
|
|
}
|
|
|
|
const geometry = {
|
|
index: null,
|
|
attributes: []
|
|
};
|
|
|
|
// Gather all vertex attributes.
|
|
for ( const attributeName in attributeIDs ) {
|
|
|
|
const attributeType = self[ attributeTypes[ attributeName ] ];
|
|
let attribute;
|
|
let attributeID;
|
|
|
|
// A Draco file may be created with default vertex attributes, whose attribute IDs
|
|
// are mapped 1:1 from their semantic name (POSITION, NORMAL, ...). Alternatively,
|
|
// a Draco file may contain a custom set of attributes, identified by known unique
|
|
// IDs. glTF files always do the latter, and `.drc` files typically do the former.
|
|
if ( taskConfig.useUniqueIDs ) {
|
|
|
|
attributeID = attributeIDs[ attributeName ];
|
|
attribute = decoder.GetAttributeByUniqueId( dracoGeometry, attributeID );
|
|
|
|
} else {
|
|
|
|
attributeID = decoder.GetAttributeId( dracoGeometry, draco[ attributeIDs[ attributeName ] ] );
|
|
if ( attributeID === - 1 ) continue;
|
|
attribute = decoder.GetAttribute( dracoGeometry, attributeID );
|
|
|
|
}
|
|
|
|
geometry.attributes.push( decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute ) );
|
|
|
|
}
|
|
|
|
// Add index.
|
|
if ( geometryType === draco.TRIANGULAR_MESH ) {
|
|
|
|
geometry.index = decodeIndex( draco, decoder, dracoGeometry );
|
|
|
|
}
|
|
|
|
draco.destroy( dracoGeometry );
|
|
return geometry;
|
|
|
|
}
|
|
|
|
function decodeIndex( draco, decoder, dracoGeometry ) {
|
|
|
|
const numFaces = dracoGeometry.num_faces();
|
|
const numIndices = numFaces * 3;
|
|
const byteLength = numIndices * 4;
|
|
const ptr = draco._malloc( byteLength );
|
|
decoder.GetTrianglesUInt32Array( dracoGeometry, byteLength, ptr );
|
|
const index = new Uint32Array( draco.HEAPF32.buffer, ptr, numIndices ).slice();
|
|
draco._free( ptr );
|
|
return {
|
|
array: index,
|
|
itemSize: 1
|
|
};
|
|
|
|
}
|
|
|
|
function decodeAttribute( draco, decoder, dracoGeometry, attributeName, attributeType, attribute ) {
|
|
|
|
const numComponents = attribute.num_components();
|
|
const numPoints = dracoGeometry.num_points();
|
|
const numValues = numPoints * numComponents;
|
|
const byteLength = numValues * attributeType.BYTES_PER_ELEMENT;
|
|
const dataType = getDracoDataType( draco, attributeType );
|
|
const ptr = draco._malloc( byteLength );
|
|
decoder.GetAttributeDataArrayForAllPoints( dracoGeometry, attribute, dataType, byteLength, ptr );
|
|
const array = new attributeType( draco.HEAPF32.buffer, ptr, numValues ).slice();
|
|
draco._free( ptr );
|
|
return {
|
|
name: attributeName,
|
|
array: array,
|
|
itemSize: numComponents
|
|
};
|
|
|
|
}
|
|
|
|
function getDracoDataType( draco, attributeType ) {
|
|
|
|
switch ( attributeType ) {
|
|
|
|
case Float32Array:
|
|
return draco.DT_FLOAT32;
|
|
case Int8Array:
|
|
return draco.DT_INT8;
|
|
case Int16Array:
|
|
return draco.DT_INT16;
|
|
case Int32Array:
|
|
return draco.DT_INT32;
|
|
case Uint8Array:
|
|
return draco.DT_UINT8;
|
|
case Uint16Array:
|
|
return draco.DT_UINT16;
|
|
case Uint32Array:
|
|
return draco.DT_UINT32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
THREE.DRACOLoader = DRACOLoader;
|
|
|
|
} )();
|
|
|