540 lines
10 KiB
JavaScript
540 lines
10 KiB
JavaScript
/**
|
|
* @author mrdoob / http://mrdoob.com/
|
|
*/
|
|
|
|
THREE.ObjectLoader = function ( manager ) {
|
|
|
|
this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
|
|
this.texturePath = '';
|
|
|
|
};
|
|
|
|
THREE.ObjectLoader.prototype = {
|
|
|
|
constructor: THREE.ObjectLoader,
|
|
|
|
load: function ( url, onLoad, onProgress, onError ) {
|
|
|
|
if ( this.texturePath === '' ) {
|
|
|
|
this.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 );
|
|
|
|
}
|
|
|
|
var scope = this;
|
|
|
|
var loader = new THREE.XHRLoader( scope.manager );
|
|
loader.setCrossOrigin( this.crossOrigin );
|
|
loader.load( url, function ( text ) {
|
|
|
|
scope.parse( JSON.parse( text ), onLoad );
|
|
|
|
}, onProgress, onError );
|
|
|
|
},
|
|
|
|
setTexturePath: function ( value ) {
|
|
|
|
this.texturePath = value;
|
|
|
|
},
|
|
|
|
setCrossOrigin: function ( value ) {
|
|
|
|
this.crossOrigin = value;
|
|
|
|
},
|
|
|
|
parse: function ( json, onLoad ) {
|
|
|
|
var geometries = this.parseGeometries( json.geometries );
|
|
|
|
var images = this.parseImages( json.images, function () {
|
|
|
|
if ( onLoad !== undefined ) onLoad( object );
|
|
|
|
} );
|
|
var textures = this.parseTextures( json.textures, images );
|
|
var materials = this.parseMaterials( json.materials, textures );
|
|
var object = this.parseObject( json.object, geometries, materials );
|
|
|
|
if ( json.images === undefined || json.images.length === 0 ) {
|
|
|
|
if ( onLoad !== undefined ) onLoad( object );
|
|
|
|
}
|
|
|
|
return object;
|
|
|
|
},
|
|
|
|
parseGeometries: function ( json ) {
|
|
|
|
var geometries = {};
|
|
|
|
if ( json !== undefined ) {
|
|
|
|
var geometryLoader = new THREE.JSONLoader();
|
|
var bufferGeometryLoader = new THREE.BufferGeometryLoader();
|
|
|
|
for ( var i = 0, l = json.length; i < l; i ++ ) {
|
|
|
|
var geometry;
|
|
var data = json[ i ];
|
|
|
|
switch ( data.type ) {
|
|
|
|
case 'PlaneGeometry':
|
|
case 'PlaneBufferGeometry':
|
|
|
|
geometry = new THREE[ data.type ](
|
|
data.width,
|
|
data.height,
|
|
data.widthSegments,
|
|
data.heightSegments
|
|
);
|
|
|
|
break;
|
|
|
|
case 'BoxGeometry':
|
|
case 'CubeGeometry': // backwards compatible
|
|
|
|
geometry = new THREE.BoxGeometry(
|
|
data.width,
|
|
data.height,
|
|
data.depth,
|
|
data.widthSegments,
|
|
data.heightSegments,
|
|
data.depthSegments
|
|
);
|
|
|
|
break;
|
|
|
|
case 'CircleGeometry':
|
|
|
|
geometry = new THREE.CircleGeometry(
|
|
data.radius,
|
|
data.segments
|
|
);
|
|
|
|
break;
|
|
|
|
case 'CylinderGeometry':
|
|
|
|
geometry = new THREE.CylinderGeometry(
|
|
data.radiusTop,
|
|
data.radiusBottom,
|
|
data.height,
|
|
data.radialSegments,
|
|
data.heightSegments,
|
|
data.openEnded
|
|
);
|
|
|
|
break;
|
|
|
|
case 'SphereGeometry':
|
|
|
|
geometry = new THREE.SphereGeometry(
|
|
data.radius,
|
|
data.widthSegments,
|
|
data.heightSegments,
|
|
data.phiStart,
|
|
data.phiLength,
|
|
data.thetaStart,
|
|
data.thetaLength
|
|
);
|
|
|
|
break;
|
|
|
|
case 'IcosahedronGeometry':
|
|
|
|
geometry = new THREE.IcosahedronGeometry(
|
|
data.radius,
|
|
data.detail
|
|
);
|
|
|
|
break;
|
|
|
|
case 'TorusGeometry':
|
|
|
|
geometry = new THREE.TorusGeometry(
|
|
data.radius,
|
|
data.tube,
|
|
data.radialSegments,
|
|
data.tubularSegments,
|
|
data.arc
|
|
);
|
|
|
|
break;
|
|
|
|
case 'TorusKnotGeometry':
|
|
|
|
geometry = new THREE.TorusKnotGeometry(
|
|
data.radius,
|
|
data.tube,
|
|
data.radialSegments,
|
|
data.tubularSegments,
|
|
data.p,
|
|
data.q,
|
|
data.heightScale
|
|
);
|
|
|
|
break;
|
|
|
|
case 'BufferGeometry':
|
|
|
|
geometry = bufferGeometryLoader.parse( data );
|
|
|
|
break;
|
|
|
|
case 'Geometry':
|
|
|
|
geometry = geometryLoader.parse( data.data ).geometry;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
geometry.uuid = data.uuid;
|
|
|
|
if ( data.name !== undefined ) geometry.name = data.name;
|
|
|
|
geometries[ data.uuid ] = geometry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return geometries;
|
|
|
|
},
|
|
|
|
parseMaterials: function ( json, textures ) {
|
|
|
|
var materials = {};
|
|
|
|
if ( json !== undefined ) {
|
|
|
|
var getTexture = function ( name ) {
|
|
|
|
if ( textures[ name ] === undefined ) {
|
|
|
|
THREE.warn( 'THREE.ObjectLoader: Undefined texture', name );
|
|
|
|
}
|
|
|
|
return textures[ name ];
|
|
|
|
};
|
|
|
|
var loader = new THREE.MaterialLoader();
|
|
|
|
for ( var i = 0, l = json.length; i < l; i ++ ) {
|
|
|
|
var data = json[ i ];
|
|
var material = loader.parse( data );
|
|
|
|
material.uuid = data.uuid;
|
|
|
|
if ( data.name !== undefined ) material.name = data.name;
|
|
|
|
if ( data.map !== undefined ) {
|
|
|
|
material.map = getTexture( data.map );
|
|
|
|
}
|
|
|
|
if ( data.bumpMap !== undefined ) {
|
|
|
|
material.bumpMap = getTexture( data.bumpMap );
|
|
if ( data.bumpScale ) {
|
|
material.bumpScale = new THREE.Vector2( data.bumpScale, data.bumpScale );
|
|
}
|
|
|
|
}
|
|
|
|
if ( data.alphaMap !== undefined ) {
|
|
|
|
material.alphaMap = getTexture( data.alphaMap );
|
|
|
|
}
|
|
|
|
if ( data.envMap !== undefined ) {
|
|
|
|
material.envMap = getTexture( data.envMap );
|
|
|
|
}
|
|
|
|
if ( data.normalMap !== undefined ) {
|
|
|
|
material.normalMap = getTexture( data.normalMap );
|
|
if ( data.normalScale ) {
|
|
material.normalScale = new THREE.Vector2( data.normalScale, data.normalScale );
|
|
}
|
|
|
|
}
|
|
|
|
if ( data.lightMap !== undefined ) {
|
|
|
|
material.lightMap = getTexture( data.lightMap );
|
|
|
|
}
|
|
|
|
if ( data.specularMap !== undefined ) {
|
|
|
|
material.specularMap = getTexture( data.specularMap );
|
|
|
|
}
|
|
|
|
materials[ data.uuid ] = material;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return materials;
|
|
|
|
},
|
|
|
|
parseImages: function ( json, onLoad ) {
|
|
|
|
var scope = this;
|
|
var images = {};
|
|
|
|
if ( json !== undefined && json.length > 0 ) {
|
|
|
|
var manager = new THREE.LoadingManager( onLoad );
|
|
|
|
var loader = new THREE.ImageLoader( manager );
|
|
loader.setCrossOrigin( this.crossOrigin );
|
|
|
|
var loadImage = function ( url ) {
|
|
|
|
scope.manager.itemStart( url );
|
|
|
|
return loader.load( url, function () {
|
|
|
|
scope.manager.itemEnd( url );
|
|
|
|
} );
|
|
|
|
};
|
|
|
|
for ( var i = 0, l = json.length; i < l; i ++ ) {
|
|
|
|
var image = json[ i ];
|
|
var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url;
|
|
|
|
images[ image.uuid ] = loadImage( path );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return images;
|
|
|
|
},
|
|
|
|
parseTextures: function ( json, images ) {
|
|
|
|
var textures = {};
|
|
|
|
if ( json !== undefined ) {
|
|
|
|
for ( var i = 0, l = json.length; i < l; i ++ ) {
|
|
|
|
var data = json[ i ];
|
|
|
|
if ( data.image === undefined ) {
|
|
|
|
THREE.warn( 'THREE.ObjectLoader: No "image" speficied for', data.uuid );
|
|
|
|
}
|
|
|
|
if ( images[ data.image ] === undefined ) {
|
|
|
|
THREE.warn( 'THREE.ObjectLoader: Undefined image', data.image );
|
|
|
|
}
|
|
|
|
var texture = new THREE.Texture( images[ data.image ] );
|
|
texture.needsUpdate = true;
|
|
|
|
texture.uuid = data.uuid;
|
|
|
|
if ( data.name !== undefined ) texture.name = data.name;
|
|
if ( data.repeat !== undefined ) texture.repeat = new THREE.Vector2( data.repeat[ 0 ], data.repeat[ 1 ] );
|
|
if ( data.minFilter !== undefined ) texture.minFilter = THREE[ data.minFilter ];
|
|
if ( data.magFilter !== undefined ) texture.magFilter = THREE[ data.magFilter ];
|
|
if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
|
|
if ( data.wrap instanceof Array ) {
|
|
|
|
texture.wrapS = THREE[ data.wrap[ 0 ] ];
|
|
texture.wrapT = THREE[ data.wrap[ 1 ] ];
|
|
|
|
}
|
|
|
|
textures[ data.uuid ] = texture;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return textures;
|
|
|
|
},
|
|
|
|
parseObject: function () {
|
|
|
|
var matrix = new THREE.Matrix4();
|
|
|
|
return function ( data, geometries, materials ) {
|
|
|
|
var object;
|
|
|
|
var getGeometry = function ( name ) {
|
|
|
|
if ( geometries[ name ] === undefined ) {
|
|
|
|
THREE.warn( 'THREE.ObjectLoader: Undefined geometry', name );
|
|
|
|
}
|
|
|
|
return geometries[ name ];
|
|
|
|
};
|
|
|
|
var getMaterial = function ( name ) {
|
|
|
|
if ( materials[ name ] === undefined ) {
|
|
|
|
THREE.warn( 'THREE.ObjectLoader: Undefined material', name );
|
|
|
|
}
|
|
|
|
return materials[ name ];
|
|
|
|
};
|
|
|
|
switch ( data.type ) {
|
|
|
|
case 'Scene':
|
|
|
|
object = new THREE.Scene();
|
|
|
|
break;
|
|
|
|
case 'PerspectiveCamera':
|
|
|
|
object = new THREE.PerspectiveCamera( data.fov, data.aspect, data.near, data.far );
|
|
|
|
break;
|
|
|
|
case 'OrthographicCamera':
|
|
|
|
object = new THREE.OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
|
|
|
|
break;
|
|
|
|
case 'AmbientLight':
|
|
|
|
object = new THREE.AmbientLight( data.color );
|
|
|
|
break;
|
|
|
|
case 'DirectionalLight':
|
|
|
|
object = new THREE.DirectionalLight( data.color, data.intensity );
|
|
|
|
break;
|
|
|
|
case 'PointLight':
|
|
|
|
object = new THREE.PointLight( data.color, data.intensity, data.distance, data.decay );
|
|
|
|
break;
|
|
|
|
case 'SpotLight':
|
|
|
|
object = new THREE.SpotLight( data.color, data.intensity, data.distance, data.angle, data.exponent, data.decay );
|
|
|
|
break;
|
|
|
|
case 'HemisphereLight':
|
|
|
|
object = new THREE.HemisphereLight( data.color, data.groundColor, data.intensity );
|
|
|
|
break;
|
|
|
|
case 'Mesh':
|
|
|
|
object = new THREE.Mesh( getGeometry( data.geometry ), getMaterial( data.material ) );
|
|
|
|
break;
|
|
|
|
case 'Line':
|
|
|
|
object = new THREE.Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );
|
|
|
|
break;
|
|
|
|
case 'PointCloud':
|
|
|
|
object = new THREE.PointCloud( getGeometry( data.geometry ), getMaterial( data.material ) );
|
|
|
|
break;
|
|
|
|
case 'Sprite':
|
|
|
|
object = new THREE.Sprite( getMaterial( data.material ) );
|
|
|
|
break;
|
|
|
|
case 'Group':
|
|
|
|
object = new THREE.Group();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
object = new THREE.Object3D();
|
|
|
|
}
|
|
|
|
object.uuid = data.uuid;
|
|
|
|
if ( data.name !== undefined ) object.name = data.name;
|
|
if ( data.matrix !== undefined ) {
|
|
|
|
matrix.fromArray( data.matrix );
|
|
matrix.decompose( object.position, object.quaternion, object.scale );
|
|
|
|
} else {
|
|
|
|
if ( data.position !== undefined ) object.position.fromArray( data.position );
|
|
if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
|
|
if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
|
|
|
|
}
|
|
|
|
if ( data.visible !== undefined ) object.visible = data.visible;
|
|
if ( data.userData !== undefined ) object.userData = data.userData;
|
|
|
|
if ( data.children !== undefined ) {
|
|
|
|
for ( var child in data.children ) {
|
|
|
|
object.add( this.parseObject( data.children[ child ], geometries, materials ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return object;
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
};
|