Doodle3D-Slicer/three.js-master/examples/js/loaders/gltf/glTFLoaderUtils.js

221 lines
6.0 KiB
JavaScript
Raw Normal View History

2015-06-12 15:58:26 +02:00
/**
* @author Tony Parisi / http://www.tonyparisi.com/
*/
THREE.GLTFLoaderUtils = Object.create(Object, {
// errors
MISSING_DESCRIPTION: { value: "MISSING_DESCRIPTION" },
INVALID_PATH: { value: "INVALID_PATH" },
INVALID_TYPE: { value: "INVALID_TYPE" },
XMLHTTPREQUEST_STATUS_ERROR: { value: "XMLHTTPREQUEST_STATUS_ERROR" },
NOT_FOUND: { value: "NOT_FOUND" },
// misc constants
ARRAY_BUFFER: { value: "ArrayBuffer" },
_streams : { value:{}, writable: true },
_streamsStatus: { value: {}, writable: true },
_resources: { value: {}, writable: true },
_resourcesStatus: { value: {}, writable: true },
// initialization
init: {
value: function() {
this._streams = {};
this._streamsStatus = {};
this._resources = {};
this._resourcesStatus = {};
}
},
//manage entries
_containsResource: {
enumerable: false,
value: function(resourceID) {
return this._resources[resourceID] ? true : false;
}
},
_storeResource: {
enumerable: false,
value: function(resourceID, resource) {
if (!resourceID) {
console.log("ERROR: entry does not contain id, cannot store");
return;
}
if (this._containsResource[resourceID]) {
console.log("WARNING: resource:" + resourceID + " is already stored, overriding");
}
this._resources[resourceID] = resource;
}
},
_getResource: {
enumerable: false,
value: function(resourceID) {
return this._resources[resourceID];
}
},
_loadStream: {
value: function(path, type, delegate) {
var self = this;
if (!type) {
delegate.handleError(THREE.GLTFLoaderUtils.INVALID_TYPE, null);
return;
}
if (!path) {
delegate.handleError(THREE.GLTFLoaderUtils.INVALID_PATH);
return;
}
var xhr = new XMLHttpRequest();
xhr.open('GET', path, true);
xhr.responseType = (type === this.ARRAY_BUFFER) ? "arraybuffer" : "text";
//if this is not specified, 1 "big blob" scenes fails to load.
xhr.setRequestHeader("If-Modified-Since", "Sat, 01 Jan 1970 00:00:00 GMT");
xhr.addEventListener( 'load', function ( event ) {
delegate.streamAvailable(path, xhr.response);
}, false );
xhr.addEventListener( 'error', function ( event ) {
delegate.handleError(THREE.GLTFLoaderUtils.XMLHTTPREQUEST_STATUS_ERROR, xhr.status);
}, false );
xhr.send(null);
}
},
send: { value: 0, writable: true },
requested: { value: 0, writable: true },
_handleRequest: {
value: function(request) {
var resourceStatus = this._resourcesStatus[request.id];
if (resourceStatus)
{
this._resourcesStatus[request.id] ++;
}
else
{
this._resourcesStatus[request.id] = 1;
}
var streamStatus = this._streamsStatus[request.path];
if (streamStatus && streamStatus.status === "loading" )
{
streamStatus.requests.push(request);
return;
}
this._streamsStatus[request.path] = { status : "loading", requests : [ request ] };
var self = this;
var processResourceDelegate = {};
processResourceDelegate.streamAvailable = function(path, res_) {
var streamStatus = self._streamsStatus[path];
var requests = streamStatus.requests;
requests.forEach( function(req_) {
var subArray = res_.slice(req_.range[0], req_.range[1]);
var convertedResource = req_.delegate.convert(subArray, req_.ctx);
self._storeResource(req_.id, convertedResource);
req_.delegate.resourceAvailable(convertedResource, req_.ctx);
-- self._resourcesStatus[req_.id];
}, this);
delete self._streamsStatus[path];
};
processResourceDelegate.handleError = function(errorCode, info) {
request.delegate.handleError(errorCode, info);
}
this._loadStream(request.path, request.type, processResourceDelegate);
}
},
_elementSizeForGLType: {
value: function(glType) {
switch (glType) {
case WebGLRenderingContext.FLOAT :
return Float32Array.BYTES_PER_ELEMENT;
case WebGLRenderingContext.UNSIGNED_BYTE :
return Uint8Array.BYTES_PER_ELEMENT;
case WebGLRenderingContext.UNSIGNED_SHORT :
return Uint16Array.BYTES_PER_ELEMENT;
case WebGLRenderingContext.FLOAT_VEC2 :
return Float32Array.BYTES_PER_ELEMENT * 2;
case WebGLRenderingContext.FLOAT_VEC3 :
return Float32Array.BYTES_PER_ELEMENT * 3;
case WebGLRenderingContext.FLOAT_VEC4 :
return Float32Array.BYTES_PER_ELEMENT * 4;
case WebGLRenderingContext.FLOAT_MAT3 :
return Float32Array.BYTES_PER_ELEMENT * 9;
case WebGLRenderingContext.FLOAT_MAT4 :
return Float32Array.BYTES_PER_ELEMENT * 16;
default:
return null;
}
}
},
_handleWrappedBufferViewResourceLoading: {
value: function(wrappedBufferView, delegate, ctx) {
var bufferView = wrappedBufferView.bufferView;
var buffer = bufferView.buffer;
var byteOffset = wrappedBufferView.byteOffset + bufferView.description.byteOffset;
var range = [ byteOffset, (this._elementSizeForGLType(wrappedBufferView.type) * wrappedBufferView.count) + byteOffset ];
this._handleRequest({ "id" : wrappedBufferView.id,
"range" : range,
"type" : buffer.description.type,
"path" : buffer.description.path,
"delegate" : delegate,
"ctx" : ctx }, null);
}
},
getBuffer: {
value: function(wrappedBufferView, delegate, ctx) {
var savedBuffer = this._getResource(wrappedBufferView.id);
if (savedBuffer) {
return savedBuffer;
} else {
this._handleWrappedBufferViewResourceLoading(wrappedBufferView, delegate, ctx);
}
return null;
}
},
getFile: {
value: function(request, delegate, ctx) {
request.delegate = delegate;
request.ctx = ctx;
this._handleRequest({ "id" : request.id,
"path" : request.path,
"range" : [ 0 ],
"type" : "text",
"delegate" : delegate,
"ctx" : ctx }, null);
return null;
}
},
});