three#SkinnedMesh JavaScript Examples
The following examples show how to use
three#SkinnedMesh.
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
| Source File: FBXLoader.js From canvas with Apache License 2.0 | 4 votes |
|
FBXLoader = ( function () {
var fbxTree;
var connections;
var sceneGraph;
function FBXLoader( manager ) {
Loader.call( this, manager );
}
FBXLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
constructor: FBXLoader,
load: function ( url, onLoad, onProgress, onError ) {
var scope = this;
var path = ( scope.path === '' ) ? LoaderUtils.extractUrlBase( url ) : scope.path;
var loader = new FileLoader( this.manager );
loader.setPath( scope.path );
loader.setResponseType( 'arraybuffer' );
loader.load( url, function ( buffer ) {
try {
onLoad( scope.parse( buffer, path ) );
} catch ( error ) {
setTimeout( function () {
if ( onError ) onError( error );
scope.manager.itemError( url );
}, 0 );
}
}, onProgress, onError );
},
parse: function ( FBXBuffer, path ) {
if ( isFbxFormatBinary( FBXBuffer ) ) {
fbxTree = new BinaryParser().parse( FBXBuffer );
} else {
var FBXText = convertArrayBufferToString( FBXBuffer );
if ( ! isFbxFormatASCII( FBXText ) ) {
throw new Error( 'THREE.FBXLoader: Unknown format.' );
}
if ( getFbxVersion( FBXText ) < 7000 ) {
throw new Error( 'THREE.FBXLoader: FBX version not supported, FileVersion: ' + getFbxVersion( FBXText ) );
}
fbxTree = new TextParser().parse( FBXText );
}
// console.log( fbxTree );
var textureLoader = new TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
return new FBXTreeParser( textureLoader, this.manager ).parse( fbxTree );
}
} );
// Parse the FBXTree object returned by the BinaryParser or TextParser and return a Group
function FBXTreeParser( textureLoader, manager ) {
this.textureLoader = textureLoader;
this.manager = manager;
}
FBXTreeParser.prototype = {
constructor: FBXTreeParser,
parse: function () {
connections = this.parseConnections();
var images = this.parseImages();
var textures = this.parseTextures( images );
var materials = this.parseMaterials( textures );
var deformers = this.parseDeformers();
var geometryMap = new GeometryParser().parse( deformers );
this.parseScene( deformers, geometryMap, materials );
return sceneGraph;
},
// Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )
// and details the connection type
parseConnections: function () {
var connectionMap = new Map();
if ( 'Connections' in fbxTree ) {
var rawConnections = fbxTree.Connections.connections;
rawConnections.forEach( function ( rawConnection ) {
var fromID = rawConnection[ 0 ];
var toID = rawConnection[ 1 ];
var relationship = rawConnection[ 2 ];
if ( ! connectionMap.has( fromID ) ) {
connectionMap.set( fromID, {
parents: [],
children: []
} );
}
var parentRelationship = { ID: toID, relationship: relationship };
connectionMap.get( fromID ).parents.push( parentRelationship );
if ( ! connectionMap.has( toID ) ) {
connectionMap.set( toID, {
parents: [],
children: []
} );
}
var childRelationship = { ID: fromID, relationship: relationship };
connectionMap.get( toID ).children.push( childRelationship );
} );
}
return connectionMap;
},
// Parse FBXTree.Objects.Video for embedded image data
// These images are connected to textures in FBXTree.Objects.Textures
// via FBXTree.Connections.
parseImages: function () {
var images = {};
var blobs = {};
if ( 'Video' in fbxTree.Objects ) {
var videoNodes = fbxTree.Objects.Video;
for ( var nodeID in videoNodes ) {
var videoNode = videoNodes[ nodeID ];
var id = parseInt( nodeID );
images[ id ] = videoNode.RelativeFilename || videoNode.Filename;
// raw image data is in videoNode.Content
if ( 'Content' in videoNode ) {
var arrayBufferContent = ( videoNode.Content instanceof ArrayBuffer ) && ( videoNode.Content.byteLength > 0 );
var base64Content = ( typeof videoNode.Content === 'string' ) && ( videoNode.Content !== '' );
if ( arrayBufferContent || base64Content ) {
var image = this.parseImage( videoNodes[ nodeID ] );
blobs[ videoNode.RelativeFilename || videoNode.Filename ] = image;
}
}
}
}
for ( var id in images ) {
var filename = images[ id ];
if ( blobs[ filename ] !== undefined ) images[ id ] = blobs[ filename ];
else images[ id ] = images[ id ].split( '\\' ).pop();
}
return images;
},
// Parse embedded image data in FBXTree.Video.Content
parseImage: function ( videoNode ) {
var content = videoNode.Content;
var fileName = videoNode.RelativeFilename || videoNode.Filename;
var extension = fileName.slice( fileName.lastIndexOf( '.' ) + 1 ).toLowerCase();
var type;
switch ( extension ) {
case 'bmp':
type = 'image/bmp';
break;
case 'jpg':
case 'jpeg':
type = 'image/jpeg';
break;
case 'png':
type = 'image/png';
break;
case 'tif':
type = 'image/tiff';
break;
case 'tga':
if ( this.manager.getHandler( '.tga' ) === null ) {
console.warn( 'FBXLoader: TGA loader not found, skipping ', fileName );
}
type = 'image/tga';
break;
default:
console.warn( 'FBXLoader: Image type "' + extension + '" is not supported.' );
return;
}
if ( typeof content === 'string' ) { // ASCII format
return 'data:' + type + ';base64,' + content;
} else { // Binary Format
var array = new Uint8Array( content );
return window.URL.createObjectURL( new Blob( [ array ], { type: type } ) );
}
},
// Parse nodes in FBXTree.Objects.Texture
// These contain details such as UV scaling, cropping, rotation etc and are connected
// to images in FBXTree.Objects.Video
parseTextures: function ( images ) {
var textureMap = new Map();
if ( 'Texture' in fbxTree.Objects ) {
var textureNodes = fbxTree.Objects.Texture;
for ( var nodeID in textureNodes ) {
var texture = this.parseTexture( textureNodes[ nodeID ], images );
textureMap.set( parseInt( nodeID ), texture );
}
}
return textureMap;
},
// Parse individual node in FBXTree.Objects.Texture
parseTexture: function ( textureNode, images ) {
var texture = this.loadTexture( textureNode, images );
texture.ID = textureNode.id;
texture.name = textureNode.attrName;
var wrapModeU = textureNode.WrapModeU;
var wrapModeV = textureNode.WrapModeV;
var valueU = wrapModeU !== undefined ? wrapModeU.value : 0;
var valueV = wrapModeV !== undefined ? wrapModeV.value : 0;
// http://download.autodesk.com/us/fbx/SDKdocs/FBX_SDK_Help/files/fbxsdkref/class_k_fbx_texture.html#889640e63e2e681259ea81061b85143a
// 0: repeat(default), 1: clamp
texture.wrapS = valueU === 0 ? RepeatWrapping : ClampToEdgeWrapping;
texture.wrapT = valueV === 0 ? RepeatWrapping : ClampToEdgeWrapping;
if ( 'Scaling' in textureNode ) {
var values = textureNode.Scaling.value;
texture.repeat.x = values[ 0 ];
texture.repeat.y = values[ 1 ];
}
return texture;
},
// load a texture specified as a blob or data URI, or via an external URL using TextureLoader
loadTexture: function ( textureNode, images ) {
var fileName;
var currentPath = this.textureLoader.path;
var children = connections.get( textureNode.id ).children;
if ( children !== undefined && children.length > 0 && images[ children[ 0 ].ID ] !== undefined ) {
fileName = images[ children[ 0 ].ID ];
if ( fileName.indexOf( 'blob:' ) === 0 || fileName.indexOf( 'data:' ) === 0 ) {
this.textureLoader.setPath( undefined );
}
}
var texture;
var extension = textureNode.FileName.slice( - 3 ).toLowerCase();
if ( extension === 'tga' ) {
var loader = this.manager.getHandler( '.tga' );
if ( loader === null ) {
console.warn( 'FBXLoader: TGA loader not found, creating placeholder texture for', textureNode.RelativeFilename );
texture = new Texture();
} else {
texture = loader.load( fileName );
}
} else if ( extension === 'psd' ) {
console.warn( 'FBXLoader: PSD textures are not supported, creating placeholder texture for', textureNode.RelativeFilename );
texture = new Texture();
} else {
texture = this.textureLoader.load( fileName );
}
this.textureLoader.setPath( currentPath );
return texture;
},
// Parse nodes in FBXTree.Objects.Material
parseMaterials: function ( textureMap ) {
var materialMap = new Map();
if ( 'Material' in fbxTree.Objects ) {
var materialNodes = fbxTree.Objects.Material;
for ( var nodeID in materialNodes ) {
var material = this.parseMaterial( materialNodes[ nodeID ], textureMap );
if ( material !== null ) materialMap.set( parseInt( nodeID ), material );
}
}
return materialMap;
},
// Parse single node in FBXTree.Objects.Material
// Materials are connected to texture maps in FBXTree.Objects.Textures
// FBX format currently only supports Lambert and Phong shading models
parseMaterial: function ( materialNode, textureMap ) {
var ID = materialNode.id;
var name = materialNode.attrName;
var type = materialNode.ShadingModel;
// Case where FBX wraps shading model in property object.
if ( typeof type === 'object' ) {
type = type.value;
}
// Ignore unused materials which don't have any connections.
if ( ! connections.has( ID ) ) return null;
var parameters = this.parseParameters( materialNode, textureMap, ID );
var material;
switch ( type.toLowerCase() ) {
case 'phong':
material = new MeshPhongMaterial();
break;
case 'lambert':
material = new MeshLambertMaterial();
break;
default:
console.warn( 'THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type );
material = new MeshPhongMaterial();
break;
}
material.setValues( parameters );
material.name = name;
return material;
},
// Parse FBX material and return parameters suitable for a three.js material
// Also parse the texture map and return any textures associated with the material
parseParameters: function ( materialNode, textureMap, ID ) {
var parameters = {};
if ( materialNode.BumpFactor ) {
parameters.bumpScale = materialNode.BumpFactor.value;
}
if ( materialNode.Diffuse ) {
parameters.color = new Color().fromArray( materialNode.Diffuse.value );
} else if ( materialNode.DiffuseColor && materialNode.DiffuseColor.type === 'Color' ) {
// The blender exporter exports diffuse here instead of in materialNode.Diffuse
parameters.color = new Color().fromArray( materialNode.DiffuseColor.value );
}
if ( materialNode.DisplacementFactor ) {
parameters.displacementScale = materialNode.DisplacementFactor.value;
}
if ( materialNode.Emissive ) {
parameters.emissive = new Color().fromArray( materialNode.Emissive.value );
} else if ( materialNode.EmissiveColor && materialNode.EmissiveColor.type === 'Color' ) {
// The blender exporter exports emissive color here instead of in materialNode.Emissive
parameters.emissive = new Color().fromArray( materialNode.EmissiveColor.value );
}
if ( materialNode.EmissiveFactor ) {
parameters.emissiveIntensity = parseFloat( materialNode.EmissiveFactor.value );
}
if ( materialNode.Opacity ) {
parameters.opacity = parseFloat( materialNode.Opacity.value );
}
if ( parameters.opacity < 1.0 ) {
parameters.transparent = true;
}
if ( materialNode.ReflectionFactor ) {
parameters.reflectivity = materialNode.ReflectionFactor.value;
}
if ( materialNode.Shininess ) {
parameters.shininess = materialNode.Shininess.value;
}
if ( materialNode.Specular ) {
parameters.specular = new Color().fromArray( materialNode.Specular.value );
} else if ( materialNode.SpecularColor && materialNode.SpecularColor.type === 'Color' ) {
// The blender exporter exports specular color here instead of in materialNode.Specular
parameters.specular = new Color().fromArray( materialNode.SpecularColor.value );
}
var scope = this;
connections.get( ID ).children.forEach( function ( child ) {
var type = child.relationship;
switch ( type ) {
case 'Bump':
parameters.bumpMap = scope.getTexture( textureMap, child.ID );
break;
case 'Maya|TEX_ao_map':
parameters.aoMap = scope.getTexture( textureMap, child.ID );
break;
case 'DiffuseColor':
case 'Maya|TEX_color_map':
parameters.map = scope.getTexture( textureMap, child.ID );
parameters.map.encoding = sRGBEncoding;
break;
case 'DisplacementColor':
parameters.displacementMap = scope.getTexture( textureMap, child.ID );
break;
case 'EmissiveColor':
parameters.emissiveMap = scope.getTexture( textureMap, child.ID );
parameters.emissiveMap.encoding = sRGBEncoding;
break;
case 'NormalMap':
case 'Maya|TEX_normal_map':
parameters.normalMap = scope.getTexture( textureMap, child.ID );
break;
case 'ReflectionColor':
parameters.envMap = scope.getTexture( textureMap, child.ID );
parameters.envMap.mapping = EquirectangularReflectionMapping;
parameters.envMap.encoding = sRGBEncoding;
break;
case 'SpecularColor':
parameters.specularMap = scope.getTexture( textureMap, child.ID );
parameters.specularMap.encoding = sRGBEncoding;
break;
case 'TransparentColor':
case 'TransparencyFactor':
parameters.alphaMap = scope.getTexture( textureMap, child.ID );
parameters.transparent = true;
break;
case 'AmbientColor':
case 'ShininessExponent': // AKA glossiness map
case 'SpecularFactor': // AKA specularLevel
case 'VectorDisplacementColor': // NOTE: Seems to be a copy of DisplacementColor
default:
console.warn( 'THREE.FBXLoader: %s map is not supported in three.js, skipping texture.', type );
break;
}
} );
return parameters;
},
// get a texture from the textureMap for use by a material.
getTexture: function ( textureMap, id ) {
// if the texture is a layered texture, just use the first layer and issue a warning
if ( 'LayeredTexture' in fbxTree.Objects && id in fbxTree.Objects.LayeredTexture ) {
console.warn( 'THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.' );
id = connections.get( id ).children[ 0 ].ID;
}
return textureMap.get( id );
},
// Parse nodes in FBXTree.Objects.Deformer
// Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here
// Generates map of Skeleton-like objects for use later when generating and binding skeletons.
parseDeformers: function () {
var skeletons = {};
var morphTargets = {};
if ( 'Deformer' in fbxTree.Objects ) {
var DeformerNodes = fbxTree.Objects.Deformer;
for ( var nodeID in DeformerNodes ) {
var deformerNode = DeformerNodes[ nodeID ];
var relationships = connections.get( parseInt( nodeID ) );
if ( deformerNode.attrType === 'Skin' ) {
var skeleton = this.parseSkeleton( relationships, DeformerNodes );
skeleton.ID = nodeID;
if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: skeleton attached to more than one geometry is not supported.' );
skeleton.geometryID = relationships.parents[ 0 ].ID;
skeletons[ nodeID ] = skeleton;
} else if ( deformerNode.attrType === 'BlendShape' ) {
var morphTarget = {
id: nodeID,
};
morphTarget.rawTargets = this.parseMorphTargets( relationships, DeformerNodes );
morphTarget.id = nodeID;
if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: morph target attached to more than one geometry is not supported.' );
morphTargets[ nodeID ] = morphTarget;
}
}
}
return {
skeletons: skeletons,
morphTargets: morphTargets,
};
},
// Parse single nodes in FBXTree.Objects.Deformer
// The top level skeleton node has type 'Skin' and sub nodes have type 'Cluster'
// Each skin node represents a skeleton and each cluster node represents a bone
parseSkeleton: function ( relationships, deformerNodes ) {
var rawBones = [];
relationships.children.forEach( function ( child ) {
var boneNode = deformerNodes[ child.ID ];
if ( boneNode.attrType !== 'Cluster' ) return;
var rawBone = {
ID: child.ID,
indices: [],
weights: [],
transformLink: new Matrix4().fromArray( boneNode.TransformLink.a ),
// transform: new Matrix4().fromArray( boneNode.Transform.a ),
// linkMode: boneNode.Mode,
};
if ( 'Indexes' in boneNode ) {
rawBone.indices = boneNode.Indexes.a;
rawBone.weights = boneNode.Weights.a;
}
rawBones.push( rawBone );
} );
return {
rawBones: rawBones,
bones: []
};
},
// The top level morph deformer node has type "BlendShape" and sub nodes have type "BlendShapeChannel"
parseMorphTargets: function ( relationships, deformerNodes ) {
var rawMorphTargets = [];
for ( var i = 0; i < relationships.children.length; i ++ ) {
var child = relationships.children[ i ];
var morphTargetNode = deformerNodes[ child.ID ];
var rawMorphTarget = {
name: morphTargetNode.attrName,
initialWeight: morphTargetNode.DeformPercent,
id: morphTargetNode.id,
fullWeights: morphTargetNode.FullWeights.a
};
if ( morphTargetNode.attrType !== 'BlendShapeChannel' ) return;
rawMorphTarget.geoID = connections.get( parseInt( child.ID ) ).children.filter( function ( child ) {
return child.relationship === undefined;
} )[ 0 ].ID;
rawMorphTargets.push( rawMorphTarget );
}
return rawMorphTargets;
},
// create the main Group() to be returned by the loader
parseScene: function ( deformers, geometryMap, materialMap ) {
sceneGraph = new Group();
var modelMap = this.parseModels( deformers.skeletons, geometryMap, materialMap );
var modelNodes = fbxTree.Objects.Model;
var scope = this;
modelMap.forEach( function ( model ) {
var modelNode = modelNodes[ model.ID ];
scope.setLookAtProperties( model, modelNode );
var parentConnections = connections.get( model.ID ).parents;
parentConnections.forEach( function ( connection ) {
var parent = modelMap.get( connection.ID );
if ( parent !== undefined ) parent.add( model );
} );
if ( model.parent === null ) {
sceneGraph.add( model );
}
} );
this.bindSkeleton( deformers.skeletons, geometryMap, modelMap );
this.createAmbientLight();
this.setupMorphMaterials();
sceneGraph.traverse( function ( node ) {
if ( node.userData.transformData ) {
if ( node.parent ) node.userData.transformData.parentMatrixWorld = node.parent.matrix;
var transform = generateTransform( node.userData.transformData );
node.applyMatrix4( transform );
}
} );
var animations = new AnimationParser().parse();
// if all the models where already combined in a single group, just return that
if ( sceneGraph.children.length === 1 && sceneGraph.children[ 0 ].isGroup ) {
sceneGraph.children[ 0 ].animations = animations;
sceneGraph = sceneGraph.children[ 0 ];
}
sceneGraph.animations = animations;
},
// parse nodes in FBXTree.Objects.Model
parseModels: function ( skeletons, geometryMap, materialMap ) {
var modelMap = new Map();
var modelNodes = fbxTree.Objects.Model;
for ( var nodeID in modelNodes ) {
var id = parseInt( nodeID );
var node = modelNodes[ nodeID ];
var relationships = connections.get( id );
var model = this.buildSkeleton( relationships, skeletons, id, node.attrName );
if ( ! model ) {
switch ( node.attrType ) {
case 'Camera':
model = this.createCamera( relationships );
break;
case 'Light':
model = this.createLight( relationships );
break;
case 'Mesh':
model = this.createMesh( relationships, geometryMap, materialMap );
break;
case 'NurbsCurve':
model = this.createCurve( relationships, geometryMap );
break;
case 'LimbNode':
case 'Root':
model = new Bone();
break;
case 'Null':
default:
model = new Group();
break;
}
model.name = node.attrName ? PropertyBinding.sanitizeNodeName( node.attrName ) : '';
model.ID = id;
}
this.getTransformData( model, node );
modelMap.set( id, model );
}
return modelMap;
},
buildSkeleton: function ( relationships, skeletons, id, name ) {
var bone = null;
relationships.parents.forEach( function ( parent ) {
for ( var ID in skeletons ) {
var skeleton = skeletons[ ID ];
skeleton.rawBones.forEach( function ( rawBone, i ) {
if ( rawBone.ID === parent.ID ) {
var subBone = bone;
bone = new Bone();
bone.matrixWorld.copy( rawBone.transformLink );
// set name and id here - otherwise in cases where "subBone" is created it will not have a name / id
bone.name = name ? PropertyBinding.sanitizeNodeName( name ) : '';
bone.ID = id;
skeleton.bones[ i ] = bone;
// In cases where a bone is shared between multiple meshes
// duplicate the bone here and and it as a child of the first bone
if ( subBone !== null ) {
bone.add( subBone );
}
}
} );
}
} );
return bone;
},
// create a PerspectiveCamera or OrthographicCamera
createCamera: function ( relationships ) {
var model;
var cameraAttribute;
relationships.children.forEach( function ( child ) {
var attr = fbxTree.Objects.NodeAttribute[ child.ID ];
if ( attr !== undefined ) {
cameraAttribute = attr;
}
} );
if ( cameraAttribute === undefined ) {
model = new Object3D();
} else {
var type = 0;
if ( cameraAttribute.CameraProjectionType !== undefined && cameraAttribute.CameraProjectionType.value === 1 ) {
type = 1;
}
var nearClippingPlane = 1;
if ( cameraAttribute.NearPlane !== undefined ) {
nearClippingPlane = cameraAttribute.NearPlane.value / 1000;
}
var farClippingPlane = 1000;
if ( cameraAttribute.FarPlane !== undefined ) {
farClippingPlane = cameraAttribute.FarPlane.value / 1000;
}
var width = window.innerWidth;
var height = window.innerHeight;
if ( cameraAttribute.AspectWidth !== undefined && cameraAttribute.AspectHeight !== undefined ) {
width = cameraAttribute.AspectWidth.value;
height = cameraAttribute.AspectHeight.value;
}
var aspect = width / height;
var fov = 45;
if ( cameraAttribute.FieldOfView !== undefined ) {
fov = cameraAttribute.FieldOfView.value;
}
var focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;
switch ( type ) {
case 0: // Perspective
model = new PerspectiveCamera( fov, aspect, nearClippingPlane, farClippingPlane );
if ( focalLength !== null ) model.setFocalLength( focalLength );
break;
case 1: // Orthographic
model = new OrthographicCamera( - width / 2, width / 2, height / 2, - height / 2, nearClippingPlane, farClippingPlane );
break;
default:
console.warn( 'THREE.FBXLoader: Unknown camera type ' + type + '.' );
model = new Object3D();
break;
}
}
return model;
},
// Create a DirectionalLight, PointLight or SpotLight
createLight: function ( relationships ) {
var model;
var lightAttribute;
relationships.children.forEach( function ( child ) {
var attr = fbxTree.Objects.NodeAttribute[ child.ID ];
if ( attr !== undefined ) {
lightAttribute = attr;
}
} );
if ( lightAttribute === undefined ) {
model = new Object3D();
} else {
var type;
// LightType can be undefined for Point lights
if ( lightAttribute.LightType === undefined ) {
type = 0;
} else {
type = lightAttribute.LightType.value;
}
var color = 0xffffff;
if ( lightAttribute.Color !== undefined ) {
color = new Color().fromArray( lightAttribute.Color.value );
}
var intensity = ( lightAttribute.Intensity === undefined ) ? 1 : lightAttribute.Intensity.value / 100;
// light disabled
if ( lightAttribute.CastLightOnObject !== undefined && lightAttribute.CastLightOnObject.value === 0 ) {
intensity = 0;
}
var distance = 0;
if ( lightAttribute.FarAttenuationEnd !== undefined ) {
if ( lightAttribute.EnableFarAttenuation !== undefined && lightAttribute.EnableFarAttenuation.value === 0 ) {
distance = 0;
} else {
distance = lightAttribute.FarAttenuationEnd.value;
}
}
// TODO: could this be calculated linearly from FarAttenuationStart to FarAttenuationEnd?
var decay = 1;
switch ( type ) {
case 0: // Point
model = new PointLight( color, intensity, distance, decay );
break;
case 1: // Directional
model = new DirectionalLight( color, intensity );
break;
case 2: // Spot
var angle = Math.PI / 3;
if ( lightAttribute.InnerAngle !== undefined ) {
angle = MathUtils.degToRad( lightAttribute.InnerAngle.value );
}
var penumbra = 0;
if ( lightAttribute.OuterAngle !== undefined ) {
// TODO: this is not correct - FBX calculates outer and inner angle in degrees
// with OuterAngle > InnerAngle && OuterAngle <= Math.PI
// while three.js uses a penumbra between (0, 1) to attenuate the inner angle
penumbra = MathUtils.degToRad( lightAttribute.OuterAngle.value );
penumbra = Math.max( penumbra, 1 );
}
model = new SpotLight( color, intensity, distance, angle, penumbra, decay );
break;
default:
console.warn( 'THREE.FBXLoader: Unknown light type ' + lightAttribute.LightType.value + ', defaulting to a PointLight.' );
model = new PointLight( color, intensity );
break;
}
if ( lightAttribute.CastShadows !== undefined && lightAttribute.CastShadows.value === 1 ) {
model.castShadow = true;
}
}
return model;
},
createMesh: function ( relationships, geometryMap, materialMap ) {
var model;
var geometry = null;
var material = null;
var materials = [];
// get geometry and materials(s) from connections
relationships.children.forEach( function ( child ) {
if ( geometryMap.has( child.ID ) ) {
geometry = geometryMap.get( child.ID );
}
if ( materialMap.has( child.ID ) ) {
materials.push( materialMap.get( child.ID ) );
}
} );
if ( materials.length > 1 ) {
material = materials;
} else if ( materials.length > 0 ) {
material = materials[ 0 ];
} else {
material = new MeshPhongMaterial( { color: 0xcccccc } );
materials.push( material );
}
if ( 'color' in geometry.attributes ) {
materials.forEach( function ( material ) {
material.vertexColors = true;
} );
}
if ( geometry.FBX_Deformer ) {
materials.forEach( function ( material ) {
material.skinning = true;
} );
model = new SkinnedMesh( geometry, material );
model.normalizeSkinWeights();
} else {
model = new Mesh( geometry, material );
}
return model;
},
createCurve: function ( relationships, geometryMap ) {
var geometry = relationships.children.reduce( function ( geo, child ) {
if ( geometryMap.has( child.ID ) ) geo = geometryMap.get( child.ID );
return geo;
}, null );
// FBX does not list materials for Nurbs lines, so we'll just put our own in here.
var material = new LineBasicMaterial( { color: 0x3300ff, linewidth: 1 } );
return new Line( geometry, material );
},
// parse the model node for transform data
getTransformData: function ( model, modelNode ) {
var transformData = {};
if ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );
if ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );
else transformData.eulerOrder = 'ZYX';
if ( 'Lcl_Translation' in modelNode ) transformData.translation = modelNode.Lcl_Translation.value;
if ( 'PreRotation' in modelNode ) transformData.preRotation = modelNode.PreRotation.value;
if ( 'Lcl_Rotation' in modelNode ) transformData.rotation = modelNode.Lcl_Rotation.value;
if ( 'PostRotation' in modelNode ) transformData.postRotation = modelNode.PostRotation.value;
if ( 'Lcl_Scaling' in modelNode ) transformData.scale = modelNode.Lcl_Scaling.value;
if ( 'ScalingOffset' in modelNode ) transformData.scalingOffset = modelNode.ScalingOffset.value;
if ( 'ScalingPivot' in modelNode ) transformData.scalingPivot = modelNode.ScalingPivot.value;
if ( 'RotationOffset' in modelNode ) transformData.rotationOffset = modelNode.RotationOffset.value;
if ( 'RotationPivot' in modelNode ) transformData.rotationPivot = modelNode.RotationPivot.value;
model.userData.transformData = transformData;
},
setLookAtProperties: function ( model, modelNode ) {
if ( 'LookAtProperty' in modelNode ) {
var children = connections.get( model.ID ).children;
children.forEach( function ( child ) {
if ( child.relationship === 'LookAtProperty' ) {
var lookAtTarget = fbxTree.Objects.Model[ child.ID ];
if ( 'Lcl_Translation' in lookAtTarget ) {
var pos = lookAtTarget.Lcl_Translation.value;
// DirectionalLight, SpotLight
if ( model.target !== undefined ) {
model.target.position.fromArray( pos );
sceneGraph.add( model.target );
} else { // Cameras and other Object3Ds
model.lookAt( new Vector3().fromArray( pos ) );
}
}
}
} );
}
},
bindSkeleton: function ( skeletons, geometryMap, modelMap ) {
var bindMatrices = this.parsePoseNodes();
for ( var ID in skeletons ) {
var skeleton = skeletons[ ID ];
var parents = connections.get( parseInt( skeleton.ID ) ).parents;
parents.forEach( function ( parent ) {
if ( geometryMap.has( parent.ID ) ) {
var geoID = parent.ID;
var geoRelationships = connections.get( geoID );
geoRelationships.parents.forEach( function ( geoConnParent ) {
if ( modelMap.has( geoConnParent.ID ) ) {
var model = modelMap.get( geoConnParent.ID );
model.bind( new Skeleton( skeleton.bones ), bindMatrices[ geoConnParent.ID ] );
}
} );
}
} );
}
},
parsePoseNodes: function () {
var bindMatrices = {};
if ( 'Pose' in fbxTree.Objects ) {
var BindPoseNode = fbxTree.Objects.Pose;
for ( var nodeID in BindPoseNode ) {
if ( BindPoseNode[ nodeID ].attrType === 'BindPose' ) {
var poseNodes = BindPoseNode[ nodeID ].PoseNode;
if ( Array.isArray( poseNodes ) ) {
poseNodes.forEach( function ( poseNode ) {
bindMatrices[ poseNode.Node ] = new Matrix4().fromArray( poseNode.Matrix.a );
} );
} else {
bindMatrices[ poseNodes.Node ] = new Matrix4().fromArray( poseNodes.Matrix.a );
}
}
}
}
return bindMatrices;
},
// Parse ambient color in FBXTree.GlobalSettings - if it's not set to black (default), create an ambient light
createAmbientLight: function () {
if ( 'GlobalSettings' in fbxTree && 'AmbientColor' in fbxTree.GlobalSettings ) {
var ambientColor = fbxTree.GlobalSettings.AmbientColor.value;
var r = ambientColor[ 0 ];
var g = ambientColor[ 1 ];
var b = ambientColor[ 2 ];
if ( r !== 0 || g !== 0 || b !== 0 ) {
var color = new Color( r, g, b );
sceneGraph.add( new AmbientLight( color, 1 ) );
}
}
},
setupMorphMaterials: function () {
var scope = this;
sceneGraph.traverse( function ( child ) {
if ( child.isMesh ) {
if ( child.geometry.morphAttributes.position && child.geometry.morphAttributes.position.length ) {
if ( Array.isArray( child.material ) ) {
child.material.forEach( function ( material, i ) {
scope.setupMorphMaterial( child, material, i );
} );
} else {
scope.setupMorphMaterial( child, child.material );
}
}
}
} );
},
setupMorphMaterial: function ( child, material, index ) {
var uuid = child.uuid;
var matUuid = material.uuid;
// if a geometry has morph targets, it cannot share the material with other geometries
var sharedMat = false;
sceneGraph.traverse( function ( node ) {
if ( node.isMesh ) {
if ( Array.isArray( node.material ) ) {
node.material.forEach( function ( mat ) {
if ( mat.uuid === matUuid && node.uuid !== uuid ) sharedMat = true;
} );
} else if ( node.material.uuid === matUuid && node.uuid !== uuid ) sharedMat = true;
}
} );
if ( sharedMat === true ) {
var clonedMat = material.clone();
clonedMat.morphTargets = true;
if ( index === undefined ) child.material = clonedMat;
else child.material[ index ] = clonedMat;
} else material.morphTargets = true;
}
};
// parse Geometry data from FBXTree and return map of BufferGeometries
function GeometryParser() {}
GeometryParser.prototype = {
constructor: GeometryParser,
// Parse nodes in FBXTree.Objects.Geometry
parse: function ( deformers ) {
var geometryMap = new Map();
if ( 'Geometry' in fbxTree.Objects ) {
var geoNodes = fbxTree.Objects.Geometry;
for ( var nodeID in geoNodes ) {
var relationships = connections.get( parseInt( nodeID ) );
var geo = this.parseGeometry( relationships, geoNodes[ nodeID ], deformers );
geometryMap.set( parseInt( nodeID ), geo );
}
}
return geometryMap;
},
// Parse single node in FBXTree.Objects.Geometry
parseGeometry: function ( relationships, geoNode, deformers ) {
switch ( geoNode.attrType ) {
case 'Mesh':
return this.parseMeshGeometry( relationships, geoNode, deformers );
break;
case 'NurbsCurve':
return this.parseNurbsGeometry( geoNode );
break;
}
},
// Parse single node mesh geometry in FBXTree.Objects.Geometry
parseMeshGeometry: function ( relationships, geoNode, deformers ) {
var skeletons = deformers.skeletons;
var morphTargets = [];
var modelNodes = relationships.parents.map( function ( parent ) {
return fbxTree.Objects.Model[ parent.ID ];
} );
// don't create geometry if it is not associated with any models
if ( modelNodes.length === 0 ) return;
var skeleton = relationships.children.reduce( function ( skeleton, child ) {
if ( skeletons[ child.ID ] !== undefined ) skeleton = skeletons[ child.ID ];
return skeleton;
}, null );
relationships.children.forEach( function ( child ) {
if ( deformers.morphTargets[ child.ID ] !== undefined ) {
morphTargets.push( deformers.morphTargets[ child.ID ] );
}
} );
// Assume one model and get the preRotation from that
// if there is more than one model associated with the geometry this may cause problems
var modelNode = modelNodes[ 0 ];
var transformData = {};
if ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );
if ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );
if ( 'GeometricTranslation' in modelNode ) transformData.translation = modelNode.GeometricTranslation.value;
if ( 'GeometricRotation' in modelNode ) transformData.rotation = modelNode.GeometricRotation.value;
if ( 'GeometricScaling' in modelNode ) transformData.scale = modelNode.GeometricScaling.value;
var transform = generateTransform( transformData );
return this.genGeometry( geoNode, skeleton, morphTargets, transform );
},
// Generate a BufferGeometry from a node in FBXTree.Objects.Geometry
genGeometry: function ( geoNode, skeleton, morphTargets, preTransform ) {
var geo = new BufferGeometry();
if ( geoNode.attrName ) geo.name = geoNode.attrName;
var geoInfo = this.parseGeoNode( geoNode, skeleton );
var buffers = this.genBuffers( geoInfo );
var positionAttribute = new Float32BufferAttribute( buffers.vertex, 3 );
positionAttribute.applyMatrix4( preTransform );
geo.setAttribute( 'position', positionAttribute );
if ( buffers.colors.length > 0 ) {
geo.setAttribute( 'color', new Float32BufferAttribute( buffers.colors, 3 ) );
}
if ( skeleton ) {
geo.setAttribute( 'skinIndex', new Uint16BufferAttribute( buffers.weightsIndices, 4 ) );
geo.setAttribute( 'skinWeight', new Float32BufferAttribute( buffers.vertexWeights, 4 ) );
// used later to bind the skeleton to the model
geo.FBX_Deformer = skeleton;
}
if ( buffers.normal.length > 0 ) {
var normalMatrix = new Matrix3().getNormalMatrix( preTransform );
var normalAttribute = new Float32BufferAttribute( buffers.normal, 3 );
normalAttribute.applyNormalMatrix( normalMatrix );
geo.setAttribute( 'normal', normalAttribute );
}
buffers.uvs.forEach( function ( uvBuffer, i ) {
// subsequent uv buffers are called 'uv1', 'uv2', ...
var name = 'uv' + ( i + 1 ).toString();
// the first uv buffer is just called 'uv'
if ( i === 0 ) {
name = 'uv';
}
geo.setAttribute( name, new Float32BufferAttribute( buffers.uvs[ i ], 2 ) );
} );
if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
// Convert the material indices of each vertex into rendering groups on the geometry.
var prevMaterialIndex = buffers.materialIndex[ 0 ];
var startIndex = 0;
buffers.materialIndex.forEach( function ( currentIndex, i ) {
if ( currentIndex !== prevMaterialIndex ) {
geo.addGroup( startIndex, i - startIndex, prevMaterialIndex );
prevMaterialIndex = currentIndex;
startIndex = i;
}
} );
// the loop above doesn't add the last group, do that here.
if ( geo.groups.length > 0 ) {
var lastGroup = geo.groups[ geo.groups.length - 1 ];
var lastIndex = lastGroup.start + lastGroup.count;
if ( lastIndex !== buffers.materialIndex.length ) {
geo.addGroup( lastIndex, buffers.materialIndex.length - lastIndex, prevMaterialIndex );
}
}
// case where there are multiple materials but the whole geometry is only
// using one of them
if ( geo.groups.length === 0 ) {
geo.addGroup( 0, buffers.materialIndex.length, buffers.materialIndex[ 0 ] );
}
}
this.addMorphTargets( geo, geoNode, morphTargets, preTransform );
return geo;
},
parseGeoNode: function ( geoNode, skeleton ) {
var geoInfo = {};
geoInfo.vertexPositions = ( geoNode.Vertices !== undefined ) ? geoNode.Vertices.a : [];
geoInfo.vertexIndices = ( geoNode.PolygonVertexIndex !== undefined ) ? geoNode.PolygonVertexIndex.a : [];
if ( geoNode.LayerElementColor ) {
geoInfo.color = this.parseVertexColors( geoNode.LayerElementColor[ 0 ] );
}
if ( geoNode.LayerElementMaterial ) {
geoInfo.material = this.parseMaterialIndices( geoNode.LayerElementMaterial[ 0 ] );
}
if ( geoNode.LayerElementNormal ) {
geoInfo.normal = this.parseNormals( geoNode.LayerElementNormal[ 0 ] );
}
if ( geoNode.LayerElementUV ) {
geoInfo.uv = [];
var i = 0;
while ( geoNode.LayerElementUV[ i ] ) {
geoInfo.uv.push( this.parseUVs( geoNode.LayerElementUV[ i ] ) );
i ++;
}
}
geoInfo.weightTable = {};
if ( skeleton !== null ) {
geoInfo.skeleton = skeleton;
skeleton.rawBones.forEach( function ( rawBone, i ) {
// loop over the bone's vertex indices and weights
rawBone.indices.forEach( function ( index, j ) {
if ( geoInfo.weightTable[ index ] === undefined ) geoInfo.weightTable[ index ] = [];
geoInfo.weightTable[ index ].push( {
id: i,
weight: rawBone.weights[ j ],
} );
} );
} );
}
return geoInfo;
},
genBuffers: function ( geoInfo ) {
var buffers = {
vertex: [],
normal: [],
colors: [],
uvs: [],
materialIndex: [],
vertexWeights: [],
weightsIndices: [],
};
var polygonIndex = 0;
var faceLength = 0;
var displayedWeightsWarning = false;
// these will hold data for a single face
var facePositionIndexes = [];
var faceNormals = [];
var faceColors = [];
var faceUVs = [];
var faceWeights = [];
var faceWeightIndices = [];
var scope = this;
geoInfo.vertexIndices.forEach( function ( vertexIndex, polygonVertexIndex ) {
var endOfFace = false;
// Face index and vertex index arrays are combined in a single array
// A cube with quad faces looks like this:
// PolygonVertexIndex: *24 {
// a: 0, 1, 3, -3, 2, 3, 5, -5, 4, 5, 7, -7, 6, 7, 1, -1, 1, 7, 5, -4, 6, 0, 2, -5
// }
// Negative numbers mark the end of a face - first face here is 0, 1, 3, -3
// to find index of last vertex bit shift the index: ^ - 1
if ( vertexIndex < 0 ) {
vertexIndex = vertexIndex ^ - 1; // equivalent to ( x * -1 ) - 1
endOfFace = true;
}
var weightIndices = [];
var weights = [];
facePositionIndexes.push( vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2 );
if ( geoInfo.color ) {
var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.color );
faceColors.push( data[ 0 ], data[ 1 ], data[ 2 ] );
}
if ( geoInfo.skeleton ) {
if ( geoInfo.weightTable[ vertexIndex ] !== undefined ) {
geoInfo.weightTable[ vertexIndex ].forEach( function ( wt ) {
weights.push( wt.weight );
weightIndices.push( wt.id );
} );
}
if ( weights.length > 4 ) {
if ( ! displayedWeightsWarning ) {
console.warn( 'THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.' );
displayedWeightsWarning = true;
}
var wIndex = [ 0, 0, 0, 0 ];
var Weight = [ 0, 0, 0, 0 ];
weights.forEach( function ( weight, weightIndex ) {
var currentWeight = weight;
var currentIndex = weightIndices[ weightIndex ];
Weight.forEach( function ( comparedWeight, comparedWeightIndex, comparedWeightArray ) {
if ( currentWeight > comparedWeight ) {
comparedWeightArray[ comparedWeightIndex ] = currentWeight;
currentWeight = comparedWeight;
var tmp = wIndex[ comparedWeightIndex ];
wIndex[ comparedWeightIndex ] = currentIndex;
currentIndex = tmp;
}
} );
} );
weightIndices = wIndex;
weights = Weight;
}
// if the weight array is shorter than 4 pad with 0s
while ( weights.length < 4 ) {
weights.push( 0 );
weightIndices.push( 0 );
}
for ( var i = 0; i < 4; ++ i ) {
faceWeights.push( weights[ i ] );
faceWeightIndices.push( weightIndices[ i ] );
}
}
if ( geoInfo.normal ) {
var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.normal );
faceNormals.push( data[ 0 ], data[ 1 ], data[ 2 ] );
}
if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
var materialIndex = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.material )[ 0 ];
}
if ( geoInfo.uv ) {
geoInfo.uv.forEach( function ( uv, i ) {
var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, uv );
if ( faceUVs[ i ] === undefined ) {
faceUVs[ i ] = [];
}
faceUVs[ i ].push( data[ 0 ] );
faceUVs[ i ].push( data[ 1 ] );
} );
}
faceLength ++;
if ( endOfFace ) {
scope.genFace( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength );
polygonIndex ++;
faceLength = 0;
// reset arrays for the next face
facePositionIndexes = [];
faceNormals = [];
faceColors = [];
faceUVs = [];
faceWeights = [];
faceWeightIndices = [];
}
} );
return buffers;
},
// Generate data for a single face in a geometry. If the face is a quad then split it into 2 tris
genFace: function ( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength ) {
for ( var i = 2; i < faceLength; i ++ ) {
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 0 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 1 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 2 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 + 1 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 + 2 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 + 1 ] ] );
buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 + 2 ] ] );
if ( geoInfo.skeleton ) {
buffers.vertexWeights.push( faceWeights[ 0 ] );
buffers.vertexWeights.push( faceWeights[ 1 ] );
buffers.vertexWeights.push( faceWeights[ 2 ] );
buffers.vertexWeights.push( faceWeights[ 3 ] );
buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 ] );
buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 1 ] );
buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 2 ] );
buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 3 ] );
buffers.vertexWeights.push( faceWeights[ i * 4 ] );
buffers.vertexWeights.push( faceWeights[ i * 4 + 1 ] );
buffers.vertexWeights.push( faceWeights[ i * 4 + 2 ] );
buffers.vertexWeights.push( faceWeights[ i * 4 + 3 ] );
buffers.weightsIndices.push( faceWeightIndices[ 0 ] );
buffers.weightsIndices.push( faceWeightIndices[ 1 ] );
buffers.weightsIndices.push( faceWeightIndices[ 2 ] );
buffers.weightsIndices.push( faceWeightIndices[ 3 ] );
buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 ] );
buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 1 ] );
buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 2 ] );
buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 3 ] );
buffers.weightsIndices.push( faceWeightIndices[ i * 4 ] );
buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 1 ] );
buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 2 ] );
buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 3 ] );
}
if ( geoInfo.color ) {
buffers.colors.push( faceColors[ 0 ] );
buffers.colors.push( faceColors[ 1 ] );
buffers.colors.push( faceColors[ 2 ] );
buffers.colors.push( faceColors[ ( i - 1 ) * 3 ] );
buffers.colors.push( faceColors[ ( i - 1 ) * 3 + 1 ] );
buffers.colors.push( faceColors[ ( i - 1 ) * 3 + 2 ] );
buffers.colors.push( faceColors[ i * 3 ] );
buffers.colors.push( faceColors[ i * 3 + 1 ] );
buffers.colors.push( faceColors[ i * 3 + 2 ] );
}
if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
buffers.materialIndex.push( materialIndex );
buffers.materialIndex.push( materialIndex );
buffers.materialIndex.push( materialIndex );
}
if ( geoInfo.normal ) {
buffers.normal.push( faceNormals[ 0 ] );
buffers.normal.push( faceNormals[ 1 ] );
buffers.normal.push( faceNormals[ 2 ] );
buffers.normal.push( faceNormals[ ( i - 1 ) * 3 ] );
buffers.normal.push( faceNormals[ ( i - 1 ) * 3 + 1 ] );
buffers.normal.push( faceNormals[ ( i - 1 ) * 3 + 2 ] );
buffers.normal.push( faceNormals[ i * 3 ] );
buffers.normal.push( faceNormals[ i * 3 + 1 ] );
buffers.normal.push( faceNormals[ i * 3 + 2 ] );
}
if ( geoInfo.uv ) {
geoInfo.uv.forEach( function ( uv, j ) {
if ( buffers.uvs[ j ] === undefined ) buffers.uvs[ j ] = [];
buffers.uvs[ j ].push( faceUVs[ j ][ 0 ] );
buffers.uvs[ j ].push( faceUVs[ j ][ 1 ] );
buffers.uvs[ j ].push( faceUVs[ j ][ ( i - 1 ) * 2 ] );
buffers.uvs[ j ].push( faceUVs[ j ][ ( i - 1 ) * 2 + 1 ] );
buffers.uvs[ j ].push( faceUVs[ j ][ i * 2 ] );
buffers.uvs[ j ].push( faceUVs[ j ][ i * 2 + 1 ] );
} );
}
}
},
addMorphTargets: function ( parentGeo, parentGeoNode, morphTargets, preTransform ) {
if ( morphTargets.length === 0 ) return;
parentGeo.morphTargetsRelative = true;
parentGeo.morphAttributes.position = [];
// parentGeo.morphAttributes.normal = []; // not implemented
var scope = this;
morphTargets.forEach( function ( morphTarget ) {
morphTarget.rawTargets.forEach( function ( rawTarget ) {
var morphGeoNode = fbxTree.Objects.Geometry[ rawTarget.geoID ];
if ( morphGeoNode !== undefined ) {
scope.genMorphGeometry( parentGeo, parentGeoNode, morphGeoNode, preTransform, rawTarget.name );
}
} );
} );
},
// a morph geometry node is similar to a standard node, and the node is also contained
// in FBXTree.Objects.Geometry, however it can only have attributes for position, normal
// and a special attribute Index defining which vertices of the original geometry are affected
// Normal and position attributes only have data for the vertices that are affected by the morph
genMorphGeometry: function ( parentGeo, parentGeoNode, morphGeoNode, preTransform, name ) {
var vertexIndices = ( parentGeoNode.PolygonVertexIndex !== undefined ) ? parentGeoNode.PolygonVertexIndex.a : [];
var morphPositionsSparse = ( morphGeoNode.Vertices !== undefined ) ? morphGeoNode.Vertices.a : [];
var indices = ( morphGeoNode.Indexes !== undefined ) ? morphGeoNode.Indexes.a : [];
var length = parentGeo.attributes.position.count * 3;
var morphPositions = new Float32Array( length );
for ( var i = 0; i < indices.length; i ++ ) {
var morphIndex = indices[ i ] * 3;
morphPositions[ morphIndex ] = morphPositionsSparse[ i * 3 ];
morphPositions[ morphIndex + 1 ] = morphPositionsSparse[ i * 3 + 1 ];
morphPositions[ morphIndex + 2 ] = morphPositionsSparse[ i * 3 + 2 ];
}
// TODO: add morph normal support
var morphGeoInfo = {
vertexIndices: vertexIndices,
vertexPositions: morphPositions,
};
var morphBuffers = this.genBuffers( morphGeoInfo );
var positionAttribute = new Float32BufferAttribute( morphBuffers.vertex, 3 );
positionAttribute.name = name || morphGeoNode.attrName;
positionAttribute.applyMatrix4( preTransform );
parentGeo.morphAttributes.position.push( positionAttribute );
},
// Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists
parseNormals: function ( NormalNode ) {
var mappingType = NormalNode.MappingInformationType;
var referenceType = NormalNode.ReferenceInformationType;
var buffer = NormalNode.Normals.a;
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
if ( 'NormalIndex' in NormalNode ) {
indexBuffer = NormalNode.NormalIndex.a;
} else if ( 'NormalsIndex' in NormalNode ) {
indexBuffer = NormalNode.NormalsIndex.a;
}
}
return {
dataSize: 3,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
},
// Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists
parseUVs: function ( UVNode ) {
var mappingType = UVNode.MappingInformationType;
var referenceType = UVNode.ReferenceInformationType;
var buffer = UVNode.UV.a;
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
indexBuffer = UVNode.UVIndex.a;
}
return {
dataSize: 2,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
},
// Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists
parseVertexColors: function ( ColorNode ) {
var mappingType = ColorNode.MappingInformationType;
var referenceType = ColorNode.ReferenceInformationType;
var buffer = ColorNode.Colors.a;
var indexBuffer = [];
if ( referenceType === 'IndexToDirect' ) {
indexBuffer = ColorNode.ColorIndex.a;
}
return {
dataSize: 4,
buffer: buffer,
indices: indexBuffer,
mappingType: mappingType,
referenceType: referenceType
};
},
// Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists
parseMaterialIndices: function ( MaterialNode ) {
var mappingType = MaterialNode.MappingInformationType;
var referenceType = MaterialNode.ReferenceInformationType;
if ( mappingType === 'NoMappingInformation' ) {
return {
dataSize: 1,
buffer: [ 0 ],
indices: [ 0 ],
mappingType: 'AllSame',
referenceType: referenceType
};
}
var materialIndexBuffer = MaterialNode.Materials.a;
// Since materials are stored as indices, there's a bit of a mismatch between FBX and what
// we expect.So we create an intermediate buffer that points to the index in the buffer,
// for conforming with the other functions we've written for other data.
var materialIndices = [];
for ( var i = 0; i < materialIndexBuffer.length; ++ i ) {
materialIndices.push( i );
}
return {
dataSize: 1,
buffer: materialIndexBuffer,
indices: materialIndices,
mappingType: mappingType,
referenceType: referenceType
};
},
// Generate a NurbGeometry from a node in FBXTree.Objects.Geometry
parseNurbsGeometry: function ( geoNode ) {
if ( NURBSCurve === undefined ) {
console.error( 'THREE.FBXLoader: The loader relies on NURBSCurve for any nurbs present in the model. Nurbs will show up as empty geometry.' );
return new BufferGeometry();
}
var order = parseInt( geoNode.Order );
if ( isNaN( order ) ) {
console.error( 'THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geoNode.Order, geoNode.id );
return new BufferGeometry();
}
var degree = order - 1;
var knots = geoNode.KnotVector.a;
var controlPoints = [];
var pointsValues = geoNode.Points.a;
for ( var i = 0, l = pointsValues.length; i < l; i += 4 ) {
controlPoints.push( new Vector4().fromArray( pointsValues, i ) );
}
var startKnot, endKnot;
if ( geoNode.Form === 'Closed' ) {
controlPoints.push( controlPoints[ 0 ] );
} else if ( geoNode.Form === 'Periodic' ) {
startKnot = degree;
endKnot = knots.length - 1 - startKnot;
for ( var i = 0; i < degree; ++ i ) {
controlPoints.push( controlPoints[ i ] );
}
}
var curve = new NURBSCurve( degree, knots, controlPoints, startKnot, endKnot );
var vertices = curve.getPoints( controlPoints.length * 7 );
var positions = new Float32Array( vertices.length * 3 );
vertices.forEach( function ( vertex, i ) {
vertex.toArray( positions, i * 3 );
} );
var geometry = new BufferGeometry();
geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
return geometry;
},
};
// parse animation data from FBXTree
function AnimationParser() {}
AnimationParser.prototype = {
constructor: AnimationParser,
// take raw animation clips and turn them into three.js animation clips
parse: function () {
var animationClips = [];
var rawClips = this.parseClips();
if ( rawClips !== undefined ) {
for ( var key in rawClips ) {
var rawClip = rawClips[ key ];
var clip = this.addClip( rawClip );
animationClips.push( clip );
}
}
return animationClips;
},
parseClips: function () {
// since the actual transformation data is stored in FBXTree.Objects.AnimationCurve,
// if this is undefined we can safely assume there are no animations
if ( fbxTree.Objects.AnimationCurve === undefined ) return undefined;
var curveNodesMap = this.parseAnimationCurveNodes();
this.parseAnimationCurves( curveNodesMap );
var layersMap = this.parseAnimationLayers( curveNodesMap );
var rawClips = this.parseAnimStacks( layersMap );
return rawClips;
},
// parse nodes in FBXTree.Objects.AnimationCurveNode
// each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation )
// and is referenced by an AnimationLayer
parseAnimationCurveNodes: function () {
var rawCurveNodes = fbxTree.Objects.AnimationCurveNode;
var curveNodesMap = new Map();
for ( var nodeID in rawCurveNodes ) {
var rawCurveNode = rawCurveNodes[ nodeID ];
if ( rawCurveNode.attrName.match( /S|R|T|DeformPercent/ ) !== null ) {
var curveNode = {
id: rawCurveNode.id,
attr: rawCurveNode.attrName,
curves: {},
};
curveNodesMap.set( curveNode.id, curveNode );
}
}
return curveNodesMap;
},
// parse nodes in FBXTree.Objects.AnimationCurve and connect them up to
// previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated
// axis ( e.g. times and values of x rotation)
parseAnimationCurves: function ( curveNodesMap ) {
var rawCurves = fbxTree.Objects.AnimationCurve;
// TODO: Many values are identical up to roundoff error, but won't be optimised
// e.g. position times: [0, 0.4, 0. 8]
// position values: [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.235384487103147e-7, 93.67520904541016, -0.9982695579528809]
// clearly, this should be optimised to
// times: [0], positions [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809]
// this shows up in nearly every FBX file, and generally time array is length > 100
for ( var nodeID in rawCurves ) {
var animationCurve = {
id: rawCurves[ nodeID ].id,
times: rawCurves[ nodeID ].KeyTime.a.map( convertFBXTimeToSeconds ),
values: rawCurves[ nodeID ].KeyValueFloat.a,
};
var relationships = connections.get( animationCurve.id );
if ( relationships !== undefined ) {
var animationCurveID = relationships.parents[ 0 ].ID;
var animationCurveRelationship = relationships.parents[ 0 ].relationship;
if ( animationCurveRelationship.match( /X/ ) ) {
curveNodesMap.get( animationCurveID ).curves[ 'x' ] = animationCurve;
} else if ( animationCurveRelationship.match( /Y/ ) ) {
curveNodesMap.get( animationCurveID ).curves[ 'y' ] = animationCurve;
} else if ( animationCurveRelationship.match( /Z/ ) ) {
curveNodesMap.get( animationCurveID ).curves[ 'z' ] = animationCurve;
} else if ( animationCurveRelationship.match( /d|DeformPercent/ ) && curveNodesMap.has( animationCurveID ) ) {
curveNodesMap.get( animationCurveID ).curves[ 'morph' ] = animationCurve;
}
}
}
},
// parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references
// to various AnimationCurveNodes and is referenced by an AnimationStack node
// note: theoretically a stack can have multiple layers, however in practice there always seems to be one per stack
parseAnimationLayers: function ( curveNodesMap ) {
var rawLayers = fbxTree.Objects.AnimationLayer;
var layersMap = new Map();
for ( var nodeID in rawLayers ) {
var layerCurveNodes = [];
var connection = connections.get( parseInt( nodeID ) );
if ( connection !== undefined ) {
// all the animationCurveNodes used in the layer
var children = connection.children;
children.forEach( function ( child, i ) {
if ( curveNodesMap.has( child.ID ) ) {
var curveNode = curveNodesMap.get( child.ID );
// check that the curves are defined for at least one axis, otherwise ignore the curveNode
if ( curveNode.curves.x !== undefined || curveNode.curves.y !== undefined || curveNode.curves.z !== undefined ) {
if ( layerCurveNodes[ i ] === undefined ) {
var modelID = connections.get( child.ID ).parents.filter( function ( parent ) {
return parent.relationship !== undefined;
} )[ 0 ].ID;
if ( modelID !== undefined ) {
var rawModel = fbxTree.Objects.Model[ modelID.toString() ];
var node = {
modelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',
ID: rawModel.id,
initialPosition: [ 0, 0, 0 ],
initialRotation: [ 0, 0, 0 ],
initialScale: [ 1, 1, 1 ],
};
sceneGraph.traverse( function ( child ) {
if ( child.ID === rawModel.id ) {
node.transform = child.matrix;
if ( child.userData.transformData ) node.eulerOrder = child.userData.transformData.eulerOrder;
}
} );
if ( ! node.transform ) node.transform = new Matrix4();
// if the animated model is pre rotated, we'll have to apply the pre rotations to every
// animation value as well
if ( 'PreRotation' in rawModel ) node.preRotation = rawModel.PreRotation.value;
if ( 'PostRotation' in rawModel ) node.postRotation = rawModel.PostRotation.value;
layerCurveNodes[ i ] = node;
}
}
if ( layerCurveNodes[ i ] ) layerCurveNodes[ i ][ curveNode.attr ] = curveNode;
} else if ( curveNode.curves.morph !== undefined ) {
if ( layerCurveNodes[ i ] === undefined ) {
var deformerID = connections.get( child.ID ).parents.filter( function ( parent ) {
return parent.relationship !== undefined;
} )[ 0 ].ID;
var morpherID = connections.get( deformerID ).parents[ 0 ].ID;
var geoID = connections.get( morpherID ).parents[ 0 ].ID;
// assuming geometry is not used in more than one model
var modelID = connections.get( geoID ).parents[ 0 ].ID;
var rawModel = fbxTree.Objects.Model[ modelID ];
var node = {
modelName: rawModel.attrName ? PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',
morphName: fbxTree.Objects.Deformer[ deformerID ].attrName,
};
layerCurveNodes[ i ] = node;
}
layerCurveNodes[ i ][ curveNode.attr ] = curveNode;
}
}
} );
layersMap.set( parseInt( nodeID ), layerCurveNodes );
}
}
return layersMap;
},
// parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation
// hierarchy. Each Stack node will be used to create a AnimationClip
parseAnimStacks: function ( layersMap ) {
var rawStacks = fbxTree.Objects.AnimationStack;
// connect the stacks (clips) up to the layers
var rawClips = {};
for ( var nodeID in rawStacks ) {
var children = connections.get( parseInt( nodeID ) ).children;
if ( children.length > 1 ) {
// it seems like stacks will always be associated with a single layer. But just in case there are files
// where there are multiple layers per stack, we'll display a warning
console.warn( 'THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers.' );
}
var layer = layersMap.get( children[ 0 ].ID );
rawClips[ nodeID ] = {
name: rawStacks[ nodeID ].attrName,
layer: layer,
};
}
return rawClips;
},
addClip: function ( rawClip ) {
var tracks = [];
var scope = this;
rawClip.layer.forEach( function ( rawTracks ) {
tracks = tracks.concat( scope.generateTracks( rawTracks ) );
} );
return new AnimationClip( rawClip.name, - 1, tracks );
},
generateTracks: function ( rawTracks ) {
var tracks = [];
var initialPosition = new Vector3();
var initialRotation = new Quaternion();
var initialScale = new Vector3();
if ( rawTracks.transform ) rawTracks.transform.decompose( initialPosition, initialRotation, initialScale );
initialPosition = initialPosition.toArray();
initialRotation = new Euler().setFromQuaternion( initialRotation, rawTracks.eulerOrder ).toArray();
initialScale = initialScale.toArray();
if ( rawTracks.T !== undefined && Object.keys( rawTracks.T.curves ).length > 0 ) {
var positionTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.T.curves, initialPosition, 'position' );
if ( positionTrack !== undefined ) tracks.push( positionTrack );
}
if ( rawTracks.R !== undefined && Object.keys( rawTracks.R.curves ).length > 0 ) {
var rotationTrack = this.generateRotationTrack( rawTracks.modelName, rawTracks.R.curves, initialRotation, rawTracks.preRotation, rawTracks.postRotation, rawTracks.eulerOrder );
if ( rotationTrack !== undefined ) tracks.push( rotationTrack );
}
if ( rawTracks.S !== undefined && Object.keys( rawTracks.S.curves ).length > 0 ) {
var scaleTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.S.curves, initialScale, 'scale' );
if ( scaleTrack !== undefined ) tracks.push( scaleTrack );
}
if ( rawTracks.DeformPercent !== undefined ) {
var morphTrack = this.generateMorphTrack( rawTracks );
if ( morphTrack !== undefined ) tracks.push( morphTrack );
}
return tracks;
},
generateVectorTrack: function ( modelName, curves, initialValue, type ) {
var times = this.getTimesForAllAxes( curves );
var values = this.getKeyframeTrackValues( times, curves, initialValue );
return new VectorKeyframeTrack( modelName + '.' + type, times, values );
},
generateRotationTrack: function ( modelName, curves, initialValue, preRotation, postRotation, eulerOrder ) {
if ( curves.x !== undefined ) {
this.interpolateRotations( curves.x );
curves.x.values = curves.x.values.map( MathUtils.degToRad );
}
if ( curves.y !== undefined ) {
this.interpolateRotations( curves.y );
curves.y.values = curves.y.values.map( MathUtils.degToRad );
}
if ( curves.z !== undefined ) {
this.interpolateRotations( curves.z );
curves.z.values = curves.z.values.map( MathUtils.degToRad );
}
var times = this.getTimesForAllAxes( curves );
var values = this.getKeyframeTrackValues( times, curves, initialValue );
if ( preRotation !== undefined ) {
preRotation = preRotation.map( MathUtils.degToRad );
preRotation.push( eulerOrder );
preRotation = new Euler().fromArray( preRotation );
preRotation = new Quaternion().setFromEuler( preRotation );
}
if ( postRotation !== undefined ) {
postRotation = postRotation.map( MathUtils.degToRad );
postRotation.push( eulerOrder );
postRotation = new Euler().fromArray( postRotation );
postRotation = new Quaternion().setFromEuler( postRotation ).inverse();
}
var quaternion = new Quaternion();
var euler = new Euler();
var quaternionValues = [];
for ( var i = 0; i < values.length; i += 3 ) {
euler.set( values[ i ], values[ i + 1 ], values[ i + 2 ], eulerOrder );
quaternion.setFromEuler( euler );
if ( preRotation !== undefined ) quaternion.premultiply( preRotation );
if ( postRotation !== undefined ) quaternion.multiply( postRotation );
quaternion.toArray( quaternionValues, ( i / 3 ) * 4 );
}
return new QuaternionKeyframeTrack( modelName + '.quaternion', times, quaternionValues );
},
generateMorphTrack: function ( rawTracks ) {
var curves = rawTracks.DeformPercent.curves.morph;
var values = curves.values.map( function ( val ) {
return val / 100;
} );
var morphNum = sceneGraph.getObjectByName( rawTracks.modelName ).morphTargetDictionary[ rawTracks.morphName ];
return new NumberKeyframeTrack( rawTracks.modelName + '.morphTargetInfluences[' + morphNum + ']', curves.times, values );
},
// For all animated objects, times are defined separately for each axis
// Here we'll combine the times into one sorted array without duplicates
getTimesForAllAxes: function ( curves ) {
var times = [];
// first join together the times for each axis, if defined
if ( curves.x !== undefined ) times = times.concat( curves.x.times );
if ( curves.y !== undefined ) times = times.concat( curves.y.times );
if ( curves.z !== undefined ) times = times.concat( curves.z.times );
// then sort them and remove duplicates
times = times.sort( function ( a, b ) {
return a - b;
} ).filter( function ( elem, index, array ) {
return array.indexOf( elem ) == index;
} );
return times;
},
getKeyframeTrackValues: function ( times, curves, initialValue ) {
var prevValue = initialValue;
var values = [];
var xIndex = - 1;
var yIndex = - 1;
var zIndex = - 1;
times.forEach( function ( time ) {
if ( curves.x ) xIndex = curves.x.times.indexOf( time );
if ( curves.y ) yIndex = curves.y.times.indexOf( time );
if ( curves.z ) zIndex = curves.z.times.indexOf( time );
// if there is an x value defined for this frame, use that
if ( xIndex !== - 1 ) {
var xValue = curves.x.values[ xIndex ];
values.push( xValue );
prevValue[ 0 ] = xValue;
} else {
// otherwise use the x value from the previous frame
values.push( prevValue[ 0 ] );
}
if ( yIndex !== - 1 ) {
var yValue = curves.y.values[ yIndex ];
values.push( yValue );
prevValue[ 1 ] = yValue;
} else {
values.push( prevValue[ 1 ] );
}
if ( zIndex !== - 1 ) {
var zValue = curves.z.values[ zIndex ];
values.push( zValue );
prevValue[ 2 ] = zValue;
} else {
values.push( prevValue[ 2 ] );
}
} );
return values;
},
// Rotations are defined as Euler angles which can have values of any size
// These will be converted to quaternions which don't support values greater than
// PI, so we'll interpolate large rotations
interpolateRotations: function ( curve ) {
for ( var i = 1; i < curve.values.length; i ++ ) {
var initialValue = curve.values[ i - 1 ];
var valuesSpan = curve.values[ i ] - initialValue;
var absoluteSpan = Math.abs( valuesSpan );
if ( absoluteSpan >= 180 ) {
var numSubIntervals = absoluteSpan / 180;
var step = valuesSpan / numSubIntervals;
var nextValue = initialValue + step;
var initialTime = curve.times[ i - 1 ];
var timeSpan = curve.times[ i ] - initialTime;
var interval = timeSpan / numSubIntervals;
var nextTime = initialTime + interval;
var interpolatedTimes = [];
var interpolatedValues = [];
while ( nextTime < curve.times[ i ] ) {
interpolatedTimes.push( nextTime );
nextTime += interval;
interpolatedValues.push( nextValue );
nextValue += step;
}
curve.times = inject( curve.times, i, interpolatedTimes );
curve.values = inject( curve.values, i, interpolatedValues );
}
}
},
};
// parse an FBX file in ASCII format
function TextParser() {}
TextParser.prototype = {
constructor: TextParser,
getPrevNode: function () {
return this.nodeStack[ this.currentIndent - 2 ];
},
getCurrentNode: function () {
return this.nodeStack[ this.currentIndent - 1 ];
},
getCurrentProp: function () {
return this.currentProp;
},
pushStack: function ( node ) {
this.nodeStack.push( node );
this.currentIndent += 1;
},
popStack: function () {
this.nodeStack.pop();
this.currentIndent -= 1;
},
setCurrentProp: function ( val, name ) {
this.currentProp = val;
this.currentPropName = name;
},
parse: function ( text ) {
this.currentIndent = 0;
this.allNodes = new FBXTree();
this.nodeStack = [];
this.currentProp = [];
this.currentPropName = '';
var scope = this;
var split = text.split( /[\r\n]+/ );
split.forEach( function ( line, i ) {
var matchComment = line.match( /^[\s\t]*;/ );
var matchEmpty = line.match( /^[\s\t]*$/ );
if ( matchComment || matchEmpty ) return;
var matchBeginning = line.match( '^\\t{' + scope.currentIndent + '}(\\w+):(.*){', '' );
var matchProperty = line.match( '^\\t{' + ( scope.currentIndent ) + '}(\\w+):[\\s\\t\\r\\n](.*)' );
var matchEnd = line.match( '^\\t{' + ( scope.currentIndent - 1 ) + '}}' );
if ( matchBeginning ) {
scope.parseNodeBegin( line, matchBeginning );
} else if ( matchProperty ) {
scope.parseNodeProperty( line, matchProperty, split[ ++ i ] );
} else if ( matchEnd ) {
scope.popStack();
} else if ( line.match( /^[^\s\t}]/ ) ) {
// large arrays are split over multiple lines terminated with a ',' character
// if this is encountered the line needs to be joined to the previous line
scope.parseNodePropertyContinued( line );
}
} );
return this.allNodes;
},
parseNodeBegin: function ( line, property ) {
var nodeName = property[ 1 ].trim().replace( /^"/, '' ).replace( /"$/, '' );
var nodeAttrs = property[ 2 ].split( ',' ).map( function ( attr ) {
return attr.trim().replace( /^"/, '' ).replace( /"$/, '' );
} );
var node = { name: nodeName };
var attrs = this.parseNodeAttr( nodeAttrs );
var currentNode = this.getCurrentNode();
// a top node
if ( this.currentIndent === 0 ) {
this.allNodes.add( nodeName, node );
} else { // a subnode
// if the subnode already exists, append it
if ( nodeName in currentNode ) {
// special case Pose needs PoseNodes as an array
if ( nodeName === 'PoseNode' ) {
currentNode.PoseNode.push( node );
} else if ( currentNode[ nodeName ].id !== undefined ) {
currentNode[ nodeName ] = {};
currentNode[ nodeName ][ currentNode[ nodeName ].id ] = currentNode[ nodeName ];
}
if ( attrs.id !== '' ) currentNode[ nodeName ][ attrs.id ] = node;
} else if ( typeof attrs.id === 'number' ) {
currentNode[ nodeName ] = {};
currentNode[ nodeName ][ attrs.id ] = node;
} else if ( nodeName !== 'Properties70' ) {
if ( nodeName === 'PoseNode' ) currentNode[ nodeName ] = [ node ];
else currentNode[ nodeName ] = node;
}
}
if ( typeof attrs.id === 'number' ) node.id = attrs.id;
if ( attrs.name !== '' ) node.attrName = attrs.name;
if ( attrs.type !== '' ) node.attrType = attrs.type;
this.pushStack( node );
},
parseNodeAttr: function ( attrs ) {
var id = attrs[ 0 ];
if ( attrs[ 0 ] !== '' ) {
id = parseInt( attrs[ 0 ] );
if ( isNaN( id ) ) {
id = attrs[ 0 ];
}
}
var name = '', type = '';
if ( attrs.length > 1 ) {
name = attrs[ 1 ].replace( /^(\w+)::/, '' );
type = attrs[ 2 ];
}
return { id: id, name: name, type: type };
},
parseNodeProperty: function ( line, property, contentLine ) {
var propName = property[ 1 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
var propValue = property[ 2 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
// for special case: base64 image data follows "Content: ," line
// Content: ,
// "/9j/4RDaRXhpZgAATU0A..."
if ( propName === 'Content' && propValue === ',' ) {
propValue = contentLine.replace( /"/g, '' ).replace( /,$/, '' ).trim();
}
var currentNode = this.getCurrentNode();
var parentName = currentNode.name;
if ( parentName === 'Properties70' ) {
this.parseNodeSpecialProperty( line, propName, propValue );
return;
}
// Connections
if ( propName === 'C' ) {
var connProps = propValue.split( ',' ).slice( 1 );
var from = parseInt( connProps[ 0 ] );
var to = parseInt( connProps[ 1 ] );
var rest = propValue.split( ',' ).slice( 3 );
rest = rest.map( function ( elem ) {
return elem.trim().replace( /^"/, '' );
} );
propName = 'connections';
propValue = [ from, to ];
append( propValue, rest );
if ( currentNode[ propName ] === undefined ) {
currentNode[ propName ] = [];
}
}
// Node
if ( propName === 'Node' ) currentNode.id = propValue;
// connections
if ( propName in currentNode && Array.isArray( currentNode[ propName ] ) ) {
currentNode[ propName ].push( propValue );
} else {
if ( propName !== 'a' ) currentNode[ propName ] = propValue;
else currentNode.a = propValue;
}
this.setCurrentProp( currentNode, propName );
// convert string to array, unless it ends in ',' in which case more will be added to it
if ( propName === 'a' && propValue.slice( - 1 ) !== ',' ) {
currentNode.a = parseNumberArray( propValue );
}
},
parseNodePropertyContinued: function ( line ) {
var currentNode = this.getCurrentNode();
currentNode.a += line;
// if the line doesn't end in ',' we have reached the end of the property value
// so convert the string to an array
if ( line.slice( - 1 ) !== ',' ) {
currentNode.a = parseNumberArray( currentNode.a );
}
},
// parse "Property70"
parseNodeSpecialProperty: function ( line, propName, propValue ) {
// split this
// P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1
// into array like below
// ["Lcl Scaling", "Lcl Scaling", "", "A", "1,1,1" ]
var props = propValue.split( '",' ).map( function ( prop ) {
return prop.trim().replace( /^\"/, '' ).replace( /\s/, '_' );
} );
var innerPropName = props[ 0 ];
var innerPropType1 = props[ 1 ];
var innerPropType2 = props[ 2 ];
var innerPropFlag = props[ 3 ];
var innerPropValue = props[ 4 ];
// cast values where needed, otherwise leave as strings
switch ( innerPropType1 ) {
case 'int':
case 'enum':
case 'bool':
case 'ULongLong':
case 'double':
case 'Number':
case 'FieldOfView':
innerPropValue = parseFloat( innerPropValue );
break;
case 'Color':
case 'ColorRGB':
case 'Vector3D':
case 'Lcl_Translation':
case 'Lcl_Rotation':
case 'Lcl_Scaling':
innerPropValue = parseNumberArray( innerPropValue );
break;
}
// CAUTION: these props must append to parent's parent
this.getPrevNode()[ innerPropName ] = {
'type': innerPropType1,
'type2': innerPropType2,
'flag': innerPropFlag,
'value': innerPropValue
};
this.setCurrentProp( this.getPrevNode(), innerPropName );
},
};
// Parse an FBX file in Binary format
function BinaryParser() {}
BinaryParser.prototype = {
constructor: BinaryParser,
parse: function ( buffer ) {
var reader = new BinaryReader( buffer );
reader.skip( 23 ); // skip magic 23 bytes
var version = reader.getUint32();
console.log( 'THREE.FBXLoader: FBX binary version: ' + version );
var allNodes = new FBXTree();
while ( ! this.endOfContent( reader ) ) {
var node = this.parseNode( reader, version );
if ( node !== null ) allNodes.add( node.name, node );
}
return allNodes;
},
// Check if reader has reached the end of content.
endOfContent: function ( reader ) {
// footer size: 160bytes + 16-byte alignment padding
// - 16bytes: magic
// - padding til 16-byte alignment (at least 1byte?)
// (seems like some exporters embed fixed 15 or 16bytes?)
// - 4bytes: magic
// - 4bytes: version
// - 120bytes: zero
// - 16bytes: magic
if ( reader.size() % 16 === 0 ) {
return ( ( reader.getOffset() + 160 + 16 ) & ~ 0xf ) >= reader.size();
} else {
return reader.getOffset() + 160 + 16 >= reader.size();
}
},
// recursively parse nodes until the end of the file is reached
parseNode: function ( reader, version ) {
var node = {};
// The first three data sizes depends on version.
var endOffset = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
var numProperties = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
( version >= 7500 ) ? reader.getUint64() : reader.getUint32(); // the returned propertyListLen is not used
var nameLen = reader.getUint8();
var name = reader.getString( nameLen );
// Regards this node as NULL-record if endOffset is zero
if ( endOffset === 0 ) return null;
var propertyList = [];
for ( var i = 0; i < numProperties; i ++ ) {
propertyList.push( this.parseProperty( reader ) );
}
// Regards the first three elements in propertyList as id, attrName, and attrType
var id = propertyList.length > 0 ? propertyList[ 0 ] : '';
var attrName = propertyList.length > 1 ? propertyList[ 1 ] : '';
var attrType = propertyList.length > 2 ? propertyList[ 2 ] : '';
// check if this node represents just a single property
// like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}
node.singleProperty = ( numProperties === 1 && reader.getOffset() === endOffset ) ? true : false;
while ( endOffset > reader.getOffset() ) {
var subNode = this.parseNode( reader, version );
if ( subNode !== null ) this.parseSubNode( name, node, subNode );
}
node.propertyList = propertyList; // raw property list used by parent
if ( typeof id === 'number' ) node.id = id;
if ( attrName !== '' ) node.attrName = attrName;
if ( attrType !== '' ) node.attrType = attrType;
if ( name !== '' ) node.name = name;
return node;
},
parseSubNode: function ( name, node, subNode ) {
// special case: child node is single property
if ( subNode.singleProperty === true ) {
var value = subNode.propertyList[ 0 ];
if ( Array.isArray( value ) ) {
node[ subNode.name ] = subNode;
subNode.a = value;
} else {
node[ subNode.name ] = value;
}
} else if ( name === 'Connections' && subNode.name === 'C' ) {
var array = [];
subNode.propertyList.forEach( function ( property, i ) {
// first Connection is FBX type (OO, OP, etc.). We'll discard these
if ( i !== 0 ) array.push( property );
} );
if ( node.connections === undefined ) {
node.connections = [];
}
node.connections.push( array );
} else if ( subNode.name === 'Properties70' ) {
var keys = Object.keys( subNode );
keys.forEach( function ( key ) {
node[ key ] = subNode[ key ];
} );
} else if ( name === 'Properties70' && subNode.name === 'P' ) {
var innerPropName = subNode.propertyList[ 0 ];
var innerPropType1 = subNode.propertyList[ 1 ];
var innerPropType2 = subNode.propertyList[ 2 ];
var innerPropFlag = subNode.propertyList[ 3 ];
var innerPropValue;
if ( innerPropName.indexOf( 'Lcl ' ) === 0 ) innerPropName = innerPropName.replace( 'Lcl ', 'Lcl_' );
if ( innerPropType1.indexOf( 'Lcl ' ) === 0 ) innerPropType1 = innerPropType1.replace( 'Lcl ', 'Lcl_' );
if ( innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf( 'Lcl_' ) === 0 ) {
innerPropValue = [
subNode.propertyList[ 4 ],
subNode.propertyList[ 5 ],
subNode.propertyList[ 6 ]
];
} else {
innerPropValue = subNode.propertyList[ 4 ];
}
// this will be copied to parent, see above
node[ innerPropName ] = {
'type': innerPropType1,
'type2': innerPropType2,
'flag': innerPropFlag,
'value': innerPropValue
};
} else if ( node[ subNode.name ] === undefined ) {
if ( typeof subNode.id === 'number' ) {
node[ subNode.name ] = {};
node[ subNode.name ][ subNode.id ] = subNode;
} else {
node[ subNode.name ] = subNode;
}
} else {
if ( subNode.name === 'PoseNode' ) {
if ( ! Array.isArray( node[ subNode.name ] ) ) {
node[ subNode.name ] = [ node[ subNode.name ] ];
}
node[ subNode.name ].push( subNode );
} else if ( node[ subNode.name ][ subNode.id ] === undefined ) {
node[ subNode.name ][ subNode.id ] = subNode;
}
}
},
parseProperty: function ( reader ) {
var type = reader.getString( 1 );
switch ( type ) {
case 'C':
return reader.getBoolean();
case 'D':
return reader.getFloat64();
case 'F':
return reader.getFloat32();
case 'I':
return reader.getInt32();
case 'L':
return reader.getInt64();
case 'R':
var length = reader.getUint32();
return reader.getArrayBuffer( length );
case 'S':
var length = reader.getUint32();
return reader.getString( length );
case 'Y':
return reader.getInt16();
case 'b':
case 'c':
case 'd':
case 'f':
case 'i':
case 'l':
var arrayLength = reader.getUint32();
var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
var compressedLength = reader.getUint32();
if ( encoding === 0 ) {
switch ( type ) {
case 'b':
case 'c':
return reader.getBooleanArray( arrayLength );
case 'd':
return reader.getFloat64Array( arrayLength );
case 'f':
return reader.getFloat32Array( arrayLength );
case 'i':
return reader.getInt32Array( arrayLength );
case 'l':
return reader.getInt64Array( arrayLength );
}
}
if ( typeof Zlib === 'undefined' ) {
console.error( 'THREE.FBXLoader: External library Inflate.min.js required, obtain or import from https://github.com/imaya/zlib.js' );
}
var inflate = new Zlib.Inflate( new Uint8Array( reader.getArrayBuffer( compressedLength ) ) ); // eslint-disable-line no-undef
var reader2 = new BinaryReader( inflate.decompress().buffer );
switch ( type ) {
case 'b':
case 'c':
return reader2.getBooleanArray( arrayLength );
case 'd':
return reader2.getFloat64Array( arrayLength );
case 'f':
return reader2.getFloat32Array( arrayLength );
case 'i':
return reader2.getInt32Array( arrayLength );
case 'l':
return reader2.getInt64Array( arrayLength );
}
default:
throw new Error( 'THREE.FBXLoader: Unknown property type ' + type );
}
}
};
function BinaryReader( buffer, littleEndian ) {
this.dv = new DataView( buffer );
this.offset = 0;
this.littleEndian = ( littleEndian !== undefined ) ? littleEndian : true;
}
BinaryReader.prototype = {
constructor: BinaryReader,
getOffset: function () {
return this.offset;
},
size: function () {
return this.dv.buffer.byteLength;
},
skip: function ( length ) {
this.offset += length;
},
// seems like true/false representation depends on exporter.
// true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)
// then sees LSB.
getBoolean: function () {
return ( this.getUint8() & 1 ) === 1;
},
getBooleanArray: function ( size ) {
var a = [];
for ( var i = 0; i < size; i ++ ) {
a.push( this.getBoolean() );
}
return a;
},
getUint8: function () {
var value = this.dv.getUint8( this.offset );
this.offset += 1;
return value;
},
getInt16: function () {
var value = this.dv.getInt16( this.offset, this.littleEndian );
this.offset += 2;
return value;
},
getInt32: function () {
var value = this.dv.getInt32( this.offset, this.littleEndian );
this.offset += 4;
return value;
},
getInt32Array: function ( size ) {
var a = [];
for ( var i = 0; i < size; i ++ ) {
a.push( this.getInt32() );
}
return a;
},
getUint32: function () {
var value = this.dv.getUint32( this.offset, this.littleEndian );
this.offset += 4;
return value;
},
// JavaScript doesn't support 64-bit integer so calculate this here
// 1 << 32 will return 1 so using multiply operation instead here.
// There's a possibility that this method returns wrong value if the value
// is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
// TODO: safely handle 64-bit integer
getInt64: function () {
var low, high;
if ( this.littleEndian ) {
low = this.getUint32();
high = this.getUint32();
} else {
high = this.getUint32();
low = this.getUint32();
}
// calculate negative value
if ( high & 0x80000000 ) {
high = ~ high & 0xFFFFFFFF;
low = ~ low & 0xFFFFFFFF;
if ( low === 0xFFFFFFFF ) high = ( high + 1 ) & 0xFFFFFFFF;
low = ( low + 1 ) & 0xFFFFFFFF;
return - ( high * 0x100000000 + low );
}
return high * 0x100000000 + low;
},
getInt64Array: function ( size ) {
var a = [];
for ( var i = 0; i < size; i ++ ) {
a.push( this.getInt64() );
}
return a;
},
// Note: see getInt64() comment
getUint64: function () {
var low, high;
if ( this.littleEndian ) {
low = this.getUint32();
high = this.getUint32();
} else {
high = this.getUint32();
low = this.getUint32();
}
return high * 0x100000000 + low;
},
getFloat32: function () {
var value = this.dv.getFloat32( this.offset, this.littleEndian );
this.offset += 4;
return value;
},
getFloat32Array: function ( size ) {
var a = [];
for ( var i = 0; i < size; i ++ ) {
a.push( this.getFloat32() );
}
return a;
},
getFloat64: function () {
var value = this.dv.getFloat64( this.offset, this.littleEndian );
this.offset += 8;
return value;
},
getFloat64Array: function ( size ) {
var a = [];
for ( var i = 0; i < size; i ++ ) {
a.push( this.getFloat64() );
}
return a;
},
getArrayBuffer: function ( size ) {
var value = this.dv.buffer.slice( this.offset, this.offset + size );
this.offset += size;
return value;
},
getString: function ( size ) {
// note: safari 9 doesn't support Uint8Array.indexOf; create intermediate array instead
var a = [];
for ( var i = 0; i < size; i ++ ) {
a[ i ] = this.getUint8();
}
var nullByte = a.indexOf( 0 );
if ( nullByte >= 0 ) a = a.slice( 0, nullByte );
return LoaderUtils.decodeText( new Uint8Array( a ) );
}
};
// FBXTree holds a representation of the FBX data, returned by the TextParser ( FBX ASCII format)
// and BinaryParser( FBX Binary format)
function FBXTree() {}
FBXTree.prototype = {
constructor: FBXTree,
add: function ( key, val ) {
this[ key ] = val;
},
};
// ************** UTILITY FUNCTIONS **************
function isFbxFormatBinary( buffer ) {
var CORRECT = 'Kaydara FBX Binary \0';
return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString( buffer, 0, CORRECT.length );
}
function isFbxFormatASCII( text ) {
var CORRECT = [ 'K', 'a', 'y', 'd', 'a', 'r', 'a', '\\', 'F', 'B', 'X', '\\', 'B', 'i', 'n', 'a', 'r', 'y', '\\', '\\' ];
var cursor = 0;
function read( offset ) {
var result = text[ offset - 1 ];
text = text.slice( cursor + offset );
cursor ++;
return result;
}
for ( var i = 0; i < CORRECT.length; ++ i ) {
var num = read( 1 );
if ( num === CORRECT[ i ] ) {
return false;
}
}
return true;
}
function getFbxVersion( text ) {
var versionRegExp = /FBXVersion: (\d+)/;
var match = text.match( versionRegExp );
if ( match ) {
var version = parseInt( match[ 1 ] );
return version;
}
throw new Error( 'THREE.FBXLoader: Cannot find the version number for the file given.' );
}
// Converts FBX ticks into real time seconds.
function convertFBXTimeToSeconds( time ) {
return time / 46186158000;
}
var dataArray = [];
// extracts the data from the correct position in the FBX array based on indexing type
function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
var index;
switch ( infoObject.mappingType ) {
case 'ByPolygonVertex' :
index = polygonVertexIndex;
break;
case 'ByPolygon' :
index = polygonIndex;
break;
case 'ByVertice' :
index = vertexIndex;
break;
case 'AllSame' :
index = infoObject.indices[ 0 ];
break;
default :
console.warn( 'THREE.FBXLoader: unknown attribute mapping type ' + infoObject.mappingType );
}
if ( infoObject.referenceType === 'IndexToDirect' ) index = infoObject.indices[ index ];
var from = index * infoObject.dataSize;
var to = from + infoObject.dataSize;
return slice( dataArray, infoObject.buffer, from, to );
}
var tempEuler = new Euler();
var tempVec = new Vector3();
// generate transformation from FBX transform data
// ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm
// ref: http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/index.html?url=cpp_ref/_transformations_2main_8cxx-example.html,topicNumber=cpp_ref__transformations_2main_8cxx_example_htmlfc10a1e1-b18d-4e72-9dc0-70d0f1959f5e
function generateTransform( transformData ) {
var lTranslationM = new Matrix4();
var lPreRotationM = new Matrix4();
var lRotationM = new Matrix4();
var lPostRotationM = new Matrix4();
var lScalingM = new Matrix4();
var lScalingPivotM = new Matrix4();
var lScalingOffsetM = new Matrix4();
var lRotationOffsetM = new Matrix4();
var lRotationPivotM = new Matrix4();
var lParentGX = new Matrix4();
var lGlobalT = new Matrix4();
var inheritType = ( transformData.inheritType ) ? transformData.inheritType : 0;
if ( transformData.translation ) lTranslationM.setPosition( tempVec.fromArray( transformData.translation ) );
if ( transformData.preRotation ) {
var array = transformData.preRotation.map( MathUtils.degToRad );
array.push( transformData.eulerOrder );
lPreRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
}
if ( transformData.rotation ) {
var array = transformData.rotation.map( MathUtils.degToRad );
array.push( transformData.eulerOrder );
lRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
}
if ( transformData.postRotation ) {
var array = transformData.postRotation.map( MathUtils.degToRad );
array.push( transformData.eulerOrder );
lPostRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
}
if ( transformData.scale ) lScalingM.scale( tempVec.fromArray( transformData.scale ) );
// Pivots and offsets
if ( transformData.scalingOffset ) lScalingOffsetM.setPosition( tempVec.fromArray( transformData.scalingOffset ) );
if ( transformData.scalingPivot ) lScalingPivotM.setPosition( tempVec.fromArray( transformData.scalingPivot ) );
if ( transformData.rotationOffset ) lRotationOffsetM.setPosition( tempVec.fromArray( transformData.rotationOffset ) );
if ( transformData.rotationPivot ) lRotationPivotM.setPosition( tempVec.fromArray( transformData.rotationPivot ) );
// parent transform
if ( transformData.parentMatrixWorld ) lParentGX = transformData.parentMatrixWorld;
// Global Rotation
var lLRM = lPreRotationM.multiply( lRotationM ).multiply( lPostRotationM );
var lParentGRM = new Matrix4();
lParentGX.extractRotation( lParentGRM );
// Global Shear*Scaling
var lParentTM = new Matrix4();
lParentTM.copyPosition( lParentGX );
var lParentGSM = new Matrix4();
lParentGSM.getInverse( lParentGRM ).multiply( lParentGX );
var lGlobalRS = new Matrix4();
if ( inheritType === 0 ) {
lGlobalRS.copy( lParentGRM ).multiply( lLRM ).multiply( lParentGSM ).multiply( lScalingM );
} else if ( inheritType === 1 ) {
lGlobalRS.copy( lParentGRM ).multiply( lParentGSM ).multiply( lLRM ).multiply( lScalingM );
} else {
var lParentLSM_inv = new Matrix4().getInverse( lScalingM );
var lParentGSM_noLocal = new Matrix4().multiply( lParentGSM ).multiply( lParentLSM_inv );
lGlobalRS.copy( lParentGRM ).multiply( lLRM ).multiply( lParentGSM_noLocal ).multiply( lScalingM );
}
var lRotationPivotM_inv = new Matrix4().getInverse( lRotationPivotM );
var lScalingPivotM_inv = new Matrix4().getInverse( lScalingPivotM );
// Calculate the local transform matrix
var lTransform = new Matrix4();
lTransform.copy( lTranslationM ).multiply( lRotationOffsetM ).multiply( lRotationPivotM ).multiply( lPreRotationM ).multiply( lRotationM ).multiply( lPostRotationM ).multiply( lRotationPivotM_inv ).multiply( lScalingOffsetM ).multiply( lScalingPivotM ).multiply( lScalingM ).multiply( lScalingPivotM_inv );
var lLocalTWithAllPivotAndOffsetInfo = new Matrix4().copyPosition( lTransform );
var lGlobalTranslation = new Matrix4().copy( lParentGX ).multiply( lLocalTWithAllPivotAndOffsetInfo );
lGlobalT.copyPosition( lGlobalTranslation );
lTransform = new Matrix4().multiply( lGlobalT ).multiply( lGlobalRS );
return lTransform;
}
// Returns the three.js intrinsic Euler order corresponding to FBX extrinsic Euler order
// ref: http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_class_fbx_euler_html
function getEulerOrder( order ) {
order = order || 0;
var enums = [
'ZYX', // -> XYZ extrinsic
'YZX', // -> XZY extrinsic
'XZY', // -> YZX extrinsic
'ZXY', // -> YXZ extrinsic
'YXZ', // -> ZXY extrinsic
'XYZ', // -> ZYX extrinsic
//'SphericXYZ', // not possible to support
];
if ( order === 6 ) {
console.warn( 'THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect.' );
return enums[ 0 ];
}
return enums[ order ];
}
// Parses comma separated list of numbers and returns them an array.
// Used internally by the TextParser
function parseNumberArray( value ) {
var array = value.split( ',' ).map( function ( val ) {
return parseFloat( val );
} );
return array;
}
function convertArrayBufferToString( buffer, from, to ) {
if ( from === undefined ) from = 0;
if ( to === undefined ) to = buffer.byteLength;
return LoaderUtils.decodeText( new Uint8Array( buffer, from, to ) );
}
function append( a, b ) {
for ( var i = 0, j = a.length, l = b.length; i < l; i ++, j ++ ) {
a[ j ] = b[ i ];
}
}
function slice( a, b, from, to ) {
for ( var i = from, j = 0; i < to; i ++, j ++ ) {
a[ j ] = b[ i ];
}
return a;
}
// inject array a2 into array a1 at index
function inject( a1, index, a2 ) {
return a1.slice( 0, index ).concat( a2 ).concat( a1.slice( index ) );
}
return FBXLoader;
} )()
Example #2
| Source File: GLTFLoader.js From canvas with Apache License 2.0 | 4 votes |
|
GLTFLoader = ( function () {
function GLTFLoader( manager ) {
Loader.call( this, manager );
this.dracoLoader = null;
this.ddsLoader = null;
}
GLTFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
constructor: GLTFLoader,
load: function ( url, onLoad, onProgress, onError ) {
var scope = this;
var resourcePath;
if ( this.resourcePath !== '' ) {
resourcePath = this.resourcePath;
} else if ( this.path !== '' ) {
resourcePath = this.path;
} else {
resourcePath = LoaderUtils.extractUrlBase( url );
}
// Tells the LoadingManager to track an extra item, which resolves after
// the model is fully loaded. This means the count of items loaded will
// be incorrect, but ensures manager.onLoad() does not fire early.
scope.manager.itemStart( url );
var _onError = function ( e ) {
if ( onError ) {
onError( e );
} else {
console.error( e );
}
scope.manager.itemError( url );
scope.manager.itemEnd( url );
};
var loader = new FileLoader( scope.manager );
loader.setPath( this.path );
loader.setResponseType( 'arraybuffer' );
if ( scope.crossOrigin === 'use-credentials' ) {
loader.setWithCredentials( true );
}
loader.load( url, function ( data ) {
try {
scope.parse( data, resourcePath, function ( gltf ) {
onLoad( gltf );
scope.manager.itemEnd( url );
}, _onError );
} catch ( e ) {
_onError( e );
}
}, onProgress, _onError );
},
setDRACOLoader: function ( dracoLoader ) {
this.dracoLoader = dracoLoader;
return this;
},
setDDSLoader: function ( ddsLoader ) {
this.ddsLoader = ddsLoader;
return this;
},
parse: function ( data, path, onLoad, onError ) {
var content;
var extensions = {};
if ( typeof data === 'string' ) {
content = data;
} else {
var magic = LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
try {
extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
} catch ( error ) {
if ( onError ) onError( error );
return;
}
content = extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content;
} else {
content = LoaderUtils.decodeText( new Uint8Array( data ) );
}
}
var json = JSON.parse( content );
if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
return;
}
if ( json.extensionsUsed ) {
for ( var i = 0; i < json.extensionsUsed.length; ++ i ) {
var extensionName = json.extensionsUsed[ i ];
var extensionsRequired = json.extensionsRequired || [];
switch ( extensionName ) {
case EXTENSIONS.KHR_LIGHTS_PUNCTUAL:
extensions[ extensionName ] = new GLTFLightsExtension( json );
break;
case EXTENSIONS.KHR_MATERIALS_CLEARCOAT:
extensions[ extensionName ] = new GLTFMaterialsClearcoatExtension();
break;
case EXTENSIONS.KHR_MATERIALS_UNLIT:
extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
break;
case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
extensions[ extensionName ] = new GLTFMaterialsPbrSpecularGlossinessExtension();
break;
case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
break;
case EXTENSIONS.MSFT_TEXTURE_DDS:
extensions[ extensionName ] = new GLTFTextureDDSExtension( this.ddsLoader );
break;
case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
extensions[ extensionName ] = new GLTFTextureTransformExtension();
break;
case EXTENSIONS.KHR_MESH_QUANTIZATION:
extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
break;
default:
if ( extensionsRequired.indexOf( extensionName ) >= 0 ) {
console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
}
}
}
}
var parser = new GLTFParser( json, extensions, {
path: path || this.resourcePath || '',
crossOrigin: this.crossOrigin,
manager: this.manager
} );
parser.parse( onLoad, onError );
}
} );
/* GLTFREGISTRY */
function GLTFRegistry() {
var objects = {};
return {
get: function ( key ) {
return objects[ key ];
},
add: function ( key, object ) {
objects[ key ] = object;
},
remove: function ( key ) {
delete objects[ key ];
},
removeAll: function () {
objects = {};
}
};
}
/*********************************/
/********** EXTENSIONS ***********/
/*********************************/
var EXTENSIONS = {
KHR_BINARY_GLTF: 'KHR_binary_glTF',
KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
MSFT_TEXTURE_DDS: 'MSFT_texture_dds'
};
/**
* DDS Texture Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds
*
*/
function GLTFTextureDDSExtension( ddsLoader ) {
if ( ! ddsLoader ) {
throw new Error( 'THREE.GLTFLoader: Attempting to load .dds texture without importing DDSLoader' );
}
this.name = EXTENSIONS.MSFT_TEXTURE_DDS;
this.ddsLoader = ddsLoader;
}
/**
* Punctual Lights Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
*/
function GLTFLightsExtension( json ) {
this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
var extension = ( json.extensions && json.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ] ) || {};
this.lightDefs = extension.lights || [];
}
GLTFLightsExtension.prototype.loadLight = function ( lightIndex ) {
var lightDef = this.lightDefs[ lightIndex ];
var lightNode;
var color = new Color( 0xffffff );
if ( lightDef.color !== undefined ) color.fromArray( lightDef.color );
var range = lightDef.range !== undefined ? lightDef.range : 0;
switch ( lightDef.type ) {
case 'directional':
lightNode = new DirectionalLight( color );
lightNode.target.position.set( 0, 0, - 1 );
lightNode.add( lightNode.target );
break;
case 'point':
lightNode = new PointLight( color );
lightNode.distance = range;
break;
case 'spot':
lightNode = new SpotLight( color );
lightNode.distance = range;
// Handle spotlight properties.
lightDef.spot = lightDef.spot || {};
lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
lightNode.angle = lightDef.spot.outerConeAngle;
lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
lightNode.target.position.set( 0, 0, - 1 );
lightNode.add( lightNode.target );
break;
default:
throw new Error( 'THREE.GLTFLoader: Unexpected light type, "' + lightDef.type + '".' );
}
// Some lights (e.g. spot) default to a position other than the origin. Reset the position
// here, because node-level parsing will only override position if explicitly specified.
lightNode.position.set( 0, 0, 0 );
lightNode.decay = 2;
if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
lightNode.name = lightDef.name || ( 'light_' + lightIndex );
return Promise.resolve( lightNode );
};
/**
* Unlit Materials Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
*/
function GLTFMaterialsUnlitExtension() {
this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
}
GLTFMaterialsUnlitExtension.prototype.getMaterialType = function () {
return MeshBasicMaterial;
};
GLTFMaterialsUnlitExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
var pending = [];
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
var metallicRoughness = materialDef.pbrMetallicRoughness;
if ( metallicRoughness ) {
if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
var array = metallicRoughness.baseColorFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( metallicRoughness.baseColorTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
}
}
return Promise.all( pending );
};
/**
* Clearcoat Materials Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
*/
function GLTFMaterialsClearcoatExtension() {
this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
}
GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function () {
return MeshPhysicalMaterial;
};
GLTFMaterialsClearcoatExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
var pending = [];
var extension = materialDef.extensions[ this.name ];
if ( extension.clearcoatFactor !== undefined ) {
materialParams.clearcoat = extension.clearcoatFactor;
}
if ( extension.clearcoatTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );
}
if ( extension.clearcoatRoughnessFactor !== undefined ) {
materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
}
if ( extension.clearcoatRoughnessTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );
}
if ( extension.clearcoatNormalTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );
if ( extension.clearcoatNormalTexture.scale !== undefined ) {
var scale = extension.clearcoatNormalTexture.scale;
materialParams.clearcoatNormalScale = new Vector2( scale, scale );
}
}
return Promise.all( pending );
};
/* BINARY EXTENSION */
var BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
var BINARY_EXTENSION_HEADER_LENGTH = 12;
var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };
function GLTFBinaryExtension( data ) {
this.name = EXTENSIONS.KHR_BINARY_GLTF;
this.content = null;
this.body = null;
var headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
this.header = {
magic: LoaderUtils.decodeText( new Uint8Array( data.slice( 0, 4 ) ) ),
version: headerView.getUint32( 4, true ),
length: headerView.getUint32( 8, true )
};
if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {
throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );
} else if ( this.header.version < 2.0 ) {
throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );
}
var chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
var chunkIndex = 0;
while ( chunkIndex < chunkView.byteLength ) {
var chunkLength = chunkView.getUint32( chunkIndex, true );
chunkIndex += 4;
var chunkType = chunkView.getUint32( chunkIndex, true );
chunkIndex += 4;
if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
var contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
this.content = LoaderUtils.decodeText( contentArray );
} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
this.body = data.slice( byteOffset, byteOffset + chunkLength );
}
// Clients must ignore chunks with unknown types.
chunkIndex += chunkLength;
}
if ( this.content === null ) {
throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
}
}
/**
* DRACO Mesh Compression Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
*/
function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
if ( ! dracoLoader ) {
throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
}
this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
this.json = json;
this.dracoLoader = dracoLoader;
this.dracoLoader.preload();
}
GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function ( primitive, parser ) {
var json = this.json;
var dracoLoader = this.dracoLoader;
var bufferViewIndex = primitive.extensions[ this.name ].bufferView;
var gltfAttributeMap = primitive.extensions[ this.name ].attributes;
var threeAttributeMap = {};
var attributeNormalizedMap = {};
var attributeTypeMap = {};
for ( var attributeName in gltfAttributeMap ) {
var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
}
for ( attributeName in primitive.attributes ) {
var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
if ( gltfAttributeMap[ attributeName ] !== undefined ) {
var accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
var componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
attributeTypeMap[ threeAttributeName ] = componentType;
attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
}
}
return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
return new Promise( function ( resolve ) {
dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
for ( var attributeName in geometry.attributes ) {
var attribute = geometry.attributes[ attributeName ];
var normalized = attributeNormalizedMap[ attributeName ];
if ( normalized !== undefined ) attribute.normalized = normalized;
}
resolve( geometry );
}, threeAttributeMap, attributeTypeMap );
} );
} );
};
/**
* Texture Transform Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
*/
function GLTFTextureTransformExtension() {
this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
}
GLTFTextureTransformExtension.prototype.extendTexture = function ( texture, transform ) {
texture = texture.clone();
if ( transform.offset !== undefined ) {
texture.offset.fromArray( transform.offset );
}
if ( transform.rotation !== undefined ) {
texture.rotation = transform.rotation;
}
if ( transform.scale !== undefined ) {
texture.repeat.fromArray( transform.scale );
}
if ( transform.texCoord !== undefined ) {
console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
}
texture.needsUpdate = true;
return texture;
};
/**
* Specular-Glossiness Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
*/
/**
* A sub class of StandardMaterial with some of the functionality
* changed via the `onBeforeCompile` callback
* @pailhead
*/
function GLTFMeshStandardSGMaterial( params ) {
MeshStandardMaterial.call( this );
this.isGLTFSpecularGlossinessMaterial = true;
//various chunks that need replacing
var specularMapParsFragmentChunk = [
'#ifdef USE_SPECULARMAP',
' uniform sampler2D specularMap;',
'#endif'
].join( '\n' );
var glossinessMapParsFragmentChunk = [
'#ifdef USE_GLOSSINESSMAP',
' uniform sampler2D glossinessMap;',
'#endif'
].join( '\n' );
var specularMapFragmentChunk = [
'vec3 specularFactor = specular;',
'#ifdef USE_SPECULARMAP',
' vec4 texelSpecular = texture2D( specularMap, vUv );',
' texelSpecular = sRGBToLinear( texelSpecular );',
' // reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture',
' specularFactor *= texelSpecular.rgb;',
'#endif'
].join( '\n' );
var glossinessMapFragmentChunk = [
'float glossinessFactor = glossiness;',
'#ifdef USE_GLOSSINESSMAP',
' vec4 texelGlossiness = texture2D( glossinessMap, vUv );',
' // reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture',
' glossinessFactor *= texelGlossiness.a;',
'#endif'
].join( '\n' );
var lightPhysicalFragmentChunk = [
'PhysicalMaterial material;',
'material.diffuseColor = diffuseColor.rgb;',
'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );',
'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );',
'material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 );// 0.0525 corresponds to the base mip of a 256 cubemap.',
'material.specularRoughness += geometryRoughness;',
'material.specularRoughness = min( material.specularRoughness, 1.0 );',
'material.specularColor = specularFactor.rgb;',
].join( '\n' );
var uniforms = {
specular: { value: new Color().setHex( 0xffffff ) },
glossiness: { value: 1 },
specularMap: { value: null },
glossinessMap: { value: null }
};
this._extraUniforms = uniforms;
// please see #14031 or #13198 for an alternate approach
this.onBeforeCompile = function ( shader ) {
for ( var uniformName in uniforms ) {
shader.uniforms[ uniformName ] = uniforms[ uniformName ];
}
shader.fragmentShader = shader.fragmentShader.replace( 'uniform float roughness;', 'uniform vec3 specular;' );
shader.fragmentShader = shader.fragmentShader.replace( 'uniform float metalness;', 'uniform float glossiness;' );
shader.fragmentShader = shader.fragmentShader.replace( '#include <roughnessmap_pars_fragment>', specularMapParsFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <metalnessmap_pars_fragment>', glossinessMapParsFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <roughnessmap_fragment>', specularMapFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <metalnessmap_fragment>', glossinessMapFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <lights_physical_fragment>', lightPhysicalFragmentChunk );
};
/*eslint-disable*/
Object.defineProperties(
this,
{
specular: {
get: function () { return uniforms.specular.value; },
set: function ( v ) { uniforms.specular.value = v; }
},
specularMap: {
get: function () { return uniforms.specularMap.value; },
set: function ( v ) { uniforms.specularMap.value = v; }
},
glossiness: {
get: function () { return uniforms.glossiness.value; },
set: function ( v ) { uniforms.glossiness.value = v; }
},
glossinessMap: {
get: function () { return uniforms.glossinessMap.value; },
set: function ( v ) {
uniforms.glossinessMap.value = v;
//how about something like this - @pailhead
if ( v ) {
this.defines.USE_GLOSSINESSMAP = '';
// set USE_ROUGHNESSMAP to enable vUv
this.defines.USE_ROUGHNESSMAP = '';
} else {
delete this.defines.USE_ROUGHNESSMAP;
delete this.defines.USE_GLOSSINESSMAP;
}
}
}
}
);
/*eslint-enable*/
delete this.metalness;
delete this.roughness;
delete this.metalnessMap;
delete this.roughnessMap;
this.setValues( params );
}
GLTFMeshStandardSGMaterial.prototype = Object.create( MeshStandardMaterial.prototype );
GLTFMeshStandardSGMaterial.prototype.constructor = GLTFMeshStandardSGMaterial;
GLTFMeshStandardSGMaterial.prototype.copy = function ( source ) {
MeshStandardMaterial.prototype.copy.call( this, source );
this.specularMap = source.specularMap;
this.specular.copy( source.specular );
this.glossinessMap = source.glossinessMap;
this.glossiness = source.glossiness;
delete this.metalness;
delete this.roughness;
delete this.metalnessMap;
delete this.roughnessMap;
return this;
};
function GLTFMaterialsPbrSpecularGlossinessExtension() {
return {
name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,
specularGlossinessParams: [
'color',
'map',
'lightMap',
'lightMapIntensity',
'aoMap',
'aoMapIntensity',
'emissive',
'emissiveIntensity',
'emissiveMap',
'bumpMap',
'bumpScale',
'normalMap',
'normalMapType',
'displacementMap',
'displacementScale',
'displacementBias',
'specularMap',
'specular',
'glossinessMap',
'glossiness',
'alphaMap',
'envMap',
'envMapIntensity',
'refractionRatio',
],
getMaterialType: function () {
return GLTFMeshStandardSGMaterial;
},
extendParams: function ( materialParams, materialDef, parser ) {
var pbrSpecularGlossiness = materialDef.extensions[ this.name ];
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
var pending = [];
if ( Array.isArray( pbrSpecularGlossiness.diffuseFactor ) ) {
var array = pbrSpecularGlossiness.diffuseFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( pbrSpecularGlossiness.diffuseTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', pbrSpecularGlossiness.diffuseTexture ) );
}
materialParams.emissive = new Color( 0.0, 0.0, 0.0 );
materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== undefined ? pbrSpecularGlossiness.glossinessFactor : 1.0;
materialParams.specular = new Color( 1.0, 1.0, 1.0 );
if ( Array.isArray( pbrSpecularGlossiness.specularFactor ) ) {
materialParams.specular.fromArray( pbrSpecularGlossiness.specularFactor );
}
if ( pbrSpecularGlossiness.specularGlossinessTexture !== undefined ) {
var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
pending.push( parser.assignTexture( materialParams, 'glossinessMap', specGlossMapDef ) );
pending.push( parser.assignTexture( materialParams, 'specularMap', specGlossMapDef ) );
}
return Promise.all( pending );
},
createMaterial: function ( materialParams ) {
var material = new GLTFMeshStandardSGMaterial( materialParams );
material.fog = true;
material.color = materialParams.color;
material.map = materialParams.map === undefined ? null : materialParams.map;
material.lightMap = null;
material.lightMapIntensity = 1.0;
material.aoMap = materialParams.aoMap === undefined ? null : materialParams.aoMap;
material.aoMapIntensity = 1.0;
material.emissive = materialParams.emissive;
material.emissiveIntensity = 1.0;
material.emissiveMap = materialParams.emissiveMap === undefined ? null : materialParams.emissiveMap;
material.bumpMap = materialParams.bumpMap === undefined ? null : materialParams.bumpMap;
material.bumpScale = 1;
material.normalMap = materialParams.normalMap === undefined ? null : materialParams.normalMap;
material.normalMapType = TangentSpaceNormalMap;
if ( materialParams.normalScale ) material.normalScale = materialParams.normalScale;
material.displacementMap = null;
material.displacementScale = 1;
material.displacementBias = 0;
material.specularMap = materialParams.specularMap === undefined ? null : materialParams.specularMap;
material.specular = materialParams.specular;
material.glossinessMap = materialParams.glossinessMap === undefined ? null : materialParams.glossinessMap;
material.glossiness = materialParams.glossiness;
material.alphaMap = null;
material.envMap = materialParams.envMap === undefined ? null : materialParams.envMap;
material.envMapIntensity = 1.0;
material.refractionRatio = 0.98;
return material;
},
};
}
/**
* Mesh Quantization Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
*/
function GLTFMeshQuantizationExtension() {
this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
}
/*********************************/
/********** INTERPOLATION ********/
/*********************************/
// Spline Interpolation
// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
}
GLTFCubicSplineInterpolant.prototype = Object.create( Interpolant.prototype );
GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant;
GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function ( index ) {
// Copies a sample value to the result buffer. See description of glTF
// CUBICSPLINE values layout in interpolate_() function below.
var result = this.resultBuffer,
values = this.sampleValues,
valueSize = this.valueSize,
offset = index * valueSize * 3 + valueSize;
for ( var i = 0; i !== valueSize; i ++ ) {
result[ i ] = values[ offset + i ];
}
return result;
};
GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
GLTFCubicSplineInterpolant.prototype.interpolate_ = function ( i1, t0, t, t1 ) {
var result = this.resultBuffer;
var values = this.sampleValues;
var stride = this.valueSize;
var stride2 = stride * 2;
var stride3 = stride * 3;
var td = t1 - t0;
var p = ( t - t0 ) / td;
var pp = p * p;
var ppp = pp * p;
var offset1 = i1 * stride3;
var offset0 = offset1 - stride3;
var s2 = - 2 * ppp + 3 * pp;
var s3 = ppp - pp;
var s0 = 1 - s2;
var s1 = s3 - pp + p;
// Layout of keyframe output values for CUBICSPLINE animations:
// [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
for ( var i = 0; i !== stride; i ++ ) {
var p0 = values[ offset0 + i + stride ]; // splineVertex_k
var m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
var p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
var m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)
result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
}
return result;
};
/*********************************/
/********** INTERNALS ************/
/*********************************/
/* CONSTANTS */
var WEBGL_CONSTANTS = {
FLOAT: 5126,
//FLOAT_MAT2: 35674,
FLOAT_MAT3: 35675,
FLOAT_MAT4: 35676,
FLOAT_VEC2: 35664,
FLOAT_VEC3: 35665,
FLOAT_VEC4: 35666,
LINEAR: 9729,
REPEAT: 10497,
SAMPLER_2D: 35678,
POINTS: 0,
LINES: 1,
LINE_LOOP: 2,
LINE_STRIP: 3,
TRIANGLES: 4,
TRIANGLE_STRIP: 5,
TRIANGLE_FAN: 6,
UNSIGNED_BYTE: 5121,
UNSIGNED_SHORT: 5123
};
var WEBGL_COMPONENT_TYPES = {
5120: Int8Array,
5121: Uint8Array,
5122: Int16Array,
5123: Uint16Array,
5125: Uint32Array,
5126: Float32Array
};
var WEBGL_FILTERS = {
9728: NearestFilter,
9729: LinearFilter,
9984: NearestMipmapNearestFilter,
9985: LinearMipmapNearestFilter,
9986: NearestMipmapLinearFilter,
9987: LinearMipmapLinearFilter
};
var WEBGL_WRAPPINGS = {
33071: ClampToEdgeWrapping,
33648: MirroredRepeatWrapping,
10497: RepeatWrapping
};
var WEBGL_TYPE_SIZES = {
'SCALAR': 1,
'VEC2': 2,
'VEC3': 3,
'VEC4': 4,
'MAT2': 4,
'MAT3': 9,
'MAT4': 16
};
var ATTRIBUTES = {
POSITION: 'position',
NORMAL: 'normal',
TANGENT: 'tangent',
TEXCOORD_0: 'uv',
TEXCOORD_1: 'uv2',
COLOR_0: 'color',
WEIGHTS_0: 'skinWeight',
JOINTS_0: 'skinIndex',
};
var PATH_PROPERTIES = {
scale: 'scale',
translation: 'position',
rotation: 'quaternion',
weights: 'morphTargetInfluences'
};
var INTERPOLATION = {
CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
// keyframe track will be initialized with a default interpolation type, then modified.
LINEAR: InterpolateLinear,
STEP: InterpolateDiscrete
};
var ALPHA_MODES = {
OPAQUE: 'OPAQUE',
MASK: 'MASK',
BLEND: 'BLEND'
};
var MIME_TYPE_FORMATS = {
'image/png': RGBAFormat,
'image/jpeg': RGBFormat
};
/* UTILITY FUNCTIONS */
function resolveURL( url, path ) {
// Invalid URL
if ( typeof url !== 'string' || url === '' ) return '';
// Host Relative URL
if ( /^https?:\/\//i.test( path ) && /^\//.test( url ) ) {
path = path.replace( /(^https?:\/\/[^\/]+).*/i, '$1' );
}
// Absolute URL http://,https://,//
if ( /^(https?:)?\/\//i.test( url ) ) return url;
// Data URI
if ( /^data:.*,.*$/i.test( url ) ) return url;
// Blob URL
if ( /^blob:.*$/i.test( url ) ) return url;
// Relative URL
return path + url;
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
*/
function createDefaultMaterial( cache ) {
if ( cache[ 'DefaultMaterial' ] === undefined ) {
cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {
color: 0xFFFFFF,
emissive: 0x000000,
metalness: 1,
roughness: 1,
transparent: false,
depthTest: true,
side: FrontSide
} );
}
return cache[ 'DefaultMaterial' ];
}
function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
// Add unknown glTF extensions to an object's userData.
for ( var name in objectDef.extensions ) {
if ( knownExtensions[ name ] === undefined ) {
object.userData.gltfExtensions = object.userData.gltfExtensions || {};
object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
}
}
}
/**
* @param {Object3D|Material|BufferGeometry} object
* @param {GLTF.definition} gltfDef
*/
function assignExtrasToUserData( object, gltfDef ) {
if ( gltfDef.extras !== undefined ) {
if ( typeof gltfDef.extras === 'object' ) {
Object.assign( object.userData, gltfDef.extras );
} else {
console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
}
}
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
*
* @param {BufferGeometry} geometry
* @param {Array<GLTF.Target>} targets
* @param {GLTFParser} parser
* @return {Promise<BufferGeometry>}
*/
function addMorphTargets( geometry, targets, parser ) {
var hasMorphPosition = false;
var hasMorphNormal = false;
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( target.POSITION !== undefined ) hasMorphPosition = true;
if ( target.NORMAL !== undefined ) hasMorphNormal = true;
if ( hasMorphPosition && hasMorphNormal ) break;
}
if ( ! hasMorphPosition && ! hasMorphNormal ) return Promise.resolve( geometry );
var pendingPositionAccessors = [];
var pendingNormalAccessors = [];
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( hasMorphPosition ) {
var pendingAccessor = target.POSITION !== undefined
? parser.getDependency( 'accessor', target.POSITION )
: geometry.attributes.position;
pendingPositionAccessors.push( pendingAccessor );
}
if ( hasMorphNormal ) {
var pendingAccessor = target.NORMAL !== undefined
? parser.getDependency( 'accessor', target.NORMAL )
: geometry.attributes.normal;
pendingNormalAccessors.push( pendingAccessor );
}
}
return Promise.all( [
Promise.all( pendingPositionAccessors ),
Promise.all( pendingNormalAccessors )
] ).then( function ( accessors ) {
var morphPositions = accessors[ 0 ];
var morphNormals = accessors[ 1 ];
if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
geometry.morphTargetsRelative = true;
return geometry;
} );
}
/**
* @param {Mesh} mesh
* @param {GLTF.Mesh} meshDef
*/
function updateMorphTargets( mesh, meshDef ) {
mesh.updateMorphTargets();
if ( meshDef.weights !== undefined ) {
for ( var i = 0, il = meshDef.weights.length; i < il; i ++ ) {
mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
}
}
// .extras has user-defined data, so check that .extras.targetNames is an array.
if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
var targetNames = meshDef.extras.targetNames;
if ( mesh.morphTargetInfluences.length === targetNames.length ) {
mesh.morphTargetDictionary = {};
for ( var i = 0, il = targetNames.length; i < il; i ++ ) {
mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
}
} else {
console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
}
}
}
function createPrimitiveKey( primitiveDef ) {
var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
var geometryKey;
if ( dracoExtension ) {
geometryKey = 'draco:' + dracoExtension.bufferView
+ ':' + dracoExtension.indices
+ ':' + createAttributesKey( dracoExtension.attributes );
} else {
geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
}
return geometryKey;
}
function createAttributesKey( attributes ) {
var attributesKey = '';
var keys = Object.keys( attributes ).sort();
for ( var i = 0, il = keys.length; i < il; i ++ ) {
attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
}
return attributesKey;
}
/* GLTF PARSER */
function GLTFParser( json, extensions, options ) {
this.json = json || {};
this.extensions = extensions || {};
this.options = options || {};
// loader object cache
this.cache = new GLTFRegistry();
// BufferGeometry caching
this.primitiveCache = {};
this.textureLoader = new TextureLoader( this.options.manager );
this.textureLoader.setCrossOrigin( this.options.crossOrigin );
this.fileLoader = new FileLoader( this.options.manager );
this.fileLoader.setResponseType( 'arraybuffer' );
if ( this.options.crossOrigin === 'use-credentials' ) {
this.fileLoader.setWithCredentials( true );
}
}
GLTFParser.prototype.parse = function ( onLoad, onError ) {
var parser = this;
var json = this.json;
var extensions = this.extensions;
// Clear the loader cache
this.cache.removeAll();
// Mark the special nodes/meshes in json for efficient parse
this.markDefs();
Promise.all( [
this.getDependencies( 'scene' ),
this.getDependencies( 'animation' ),
this.getDependencies( 'camera' ),
] ).then( function ( dependencies ) {
var result = {
scene: dependencies[ 0 ][ json.scene || 0 ],
scenes: dependencies[ 0 ],
animations: dependencies[ 1 ],
cameras: dependencies[ 2 ],
asset: json.asset,
parser: parser,
userData: {}
};
addUnknownExtensionsToUserData( extensions, result, json );
assignExtrasToUserData( result, json );
onLoad( result );
} ).catch( onError );
};
/**
* Marks the special nodes/meshes in json for efficient parse.
*/
GLTFParser.prototype.markDefs = function () {
var nodeDefs = this.json.nodes || [];
var skinDefs = this.json.skins || [];
var meshDefs = this.json.meshes || [];
var meshReferences = {};
var meshUses = {};
// Nothing in the node definition indicates whether it is a Bone or an
// Object3D. Use the skins' joint references to mark bones.
for ( var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
var joints = skinDefs[ skinIndex ].joints;
for ( var i = 0, il = joints.length; i < il; i ++ ) {
nodeDefs[ joints[ i ] ].isBone = true;
}
}
// Meshes can (and should) be reused by multiple nodes in a glTF asset. To
// avoid having more than one Mesh with the same name, count
// references and rename instances below.
//
// Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
for ( var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
var nodeDef = nodeDefs[ nodeIndex ];
if ( nodeDef.mesh !== undefined ) {
if ( meshReferences[ nodeDef.mesh ] === undefined ) {
meshReferences[ nodeDef.mesh ] = meshUses[ nodeDef.mesh ] = 0;
}
meshReferences[ nodeDef.mesh ] ++;
// Nothing in the mesh definition indicates whether it is
// a SkinnedMesh or Mesh. Use the node's mesh reference
// to mark SkinnedMesh if node has skin.
if ( nodeDef.skin !== undefined ) {
meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
}
}
}
this.json.meshReferences = meshReferences;
this.json.meshUses = meshUses;
};
/**
* Requests the specified dependency asynchronously, with caching.
* @param {string} type
* @param {number} index
* @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
*/
GLTFParser.prototype.getDependency = function ( type, index ) {
var cacheKey = type + ':' + index;
var dependency = this.cache.get( cacheKey );
if ( ! dependency ) {
switch ( type ) {
case 'scene':
dependency = this.loadScene( index );
break;
case 'node':
dependency = this.loadNode( index );
break;
case 'mesh':
dependency = this.loadMesh( index );
break;
case 'accessor':
dependency = this.loadAccessor( index );
break;
case 'bufferView':
dependency = this.loadBufferView( index );
break;
case 'buffer':
dependency = this.loadBuffer( index );
break;
case 'material':
dependency = this.loadMaterial( index );
break;
case 'texture':
dependency = this.loadTexture( index );
break;
case 'skin':
dependency = this.loadSkin( index );
break;
case 'animation':
dependency = this.loadAnimation( index );
break;
case 'camera':
dependency = this.loadCamera( index );
break;
case 'light':
dependency = this.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].loadLight( index );
break;
default:
throw new Error( 'Unknown type: ' + type );
}
this.cache.add( cacheKey, dependency );
}
return dependency;
};
/**
* Requests all dependencies of the specified type asynchronously, with caching.
* @param {string} type
* @return {Promise<Array<Object>>}
*/
GLTFParser.prototype.getDependencies = function ( type ) {
var dependencies = this.cache.get( type );
if ( ! dependencies ) {
var parser = this;
var defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
dependencies = Promise.all( defs.map( function ( def, index ) {
return parser.getDependency( type, index );
} ) );
this.cache.add( type, dependencies );
}
return dependencies;
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
* @param {number} bufferIndex
* @return {Promise<ArrayBuffer>}
*/
GLTFParser.prototype.loadBuffer = function ( bufferIndex ) {
var bufferDef = this.json.buffers[ bufferIndex ];
var loader = this.fileLoader;
if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
}
// If present, GLB container is required to be the first buffer.
if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
}
var options = this.options;
return new Promise( function ( resolve, reject ) {
loader.load( resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
} );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
* @param {number} bufferViewIndex
* @return {Promise<ArrayBuffer>}
*/
GLTFParser.prototype.loadBufferView = function ( bufferViewIndex ) {
var bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
var byteLength = bufferViewDef.byteLength || 0;
var byteOffset = bufferViewDef.byteOffset || 0;
return buffer.slice( byteOffset, byteOffset + byteLength );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
* @param {number} accessorIndex
* @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
*/
GLTFParser.prototype.loadAccessor = function ( accessorIndex ) {
var parser = this;
var json = this.json;
var accessorDef = this.json.accessors[ accessorIndex ];
if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
// Ignore empty accessors, which may be used to declare runtime
// information about attributes coming from another source (e.g. Draco
// compression extension).
return Promise.resolve( null );
}
var pendingBufferViews = [];
if ( accessorDef.bufferView !== undefined ) {
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
} else {
pendingBufferViews.push( null );
}
if ( accessorDef.sparse !== undefined ) {
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
}
return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
var bufferView = bufferViews[ 0 ];
var itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
var TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
// For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
var elementBytes = TypedArray.BYTES_PER_ELEMENT;
var itemBytes = elementBytes * itemSize;
var byteOffset = accessorDef.byteOffset || 0;
var byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
var normalized = accessorDef.normalized === true;
var array, bufferAttribute;
// The buffer is not interleaved if the stride is the item size in bytes.
if ( byteStride && byteStride !== itemBytes ) {
// Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
// This makes sure that IBA.count reflects accessor.count properly
var ibSlice = Math.floor( byteOffset / byteStride );
var ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
var ib = parser.cache.get( ibCacheKey );
if ( ! ib ) {
array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );
// Integer parameters to IB/IBA are in array elements, not bytes.
ib = new InterleavedBuffer( array, byteStride / elementBytes );
parser.cache.add( ibCacheKey, ib );
}
bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );
} else {
if ( bufferView === null ) {
array = new TypedArray( accessorDef.count * itemSize );
} else {
array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );
}
bufferAttribute = new BufferAttribute( array, itemSize, normalized );
}
// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
if ( accessorDef.sparse !== undefined ) {
var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
var TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];
var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
var sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
var sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );
if ( bufferView !== null ) {
// Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );
}
for ( var i = 0, il = sparseIndices.length; i < il; i ++ ) {
var index = sparseIndices[ i ];
bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );
}
}
return bufferAttribute;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
* @param {number} textureIndex
* @return {Promise<THREE.Texture>}
*/
GLTFParser.prototype.loadTexture = function ( textureIndex ) {
var parser = this;
var json = this.json;
var options = this.options;
var textureLoader = this.textureLoader;
var URL = self.URL || self.webkitURL;
var textureDef = json.textures[ textureIndex ];
var textureExtensions = textureDef.extensions || {};
var source;
if ( textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ] ) {
source = json.images[ textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].source ];
} else {
source = json.images[ textureDef.source ];
}
var sourceURI = source.uri;
var isObjectURL = false;
if ( source.bufferView !== undefined ) {
// Load binary image data from bufferView, if provided.
sourceURI = parser.getDependency( 'bufferView', source.bufferView ).then( function ( bufferView ) {
isObjectURL = true;
var blob = new Blob( [ bufferView ], { type: source.mimeType } );
sourceURI = URL.createObjectURL( blob );
return sourceURI;
} );
}
return Promise.resolve( sourceURI ).then( function ( sourceURI ) {
// Load Texture resource.
var loader = options.manager.getHandler( sourceURI );
if ( ! loader ) {
loader = textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ]
? parser.extensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].ddsLoader
: textureLoader;
}
return new Promise( function ( resolve, reject ) {
loader.load( resolveURL( sourceURI, options.path ), resolve, undefined, reject );
} );
} ).then( function ( texture ) {
// Clean up resources and configure Texture.
if ( isObjectURL === true ) {
URL.revokeObjectURL( sourceURI );
}
texture.flipY = false;
if ( textureDef.name ) texture.name = textureDef.name;
// Ignore unknown mime types, like DDS files.
if ( source.mimeType in MIME_TYPE_FORMATS ) {
texture.format = MIME_TYPE_FORMATS[ source.mimeType ];
}
var samplers = json.samplers || {};
var sampler = samplers[ textureDef.sampler ] || {};
texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
return texture;
} );
};
/**
* Asynchronously assigns a texture to the given material parameters.
* @param {Object} materialParams
* @param {string} mapName
* @param {Object} mapDef
* @return {Promise}
*/
GLTFParser.prototype.assignTexture = function ( materialParams, mapName, mapDef ) {
var parser = this;
return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
if ( ! texture.isCompressedTexture ) {
switch ( mapName ) {
case 'aoMap':
case 'emissiveMap':
case 'metalnessMap':
case 'normalMap':
case 'roughnessMap':
texture.format = RGBFormat;
break;
}
}
// Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
// However, we will copy UV set 0 to UV set 1 on demand for aoMap
if ( mapDef.texCoord !== undefined && mapDef.texCoord != 0 && ! ( mapName === 'aoMap' && mapDef.texCoord == 1 ) ) {
console.warn( 'THREE.GLTFLoader: Custom UV set ' + mapDef.texCoord + ' for texture ' + mapName + ' not yet supported.' );
}
if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {
var transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;
if ( transform ) {
texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
}
}
materialParams[ mapName ] = texture;
} );
};
/**
* Assigns final material to a Mesh, Line, or Points instance. The instance
* already has a material (generated from the glTF material options alone)
* but reuse of the same glTF material may require multiple threejs materials
* to accomodate different primitive types, defines, etc. New materials will
* be created if necessary, and reused from a cache.
* @param {Object3D} mesh Mesh, Line, or Points instance.
*/
GLTFParser.prototype.assignFinalMaterial = function ( mesh ) {
var geometry = mesh.geometry;
var material = mesh.material;
var useVertexTangents = geometry.attributes.tangent !== undefined;
var useVertexColors = geometry.attributes.color !== undefined;
var useFlatShading = geometry.attributes.normal === undefined;
var useSkinning = mesh.isSkinnedMesh === true;
var useMorphTargets = Object.keys( geometry.morphAttributes ).length > 0;
var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined;
if ( mesh.isPoints ) {
var cacheKey = 'PointsMaterial:' + material.uuid;
var pointsMaterial = this.cache.get( cacheKey );
if ( ! pointsMaterial ) {
pointsMaterial = new PointsMaterial();
Material.prototype.copy.call( pointsMaterial, material );
pointsMaterial.color.copy( material.color );
pointsMaterial.map = material.map;
pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px
this.cache.add( cacheKey, pointsMaterial );
}
material = pointsMaterial;
} else if ( mesh.isLine ) {
var cacheKey = 'LineBasicMaterial:' + material.uuid;
var lineMaterial = this.cache.get( cacheKey );
if ( ! lineMaterial ) {
lineMaterial = new LineBasicMaterial();
Material.prototype.copy.call( lineMaterial, material );
lineMaterial.color.copy( material.color );
this.cache.add( cacheKey, lineMaterial );
}
material = lineMaterial;
}
// Clone the material if it will be modified
if ( useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets ) {
var cacheKey = 'ClonedMaterial:' + material.uuid + ':';
if ( material.isGLTFSpecularGlossinessMaterial ) cacheKey += 'specular-glossiness:';
if ( useSkinning ) cacheKey += 'skinning:';
if ( useVertexTangents ) cacheKey += 'vertex-tangents:';
if ( useVertexColors ) cacheKey += 'vertex-colors:';
if ( useFlatShading ) cacheKey += 'flat-shading:';
if ( useMorphTargets ) cacheKey += 'morph-targets:';
if ( useMorphNormals ) cacheKey += 'morph-normals:';
var cachedMaterial = this.cache.get( cacheKey );
if ( ! cachedMaterial ) {
cachedMaterial = material.clone();
if ( useSkinning ) cachedMaterial.skinning = true;
if ( useVertexTangents ) cachedMaterial.vertexTangents = true;
if ( useVertexColors ) cachedMaterial.vertexColors = true;
if ( useFlatShading ) cachedMaterial.flatShading = true;
if ( useMorphTargets ) cachedMaterial.morphTargets = true;
if ( useMorphNormals ) cachedMaterial.morphNormals = true;
this.cache.add( cacheKey, cachedMaterial );
}
material = cachedMaterial;
}
// workarounds for mesh and geometry
if ( material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined ) {
geometry.setAttribute( 'uv2', geometry.attributes.uv );
}
// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
if ( material.normalScale && ! useVertexTangents ) {
material.normalScale.y = - material.normalScale.y;
}
if ( material.clearcoatNormalScale && ! useVertexTangents ) {
material.clearcoatNormalScale.y = - material.clearcoatNormalScale.y;
}
mesh.material = material;
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
* @param {number} materialIndex
* @return {Promise<Material>}
*/
GLTFParser.prototype.loadMaterial = function ( materialIndex ) {
var parser = this;
var json = this.json;
var extensions = this.extensions;
var materialDef = json.materials[ materialIndex ];
var materialType;
var materialParams = {};
var materialExtensions = materialDef.extensions || {};
var pending = [];
if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ] ) {
var sgExtension = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ];
materialType = sgExtension.getMaterialType();
pending.push( sgExtension.extendParams( materialParams, materialDef, parser ) );
} else if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {
var kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
materialType = kmuExtension.getMaterialType();
pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );
} else {
// Specification:
// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material
materialType = MeshStandardMaterial;
var metallicRoughness = materialDef.pbrMetallicRoughness || {};
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
var array = metallicRoughness.baseColorFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( metallicRoughness.baseColorTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
}
materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );
}
}
if ( materialDef.doubleSided === true ) {
materialParams.side = DoubleSide;
}
var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
if ( alphaMode === ALPHA_MODES.BLEND ) {
materialParams.transparent = true;
// See: https://github.com/mrdoob/three.js/issues/17706
materialParams.depthWrite = false;
} else {
materialParams.transparent = false;
if ( alphaMode === ALPHA_MODES.MASK ) {
materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
}
}
if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );
materialParams.normalScale = new Vector2( 1, 1 );
if ( materialDef.normalTexture.scale !== undefined ) {
materialParams.normalScale.set( materialDef.normalTexture.scale, materialDef.normalTexture.scale );
}
}
if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );
if ( materialDef.occlusionTexture.strength !== undefined ) {
materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
}
}
if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {
materialParams.emissive = new Color().fromArray( materialDef.emissiveFactor );
}
if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture ) );
}
if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_CLEARCOAT ] ) {
var clearcoatExtension = extensions[ EXTENSIONS.KHR_MATERIALS_CLEARCOAT ];
materialType = clearcoatExtension.getMaterialType();
pending.push( clearcoatExtension.extendParams( materialParams, { extensions: materialExtensions }, parser ) );
}
return Promise.all( pending ).then( function () {
var material;
if ( materialType === GLTFMeshStandardSGMaterial ) {
material = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].createMaterial( materialParams );
} else {
material = new materialType( materialParams );
}
if ( materialDef.name ) material.name = materialDef.name;
// baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
if ( material.map ) material.map.encoding = sRGBEncoding;
if ( material.emissiveMap ) material.emissiveMap.encoding = sRGBEncoding;
assignExtrasToUserData( material, materialDef );
if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );
return material;
} );
};
/**
* @param {BufferGeometry} geometry
* @param {GLTF.Primitive} primitiveDef
* @param {GLTFParser} parser
*/
function computeBounds( geometry, primitiveDef, parser ) {
var attributes = primitiveDef.attributes;
var box = new Box3();
if ( attributes.POSITION !== undefined ) {
var accessor = parser.json.accessors[ attributes.POSITION ];
var min = accessor.min;
var max = accessor.max;
// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
if ( min !== undefined && max !== undefined ) {
box.set(
new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),
new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] ) );
} else {
console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
return;
}
} else {
return;
}
var targets = primitiveDef.targets;
if ( targets !== undefined ) {
var maxDisplacement = new Vector3();
var vector = new Vector3();
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( target.POSITION !== undefined ) {
var accessor = parser.json.accessors[ target.POSITION ];
var min = accessor.min;
var max = accessor.max;
// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
if ( min !== undefined && max !== undefined ) {
// we need to get max of absolute components because target weight is [-1,1]
vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );
vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );
vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );
// Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
// to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
// are used to implement key-frame animations and as such only two are active at a time - this results in very large
// boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
maxDisplacement.max( vector );
} else {
console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
}
}
}
// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
box.expandByVector( maxDisplacement );
}
geometry.boundingBox = box;
var sphere = new Sphere();
box.getCenter( sphere.center );
sphere.radius = box.min.distanceTo( box.max ) / 2;
geometry.boundingSphere = sphere;
}
/**
* @param {BufferGeometry} geometry
* @param {GLTF.Primitive} primitiveDef
* @param {GLTFParser} parser
* @return {Promise<BufferGeometry>}
*/
function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
var attributes = primitiveDef.attributes;
var pending = [];
function assignAttributeAccessor( accessorIndex, attributeName ) {
return parser.getDependency( 'accessor', accessorIndex )
.then( function ( accessor ) {
geometry.setAttribute( attributeName, accessor );
} );
}
for ( var gltfAttributeName in attributes ) {
var threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
// Skip attributes already provided by e.g. Draco extension.
if ( threeAttributeName in geometry.attributes ) continue;
pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
}
if ( primitiveDef.indices !== undefined && ! geometry.index ) {
var accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
geometry.setIndex( accessor );
} );
pending.push( accessor );
}
assignExtrasToUserData( geometry, primitiveDef );
computeBounds( geometry, primitiveDef, parser );
return Promise.all( pending ).then( function () {
return primitiveDef.targets !== undefined
? addMorphTargets( geometry, primitiveDef.targets, parser )
: geometry;
} );
}
/**
* @param {BufferGeometry} geometry
* @param {Number} drawMode
* @return {BufferGeometry}
*/
function toTrianglesDrawMode( geometry, drawMode ) {
var index = geometry.getIndex();
// generate index if not present
if ( index === null ) {
var indices = [];
var position = geometry.getAttribute( 'position' );
if ( position !== undefined ) {
for ( var i = 0; i < position.count; i ++ ) {
indices.push( i );
}
geometry.setIndex( indices );
index = geometry.getIndex();
} else {
console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
return geometry;
}
}
//
var numberOfTriangles = index.count - 2;
var newIndices = [];
if ( drawMode === TriangleFanDrawMode ) {
// gl.TRIANGLE_FAN
for ( var i = 1; i <= numberOfTriangles; i ++ ) {
newIndices.push( index.getX( 0 ) );
newIndices.push( index.getX( i ) );
newIndices.push( index.getX( i + 1 ) );
}
} else {
// gl.TRIANGLE_STRIP
for ( var i = 0; i < numberOfTriangles; i ++ ) {
if ( i % 2 === 0 ) {
newIndices.push( index.getX( i ) );
newIndices.push( index.getX( i + 1 ) );
newIndices.push( index.getX( i + 2 ) );
} else {
newIndices.push( index.getX( i + 2 ) );
newIndices.push( index.getX( i + 1 ) );
newIndices.push( index.getX( i ) );
}
}
}
if ( ( newIndices.length / 3 ) !== numberOfTriangles ) {
console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
}
// build final geometry
var newGeometry = geometry.clone();
newGeometry.setIndex( newIndices );
return newGeometry;
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
*
* Creates BufferGeometries from primitives.
*
* @param {Array<GLTF.Primitive>} primitives
* @return {Promise<Array<BufferGeometry>>}
*/
GLTFParser.prototype.loadGeometries = function ( primitives ) {
var parser = this;
var extensions = this.extensions;
var cache = this.primitiveCache;
function createDracoPrimitive( primitive ) {
return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
.decodePrimitive( primitive, parser )
.then( function ( geometry ) {
return addPrimitiveAttributes( geometry, primitive, parser );
} );
}
var pending = [];
for ( var i = 0, il = primitives.length; i < il; i ++ ) {
var primitive = primitives[ i ];
var cacheKey = createPrimitiveKey( primitive );
// See if we've already created this geometry
var cached = cache[ cacheKey ];
if ( cached ) {
// Use the cached geometry if it exists
pending.push( cached.promise );
} else {
var geometryPromise;
if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {
// Use DRACO geometry if available
geometryPromise = createDracoPrimitive( primitive );
} else {
// Otherwise create a new geometry
geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );
}
// Cache this geometry
cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };
pending.push( geometryPromise );
}
}
return Promise.all( pending );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
* @param {number} meshIndex
* @return {Promise<Group|Mesh|SkinnedMesh>}
*/
GLTFParser.prototype.loadMesh = function ( meshIndex ) {
var parser = this;
var json = this.json;
var meshDef = json.meshes[ meshIndex ];
var primitives = meshDef.primitives;
var pending = [];
for ( var i = 0, il = primitives.length; i < il; i ++ ) {
var material = primitives[ i ].material === undefined
? createDefaultMaterial( this.cache )
: this.getDependency( 'material', primitives[ i ].material );
pending.push( material );
}
pending.push( parser.loadGeometries( primitives ) );
return Promise.all( pending ).then( function ( results ) {
var materials = results.slice( 0, results.length - 1 );
var geometries = results[ results.length - 1 ];
var meshes = [];
for ( var i = 0, il = geometries.length; i < il; i ++ ) {
var geometry = geometries[ i ];
var primitive = primitives[ i ];
// 1. create Mesh
var mesh;
var material = materials[ i ];
if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
primitive.mode === undefined ) {
// .isSkinnedMesh isn't in glTF spec. See .markDefs()
mesh = meshDef.isSkinnedMesh === true
? new SkinnedMesh( geometry, material )
: new Mesh( geometry, material );
if ( mesh.isSkinnedMesh === true && ! mesh.geometry.attributes.skinWeight.normalized ) {
// we normalize floating point skin weight array to fix malformed assets (see #15319)
// it's important to skip this for non-float32 data since normalizeSkinWeights assumes non-normalized inputs
mesh.normalizeSkinWeights();
}
if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {
mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );
} else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {
mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );
}
} else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {
mesh = new LineSegments( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {
mesh = new Line( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {
mesh = new LineLoop( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {
mesh = new Points( geometry, material );
} else {
throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );
}
if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {
updateMorphTargets( mesh, meshDef );
}
mesh.name = meshDef.name || ( 'mesh_' + meshIndex );
if ( geometries.length > 1 ) mesh.name += '_' + i;
assignExtrasToUserData( mesh, meshDef );
parser.assignFinalMaterial( mesh );
meshes.push( mesh );
}
if ( meshes.length === 1 ) {
return meshes[ 0 ];
}
var group = new Group();
for ( var i = 0, il = meshes.length; i < il; i ++ ) {
group.add( meshes[ i ] );
}
return group;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
* @param {number} cameraIndex
* @return {Promise<THREE.Camera>}
*/
GLTFParser.prototype.loadCamera = function ( cameraIndex ) {
var camera;
var cameraDef = this.json.cameras[ cameraIndex ];
var params = cameraDef[ cameraDef.type ];
if ( ! params ) {
console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
return;
}
if ( cameraDef.type === 'perspective' ) {
camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );
} else if ( cameraDef.type === 'orthographic' ) {
camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );
}
if ( cameraDef.name ) camera.name = cameraDef.name;
assignExtrasToUserData( camera, cameraDef );
return Promise.resolve( camera );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
* @param {number} skinIndex
* @return {Promise<Object>}
*/
GLTFParser.prototype.loadSkin = function ( skinIndex ) {
var skinDef = this.json.skins[ skinIndex ];
var skinEntry = { joints: skinDef.joints };
if ( skinDef.inverseBindMatrices === undefined ) {
return Promise.resolve( skinEntry );
}
return this.getDependency( 'accessor', skinDef.inverseBindMatrices ).then( function ( accessor ) {
skinEntry.inverseBindMatrices = accessor;
return skinEntry;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
* @param {number} animationIndex
* @return {Promise<AnimationClip>}
*/
GLTFParser.prototype.loadAnimation = function ( animationIndex ) {
var json = this.json;
var animationDef = json.animations[ animationIndex ];
var pendingNodes = [];
var pendingInputAccessors = [];
var pendingOutputAccessors = [];
var pendingSamplers = [];
var pendingTargets = [];
for ( var i = 0, il = animationDef.channels.length; i < il; i ++ ) {
var channel = animationDef.channels[ i ];
var sampler = animationDef.samplers[ channel.sampler ];
var target = channel.target;
var name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
var input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
var output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
pendingNodes.push( this.getDependency( 'node', name ) );
pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
pendingSamplers.push( sampler );
pendingTargets.push( target );
}
return Promise.all( [
Promise.all( pendingNodes ),
Promise.all( pendingInputAccessors ),
Promise.all( pendingOutputAccessors ),
Promise.all( pendingSamplers ),
Promise.all( pendingTargets )
] ).then( function ( dependencies ) {
var nodes = dependencies[ 0 ];
var inputAccessors = dependencies[ 1 ];
var outputAccessors = dependencies[ 2 ];
var samplers = dependencies[ 3 ];
var targets = dependencies[ 4 ];
var tracks = [];
for ( var i = 0, il = nodes.length; i < il; i ++ ) {
var node = nodes[ i ];
var inputAccessor = inputAccessors[ i ];
var outputAccessor = outputAccessors[ i ];
var sampler = samplers[ i ];
var target = targets[ i ];
if ( node === undefined ) continue;
node.updateMatrix();
node.matrixAutoUpdate = true;
var TypedKeyframeTrack;
switch ( PATH_PROPERTIES[ target.path ] ) {
case PATH_PROPERTIES.weights:
TypedKeyframeTrack = NumberKeyframeTrack;
break;
case PATH_PROPERTIES.rotation:
TypedKeyframeTrack = QuaternionKeyframeTrack;
break;
case PATH_PROPERTIES.position:
case PATH_PROPERTIES.scale:
default:
TypedKeyframeTrack = VectorKeyframeTrack;
break;
}
var targetName = node.name ? node.name : node.uuid;
var interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
var targetNames = [];
if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {
// Node may be a Group (glTF mesh with several primitives) or a Mesh.
node.traverse( function ( object ) {
if ( object.isMesh === true && object.morphTargetInfluences ) {
targetNames.push( object.name ? object.name : object.uuid );
}
} );
} else {
targetNames.push( targetName );
}
var outputArray = outputAccessor.array;
if ( outputAccessor.normalized ) {
var scale;
if ( outputArray.constructor === Int8Array ) {
scale = 1 / 127;
} else if ( outputArray.constructor === Uint8Array ) {
scale = 1 / 255;
} else if ( outputArray.constructor == Int16Array ) {
scale = 1 / 32767;
} else if ( outputArray.constructor === Uint16Array ) {
scale = 1 / 65535;
} else {
throw new Error( 'THREE.GLTFLoader: Unsupported output accessor component type.' );
}
var scaled = new Float32Array( outputArray.length );
for ( var j = 0, jl = outputArray.length; j < jl; j ++ ) {
scaled[ j ] = outputArray[ j ] * scale;
}
outputArray = scaled;
}
for ( var j = 0, jl = targetNames.length; j < jl; j ++ ) {
var track = new TypedKeyframeTrack(
targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
inputAccessor.array,
outputArray,
interpolation
);
// Override interpolation with custom factory method.
if ( sampler.interpolation === 'CUBICSPLINE' ) {
track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
// A CUBICSPLINE keyframe in glTF has three output values for each input value,
// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
// must be divided by three to get the interpolant's sampleSize argument.
return new GLTFCubicSplineInterpolant( this.times, this.values, this.getValueSize() / 3, result );
};
// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
}
tracks.push( track );
}
}
var name = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
return new AnimationClip( name, undefined, tracks );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
* @param {number} nodeIndex
* @return {Promise<Object3D>}
*/
GLTFParser.prototype.loadNode = function ( nodeIndex ) {
var json = this.json;
var extensions = this.extensions;
var parser = this;
var meshReferences = json.meshReferences;
var meshUses = json.meshUses;
var nodeDef = json.nodes[ nodeIndex ];
return ( function () {
var pending = [];
if ( nodeDef.mesh !== undefined ) {
pending.push( parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {
var node;
if ( meshReferences[ nodeDef.mesh ] > 1 ) {
var instanceNum = meshUses[ nodeDef.mesh ] ++;
node = mesh.clone();
node.name += '_instance_' + instanceNum;
} else {
node = mesh;
}
// if weights are provided on the node, override weights on the mesh.
if ( nodeDef.weights !== undefined ) {
node.traverse( function ( o ) {
if ( ! o.isMesh ) return;
for ( var i = 0, il = nodeDef.weights.length; i < il; i ++ ) {
o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];
}
} );
}
return node;
} ) );
}
if ( nodeDef.camera !== undefined ) {
pending.push( parser.getDependency( 'camera', nodeDef.camera ) );
}
if ( nodeDef.extensions
&& nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ]
&& nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light !== undefined ) {
pending.push( parser.getDependency( 'light', nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light ) );
}
return Promise.all( pending );
}() ).then( function ( objects ) {
var node;
// .isBone isn't in glTF spec. See .markDefs
if ( nodeDef.isBone === true ) {
node = new Bone();
} else if ( objects.length > 1 ) {
node = new Group();
} else if ( objects.length === 1 ) {
node = objects[ 0 ];
} else {
node = new Object3D();
}
if ( node !== objects[ 0 ] ) {
for ( var i = 0, il = objects.length; i < il; i ++ ) {
node.add( objects[ i ] );
}
}
if ( nodeDef.name ) {
node.userData.name = nodeDef.name;
node.name = PropertyBinding.sanitizeNodeName( nodeDef.name );
}
assignExtrasToUserData( node, nodeDef );
if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );
if ( nodeDef.matrix !== undefined ) {
var matrix = new Matrix4();
matrix.fromArray( nodeDef.matrix );
node.applyMatrix4( matrix );
} else {
if ( nodeDef.translation !== undefined ) {
node.position.fromArray( nodeDef.translation );
}
if ( nodeDef.rotation !== undefined ) {
node.quaternion.fromArray( nodeDef.rotation );
}
if ( nodeDef.scale !== undefined ) {
node.scale.fromArray( nodeDef.scale );
}
}
return node;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
* @param {number} sceneIndex
* @return {Promise<Group>}
*/
GLTFParser.prototype.loadScene = function () {
// scene node hierachy builder
function buildNodeHierachy( nodeId, parentObject, json, parser ) {
var nodeDef = json.nodes[ nodeId ];
return parser.getDependency( 'node', nodeId ).then( function ( node ) {
if ( nodeDef.skin === undefined ) return node;
// build skeleton here as well
var skinEntry;
return parser.getDependency( 'skin', nodeDef.skin ).then( function ( skin ) {
skinEntry = skin;
var pendingJoints = [];
for ( var i = 0, il = skinEntry.joints.length; i < il; i ++ ) {
pendingJoints.push( parser.getDependency( 'node', skinEntry.joints[ i ] ) );
}
return Promise.all( pendingJoints );
} ).then( function ( jointNodes ) {
node.traverse( function ( mesh ) {
if ( ! mesh.isMesh ) return;
var bones = [];
var boneInverses = [];
for ( var j = 0, jl = jointNodes.length; j < jl; j ++ ) {
var jointNode = jointNodes[ j ];
if ( jointNode ) {
bones.push( jointNode );
var mat = new Matrix4();
if ( skinEntry.inverseBindMatrices !== undefined ) {
mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );
}
boneInverses.push( mat );
} else {
console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[ j ] );
}
}
mesh.bind( new Skeleton( bones, boneInverses ), mesh.matrixWorld );
} );
return node;
} );
} ).then( function ( node ) {
// build node hierachy
parentObject.add( node );
var pending = [];
if ( nodeDef.children ) {
var children = nodeDef.children;
for ( var i = 0, il = children.length; i < il; i ++ ) {
var child = children[ i ];
pending.push( buildNodeHierachy( child, node, json, parser ) );
}
}
return Promise.all( pending );
} );
}
return function loadScene( sceneIndex ) {
var json = this.json;
var extensions = this.extensions;
var sceneDef = this.json.scenes[ sceneIndex ];
var parser = this;
// Loader returns Group, not Scene.
// See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
var scene = new Group();
if ( sceneDef.name ) scene.name = sceneDef.name;
assignExtrasToUserData( scene, sceneDef );
if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );
var nodeIds = sceneDef.nodes || [];
var pending = [];
for ( var i = 0, il = nodeIds.length; i < il; i ++ ) {
pending.push( buildNodeHierachy( nodeIds[ i ], scene, json, parser ) );
}
return Promise.all( pending ).then( function () {
return scene;
} );
};
}();
return GLTFLoader;
} )()
Example #3
| Source File: GLTFLoader.js From FirstPersonCameraControl with MIT License | 4 votes |
|
GLTFLoader = ( function () {
function GLTFLoader( manager ) {
Loader.call( this, manager );
this.dracoLoader = null;
this.ddsLoader = null;
}
GLTFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
constructor: GLTFLoader,
load: function ( url, onLoad, onProgress, onError ) {
var scope = this;
var resourcePath;
if ( this.resourcePath !== '' ) {
resourcePath = this.resourcePath;
} else if ( this.path !== '' ) {
resourcePath = this.path;
} else {
resourcePath = LoaderUtils.extractUrlBase( url );
}
// Tells the LoadingManager to track an extra item, which resolves after
// the model is fully loaded. This means the count of items loaded will
// be incorrect, but ensures manager.onLoad() does not fire early.
scope.manager.itemStart( url );
var _onError = function ( e ) {
if ( onError ) {
onError( e );
} else {
console.error( e );
}
scope.manager.itemError( url );
scope.manager.itemEnd( url );
};
var loader = new FileLoader( scope.manager );
loader.setPath( this.path );
loader.setResponseType( 'arraybuffer' );
if ( scope.crossOrigin === 'use-credentials' ) {
loader.setWithCredentials( true );
}
loader.load( url, function ( data ) {
try {
scope.parse( data, resourcePath, function ( gltf ) {
onLoad( gltf );
scope.manager.itemEnd( url );
}, _onError );
} catch ( e ) {
_onError( e );
}
}, onProgress, _onError );
},
setDRACOLoader: function ( dracoLoader ) {
this.dracoLoader = dracoLoader;
return this;
},
setDDSLoader: function ( ddsLoader ) {
this.ddsLoader = ddsLoader;
return this;
},
parse: function ( data, path, onLoad, onError ) {
var content;
var extensions = {};
if ( typeof data === 'string' ) {
content = data;
} else {
var magic = LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
try {
extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
} catch ( error ) {
if ( onError ) onError( error );
return;
}
content = extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content;
} else {
content = LoaderUtils.decodeText( new Uint8Array( data ) );
}
}
var json = JSON.parse( content );
if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
return;
}
if ( json.extensionsUsed ) {
for ( var i = 0; i < json.extensionsUsed.length; ++ i ) {
var extensionName = json.extensionsUsed[ i ];
var extensionsRequired = json.extensionsRequired || [];
switch ( extensionName ) {
case EXTENSIONS.KHR_LIGHTS_PUNCTUAL:
extensions[ extensionName ] = new GLTFLightsExtension( json );
break;
case EXTENSIONS.KHR_MATERIALS_CLEARCOAT:
extensions[ extensionName ] = new GLTFMaterialsClearcoatExtension();
break;
case EXTENSIONS.KHR_MATERIALS_UNLIT:
extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
break;
case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
extensions[ extensionName ] = new GLTFMaterialsPbrSpecularGlossinessExtension();
break;
case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
break;
case EXTENSIONS.MSFT_TEXTURE_DDS:
extensions[ extensionName ] = new GLTFTextureDDSExtension( this.ddsLoader );
break;
case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
extensions[ extensionName ] = new GLTFTextureTransformExtension();
break;
case EXTENSIONS.KHR_MESH_QUANTIZATION:
extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
break;
default:
if ( extensionsRequired.indexOf( extensionName ) >= 0 ) {
console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
}
}
}
}
var parser = new GLTFParser( json, extensions, {
path: path || this.resourcePath || '',
crossOrigin: this.crossOrigin,
manager: this.manager
} );
parser.parse( onLoad, onError );
}
} );
/* GLTFREGISTRY */
function GLTFRegistry() {
var objects = {};
return {
get: function ( key ) {
return objects[ key ];
},
add: function ( key, object ) {
objects[ key ] = object;
},
remove: function ( key ) {
delete objects[ key ];
},
removeAll: function () {
objects = {};
}
};
}
/*********************************/
/********** EXTENSIONS ***********/
/*********************************/
var EXTENSIONS = {
KHR_BINARY_GLTF: 'KHR_binary_glTF',
KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
MSFT_TEXTURE_DDS: 'MSFT_texture_dds'
};
/**
* DDS Texture Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds
*
*/
function GLTFTextureDDSExtension( ddsLoader ) {
if ( ! ddsLoader ) {
throw new Error( 'THREE.GLTFLoader: Attempting to load .dds texture without importing DDSLoader' );
}
this.name = EXTENSIONS.MSFT_TEXTURE_DDS;
this.ddsLoader = ddsLoader;
}
/**
* Punctual Lights Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
*/
function GLTFLightsExtension( json ) {
this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
var extension = ( json.extensions && json.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ] ) || {};
this.lightDefs = extension.lights || [];
}
GLTFLightsExtension.prototype.loadLight = function ( lightIndex ) {
var lightDef = this.lightDefs[ lightIndex ];
var lightNode;
var color = new Color( 0xffffff );
if ( lightDef.color !== undefined ) color.fromArray( lightDef.color );
var range = lightDef.range !== undefined ? lightDef.range : 0;
switch ( lightDef.type ) {
case 'directional':
lightNode = new DirectionalLight( color );
lightNode.target.position.set( 0, 0, - 1 );
lightNode.add( lightNode.target );
break;
case 'point':
lightNode = new PointLight( color );
lightNode.distance = range;
break;
case 'spot':
lightNode = new SpotLight( color );
lightNode.distance = range;
// Handle spotlight properties.
lightDef.spot = lightDef.spot || {};
lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
lightNode.angle = lightDef.spot.outerConeAngle;
lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
lightNode.target.position.set( 0, 0, - 1 );
lightNode.add( lightNode.target );
break;
default:
throw new Error( 'THREE.GLTFLoader: Unexpected light type, "' + lightDef.type + '".' );
}
// Some lights (e.g. spot) default to a position other than the origin. Reset the position
// here, because node-level parsing will only override position if explicitly specified.
lightNode.position.set( 0, 0, 0 );
lightNode.decay = 2;
if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
lightNode.name = lightDef.name || ( 'light_' + lightIndex );
return Promise.resolve( lightNode );
};
/**
* Unlit Materials Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
*/
function GLTFMaterialsUnlitExtension() {
this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
}
GLTFMaterialsUnlitExtension.prototype.getMaterialType = function () {
return MeshBasicMaterial;
};
GLTFMaterialsUnlitExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
var pending = [];
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
var metallicRoughness = materialDef.pbrMetallicRoughness;
if ( metallicRoughness ) {
if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
var array = metallicRoughness.baseColorFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( metallicRoughness.baseColorTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
}
}
return Promise.all( pending );
};
/**
* Clearcoat Materials Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
*/
function GLTFMaterialsClearcoatExtension() {
this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
}
GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function () {
return MeshPhysicalMaterial;
};
GLTFMaterialsClearcoatExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
var pending = [];
var extension = materialDef.extensions[ this.name ];
if ( extension.clearcoatFactor !== undefined ) {
materialParams.clearcoat = extension.clearcoatFactor;
}
if ( extension.clearcoatTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );
}
if ( extension.clearcoatRoughnessFactor !== undefined ) {
materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
}
if ( extension.clearcoatRoughnessTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );
}
if ( extension.clearcoatNormalTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );
if ( extension.clearcoatNormalTexture.scale !== undefined ) {
var scale = extension.clearcoatNormalTexture.scale;
materialParams.clearcoatNormalScale = new Vector2( scale, scale );
}
}
return Promise.all( pending );
};
/* BINARY EXTENSION */
var BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
var BINARY_EXTENSION_HEADER_LENGTH = 12;
var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };
function GLTFBinaryExtension( data ) {
this.name = EXTENSIONS.KHR_BINARY_GLTF;
this.content = null;
this.body = null;
var headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
this.header = {
magic: LoaderUtils.decodeText( new Uint8Array( data.slice( 0, 4 ) ) ),
version: headerView.getUint32( 4, true ),
length: headerView.getUint32( 8, true )
};
if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {
throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );
} else if ( this.header.version < 2.0 ) {
throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );
}
var chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
var chunkIndex = 0;
while ( chunkIndex < chunkView.byteLength ) {
var chunkLength = chunkView.getUint32( chunkIndex, true );
chunkIndex += 4;
var chunkType = chunkView.getUint32( chunkIndex, true );
chunkIndex += 4;
if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
var contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
this.content = LoaderUtils.decodeText( contentArray );
} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
this.body = data.slice( byteOffset, byteOffset + chunkLength );
}
// Clients must ignore chunks with unknown types.
chunkIndex += chunkLength;
}
if ( this.content === null ) {
throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
}
}
/**
* DRACO Mesh Compression Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
*/
function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
if ( ! dracoLoader ) {
throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
}
this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
this.json = json;
this.dracoLoader = dracoLoader;
this.dracoLoader.preload();
}
GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function ( primitive, parser ) {
var json = this.json;
var dracoLoader = this.dracoLoader;
var bufferViewIndex = primitive.extensions[ this.name ].bufferView;
var gltfAttributeMap = primitive.extensions[ this.name ].attributes;
var threeAttributeMap = {};
var attributeNormalizedMap = {};
var attributeTypeMap = {};
for ( var attributeName in gltfAttributeMap ) {
var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
}
for ( attributeName in primitive.attributes ) {
var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
if ( gltfAttributeMap[ attributeName ] !== undefined ) {
var accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
var componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
attributeTypeMap[ threeAttributeName ] = componentType;
attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
}
}
return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
return new Promise( function ( resolve ) {
dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
for ( var attributeName in geometry.attributes ) {
var attribute = geometry.attributes[ attributeName ];
var normalized = attributeNormalizedMap[ attributeName ];
if ( normalized !== undefined ) attribute.normalized = normalized;
}
resolve( geometry );
}, threeAttributeMap, attributeTypeMap );
} );
} );
};
/**
* Texture Transform Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
*/
function GLTFTextureTransformExtension() {
this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
}
GLTFTextureTransformExtension.prototype.extendTexture = function ( texture, transform ) {
texture = texture.clone();
if ( transform.offset !== undefined ) {
texture.offset.fromArray( transform.offset );
}
if ( transform.rotation !== undefined ) {
texture.rotation = transform.rotation;
}
if ( transform.scale !== undefined ) {
texture.repeat.fromArray( transform.scale );
}
if ( transform.texCoord !== undefined ) {
console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
}
texture.needsUpdate = true;
return texture;
};
/**
* Specular-Glossiness Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
*/
/**
* A sub class of StandardMaterial with some of the functionality
* changed via the `onBeforeCompile` callback
* @pailhead
*/
function GLTFMeshStandardSGMaterial( params ) {
MeshStandardMaterial.call( this );
this.isGLTFSpecularGlossinessMaterial = true;
//various chunks that need replacing
var specularMapParsFragmentChunk = [
'#ifdef USE_SPECULARMAP',
' uniform sampler2D specularMap;',
'#endif'
].join( '\n' );
var glossinessMapParsFragmentChunk = [
'#ifdef USE_GLOSSINESSMAP',
' uniform sampler2D glossinessMap;',
'#endif'
].join( '\n' );
var specularMapFragmentChunk = [
'vec3 specularFactor = specular;',
'#ifdef USE_SPECULARMAP',
' vec4 texelSpecular = texture2D( specularMap, vUv );',
' texelSpecular = sRGBToLinear( texelSpecular );',
' // reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture',
' specularFactor *= texelSpecular.rgb;',
'#endif'
].join( '\n' );
var glossinessMapFragmentChunk = [
'float glossinessFactor = glossiness;',
'#ifdef USE_GLOSSINESSMAP',
' vec4 texelGlossiness = texture2D( glossinessMap, vUv );',
' // reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture',
' glossinessFactor *= texelGlossiness.a;',
'#endif'
].join( '\n' );
var lightPhysicalFragmentChunk = [
'PhysicalMaterial material;',
'material.diffuseColor = diffuseColor.rgb;',
'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );',
'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );',
'material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 );// 0.0525 corresponds to the base mip of a 256 cubemap.',
'material.specularRoughness += geometryRoughness;',
'material.specularRoughness = min( material.specularRoughness, 1.0 );',
'material.specularColor = specularFactor.rgb;',
].join( '\n' );
var uniforms = {
specular: { value: new Color().setHex( 0xffffff ) },
glossiness: { value: 1 },
specularMap: { value: null },
glossinessMap: { value: null }
};
this._extraUniforms = uniforms;
// please see #14031 or #13198 for an alternate approach
this.onBeforeCompile = function ( shader ) {
for ( var uniformName in uniforms ) {
shader.uniforms[ uniformName ] = uniforms[ uniformName ];
}
shader.fragmentShader = shader.fragmentShader.replace( 'uniform float roughness;', 'uniform vec3 specular;' );
shader.fragmentShader = shader.fragmentShader.replace( 'uniform float metalness;', 'uniform float glossiness;' );
shader.fragmentShader = shader.fragmentShader.replace( '#include <roughnessmap_pars_fragment>', specularMapParsFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <metalnessmap_pars_fragment>', glossinessMapParsFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <roughnessmap_fragment>', specularMapFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <metalnessmap_fragment>', glossinessMapFragmentChunk );
shader.fragmentShader = shader.fragmentShader.replace( '#include <lights_physical_fragment>', lightPhysicalFragmentChunk );
};
/*eslint-disable*/
Object.defineProperties(
this,
{
specular: {
get: function () { return uniforms.specular.value; },
set: function ( v ) { uniforms.specular.value = v; }
},
specularMap: {
get: function () { return uniforms.specularMap.value; },
set: function ( v ) { uniforms.specularMap.value = v; }
},
glossiness: {
get: function () { return uniforms.glossiness.value; },
set: function ( v ) { uniforms.glossiness.value = v; }
},
glossinessMap: {
get: function () { return uniforms.glossinessMap.value; },
set: function ( v ) {
uniforms.glossinessMap.value = v;
//how about something like this - @pailhead
if ( v ) {
this.defines.USE_GLOSSINESSMAP = '';
// set USE_ROUGHNESSMAP to enable vUv
this.defines.USE_ROUGHNESSMAP = '';
} else {
delete this.defines.USE_ROUGHNESSMAP;
delete this.defines.USE_GLOSSINESSMAP;
}
}
}
}
);
/*eslint-enable*/
delete this.metalness;
delete this.roughness;
delete this.metalnessMap;
delete this.roughnessMap;
this.setValues( params );
}
GLTFMeshStandardSGMaterial.prototype = Object.create( MeshStandardMaterial.prototype );
GLTFMeshStandardSGMaterial.prototype.constructor = GLTFMeshStandardSGMaterial;
GLTFMeshStandardSGMaterial.prototype.copy = function ( source ) {
MeshStandardMaterial.prototype.copy.call( this, source );
this.specularMap = source.specularMap;
this.specular.copy( source.specular );
this.glossinessMap = source.glossinessMap;
this.glossiness = source.glossiness;
delete this.metalness;
delete this.roughness;
delete this.metalnessMap;
delete this.roughnessMap;
return this;
};
function GLTFMaterialsPbrSpecularGlossinessExtension() {
return {
name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,
specularGlossinessParams: [
'color',
'map',
'lightMap',
'lightMapIntensity',
'aoMap',
'aoMapIntensity',
'emissive',
'emissiveIntensity',
'emissiveMap',
'bumpMap',
'bumpScale',
'normalMap',
'normalMapType',
'displacementMap',
'displacementScale',
'displacementBias',
'specularMap',
'specular',
'glossinessMap',
'glossiness',
'alphaMap',
'envMap',
'envMapIntensity',
'refractionRatio',
],
getMaterialType: function () {
return GLTFMeshStandardSGMaterial;
},
extendParams: function ( materialParams, materialDef, parser ) {
var pbrSpecularGlossiness = materialDef.extensions[ this.name ];
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
var pending = [];
if ( Array.isArray( pbrSpecularGlossiness.diffuseFactor ) ) {
var array = pbrSpecularGlossiness.diffuseFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( pbrSpecularGlossiness.diffuseTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', pbrSpecularGlossiness.diffuseTexture ) );
}
materialParams.emissive = new Color( 0.0, 0.0, 0.0 );
materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== undefined ? pbrSpecularGlossiness.glossinessFactor : 1.0;
materialParams.specular = new Color( 1.0, 1.0, 1.0 );
if ( Array.isArray( pbrSpecularGlossiness.specularFactor ) ) {
materialParams.specular.fromArray( pbrSpecularGlossiness.specularFactor );
}
if ( pbrSpecularGlossiness.specularGlossinessTexture !== undefined ) {
var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
pending.push( parser.assignTexture( materialParams, 'glossinessMap', specGlossMapDef ) );
pending.push( parser.assignTexture( materialParams, 'specularMap', specGlossMapDef ) );
}
return Promise.all( pending );
},
createMaterial: function ( materialParams ) {
var material = new GLTFMeshStandardSGMaterial( materialParams );
material.fog = true;
material.color = materialParams.color;
material.map = materialParams.map === undefined ? null : materialParams.map;
material.lightMap = null;
material.lightMapIntensity = 1.0;
material.aoMap = materialParams.aoMap === undefined ? null : materialParams.aoMap;
material.aoMapIntensity = 1.0;
material.emissive = materialParams.emissive;
material.emissiveIntensity = 1.0;
material.emissiveMap = materialParams.emissiveMap === undefined ? null : materialParams.emissiveMap;
material.bumpMap = materialParams.bumpMap === undefined ? null : materialParams.bumpMap;
material.bumpScale = 1;
material.normalMap = materialParams.normalMap === undefined ? null : materialParams.normalMap;
material.normalMapType = TangentSpaceNormalMap;
if ( materialParams.normalScale ) material.normalScale = materialParams.normalScale;
material.displacementMap = null;
material.displacementScale = 1;
material.displacementBias = 0;
material.specularMap = materialParams.specularMap === undefined ? null : materialParams.specularMap;
material.specular = materialParams.specular;
material.glossinessMap = materialParams.glossinessMap === undefined ? null : materialParams.glossinessMap;
material.glossiness = materialParams.glossiness;
material.alphaMap = null;
material.envMap = materialParams.envMap === undefined ? null : materialParams.envMap;
material.envMapIntensity = 1.0;
material.refractionRatio = 0.98;
return material;
},
};
}
/**
* Mesh Quantization Extension
*
* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
*/
function GLTFMeshQuantizationExtension() {
this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
}
/*********************************/
/********** INTERPOLATION ********/
/*********************************/
// Spline Interpolation
// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
}
GLTFCubicSplineInterpolant.prototype = Object.create( Interpolant.prototype );
GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant;
GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function ( index ) {
// Copies a sample value to the result buffer. See description of glTF
// CUBICSPLINE values layout in interpolate_() function below.
var result = this.resultBuffer,
values = this.sampleValues,
valueSize = this.valueSize,
offset = index * valueSize * 3 + valueSize;
for ( var i = 0; i !== valueSize; i ++ ) {
result[ i ] = values[ offset + i ];
}
return result;
};
GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
GLTFCubicSplineInterpolant.prototype.interpolate_ = function ( i1, t0, t, t1 ) {
var result = this.resultBuffer;
var values = this.sampleValues;
var stride = this.valueSize;
var stride2 = stride * 2;
var stride3 = stride * 3;
var td = t1 - t0;
var p = ( t - t0 ) / td;
var pp = p * p;
var ppp = pp * p;
var offset1 = i1 * stride3;
var offset0 = offset1 - stride3;
var s2 = - 2 * ppp + 3 * pp;
var s3 = ppp - pp;
var s0 = 1 - s2;
var s1 = s3 - pp + p;
// Layout of keyframe output values for CUBICSPLINE animations:
// [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
for ( var i = 0; i !== stride; i ++ ) {
var p0 = values[ offset0 + i + stride ]; // splineVertex_k
var m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
var p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
var m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)
result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
}
return result;
};
/*********************************/
/********** INTERNALS ************/
/*********************************/
/* CONSTANTS */
var WEBGL_CONSTANTS = {
FLOAT: 5126,
//FLOAT_MAT2: 35674,
FLOAT_MAT3: 35675,
FLOAT_MAT4: 35676,
FLOAT_VEC2: 35664,
FLOAT_VEC3: 35665,
FLOAT_VEC4: 35666,
LINEAR: 9729,
REPEAT: 10497,
SAMPLER_2D: 35678,
POINTS: 0,
LINES: 1,
LINE_LOOP: 2,
LINE_STRIP: 3,
TRIANGLES: 4,
TRIANGLE_STRIP: 5,
TRIANGLE_FAN: 6,
UNSIGNED_BYTE: 5121,
UNSIGNED_SHORT: 5123
};
var WEBGL_COMPONENT_TYPES = {
5120: Int8Array,
5121: Uint8Array,
5122: Int16Array,
5123: Uint16Array,
5125: Uint32Array,
5126: Float32Array
};
var WEBGL_FILTERS = {
9728: NearestFilter,
9729: LinearFilter,
9984: NearestMipmapNearestFilter,
9985: LinearMipmapNearestFilter,
9986: NearestMipmapLinearFilter,
9987: LinearMipmapLinearFilter
};
var WEBGL_WRAPPINGS = {
33071: ClampToEdgeWrapping,
33648: MirroredRepeatWrapping,
10497: RepeatWrapping
};
var WEBGL_TYPE_SIZES = {
'SCALAR': 1,
'VEC2': 2,
'VEC3': 3,
'VEC4': 4,
'MAT2': 4,
'MAT3': 9,
'MAT4': 16
};
var ATTRIBUTES = {
POSITION: 'position',
NORMAL: 'normal',
TANGENT: 'tangent',
TEXCOORD_0: 'uv',
TEXCOORD_1: 'uv2',
COLOR_0: 'color',
WEIGHTS_0: 'skinWeight',
JOINTS_0: 'skinIndex',
};
var PATH_PROPERTIES = {
scale: 'scale',
translation: 'position',
rotation: 'quaternion',
weights: 'morphTargetInfluences'
};
var INTERPOLATION = {
CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
// keyframe track will be initialized with a default interpolation type, then modified.
LINEAR: InterpolateLinear,
STEP: InterpolateDiscrete
};
var ALPHA_MODES = {
OPAQUE: 'OPAQUE',
MASK: 'MASK',
BLEND: 'BLEND'
};
var MIME_TYPE_FORMATS = {
'image/png': RGBAFormat,
'image/jpeg': RGBFormat
};
/* UTILITY FUNCTIONS */
function resolveURL( url, path ) {
// Invalid URL
if ( typeof url !== 'string' || url === '' ) return '';
// Host Relative URL
if ( /^https?:\/\//i.test( path ) && /^\//.test( url ) ) {
path = path.replace( /(^https?:\/\/[^\/]+).*/i, '$1' );
}
// Absolute URL http://,https://,//
if ( /^(https?:)?\/\//i.test( url ) ) return url;
// Data URI
if ( /^data:.*,.*$/i.test( url ) ) return url;
// Blob URL
if ( /^blob:.*$/i.test( url ) ) return url;
// Relative URL
return path + url;
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
*/
function createDefaultMaterial( cache ) {
if ( cache[ 'DefaultMaterial' ] === undefined ) {
cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {
color: 0xFFFFFF,
emissive: 0x000000,
metalness: 1,
roughness: 1,
transparent: false,
depthTest: true,
side: FrontSide
} );
}
return cache[ 'DefaultMaterial' ];
}
function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
// Add unknown glTF extensions to an object's userData.
for ( var name in objectDef.extensions ) {
if ( knownExtensions[ name ] === undefined ) {
object.userData.gltfExtensions = object.userData.gltfExtensions || {};
object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
}
}
}
/**
* @param {Object3D|Material|BufferGeometry} object
* @param {GLTF.definition} gltfDef
*/
function assignExtrasToUserData( object, gltfDef ) {
if ( gltfDef.extras !== undefined ) {
if ( typeof gltfDef.extras === 'object' ) {
Object.assign( object.userData, gltfDef.extras );
} else {
console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
}
}
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
*
* @param {BufferGeometry} geometry
* @param {Array<GLTF.Target>} targets
* @param {GLTFParser} parser
* @return {Promise<BufferGeometry>}
*/
function addMorphTargets( geometry, targets, parser ) {
var hasMorphPosition = false;
var hasMorphNormal = false;
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( target.POSITION !== undefined ) hasMorphPosition = true;
if ( target.NORMAL !== undefined ) hasMorphNormal = true;
if ( hasMorphPosition && hasMorphNormal ) break;
}
if ( ! hasMorphPosition && ! hasMorphNormal ) return Promise.resolve( geometry );
var pendingPositionAccessors = [];
var pendingNormalAccessors = [];
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( hasMorphPosition ) {
var pendingAccessor = target.POSITION !== undefined
? parser.getDependency( 'accessor', target.POSITION )
: geometry.attributes.position;
pendingPositionAccessors.push( pendingAccessor );
}
if ( hasMorphNormal ) {
var pendingAccessor = target.NORMAL !== undefined
? parser.getDependency( 'accessor', target.NORMAL )
: geometry.attributes.normal;
pendingNormalAccessors.push( pendingAccessor );
}
}
return Promise.all( [
Promise.all( pendingPositionAccessors ),
Promise.all( pendingNormalAccessors )
] ).then( function ( accessors ) {
var morphPositions = accessors[ 0 ];
var morphNormals = accessors[ 1 ];
if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
geometry.morphTargetsRelative = true;
return geometry;
} );
}
/**
* @param {Mesh} mesh
* @param {GLTF.Mesh} meshDef
*/
function updateMorphTargets( mesh, meshDef ) {
mesh.updateMorphTargets();
if ( meshDef.weights !== undefined ) {
for ( var i = 0, il = meshDef.weights.length; i < il; i ++ ) {
mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
}
}
// .extras has user-defined data, so check that .extras.targetNames is an array.
if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
var targetNames = meshDef.extras.targetNames;
if ( mesh.morphTargetInfluences.length === targetNames.length ) {
mesh.morphTargetDictionary = {};
for ( var i = 0, il = targetNames.length; i < il; i ++ ) {
mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
}
} else {
console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
}
}
}
function createPrimitiveKey( primitiveDef ) {
var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
var geometryKey;
if ( dracoExtension ) {
geometryKey = 'draco:' + dracoExtension.bufferView
+ ':' + dracoExtension.indices
+ ':' + createAttributesKey( dracoExtension.attributes );
} else {
geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
}
return geometryKey;
}
function createAttributesKey( attributes ) {
var attributesKey = '';
var keys = Object.keys( attributes ).sort();
for ( var i = 0, il = keys.length; i < il; i ++ ) {
attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
}
return attributesKey;
}
/* GLTF PARSER */
function GLTFParser( json, extensions, options ) {
this.json = json || {};
this.extensions = extensions || {};
this.options = options || {};
// loader object cache
this.cache = new GLTFRegistry();
// BufferGeometry caching
this.primitiveCache = {};
this.textureLoader = new TextureLoader( this.options.manager );
this.textureLoader.setCrossOrigin( this.options.crossOrigin );
this.fileLoader = new FileLoader( this.options.manager );
this.fileLoader.setResponseType( 'arraybuffer' );
if ( this.options.crossOrigin === 'use-credentials' ) {
this.fileLoader.setWithCredentials( true );
}
}
GLTFParser.prototype.parse = function ( onLoad, onError ) {
var parser = this;
var json = this.json;
var extensions = this.extensions;
// Clear the loader cache
this.cache.removeAll();
// Mark the special nodes/meshes in json for efficient parse
this.markDefs();
Promise.all( [
this.getDependencies( 'scene' ),
this.getDependencies( 'animation' ),
this.getDependencies( 'camera' ),
] ).then( function ( dependencies ) {
var result = {
scene: dependencies[ 0 ][ json.scene || 0 ],
scenes: dependencies[ 0 ],
animations: dependencies[ 1 ],
cameras: dependencies[ 2 ],
asset: json.asset,
parser: parser,
userData: {}
};
addUnknownExtensionsToUserData( extensions, result, json );
assignExtrasToUserData( result, json );
onLoad( result );
} ).catch( onError );
};
/**
* Marks the special nodes/meshes in json for efficient parse.
*/
GLTFParser.prototype.markDefs = function () {
var nodeDefs = this.json.nodes || [];
var skinDefs = this.json.skins || [];
var meshDefs = this.json.meshes || [];
var meshReferences = {};
var meshUses = {};
// Nothing in the node definition indicates whether it is a Bone or an
// Object3D. Use the skins' joint references to mark bones.
for ( var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
var joints = skinDefs[ skinIndex ].joints;
for ( var i = 0, il = joints.length; i < il; i ++ ) {
nodeDefs[ joints[ i ] ].isBone = true;
}
}
// Meshes can (and should) be reused by multiple nodes in a glTF asset. To
// avoid having more than one Mesh with the same name, count
// references and rename instances below.
//
// Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
for ( var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
var nodeDef = nodeDefs[ nodeIndex ];
if ( nodeDef.mesh !== undefined ) {
if ( meshReferences[ nodeDef.mesh ] === undefined ) {
meshReferences[ nodeDef.mesh ] = meshUses[ nodeDef.mesh ] = 0;
}
meshReferences[ nodeDef.mesh ] ++;
// Nothing in the mesh definition indicates whether it is
// a SkinnedMesh or Mesh. Use the node's mesh reference
// to mark SkinnedMesh if node has skin.
if ( nodeDef.skin !== undefined ) {
meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
}
}
}
this.json.meshReferences = meshReferences;
this.json.meshUses = meshUses;
};
/**
* Requests the specified dependency asynchronously, with caching.
* @param {string} type
* @param {number} index
* @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
*/
GLTFParser.prototype.getDependency = function ( type, index ) {
var cacheKey = type + ':' + index;
var dependency = this.cache.get( cacheKey );
if ( ! dependency ) {
switch ( type ) {
case 'scene':
dependency = this.loadScene( index );
break;
case 'node':
dependency = this.loadNode( index );
break;
case 'mesh':
dependency = this.loadMesh( index );
break;
case 'accessor':
dependency = this.loadAccessor( index );
break;
case 'bufferView':
dependency = this.loadBufferView( index );
break;
case 'buffer':
dependency = this.loadBuffer( index );
break;
case 'material':
dependency = this.loadMaterial( index );
break;
case 'texture':
dependency = this.loadTexture( index );
break;
case 'skin':
dependency = this.loadSkin( index );
break;
case 'animation':
dependency = this.loadAnimation( index );
break;
case 'camera':
dependency = this.loadCamera( index );
break;
case 'light':
dependency = this.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].loadLight( index );
break;
default:
throw new Error( 'Unknown type: ' + type );
}
this.cache.add( cacheKey, dependency );
}
return dependency;
};
/**
* Requests all dependencies of the specified type asynchronously, with caching.
* @param {string} type
* @return {Promise<Array<Object>>}
*/
GLTFParser.prototype.getDependencies = function ( type ) {
var dependencies = this.cache.get( type );
if ( ! dependencies ) {
var parser = this;
var defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
dependencies = Promise.all( defs.map( function ( def, index ) {
return parser.getDependency( type, index );
} ) );
this.cache.add( type, dependencies );
}
return dependencies;
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
* @param {number} bufferIndex
* @return {Promise<ArrayBuffer>}
*/
GLTFParser.prototype.loadBuffer = function ( bufferIndex ) {
var bufferDef = this.json.buffers[ bufferIndex ];
var loader = this.fileLoader;
if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
}
// If present, GLB container is required to be the first buffer.
if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
}
var options = this.options;
return new Promise( function ( resolve, reject ) {
loader.load( resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
} );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
* @param {number} bufferViewIndex
* @return {Promise<ArrayBuffer>}
*/
GLTFParser.prototype.loadBufferView = function ( bufferViewIndex ) {
var bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
var byteLength = bufferViewDef.byteLength || 0;
var byteOffset = bufferViewDef.byteOffset || 0;
return buffer.slice( byteOffset, byteOffset + byteLength );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
* @param {number} accessorIndex
* @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
*/
GLTFParser.prototype.loadAccessor = function ( accessorIndex ) {
var parser = this;
var json = this.json;
var accessorDef = this.json.accessors[ accessorIndex ];
if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
// Ignore empty accessors, which may be used to declare runtime
// information about attributes coming from another source (e.g. Draco
// compression extension).
return Promise.resolve( null );
}
var pendingBufferViews = [];
if ( accessorDef.bufferView !== undefined ) {
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
} else {
pendingBufferViews.push( null );
}
if ( accessorDef.sparse !== undefined ) {
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
}
return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
var bufferView = bufferViews[ 0 ];
var itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
var TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
// For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
var elementBytes = TypedArray.BYTES_PER_ELEMENT;
var itemBytes = elementBytes * itemSize;
var byteOffset = accessorDef.byteOffset || 0;
var byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
var normalized = accessorDef.normalized === true;
var array, bufferAttribute;
// The buffer is not interleaved if the stride is the item size in bytes.
if ( byteStride && byteStride !== itemBytes ) {
// Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
// This makes sure that IBA.count reflects accessor.count properly
var ibSlice = Math.floor( byteOffset / byteStride );
var ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
var ib = parser.cache.get( ibCacheKey );
if ( ! ib ) {
array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );
// Integer parameters to IB/IBA are in array elements, not bytes.
ib = new InterleavedBuffer( array, byteStride / elementBytes );
parser.cache.add( ibCacheKey, ib );
}
bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );
} else {
if ( bufferView === null ) {
array = new TypedArray( accessorDef.count * itemSize );
} else {
array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );
}
bufferAttribute = new BufferAttribute( array, itemSize, normalized );
}
// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
if ( accessorDef.sparse !== undefined ) {
var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
var TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];
var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
var sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
var sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );
if ( bufferView !== null ) {
// Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );
}
for ( var i = 0, il = sparseIndices.length; i < il; i ++ ) {
var index = sparseIndices[ i ];
bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );
}
}
return bufferAttribute;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
* @param {number} textureIndex
* @return {Promise<THREE.Texture>}
*/
GLTFParser.prototype.loadTexture = function ( textureIndex ) {
var parser = this;
var json = this.json;
var options = this.options;
var textureLoader = this.textureLoader;
var URL = self.URL || self.webkitURL;
var textureDef = json.textures[ textureIndex ];
var textureExtensions = textureDef.extensions || {};
var source;
if ( textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ] ) {
source = json.images[ textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].source ];
} else {
source = json.images[ textureDef.source ];
}
var sourceURI = source.uri;
var isObjectURL = false;
if ( source.bufferView !== undefined ) {
// Load binary image data from bufferView, if provided.
sourceURI = parser.getDependency( 'bufferView', source.bufferView ).then( function ( bufferView ) {
isObjectURL = true;
var blob = new Blob( [ bufferView ], { type: source.mimeType } );
sourceURI = URL.createObjectURL( blob );
return sourceURI;
} );
}
return Promise.resolve( sourceURI ).then( function ( sourceURI ) {
// Load Texture resource.
var loader = options.manager.getHandler( sourceURI );
if ( ! loader ) {
loader = textureExtensions[ EXTENSIONS.MSFT_TEXTURE_DDS ]
? parser.extensions[ EXTENSIONS.MSFT_TEXTURE_DDS ].ddsLoader
: textureLoader;
}
return new Promise( function ( resolve, reject ) {
loader.load( resolveURL( sourceURI, options.path ), resolve, undefined, reject );
} );
} ).then( function ( texture ) {
// Clean up resources and configure Texture.
if ( isObjectURL === true ) {
URL.revokeObjectURL( sourceURI );
}
texture.flipY = false;
if ( textureDef.name ) texture.name = textureDef.name;
// Ignore unknown mime types, like DDS files.
if ( source.mimeType in MIME_TYPE_FORMATS ) {
texture.format = MIME_TYPE_FORMATS[ source.mimeType ];
}
var samplers = json.samplers || {};
var sampler = samplers[ textureDef.sampler ] || {};
texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
return texture;
} );
};
/**
* Asynchronously assigns a texture to the given material parameters.
* @param {Object} materialParams
* @param {string} mapName
* @param {Object} mapDef
* @return {Promise}
*/
GLTFParser.prototype.assignTexture = function ( materialParams, mapName, mapDef ) {
var parser = this;
return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
if ( ! texture.isCompressedTexture ) {
switch ( mapName ) {
case 'aoMap':
case 'emissiveMap':
case 'metalnessMap':
case 'normalMap':
case 'roughnessMap':
texture.format = RGBFormat;
break;
}
}
// Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
// However, we will copy UV set 0 to UV set 1 on demand for aoMap
if ( mapDef.texCoord !== undefined && mapDef.texCoord != 0 && ! ( mapName === 'aoMap' && mapDef.texCoord == 1 ) ) {
console.warn( 'THREE.GLTFLoader: Custom UV set ' + mapDef.texCoord + ' for texture ' + mapName + ' not yet supported.' );
}
if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {
var transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;
if ( transform ) {
texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
}
}
materialParams[ mapName ] = texture;
} );
};
/**
* Assigns final material to a Mesh, Line, or Points instance. The instance
* already has a material (generated from the glTF material options alone)
* but reuse of the same glTF material may require multiple threejs materials
* to accomodate different primitive types, defines, etc. New materials will
* be created if necessary, and reused from a cache.
* @param {Object3D} mesh Mesh, Line, or Points instance.
*/
GLTFParser.prototype.assignFinalMaterial = function ( mesh ) {
var geometry = mesh.geometry;
var material = mesh.material;
var useVertexTangents = geometry.attributes.tangent !== undefined;
var useVertexColors = geometry.attributes.color !== undefined;
var useFlatShading = geometry.attributes.normal === undefined;
var useSkinning = mesh.isSkinnedMesh === true;
var useMorphTargets = Object.keys( geometry.morphAttributes ).length > 0;
var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined;
if ( mesh.isPoints ) {
var cacheKey = 'PointsMaterial:' + material.uuid;
var pointsMaterial = this.cache.get( cacheKey );
if ( ! pointsMaterial ) {
pointsMaterial = new PointsMaterial();
Material.prototype.copy.call( pointsMaterial, material );
pointsMaterial.color.copy( material.color );
pointsMaterial.map = material.map;
pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px
this.cache.add( cacheKey, pointsMaterial );
}
material = pointsMaterial;
} else if ( mesh.isLine ) {
var cacheKey = 'LineBasicMaterial:' + material.uuid;
var lineMaterial = this.cache.get( cacheKey );
if ( ! lineMaterial ) {
lineMaterial = new LineBasicMaterial();
Material.prototype.copy.call( lineMaterial, material );
lineMaterial.color.copy( material.color );
this.cache.add( cacheKey, lineMaterial );
}
material = lineMaterial;
}
// Clone the material if it will be modified
if ( useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets ) {
var cacheKey = 'ClonedMaterial:' + material.uuid + ':';
if ( material.isGLTFSpecularGlossinessMaterial ) cacheKey += 'specular-glossiness:';
if ( useSkinning ) cacheKey += 'skinning:';
if ( useVertexTangents ) cacheKey += 'vertex-tangents:';
if ( useVertexColors ) cacheKey += 'vertex-colors:';
if ( useFlatShading ) cacheKey += 'flat-shading:';
if ( useMorphTargets ) cacheKey += 'morph-targets:';
if ( useMorphNormals ) cacheKey += 'morph-normals:';
var cachedMaterial = this.cache.get( cacheKey );
if ( ! cachedMaterial ) {
cachedMaterial = material.clone();
if ( useSkinning ) cachedMaterial.skinning = true;
if ( useVertexTangents ) cachedMaterial.vertexTangents = true;
if ( useVertexColors ) cachedMaterial.vertexColors = true;
if ( useFlatShading ) cachedMaterial.flatShading = true;
if ( useMorphTargets ) cachedMaterial.morphTargets = true;
if ( useMorphNormals ) cachedMaterial.morphNormals = true;
this.cache.add( cacheKey, cachedMaterial );
}
material = cachedMaterial;
}
// workarounds for mesh and geometry
if ( material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined ) {
geometry.setAttribute( 'uv2', new BufferAttribute( geometry.attributes.uv.array, 2 ) );
}
// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
if ( material.normalScale && ! useVertexTangents ) {
material.normalScale.y = - material.normalScale.y;
}
if ( material.clearcoatNormalScale && ! useVertexTangents ) {
material.clearcoatNormalScale.y = - material.clearcoatNormalScale.y;
}
mesh.material = material;
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
* @param {number} materialIndex
* @return {Promise<Material>}
*/
GLTFParser.prototype.loadMaterial = function ( materialIndex ) {
var parser = this;
var json = this.json;
var extensions = this.extensions;
var materialDef = json.materials[ materialIndex ];
var materialType;
var materialParams = {};
var materialExtensions = materialDef.extensions || {};
var pending = [];
if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ] ) {
var sgExtension = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ];
materialType = sgExtension.getMaterialType();
pending.push( sgExtension.extendParams( materialParams, materialDef, parser ) );
} else if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {
var kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
materialType = kmuExtension.getMaterialType();
pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );
} else {
// Specification:
// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material
materialType = MeshStandardMaterial;
var metallicRoughness = materialDef.pbrMetallicRoughness || {};
materialParams.color = new Color( 1.0, 1.0, 1.0 );
materialParams.opacity = 1.0;
if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
var array = metallicRoughness.baseColorFactor;
materialParams.color.fromArray( array );
materialParams.opacity = array[ 3 ];
}
if ( metallicRoughness.baseColorTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
}
materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {
pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );
}
}
if ( materialDef.doubleSided === true ) {
materialParams.side = DoubleSide;
}
var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
if ( alphaMode === ALPHA_MODES.BLEND ) {
materialParams.transparent = true;
// See: https://github.com/mrdoob/three.js/issues/17706
materialParams.depthWrite = false;
} else {
materialParams.transparent = false;
if ( alphaMode === ALPHA_MODES.MASK ) {
materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
}
}
if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );
materialParams.normalScale = new Vector2( 1, 1 );
if ( materialDef.normalTexture.scale !== undefined ) {
materialParams.normalScale.set( materialDef.normalTexture.scale, materialDef.normalTexture.scale );
}
}
if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );
if ( materialDef.occlusionTexture.strength !== undefined ) {
materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
}
}
if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {
materialParams.emissive = new Color().fromArray( materialDef.emissiveFactor );
}
if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {
pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture ) );
}
if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_CLEARCOAT ] ) {
var clearcoatExtension = extensions[ EXTENSIONS.KHR_MATERIALS_CLEARCOAT ];
materialType = clearcoatExtension.getMaterialType();
pending.push( clearcoatExtension.extendParams( materialParams, { extensions: materialExtensions }, parser ) );
}
return Promise.all( pending ).then( function () {
var material;
if ( materialType === GLTFMeshStandardSGMaterial ) {
material = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].createMaterial( materialParams );
} else {
material = new materialType( materialParams );
}
if ( materialDef.name ) material.name = materialDef.name;
// baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
if ( material.map ) material.map.encoding = sRGBEncoding;
if ( material.emissiveMap ) material.emissiveMap.encoding = sRGBEncoding;
assignExtrasToUserData( material, materialDef );
if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );
return material;
} );
};
/**
* @param {BufferGeometry} geometry
* @param {GLTF.Primitive} primitiveDef
* @param {GLTFParser} parser
*/
function computeBounds( geometry, primitiveDef, parser ) {
var attributes = primitiveDef.attributes;
var box = new Box3();
if ( attributes.POSITION !== undefined ) {
var accessor = parser.json.accessors[ attributes.POSITION ];
var min = accessor.min;
var max = accessor.max;
// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
if ( min !== undefined && max !== undefined ) {
box.set(
new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),
new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] ) );
} else {
console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
return;
}
} else {
return;
}
var targets = primitiveDef.targets;
if ( targets !== undefined ) {
var maxDisplacement = new Vector3();
var vector = new Vector3();
for ( var i = 0, il = targets.length; i < il; i ++ ) {
var target = targets[ i ];
if ( target.POSITION !== undefined ) {
var accessor = parser.json.accessors[ target.POSITION ];
var min = accessor.min;
var max = accessor.max;
// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
if ( min !== undefined && max !== undefined ) {
// we need to get max of absolute components because target weight is [-1,1]
vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );
vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );
vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );
// Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
// to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
// are used to implement key-frame animations and as such only two are active at a time - this results in very large
// boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
maxDisplacement.max( vector );
} else {
console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
}
}
}
// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
box.expandByVector( maxDisplacement );
}
geometry.boundingBox = box;
var sphere = new Sphere();
box.getCenter( sphere.center );
sphere.radius = box.min.distanceTo( box.max ) / 2;
geometry.boundingSphere = sphere;
}
/**
* @param {BufferGeometry} geometry
* @param {GLTF.Primitive} primitiveDef
* @param {GLTFParser} parser
* @return {Promise<BufferGeometry>}
*/
function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
var attributes = primitiveDef.attributes;
var pending = [];
function assignAttributeAccessor( accessorIndex, attributeName ) {
return parser.getDependency( 'accessor', accessorIndex )
.then( function ( accessor ) {
geometry.setAttribute( attributeName, accessor );
} );
}
for ( var gltfAttributeName in attributes ) {
var threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
// Skip attributes already provided by e.g. Draco extension.
if ( threeAttributeName in geometry.attributes ) continue;
pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
}
if ( primitiveDef.indices !== undefined && ! geometry.index ) {
var accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
geometry.setIndex( accessor );
} );
pending.push( accessor );
}
assignExtrasToUserData( geometry, primitiveDef );
computeBounds( geometry, primitiveDef, parser );
return Promise.all( pending ).then( function () {
return primitiveDef.targets !== undefined
? addMorphTargets( geometry, primitiveDef.targets, parser )
: geometry;
} );
}
/**
* @param {BufferGeometry} geometry
* @param {Number} drawMode
* @return {BufferGeometry}
*/
function toTrianglesDrawMode( geometry, drawMode ) {
var index = geometry.getIndex();
// generate index if not present
if ( index === null ) {
var indices = [];
var position = geometry.getAttribute( 'position' );
if ( position !== undefined ) {
for ( var i = 0; i < position.count; i ++ ) {
indices.push( i );
}
geometry.setIndex( indices );
index = geometry.getIndex();
} else {
console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
return geometry;
}
}
//
var numberOfTriangles = index.count - 2;
var newIndices = [];
if ( drawMode === TriangleFanDrawMode ) {
// gl.TRIANGLE_FAN
for ( var i = 1; i <= numberOfTriangles; i ++ ) {
newIndices.push( index.getX( 0 ) );
newIndices.push( index.getX( i ) );
newIndices.push( index.getX( i + 1 ) );
}
} else {
// gl.TRIANGLE_STRIP
for ( var i = 0; i < numberOfTriangles; i ++ ) {
if ( i % 2 === 0 ) {
newIndices.push( index.getX( i ) );
newIndices.push( index.getX( i + 1 ) );
newIndices.push( index.getX( i + 2 ) );
} else {
newIndices.push( index.getX( i + 2 ) );
newIndices.push( index.getX( i + 1 ) );
newIndices.push( index.getX( i ) );
}
}
}
if ( ( newIndices.length / 3 ) !== numberOfTriangles ) {
console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
}
// build final geometry
var newGeometry = geometry.clone();
newGeometry.setIndex( newIndices );
return newGeometry;
}
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
*
* Creates BufferGeometries from primitives.
*
* @param {Array<GLTF.Primitive>} primitives
* @return {Promise<Array<BufferGeometry>>}
*/
GLTFParser.prototype.loadGeometries = function ( primitives ) {
var parser = this;
var extensions = this.extensions;
var cache = this.primitiveCache;
function createDracoPrimitive( primitive ) {
return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
.decodePrimitive( primitive, parser )
.then( function ( geometry ) {
return addPrimitiveAttributes( geometry, primitive, parser );
} );
}
var pending = [];
for ( var i = 0, il = primitives.length; i < il; i ++ ) {
var primitive = primitives[ i ];
var cacheKey = createPrimitiveKey( primitive );
// See if we've already created this geometry
var cached = cache[ cacheKey ];
if ( cached ) {
// Use the cached geometry if it exists
pending.push( cached.promise );
} else {
var geometryPromise;
if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {
// Use DRACO geometry if available
geometryPromise = createDracoPrimitive( primitive );
} else {
// Otherwise create a new geometry
geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );
}
// Cache this geometry
cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };
pending.push( geometryPromise );
}
}
return Promise.all( pending );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
* @param {number} meshIndex
* @return {Promise<Group|Mesh|SkinnedMesh>}
*/
GLTFParser.prototype.loadMesh = function ( meshIndex ) {
var parser = this;
var json = this.json;
var meshDef = json.meshes[ meshIndex ];
var primitives = meshDef.primitives;
var pending = [];
for ( var i = 0, il = primitives.length; i < il; i ++ ) {
var material = primitives[ i ].material === undefined
? createDefaultMaterial( this.cache )
: this.getDependency( 'material', primitives[ i ].material );
pending.push( material );
}
pending.push( parser.loadGeometries( primitives ) );
return Promise.all( pending ).then( function ( results ) {
var materials = results.slice( 0, results.length - 1 );
var geometries = results[ results.length - 1 ];
var meshes = [];
for ( var i = 0, il = geometries.length; i < il; i ++ ) {
var geometry = geometries[ i ];
var primitive = primitives[ i ];
// 1. create Mesh
var mesh;
var material = materials[ i ];
if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
primitive.mode === undefined ) {
// .isSkinnedMesh isn't in glTF spec. See .markDefs()
mesh = meshDef.isSkinnedMesh === true
? new SkinnedMesh( geometry, material )
: new Mesh( geometry, material );
if ( mesh.isSkinnedMesh === true && ! mesh.geometry.attributes.skinWeight.normalized ) {
// we normalize floating point skin weight array to fix malformed assets (see #15319)
// it's important to skip this for non-float32 data since normalizeSkinWeights assumes non-normalized inputs
mesh.normalizeSkinWeights();
}
if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {
mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );
} else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {
mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );
}
} else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {
mesh = new LineSegments( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {
mesh = new Line( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {
mesh = new LineLoop( geometry, material );
} else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {
mesh = new Points( geometry, material );
} else {
throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );
}
if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {
updateMorphTargets( mesh, meshDef );
}
mesh.name = meshDef.name || ( 'mesh_' + meshIndex );
if ( geometries.length > 1 ) mesh.name += '_' + i;
assignExtrasToUserData( mesh, meshDef );
parser.assignFinalMaterial( mesh );
meshes.push( mesh );
}
if ( meshes.length === 1 ) {
return meshes[ 0 ];
}
var group = new Group();
for ( var i = 0, il = meshes.length; i < il; i ++ ) {
group.add( meshes[ i ] );
}
return group;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
* @param {number} cameraIndex
* @return {Promise<THREE.Camera>}
*/
GLTFParser.prototype.loadCamera = function ( cameraIndex ) {
var camera;
var cameraDef = this.json.cameras[ cameraIndex ];
var params = cameraDef[ cameraDef.type ];
if ( ! params ) {
console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
return;
}
if ( cameraDef.type === 'perspective' ) {
camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );
} else if ( cameraDef.type === 'orthographic' ) {
camera = new OrthographicCamera( params.xmag / - 2, params.xmag / 2, params.ymag / 2, params.ymag / - 2, params.znear, params.zfar );
}
if ( cameraDef.name ) camera.name = cameraDef.name;
assignExtrasToUserData( camera, cameraDef );
return Promise.resolve( camera );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
* @param {number} skinIndex
* @return {Promise<Object>}
*/
GLTFParser.prototype.loadSkin = function ( skinIndex ) {
var skinDef = this.json.skins[ skinIndex ];
var skinEntry = { joints: skinDef.joints };
if ( skinDef.inverseBindMatrices === undefined ) {
return Promise.resolve( skinEntry );
}
return this.getDependency( 'accessor', skinDef.inverseBindMatrices ).then( function ( accessor ) {
skinEntry.inverseBindMatrices = accessor;
return skinEntry;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
* @param {number} animationIndex
* @return {Promise<AnimationClip>}
*/
GLTFParser.prototype.loadAnimation = function ( animationIndex ) {
var json = this.json;
var animationDef = json.animations[ animationIndex ];
var pendingNodes = [];
var pendingInputAccessors = [];
var pendingOutputAccessors = [];
var pendingSamplers = [];
var pendingTargets = [];
for ( var i = 0, il = animationDef.channels.length; i < il; i ++ ) {
var channel = animationDef.channels[ i ];
var sampler = animationDef.samplers[ channel.sampler ];
var target = channel.target;
var name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
var input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
var output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
pendingNodes.push( this.getDependency( 'node', name ) );
pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
pendingSamplers.push( sampler );
pendingTargets.push( target );
}
return Promise.all( [
Promise.all( pendingNodes ),
Promise.all( pendingInputAccessors ),
Promise.all( pendingOutputAccessors ),
Promise.all( pendingSamplers ),
Promise.all( pendingTargets )
] ).then( function ( dependencies ) {
var nodes = dependencies[ 0 ];
var inputAccessors = dependencies[ 1 ];
var outputAccessors = dependencies[ 2 ];
var samplers = dependencies[ 3 ];
var targets = dependencies[ 4 ];
var tracks = [];
for ( var i = 0, il = nodes.length; i < il; i ++ ) {
var node = nodes[ i ];
var inputAccessor = inputAccessors[ i ];
var outputAccessor = outputAccessors[ i ];
var sampler = samplers[ i ];
var target = targets[ i ];
if ( node === undefined ) continue;
node.updateMatrix();
node.matrixAutoUpdate = true;
var TypedKeyframeTrack;
switch ( PATH_PROPERTIES[ target.path ] ) {
case PATH_PROPERTIES.weights:
TypedKeyframeTrack = NumberKeyframeTrack;
break;
case PATH_PROPERTIES.rotation:
TypedKeyframeTrack = QuaternionKeyframeTrack;
break;
case PATH_PROPERTIES.position:
case PATH_PROPERTIES.scale:
default:
TypedKeyframeTrack = VectorKeyframeTrack;
break;
}
var targetName = node.name ? node.name : node.uuid;
var interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
var targetNames = [];
if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {
// Node may be a Group (glTF mesh with several primitives) or a Mesh.
node.traverse( function ( object ) {
if ( object.isMesh === true && object.morphTargetInfluences ) {
targetNames.push( object.name ? object.name : object.uuid );
}
} );
} else {
targetNames.push( targetName );
}
var outputArray = outputAccessor.array;
if ( outputAccessor.normalized ) {
var scale;
if ( outputArray.constructor === Int8Array ) {
scale = 1 / 127;
} else if ( outputArray.constructor === Uint8Array ) {
scale = 1 / 255;
} else if ( outputArray.constructor == Int16Array ) {
scale = 1 / 32767;
} else if ( outputArray.constructor === Uint16Array ) {
scale = 1 / 65535;
} else {
throw new Error( 'THREE.GLTFLoader: Unsupported output accessor component type.' );
}
var scaled = new Float32Array( outputArray.length );
for ( var j = 0, jl = outputArray.length; j < jl; j ++ ) {
scaled[ j ] = outputArray[ j ] * scale;
}
outputArray = scaled;
}
for ( var j = 0, jl = targetNames.length; j < jl; j ++ ) {
var track = new TypedKeyframeTrack(
targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
inputAccessor.array,
outputArray,
interpolation
);
// Override interpolation with custom factory method.
if ( sampler.interpolation === 'CUBICSPLINE' ) {
track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
// A CUBICSPLINE keyframe in glTF has three output values for each input value,
// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
// must be divided by three to get the interpolant's sampleSize argument.
return new GLTFCubicSplineInterpolant( this.times, this.values, this.getValueSize() / 3, result );
};
// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
}
tracks.push( track );
}
}
var name = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
return new AnimationClip( name, undefined, tracks );
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
* @param {number} nodeIndex
* @return {Promise<Object3D>}
*/
GLTFParser.prototype.loadNode = function ( nodeIndex ) {
var json = this.json;
var extensions = this.extensions;
var parser = this;
var meshReferences = json.meshReferences;
var meshUses = json.meshUses;
var nodeDef = json.nodes[ nodeIndex ];
return ( function () {
var pending = [];
if ( nodeDef.mesh !== undefined ) {
pending.push( parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {
var node;
if ( meshReferences[ nodeDef.mesh ] > 1 ) {
var instanceNum = meshUses[ nodeDef.mesh ] ++;
node = mesh.clone();
node.name += '_instance_' + instanceNum;
} else {
node = mesh;
}
// if weights are provided on the node, override weights on the mesh.
if ( nodeDef.weights !== undefined ) {
node.traverse( function ( o ) {
if ( ! o.isMesh ) return;
for ( var i = 0, il = nodeDef.weights.length; i < il; i ++ ) {
o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];
}
} );
}
return node;
} ) );
}
if ( nodeDef.camera !== undefined ) {
pending.push( parser.getDependency( 'camera', nodeDef.camera ) );
}
if ( nodeDef.extensions
&& nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ]
&& nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light !== undefined ) {
pending.push( parser.getDependency( 'light', nodeDef.extensions[ EXTENSIONS.KHR_LIGHTS_PUNCTUAL ].light ) );
}
return Promise.all( pending );
}() ).then( function ( objects ) {
var node;
// .isBone isn't in glTF spec. See .markDefs
if ( nodeDef.isBone === true ) {
node = new Bone();
} else if ( objects.length > 1 ) {
node = new Group();
} else if ( objects.length === 1 ) {
node = objects[ 0 ];
} else {
node = new Object3D();
}
if ( node !== objects[ 0 ] ) {
for ( var i = 0, il = objects.length; i < il; i ++ ) {
node.add( objects[ i ] );
}
}
if ( nodeDef.name ) {
node.userData.name = nodeDef.name;
node.name = PropertyBinding.sanitizeNodeName( nodeDef.name );
}
assignExtrasToUserData( node, nodeDef );
if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );
if ( nodeDef.matrix !== undefined ) {
var matrix = new Matrix4();
matrix.fromArray( nodeDef.matrix );
node.applyMatrix4( matrix );
} else {
if ( nodeDef.translation !== undefined ) {
node.position.fromArray( nodeDef.translation );
}
if ( nodeDef.rotation !== undefined ) {
node.quaternion.fromArray( nodeDef.rotation );
}
if ( nodeDef.scale !== undefined ) {
node.scale.fromArray( nodeDef.scale );
}
}
return node;
} );
};
/**
* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
* @param {number} sceneIndex
* @return {Promise<Group>}
*/
GLTFParser.prototype.loadScene = function () {
// scene node hierachy builder
function buildNodeHierachy( nodeId, parentObject, json, parser ) {
var nodeDef = json.nodes[ nodeId ];
return parser.getDependency( 'node', nodeId ).then( function ( node ) {
if ( nodeDef.skin === undefined ) return node;
// build skeleton here as well
var skinEntry;
return parser.getDependency( 'skin', nodeDef.skin ).then( function ( skin ) {
skinEntry = skin;
var pendingJoints = [];
for ( var i = 0, il = skinEntry.joints.length; i < il; i ++ ) {
pendingJoints.push( parser.getDependency( 'node', skinEntry.joints[ i ] ) );
}
return Promise.all( pendingJoints );
} ).then( function ( jointNodes ) {
node.traverse( function ( mesh ) {
if ( ! mesh.isMesh ) return;
var bones = [];
var boneInverses = [];
for ( var j = 0, jl = jointNodes.length; j < jl; j ++ ) {
var jointNode = jointNodes[ j ];
if ( jointNode ) {
bones.push( jointNode );
var mat = new Matrix4();
if ( skinEntry.inverseBindMatrices !== undefined ) {
mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );
}
boneInverses.push( mat );
} else {
console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[ j ] );
}
}
mesh.bind( new Skeleton( bones, boneInverses ), mesh.matrixWorld );
} );
return node;
} );
} ).then( function ( node ) {
// build node hierachy
parentObject.add( node );
var pending = [];
if ( nodeDef.children ) {
var children = nodeDef.children;
for ( var i = 0, il = children.length; i < il; i ++ ) {
var child = children[ i ];
pending.push( buildNodeHierachy( child, node, json, parser ) );
}
}
return Promise.all( pending );
} );
}
return function loadScene( sceneIndex ) {
var json = this.json;
var extensions = this.extensions;
var sceneDef = this.json.scenes[ sceneIndex ];
var parser = this;
// Loader returns Group, not Scene.
// See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
var scene = new Group();
if ( sceneDef.name ) scene.name = sceneDef.name;
assignExtrasToUserData( scene, sceneDef );
if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );
var nodeIds = sceneDef.nodes || [];
var pending = [];
for ( var i = 0, il = nodeIds.length; i < il; i ++ ) {
pending.push( buildNodeHierachy( nodeIds[ i ], scene, json, parser ) );
}
return Promise.all( pending ).then( function () {
return scene;
} );
};
}();
return GLTFLoader;
} )()
Example #4
| Source File: ColladaLoader.js From Computer-Graphics with MIT License | 4 votes |
|
parse( text, path ) {
function getElementsByTagName( xml, name ) {
// Non recursive xml.getElementsByTagName() ...
const array = [];
const childNodes = xml.childNodes;
for ( let i = 0, l = childNodes.length; i < l; i ++ ) {
const child = childNodes[ i ];
if ( child.nodeName === name ) {
array.push( child );
}
}
return array;
}
function parseStrings( text ) {
if ( text.length === 0 ) return [];
const parts = text.trim().split( /\s+/ );
const array = new Array( parts.length );
for ( let i = 0, l = parts.length; i < l; i ++ ) {
array[ i ] = parts[ i ];
}
return array;
}
function parseFloats( text ) {
if ( text.length === 0 ) return [];
const parts = text.trim().split( /\s+/ );
const array = new Array( parts.length );
for ( let i = 0, l = parts.length; i < l; i ++ ) {
array[ i ] = parseFloat( parts[ i ] );
}
return array;
}
function parseInts( text ) {
if ( text.length === 0 ) return [];
const parts = text.trim().split( /\s+/ );
const array = new Array( parts.length );
for ( let i = 0, l = parts.length; i < l; i ++ ) {
array[ i ] = parseInt( parts[ i ] );
}
return array;
}
function parseId( text ) {
return text.substring( 1 );
}
function generateId() {
return 'three_default_' + ( count ++ );
}
function isEmpty( object ) {
return Object.keys( object ).length === 0;
}
// asset
function parseAsset( xml ) {
return {
unit: parseAssetUnit( getElementsByTagName( xml, 'unit' )[ 0 ] ),
upAxis: parseAssetUpAxis( getElementsByTagName( xml, 'up_axis' )[ 0 ] )
};
}
function parseAssetUnit( xml ) {
if ( ( xml !== undefined ) && ( xml.hasAttribute( 'meter' ) === true ) ) {
return parseFloat( xml.getAttribute( 'meter' ) );
} else {
return 1; // default 1 meter
}
}
function parseAssetUpAxis( xml ) {
return xml !== undefined ? xml.textContent : 'Y_UP';
}
// library
function parseLibrary( xml, libraryName, nodeName, parser ) {
const library = getElementsByTagName( xml, libraryName )[ 0 ];
if ( library !== undefined ) {
const elements = getElementsByTagName( library, nodeName );
for ( let i = 0; i < elements.length; i ++ ) {
parser( elements[ i ] );
}
}
}
function buildLibrary( data, builder ) {
for ( const name in data ) {
const object = data[ name ];
object.build = builder( data[ name ] );
}
}
// get
function getBuild( data, builder ) {
if ( data.build !== undefined ) return data.build;
data.build = builder( data );
return data.build;
}
// animation
function parseAnimation( xml ) {
const data = {
sources: {},
samplers: {},
channels: {}
};
let hasChildren = false;
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
let id;
switch ( child.nodeName ) {
case 'source':
id = child.getAttribute( 'id' );
data.sources[ id ] = parseSource( child );
break;
case 'sampler':
id = child.getAttribute( 'id' );
data.samplers[ id ] = parseAnimationSampler( child );
break;
case 'channel':
id = child.getAttribute( 'target' );
data.channels[ id ] = parseAnimationChannel( child );
break;
case 'animation':
// hierarchy of related animations
parseAnimation( child );
hasChildren = true;
break;
default:
console.log( child );
}
}
if ( hasChildren === false ) {
// since 'id' attributes can be optional, it's necessary to generate a UUID for unqiue assignment
library.animations[ xml.getAttribute( 'id' ) || MathUtils.generateUUID() ] = data;
}
}
function parseAnimationSampler( xml ) {
const data = {
inputs: {},
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'input':
const id = parseId( child.getAttribute( 'source' ) );
const semantic = child.getAttribute( 'semantic' );
data.inputs[ semantic ] = id;
break;
}
}
return data;
}
function parseAnimationChannel( xml ) {
const data = {};
const target = xml.getAttribute( 'target' );
// parsing SID Addressing Syntax
let parts = target.split( '/' );
const id = parts.shift();
let sid = parts.shift();
// check selection syntax
const arraySyntax = ( sid.indexOf( '(' ) !== - 1 );
const memberSyntax = ( sid.indexOf( '.' ) !== - 1 );
if ( memberSyntax ) {
// member selection access
parts = sid.split( '.' );
sid = parts.shift();
data.member = parts.shift();
} else if ( arraySyntax ) {
// array-access syntax. can be used to express fields in one-dimensional vectors or two-dimensional matrices.
const indices = sid.split( '(' );
sid = indices.shift();
for ( let i = 0; i < indices.length; i ++ ) {
indices[ i ] = parseInt( indices[ i ].replace( /\)/, '' ) );
}
data.indices = indices;
}
data.id = id;
data.sid = sid;
data.arraySyntax = arraySyntax;
data.memberSyntax = memberSyntax;
data.sampler = parseId( xml.getAttribute( 'source' ) );
return data;
}
function buildAnimation( data ) {
const tracks = [];
const channels = data.channels;
const samplers = data.samplers;
const sources = data.sources;
for ( const target in channels ) {
if ( channels.hasOwnProperty( target ) ) {
const channel = channels[ target ];
const sampler = samplers[ channel.sampler ];
const inputId = sampler.inputs.INPUT;
const outputId = sampler.inputs.OUTPUT;
const inputSource = sources[ inputId ];
const outputSource = sources[ outputId ];
const animation = buildAnimationChannel( channel, inputSource, outputSource );
createKeyframeTracks( animation, tracks );
}
}
return tracks;
}
function getAnimation( id ) {
return getBuild( library.animations[ id ], buildAnimation );
}
function buildAnimationChannel( channel, inputSource, outputSource ) {
const node = library.nodes[ channel.id ];
const object3D = getNode( node.id );
const transform = node.transforms[ channel.sid ];
const defaultMatrix = node.matrix.clone().transpose();
let time, stride;
let i, il, j, jl;
const data = {};
// the collada spec allows the animation of data in various ways.
// depending on the transform type (matrix, translate, rotate, scale), we execute different logic
switch ( transform ) {
case 'matrix':
for ( i = 0, il = inputSource.array.length; i < il; i ++ ) {
time = inputSource.array[ i ];
stride = i * outputSource.stride;
if ( data[ time ] === undefined ) data[ time ] = {};
if ( channel.arraySyntax === true ) {
const value = outputSource.array[ stride ];
const index = channel.indices[ 0 ] + 4 * channel.indices[ 1 ];
data[ time ][ index ] = value;
} else {
for ( j = 0, jl = outputSource.stride; j < jl; j ++ ) {
data[ time ][ j ] = outputSource.array[ stride + j ];
}
}
}
break;
case 'translate':
console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
break;
case 'rotate':
console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
break;
case 'scale':
console.warn( 'THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', transform );
break;
}
const keyframes = prepareAnimationData( data, defaultMatrix );
const animation = {
name: object3D.uuid,
keyframes: keyframes
};
return animation;
}
function prepareAnimationData( data, defaultMatrix ) {
const keyframes = [];
// transfer data into a sortable array
for ( const time in data ) {
keyframes.push( { time: parseFloat( time ), value: data[ time ] } );
}
// ensure keyframes are sorted by time
keyframes.sort( ascending );
// now we clean up all animation data, so we can use them for keyframe tracks
for ( let i = 0; i < 16; i ++ ) {
transformAnimationData( keyframes, i, defaultMatrix.elements[ i ] );
}
return keyframes;
// array sort function
function ascending( a, b ) {
return a.time - b.time;
}
}
const position = new Vector3();
const scale = new Vector3();
const quaternion = new Quaternion();
function createKeyframeTracks( animation, tracks ) {
const keyframes = animation.keyframes;
const name = animation.name;
const times = [];
const positionData = [];
const quaternionData = [];
const scaleData = [];
for ( let i = 0, l = keyframes.length; i < l; i ++ ) {
const keyframe = keyframes[ i ];
const time = keyframe.time;
const value = keyframe.value;
matrix.fromArray( value ).transpose();
matrix.decompose( position, quaternion, scale );
times.push( time );
positionData.push( position.x, position.y, position.z );
quaternionData.push( quaternion.x, quaternion.y, quaternion.z, quaternion.w );
scaleData.push( scale.x, scale.y, scale.z );
}
if ( positionData.length > 0 ) tracks.push( new VectorKeyframeTrack( name + '.position', times, positionData ) );
if ( quaternionData.length > 0 ) tracks.push( new QuaternionKeyframeTrack( name + '.quaternion', times, quaternionData ) );
if ( scaleData.length > 0 ) tracks.push( new VectorKeyframeTrack( name + '.scale', times, scaleData ) );
return tracks;
}
function transformAnimationData( keyframes, property, defaultValue ) {
let keyframe;
let empty = true;
let i, l;
// check, if values of a property are missing in our keyframes
for ( i = 0, l = keyframes.length; i < l; i ++ ) {
keyframe = keyframes[ i ];
if ( keyframe.value[ property ] === undefined ) {
keyframe.value[ property ] = null; // mark as missing
} else {
empty = false;
}
}
if ( empty === true ) {
// no values at all, so we set a default value
for ( i = 0, l = keyframes.length; i < l; i ++ ) {
keyframe = keyframes[ i ];
keyframe.value[ property ] = defaultValue;
}
} else {
// filling gaps
createMissingKeyframes( keyframes, property );
}
}
function createMissingKeyframes( keyframes, property ) {
let prev, next;
for ( let i = 0, l = keyframes.length; i < l; i ++ ) {
const keyframe = keyframes[ i ];
if ( keyframe.value[ property ] === null ) {
prev = getPrev( keyframes, i, property );
next = getNext( keyframes, i, property );
if ( prev === null ) {
keyframe.value[ property ] = next.value[ property ];
continue;
}
if ( next === null ) {
keyframe.value[ property ] = prev.value[ property ];
continue;
}
interpolate( keyframe, prev, next, property );
}
}
}
function getPrev( keyframes, i, property ) {
while ( i >= 0 ) {
const keyframe = keyframes[ i ];
if ( keyframe.value[ property ] !== null ) return keyframe;
i --;
}
return null;
}
function getNext( keyframes, i, property ) {
while ( i < keyframes.length ) {
const keyframe = keyframes[ i ];
if ( keyframe.value[ property ] !== null ) return keyframe;
i ++;
}
return null;
}
function interpolate( key, prev, next, property ) {
if ( ( next.time - prev.time ) === 0 ) {
key.value[ property ] = prev.value[ property ];
return;
}
key.value[ property ] = ( ( key.time - prev.time ) * ( next.value[ property ] - prev.value[ property ] ) / ( next.time - prev.time ) ) + prev.value[ property ];
}
// animation clips
function parseAnimationClip( xml ) {
const data = {
name: xml.getAttribute( 'id' ) || 'default',
start: parseFloat( xml.getAttribute( 'start' ) || 0 ),
end: parseFloat( xml.getAttribute( 'end' ) || 0 ),
animations: []
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'instance_animation':
data.animations.push( parseId( child.getAttribute( 'url' ) ) );
break;
}
}
library.clips[ xml.getAttribute( 'id' ) ] = data;
}
function buildAnimationClip( data ) {
const tracks = [];
const name = data.name;
const duration = ( data.end - data.start ) || - 1;
const animations = data.animations;
for ( let i = 0, il = animations.length; i < il; i ++ ) {
const animationTracks = getAnimation( animations[ i ] );
for ( let j = 0, jl = animationTracks.length; j < jl; j ++ ) {
tracks.push( animationTracks[ j ] );
}
}
return new AnimationClip( name, duration, tracks );
}
function getAnimationClip( id ) {
return getBuild( library.clips[ id ], buildAnimationClip );
}
// controller
function parseController( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'skin':
// there is exactly one skin per controller
data.id = parseId( child.getAttribute( 'source' ) );
data.skin = parseSkin( child );
break;
case 'morph':
data.id = parseId( child.getAttribute( 'source' ) );
console.warn( 'THREE.ColladaLoader: Morph target animation not supported yet.' );
break;
}
}
library.controllers[ xml.getAttribute( 'id' ) ] = data;
}
function parseSkin( xml ) {
const data = {
sources: {}
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'bind_shape_matrix':
data.bindShapeMatrix = parseFloats( child.textContent );
break;
case 'source':
const id = child.getAttribute( 'id' );
data.sources[ id ] = parseSource( child );
break;
case 'joints':
data.joints = parseJoints( child );
break;
case 'vertex_weights':
data.vertexWeights = parseVertexWeights( child );
break;
}
}
return data;
}
function parseJoints( xml ) {
const data = {
inputs: {}
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'input':
const semantic = child.getAttribute( 'semantic' );
const id = parseId( child.getAttribute( 'source' ) );
data.inputs[ semantic ] = id;
break;
}
}
return data;
}
function parseVertexWeights( xml ) {
const data = {
inputs: {}
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'input':
const semantic = child.getAttribute( 'semantic' );
const id = parseId( child.getAttribute( 'source' ) );
const offset = parseInt( child.getAttribute( 'offset' ) );
data.inputs[ semantic ] = { id: id, offset: offset };
break;
case 'vcount':
data.vcount = parseInts( child.textContent );
break;
case 'v':
data.v = parseInts( child.textContent );
break;
}
}
return data;
}
function buildController( data ) {
const build = {
id: data.id
};
const geometry = library.geometries[ build.id ];
if ( data.skin !== undefined ) {
build.skin = buildSkin( data.skin );
// we enhance the 'sources' property of the corresponding geometry with our skin data
geometry.sources.skinIndices = build.skin.indices;
geometry.sources.skinWeights = build.skin.weights;
}
return build;
}
function buildSkin( data ) {
const BONE_LIMIT = 4;
const build = {
joints: [], // this must be an array to preserve the joint order
indices: {
array: [],
stride: BONE_LIMIT
},
weights: {
array: [],
stride: BONE_LIMIT
}
};
const sources = data.sources;
const vertexWeights = data.vertexWeights;
const vcount = vertexWeights.vcount;
const v = vertexWeights.v;
const jointOffset = vertexWeights.inputs.JOINT.offset;
const weightOffset = vertexWeights.inputs.WEIGHT.offset;
const jointSource = data.sources[ data.joints.inputs.JOINT ];
const inverseSource = data.sources[ data.joints.inputs.INV_BIND_MATRIX ];
const weights = sources[ vertexWeights.inputs.WEIGHT.id ].array;
let stride = 0;
let i, j, l;
// procces skin data for each vertex
for ( i = 0, l = vcount.length; i < l; i ++ ) {
const jointCount = vcount[ i ]; // this is the amount of joints that affect a single vertex
const vertexSkinData = [];
for ( j = 0; j < jointCount; j ++ ) {
const skinIndex = v[ stride + jointOffset ];
const weightId = v[ stride + weightOffset ];
const skinWeight = weights[ weightId ];
vertexSkinData.push( { index: skinIndex, weight: skinWeight } );
stride += 2;
}
// we sort the joints in descending order based on the weights.
// this ensures, we only procced the most important joints of the vertex
vertexSkinData.sort( descending );
// now we provide for each vertex a set of four index and weight values.
// the order of the skin data matches the order of vertices
for ( j = 0; j < BONE_LIMIT; j ++ ) {
const d = vertexSkinData[ j ];
if ( d !== undefined ) {
build.indices.array.push( d.index );
build.weights.array.push( d.weight );
} else {
build.indices.array.push( 0 );
build.weights.array.push( 0 );
}
}
}
// setup bind matrix
if ( data.bindShapeMatrix ) {
build.bindMatrix = new Matrix4().fromArray( data.bindShapeMatrix ).transpose();
} else {
build.bindMatrix = new Matrix4().identity();
}
// process bones and inverse bind matrix data
for ( i = 0, l = jointSource.array.length; i < l; i ++ ) {
const name = jointSource.array[ i ];
const boneInverse = new Matrix4().fromArray( inverseSource.array, i * inverseSource.stride ).transpose();
build.joints.push( { name: name, boneInverse: boneInverse } );
}
return build;
// array sort function
function descending( a, b ) {
return b.weight - a.weight;
}
}
function getController( id ) {
return getBuild( library.controllers[ id ], buildController );
}
// image
function parseImage( xml ) {
const data = {
init_from: getElementsByTagName( xml, 'init_from' )[ 0 ].textContent
};
library.images[ xml.getAttribute( 'id' ) ] = data;
}
function buildImage( data ) {
if ( data.build !== undefined ) return data.build;
return data.init_from;
}
function getImage( id ) {
const data = library.images[ id ];
if ( data !== undefined ) {
return getBuild( data, buildImage );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find image with ID:', id );
return null;
}
// effect
function parseEffect( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'profile_COMMON':
data.profile = parseEffectProfileCOMMON( child );
break;
}
}
library.effects[ xml.getAttribute( 'id' ) ] = data;
}
function parseEffectProfileCOMMON( xml ) {
const data = {
surfaces: {},
samplers: {}
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'newparam':
parseEffectNewparam( child, data );
break;
case 'technique':
data.technique = parseEffectTechnique( child );
break;
case 'extra':
data.extra = parseEffectExtra( child );
break;
}
}
return data;
}
function parseEffectNewparam( xml, data ) {
const sid = xml.getAttribute( 'sid' );
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'surface':
data.surfaces[ sid ] = parseEffectSurface( child );
break;
case 'sampler2D':
data.samplers[ sid ] = parseEffectSampler( child );
break;
}
}
}
function parseEffectSurface( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'init_from':
data.init_from = child.textContent;
break;
}
}
return data;
}
function parseEffectSampler( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'source':
data.source = child.textContent;
break;
}
}
return data;
}
function parseEffectTechnique( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'constant':
case 'lambert':
case 'blinn':
case 'phong':
data.type = child.nodeName;
data.parameters = parseEffectParameters( child );
break;
case 'extra':
data.extra = parseEffectExtra( child );
break;
}
}
return data;
}
function parseEffectParameters( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'emission':
case 'diffuse':
case 'specular':
case 'bump':
case 'ambient':
case 'shininess':
case 'transparency':
data[ child.nodeName ] = parseEffectParameter( child );
break;
case 'transparent':
data[ child.nodeName ] = {
opaque: child.hasAttribute( 'opaque' ) ? child.getAttribute( 'opaque' ) : 'A_ONE',
data: parseEffectParameter( child )
};
break;
}
}
return data;
}
function parseEffectParameter( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'color':
data[ child.nodeName ] = parseFloats( child.textContent );
break;
case 'float':
data[ child.nodeName ] = parseFloat( child.textContent );
break;
case 'texture':
data[ child.nodeName ] = { id: child.getAttribute( 'texture' ), extra: parseEffectParameterTexture( child ) };
break;
}
}
return data;
}
function parseEffectParameterTexture( xml ) {
const data = {
technique: {}
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'extra':
parseEffectParameterTextureExtra( child, data );
break;
}
}
return data;
}
function parseEffectParameterTextureExtra( xml, data ) {
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'technique':
parseEffectParameterTextureExtraTechnique( child, data );
break;
}
}
}
function parseEffectParameterTextureExtraTechnique( xml, data ) {
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'repeatU':
case 'repeatV':
case 'offsetU':
case 'offsetV':
data.technique[ child.nodeName ] = parseFloat( child.textContent );
break;
case 'wrapU':
case 'wrapV':
// some files have values for wrapU/wrapV which become NaN via parseInt
if ( child.textContent.toUpperCase() === 'TRUE' ) {
data.technique[ child.nodeName ] = 1;
} else if ( child.textContent.toUpperCase() === 'FALSE' ) {
data.technique[ child.nodeName ] = 0;
} else {
data.technique[ child.nodeName ] = parseInt( child.textContent );
}
break;
case 'bump':
data[ child.nodeName ] = parseEffectExtraTechniqueBump( child );
break;
}
}
}
function parseEffectExtra( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'technique':
data.technique = parseEffectExtraTechnique( child );
break;
}
}
return data;
}
function parseEffectExtraTechnique( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'double_sided':
data[ child.nodeName ] = parseInt( child.textContent );
break;
case 'bump':
data[ child.nodeName ] = parseEffectExtraTechniqueBump( child );
break;
}
}
return data;
}
function parseEffectExtraTechniqueBump( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'texture':
data[ child.nodeName ] = { id: child.getAttribute( 'texture' ), texcoord: child.getAttribute( 'texcoord' ), extra: parseEffectParameterTexture( child ) };
break;
}
}
return data;
}
function buildEffect( data ) {
return data;
}
function getEffect( id ) {
return getBuild( library.effects[ id ], buildEffect );
}
// material
function parseMaterial( xml ) {
const data = {
name: xml.getAttribute( 'name' )
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'instance_effect':
data.url = parseId( child.getAttribute( 'url' ) );
break;
}
}
library.materials[ xml.getAttribute( 'id' ) ] = data;
}
function getTextureLoader( image ) {
let loader;
let extension = image.slice( ( image.lastIndexOf( '.' ) - 1 >>> 0 ) + 2 ); // http://www.jstips.co/en/javascript/get-file-extension/
extension = extension.toLowerCase();
switch ( extension ) {
case 'tga':
loader = tgaLoader;
break;
default:
loader = textureLoader;
}
return loader;
}
function buildMaterial( data ) {
const effect = getEffect( data.url );
const technique = effect.profile.technique;
let material;
switch ( technique.type ) {
case 'phong':
case 'blinn':
material = new MeshPhongMaterial();
break;
case 'lambert':
material = new MeshLambertMaterial();
break;
default:
material = new MeshBasicMaterial();
break;
}
material.name = data.name || '';
function getTexture( textureObject, encoding = null ) {
const sampler = effect.profile.samplers[ textureObject.id ];
let image = null;
// get image
if ( sampler !== undefined ) {
const surface = effect.profile.surfaces[ sampler.source ];
image = getImage( surface.init_from );
} else {
console.warn( 'THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).' );
image = getImage( textureObject.id );
}
// create texture if image is avaiable
if ( image !== null ) {
const loader = getTextureLoader( image );
if ( loader !== undefined ) {
const texture = loader.load( image );
const extra = textureObject.extra;
if ( extra !== undefined && extra.technique !== undefined && isEmpty( extra.technique ) === false ) {
const technique = extra.technique;
texture.wrapS = technique.wrapU ? RepeatWrapping : ClampToEdgeWrapping;
texture.wrapT = technique.wrapV ? RepeatWrapping : ClampToEdgeWrapping;
texture.offset.set( technique.offsetU || 0, technique.offsetV || 0 );
texture.repeat.set( technique.repeatU || 1, technique.repeatV || 1 );
} else {
texture.wrapS = RepeatWrapping;
texture.wrapT = RepeatWrapping;
}
if ( encoding !== null ) {
texture.encoding = encoding;
}
return texture;
} else {
console.warn( 'THREE.ColladaLoader: Loader for texture %s not found.', image );
return null;
}
} else {
console.warn( 'THREE.ColladaLoader: Couldn\'t create texture with ID:', textureObject.id );
return null;
}
}
const parameters = technique.parameters;
for ( const key in parameters ) {
const parameter = parameters[ key ];
switch ( key ) {
case 'diffuse':
if ( parameter.color ) material.color.fromArray( parameter.color );
if ( parameter.texture ) material.map = getTexture( parameter.texture, sRGBEncoding );
break;
case 'specular':
if ( parameter.color && material.specular ) material.specular.fromArray( parameter.color );
if ( parameter.texture ) material.specularMap = getTexture( parameter.texture );
break;
case 'bump':
if ( parameter.texture ) material.normalMap = getTexture( parameter.texture );
break;
case 'ambient':
if ( parameter.texture ) material.lightMap = getTexture( parameter.texture, sRGBEncoding );
break;
case 'shininess':
if ( parameter.float && material.shininess ) material.shininess = parameter.float;
break;
case 'emission':
if ( parameter.color && material.emissive ) material.emissive.fromArray( parameter.color );
if ( parameter.texture ) material.emissiveMap = getTexture( parameter.texture, sRGBEncoding );
break;
}
}
material.color.convertSRGBToLinear();
if ( material.specular ) material.specular.convertSRGBToLinear();
if ( material.emissive ) material.emissive.convertSRGBToLinear();
//
let transparent = parameters[ 'transparent' ];
let transparency = parameters[ 'transparency' ];
// <transparency> does not exist but <transparent>
if ( transparency === undefined && transparent ) {
transparency = {
float: 1
};
}
// <transparent> does not exist but <transparency>
if ( transparent === undefined && transparency ) {
transparent = {
opaque: 'A_ONE',
data: {
color: [ 1, 1, 1, 1 ]
} };
}
if ( transparent && transparency ) {
// handle case if a texture exists but no color
if ( transparent.data.texture ) {
// we do not set an alpha map (see #13792)
material.transparent = true;
} else {
const color = transparent.data.color;
switch ( transparent.opaque ) {
case 'A_ONE':
material.opacity = color[ 3 ] * transparency.float;
break;
case 'RGB_ZERO':
material.opacity = 1 - ( color[ 0 ] * transparency.float );
break;
case 'A_ZERO':
material.opacity = 1 - ( color[ 3 ] * transparency.float );
break;
case 'RGB_ONE':
material.opacity = color[ 0 ] * transparency.float;
break;
default:
console.warn( 'THREE.ColladaLoader: Invalid opaque type "%s" of transparent tag.', transparent.opaque );
}
if ( material.opacity < 1 ) material.transparent = true;
}
}
//
if ( technique.extra !== undefined && technique.extra.technique !== undefined ) {
const techniques = technique.extra.technique;
for ( const k in techniques ) {
const v = techniques[ k ];
switch ( k ) {
case 'double_sided':
material.side = ( v === 1 ? DoubleSide : FrontSide );
break;
case 'bump':
material.normalMap = getTexture( v.texture );
material.normalScale = new Vector2( 1, 1 );
break;
}
}
}
return material;
}
function getMaterial( id ) {
return getBuild( library.materials[ id ], buildMaterial );
}
// camera
function parseCamera( xml ) {
const data = {
name: xml.getAttribute( 'name' )
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'optics':
data.optics = parseCameraOptics( child );
break;
}
}
library.cameras[ xml.getAttribute( 'id' ) ] = data;
}
function parseCameraOptics( xml ) {
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
switch ( child.nodeName ) {
case 'technique_common':
return parseCameraTechnique( child );
}
}
return {};
}
function parseCameraTechnique( xml ) {
const data = {};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
switch ( child.nodeName ) {
case 'perspective':
case 'orthographic':
data.technique = child.nodeName;
data.parameters = parseCameraParameters( child );
break;
}
}
return data;
}
function parseCameraParameters( xml ) {
const data = {};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
switch ( child.nodeName ) {
case 'xfov':
case 'yfov':
case 'xmag':
case 'ymag':
case 'znear':
case 'zfar':
case 'aspect_ratio':
data[ child.nodeName ] = parseFloat( child.textContent );
break;
}
}
return data;
}
function buildCamera( data ) {
let camera;
switch ( data.optics.technique ) {
case 'perspective':
camera = new PerspectiveCamera(
data.optics.parameters.yfov,
data.optics.parameters.aspect_ratio,
data.optics.parameters.znear,
data.optics.parameters.zfar
);
break;
case 'orthographic':
let ymag = data.optics.parameters.ymag;
let xmag = data.optics.parameters.xmag;
const aspectRatio = data.optics.parameters.aspect_ratio;
xmag = ( xmag === undefined ) ? ( ymag * aspectRatio ) : xmag;
ymag = ( ymag === undefined ) ? ( xmag / aspectRatio ) : ymag;
xmag *= 0.5;
ymag *= 0.5;
camera = new OrthographicCamera(
- xmag, xmag, ymag, - ymag, // left, right, top, bottom
data.optics.parameters.znear,
data.optics.parameters.zfar
);
break;
default:
camera = new PerspectiveCamera();
break;
}
camera.name = data.name || '';
return camera;
}
function getCamera( id ) {
const data = library.cameras[ id ];
if ( data !== undefined ) {
return getBuild( data, buildCamera );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find camera with ID:', id );
return null;
}
// light
function parseLight( xml ) {
let data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'technique_common':
data = parseLightTechnique( child );
break;
}
}
library.lights[ xml.getAttribute( 'id' ) ] = data;
}
function parseLightTechnique( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'directional':
case 'point':
case 'spot':
case 'ambient':
data.technique = child.nodeName;
data.parameters = parseLightParameters( child );
}
}
return data;
}
function parseLightParameters( xml ) {
const data = {};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'color':
const array = parseFloats( child.textContent );
data.color = new Color().fromArray( array ).convertSRGBToLinear();
break;
case 'falloff_angle':
data.falloffAngle = parseFloat( child.textContent );
break;
case 'quadratic_attenuation':
const f = parseFloat( child.textContent );
data.distance = f ? Math.sqrt( 1 / f ) : 0;
break;
}
}
return data;
}
function buildLight( data ) {
let light;
switch ( data.technique ) {
case 'directional':
light = new DirectionalLight();
break;
case 'point':
light = new PointLight();
break;
case 'spot':
light = new SpotLight();
break;
case 'ambient':
light = new AmbientLight();
break;
}
if ( data.parameters.color ) light.color.copy( data.parameters.color );
if ( data.parameters.distance ) light.distance = data.parameters.distance;
return light;
}
function getLight( id ) {
const data = library.lights[ id ];
if ( data !== undefined ) {
return getBuild( data, buildLight );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find light with ID:', id );
return null;
}
// geometry
function parseGeometry( xml ) {
const data = {
name: xml.getAttribute( 'name' ),
sources: {},
vertices: {},
primitives: []
};
const mesh = getElementsByTagName( xml, 'mesh' )[ 0 ];
// the following tags inside geometry are not supported yet (see https://github.com/mrdoob/three.js/pull/12606): convex_mesh, spline, brep
if ( mesh === undefined ) return;
for ( let i = 0; i < mesh.childNodes.length; i ++ ) {
const child = mesh.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
const id = child.getAttribute( 'id' );
switch ( child.nodeName ) {
case 'source':
data.sources[ id ] = parseSource( child );
break;
case 'vertices':
// data.sources[ id ] = data.sources[ parseId( getElementsByTagName( child, 'input' )[ 0 ].getAttribute( 'source' ) ) ];
data.vertices = parseGeometryVertices( child );
break;
case 'polygons':
console.warn( 'THREE.ColladaLoader: Unsupported primitive type: ', child.nodeName );
break;
case 'lines':
case 'linestrips':
case 'polylist':
case 'triangles':
data.primitives.push( parseGeometryPrimitive( child ) );
break;
default:
console.log( child );
}
}
library.geometries[ xml.getAttribute( 'id' ) ] = data;
}
function parseSource( xml ) {
const data = {
array: [],
stride: 3
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'float_array':
data.array = parseFloats( child.textContent );
break;
case 'Name_array':
data.array = parseStrings( child.textContent );
break;
case 'technique_common':
const accessor = getElementsByTagName( child, 'accessor' )[ 0 ];
if ( accessor !== undefined ) {
data.stride = parseInt( accessor.getAttribute( 'stride' ) );
}
break;
}
}
return data;
}
function parseGeometryVertices( xml ) {
const data = {};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
data[ child.getAttribute( 'semantic' ) ] = parseId( child.getAttribute( 'source' ) );
}
return data;
}
function parseGeometryPrimitive( xml ) {
const primitive = {
type: xml.nodeName,
material: xml.getAttribute( 'material' ),
count: parseInt( xml.getAttribute( 'count' ) ),
inputs: {},
stride: 0,
hasUV: false
};
for ( let i = 0, l = xml.childNodes.length; i < l; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'input':
const id = parseId( child.getAttribute( 'source' ) );
const semantic = child.getAttribute( 'semantic' );
const offset = parseInt( child.getAttribute( 'offset' ) );
const set = parseInt( child.getAttribute( 'set' ) );
const inputname = ( set > 0 ? semantic + set : semantic );
primitive.inputs[ inputname ] = { id: id, offset: offset };
primitive.stride = Math.max( primitive.stride, offset + 1 );
if ( semantic === 'TEXCOORD' ) primitive.hasUV = true;
break;
case 'vcount':
primitive.vcount = parseInts( child.textContent );
break;
case 'p':
primitive.p = parseInts( child.textContent );
break;
}
}
return primitive;
}
function groupPrimitives( primitives ) {
const build = {};
for ( let i = 0; i < primitives.length; i ++ ) {
const primitive = primitives[ i ];
if ( build[ primitive.type ] === undefined ) build[ primitive.type ] = [];
build[ primitive.type ].push( primitive );
}
return build;
}
function checkUVCoordinates( primitives ) {
let count = 0;
for ( let i = 0, l = primitives.length; i < l; i ++ ) {
const primitive = primitives[ i ];
if ( primitive.hasUV === true ) {
count ++;
}
}
if ( count > 0 && count < primitives.length ) {
primitives.uvsNeedsFix = true;
}
}
function buildGeometry( data ) {
const build = {};
const sources = data.sources;
const vertices = data.vertices;
const primitives = data.primitives;
if ( primitives.length === 0 ) return {};
// our goal is to create one buffer geometry for a single type of primitives
// first, we group all primitives by their type
const groupedPrimitives = groupPrimitives( primitives );
for ( const type in groupedPrimitives ) {
const primitiveType = groupedPrimitives[ type ];
// second, ensure consistent uv coordinates for each type of primitives (polylist,triangles or lines)
checkUVCoordinates( primitiveType );
// third, create a buffer geometry for each type of primitives
build[ type ] = buildGeometryType( primitiveType, sources, vertices );
}
return build;
}
function buildGeometryType( primitives, sources, vertices ) {
const build = {};
const position = { array: [], stride: 0 };
const normal = { array: [], stride: 0 };
const uv = { array: [], stride: 0 };
const uv2 = { array: [], stride: 0 };
const color = { array: [], stride: 0 };
const skinIndex = { array: [], stride: 4 };
const skinWeight = { array: [], stride: 4 };
const geometry = new BufferGeometry();
const materialKeys = [];
let start = 0;
for ( let p = 0; p < primitives.length; p ++ ) {
const primitive = primitives[ p ];
const inputs = primitive.inputs;
// groups
let count = 0;
switch ( primitive.type ) {
case 'lines':
case 'linestrips':
count = primitive.count * 2;
break;
case 'triangles':
count = primitive.count * 3;
break;
case 'polylist':
for ( let g = 0; g < primitive.count; g ++ ) {
const vc = primitive.vcount[ g ];
switch ( vc ) {
case 3:
count += 3; // single triangle
break;
case 4:
count += 6; // quad, subdivided into two triangles
break;
default:
count += ( vc - 2 ) * 3; // polylist with more than four vertices
break;
}
}
break;
default:
console.warn( 'THREE.ColladaLoader: Unknow primitive type:', primitive.type );
}
geometry.addGroup( start, count, p );
start += count;
// material
if ( primitive.material ) {
materialKeys.push( primitive.material );
}
// geometry data
for ( const name in inputs ) {
const input = inputs[ name ];
switch ( name ) {
case 'VERTEX':
for ( const key in vertices ) {
const id = vertices[ key ];
switch ( key ) {
case 'POSITION':
const prevLength = position.array.length;
buildGeometryData( primitive, sources[ id ], input.offset, position.array );
position.stride = sources[ id ].stride;
if ( sources.skinWeights && sources.skinIndices ) {
buildGeometryData( primitive, sources.skinIndices, input.offset, skinIndex.array );
buildGeometryData( primitive, sources.skinWeights, input.offset, skinWeight.array );
}
// see #3803
if ( primitive.hasUV === false && primitives.uvsNeedsFix === true ) {
const count = ( position.array.length - prevLength ) / position.stride;
for ( let i = 0; i < count; i ++ ) {
// fill missing uv coordinates
uv.array.push( 0, 0 );
}
}
break;
case 'NORMAL':
buildGeometryData( primitive, sources[ id ], input.offset, normal.array );
normal.stride = sources[ id ].stride;
break;
case 'COLOR':
buildGeometryData( primitive, sources[ id ], input.offset, color.array );
color.stride = sources[ id ].stride;
break;
case 'TEXCOORD':
buildGeometryData( primitive, sources[ id ], input.offset, uv.array );
uv.stride = sources[ id ].stride;
break;
case 'TEXCOORD1':
buildGeometryData( primitive, sources[ id ], input.offset, uv2.array );
uv.stride = sources[ id ].stride;
break;
default:
console.warn( 'THREE.ColladaLoader: Semantic "%s" not handled in geometry build process.', key );
}
}
break;
case 'NORMAL':
buildGeometryData( primitive, sources[ input.id ], input.offset, normal.array );
normal.stride = sources[ input.id ].stride;
break;
case 'COLOR':
buildGeometryData( primitive, sources[ input.id ], input.offset, color.array, true );
color.stride = sources[ input.id ].stride;
break;
case 'TEXCOORD':
buildGeometryData( primitive, sources[ input.id ], input.offset, uv.array );
uv.stride = sources[ input.id ].stride;
break;
case 'TEXCOORD1':
buildGeometryData( primitive, sources[ input.id ], input.offset, uv2.array );
uv2.stride = sources[ input.id ].stride;
break;
}
}
}
// build geometry
if ( position.array.length > 0 ) geometry.setAttribute( 'position', new Float32BufferAttribute( position.array, position.stride ) );
if ( normal.array.length > 0 ) geometry.setAttribute( 'normal', new Float32BufferAttribute( normal.array, normal.stride ) );
if ( color.array.length > 0 ) geometry.setAttribute( 'color', new Float32BufferAttribute( color.array, color.stride ) );
if ( uv.array.length > 0 ) geometry.setAttribute( 'uv', new Float32BufferAttribute( uv.array, uv.stride ) );
if ( uv2.array.length > 0 ) geometry.setAttribute( 'uv2', new Float32BufferAttribute( uv2.array, uv2.stride ) );
if ( skinIndex.array.length > 0 ) geometry.setAttribute( 'skinIndex', new Float32BufferAttribute( skinIndex.array, skinIndex.stride ) );
if ( skinWeight.array.length > 0 ) geometry.setAttribute( 'skinWeight', new Float32BufferAttribute( skinWeight.array, skinWeight.stride ) );
build.data = geometry;
build.type = primitives[ 0 ].type;
build.materialKeys = materialKeys;
return build;
}
function buildGeometryData( primitive, source, offset, array, isColor = false ) {
const indices = primitive.p;
const stride = primitive.stride;
const vcount = primitive.vcount;
function pushVector( i ) {
let index = indices[ i + offset ] * sourceStride;
const length = index + sourceStride;
for ( ; index < length; index ++ ) {
array.push( sourceArray[ index ] );
}
if ( isColor ) {
// convert the vertex colors from srgb to linear if present
const startIndex = array.length - sourceStride - 1;
tempColor.setRGB(
array[ startIndex + 0 ],
array[ startIndex + 1 ],
array[ startIndex + 2 ]
).convertSRGBToLinear();
array[ startIndex + 0 ] = tempColor.r;
array[ startIndex + 1 ] = tempColor.g;
array[ startIndex + 2 ] = tempColor.b;
}
}
const sourceArray = source.array;
const sourceStride = source.stride;
if ( primitive.vcount !== undefined ) {
let index = 0;
for ( let i = 0, l = vcount.length; i < l; i ++ ) {
const count = vcount[ i ];
if ( count === 4 ) {
const a = index + stride * 0;
const b = index + stride * 1;
const c = index + stride * 2;
const d = index + stride * 3;
pushVector( a ); pushVector( b ); pushVector( d );
pushVector( b ); pushVector( c ); pushVector( d );
} else if ( count === 3 ) {
const a = index + stride * 0;
const b = index + stride * 1;
const c = index + stride * 2;
pushVector( a ); pushVector( b ); pushVector( c );
} else if ( count > 4 ) {
for ( let k = 1, kl = ( count - 2 ); k <= kl; k ++ ) {
const a = index + stride * 0;
const b = index + stride * k;
const c = index + stride * ( k + 1 );
pushVector( a ); pushVector( b ); pushVector( c );
}
}
index += stride * count;
}
} else {
for ( let i = 0, l = indices.length; i < l; i += stride ) {
pushVector( i );
}
}
}
function getGeometry( id ) {
return getBuild( library.geometries[ id ], buildGeometry );
}
// kinematics
function parseKinematicsModel( xml ) {
const data = {
name: xml.getAttribute( 'name' ) || '',
joints: {},
links: []
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'technique_common':
parseKinematicsTechniqueCommon( child, data );
break;
}
}
library.kinematicsModels[ xml.getAttribute( 'id' ) ] = data;
}
function buildKinematicsModel( data ) {
if ( data.build !== undefined ) return data.build;
return data;
}
function getKinematicsModel( id ) {
return getBuild( library.kinematicsModels[ id ], buildKinematicsModel );
}
function parseKinematicsTechniqueCommon( xml, data ) {
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'joint':
data.joints[ child.getAttribute( 'sid' ) ] = parseKinematicsJoint( child );
break;
case 'link':
data.links.push( parseKinematicsLink( child ) );
break;
}
}
}
function parseKinematicsJoint( xml ) {
let data;
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'prismatic':
case 'revolute':
data = parseKinematicsJointParameter( child );
break;
}
}
return data;
}
function parseKinematicsJointParameter( xml ) {
const data = {
sid: xml.getAttribute( 'sid' ),
name: xml.getAttribute( 'name' ) || '',
axis: new Vector3(),
limits: {
min: 0,
max: 0
},
type: xml.nodeName,
static: false,
zeroPosition: 0,
middlePosition: 0
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'axis':
const array = parseFloats( child.textContent );
data.axis.fromArray( array );
break;
case 'limits':
const max = child.getElementsByTagName( 'max' )[ 0 ];
const min = child.getElementsByTagName( 'min' )[ 0 ];
data.limits.max = parseFloat( max.textContent );
data.limits.min = parseFloat( min.textContent );
break;
}
}
// if min is equal to or greater than max, consider the joint static
if ( data.limits.min >= data.limits.max ) {
data.static = true;
}
// calculate middle position
data.middlePosition = ( data.limits.min + data.limits.max ) / 2.0;
return data;
}
function parseKinematicsLink( xml ) {
const data = {
sid: xml.getAttribute( 'sid' ),
name: xml.getAttribute( 'name' ) || '',
attachments: [],
transforms: []
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'attachment_full':
data.attachments.push( parseKinematicsAttachment( child ) );
break;
case 'matrix':
case 'translate':
case 'rotate':
data.transforms.push( parseKinematicsTransform( child ) );
break;
}
}
return data;
}
function parseKinematicsAttachment( xml ) {
const data = {
joint: xml.getAttribute( 'joint' ).split( '/' ).pop(),
transforms: [],
links: []
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'link':
data.links.push( parseKinematicsLink( child ) );
break;
case 'matrix':
case 'translate':
case 'rotate':
data.transforms.push( parseKinematicsTransform( child ) );
break;
}
}
return data;
}
function parseKinematicsTransform( xml ) {
const data = {
type: xml.nodeName
};
const array = parseFloats( xml.textContent );
switch ( data.type ) {
case 'matrix':
data.obj = new Matrix4();
data.obj.fromArray( array ).transpose();
break;
case 'translate':
data.obj = new Vector3();
data.obj.fromArray( array );
break;
case 'rotate':
data.obj = new Vector3();
data.obj.fromArray( array );
data.angle = MathUtils.degToRad( array[ 3 ] );
break;
}
return data;
}
// physics
function parsePhysicsModel( xml ) {
const data = {
name: xml.getAttribute( 'name' ) || '',
rigidBodies: {}
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'rigid_body':
data.rigidBodies[ child.getAttribute( 'name' ) ] = {};
parsePhysicsRigidBody( child, data.rigidBodies[ child.getAttribute( 'name' ) ] );
break;
}
}
library.physicsModels[ xml.getAttribute( 'id' ) ] = data;
}
function parsePhysicsRigidBody( xml, data ) {
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'technique_common':
parsePhysicsTechniqueCommon( child, data );
break;
}
}
}
function parsePhysicsTechniqueCommon( xml, data ) {
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'inertia':
data.inertia = parseFloats( child.textContent );
break;
case 'mass':
data.mass = parseFloats( child.textContent )[ 0 ];
break;
}
}
}
// scene
function parseKinematicsScene( xml ) {
const data = {
bindJointAxis: []
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'bind_joint_axis':
data.bindJointAxis.push( parseKinematicsBindJointAxis( child ) );
break;
}
}
library.kinematicsScenes[ parseId( xml.getAttribute( 'url' ) ) ] = data;
}
function parseKinematicsBindJointAxis( xml ) {
const data = {
target: xml.getAttribute( 'target' ).split( '/' ).pop()
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
switch ( child.nodeName ) {
case 'axis':
const param = child.getElementsByTagName( 'param' )[ 0 ];
data.axis = param.textContent;
const tmpJointIndex = data.axis.split( 'inst_' ).pop().split( 'axis' )[ 0 ];
data.jointIndex = tmpJointIndex.substr( 0, tmpJointIndex.length - 1 );
break;
}
}
return data;
}
function buildKinematicsScene( data ) {
if ( data.build !== undefined ) return data.build;
return data;
}
function getKinematicsScene( id ) {
return getBuild( library.kinematicsScenes[ id ], buildKinematicsScene );
}
function setupKinematics() {
const kinematicsModelId = Object.keys( library.kinematicsModels )[ 0 ];
const kinematicsSceneId = Object.keys( library.kinematicsScenes )[ 0 ];
const visualSceneId = Object.keys( library.visualScenes )[ 0 ];
if ( kinematicsModelId === undefined || kinematicsSceneId === undefined ) return;
const kinematicsModel = getKinematicsModel( kinematicsModelId );
const kinematicsScene = getKinematicsScene( kinematicsSceneId );
const visualScene = getVisualScene( visualSceneId );
const bindJointAxis = kinematicsScene.bindJointAxis;
const jointMap = {};
for ( let i = 0, l = bindJointAxis.length; i < l; i ++ ) {
const axis = bindJointAxis[ i ];
// the result of the following query is an element of type 'translate', 'rotate','scale' or 'matrix'
const targetElement = collada.querySelector( '[sid="' + axis.target + '"]' );
if ( targetElement ) {
// get the parent of the transform element
const parentVisualElement = targetElement.parentElement;
// connect the joint of the kinematics model with the element in the visual scene
connect( axis.jointIndex, parentVisualElement );
}
}
function connect( jointIndex, visualElement ) {
const visualElementName = visualElement.getAttribute( 'name' );
const joint = kinematicsModel.joints[ jointIndex ];
visualScene.traverse( function ( object ) {
if ( object.name === visualElementName ) {
jointMap[ jointIndex ] = {
object: object,
transforms: buildTransformList( visualElement ),
joint: joint,
position: joint.zeroPosition
};
}
} );
}
const m0 = new Matrix4();
kinematics = {
joints: kinematicsModel && kinematicsModel.joints,
getJointValue: function ( jointIndex ) {
const jointData = jointMap[ jointIndex ];
if ( jointData ) {
return jointData.position;
} else {
console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' doesn\'t exist.' );
}
},
setJointValue: function ( jointIndex, value ) {
const jointData = jointMap[ jointIndex ];
if ( jointData ) {
const joint = jointData.joint;
if ( value > joint.limits.max || value < joint.limits.min ) {
console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' value ' + value + ' outside of limits (min: ' + joint.limits.min + ', max: ' + joint.limits.max + ').' );
} else if ( joint.static ) {
console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' is static.' );
} else {
const object = jointData.object;
const axis = joint.axis;
const transforms = jointData.transforms;
matrix.identity();
// each update, we have to apply all transforms in the correct order
for ( let i = 0; i < transforms.length; i ++ ) {
const transform = transforms[ i ];
// if there is a connection of the transform node with a joint, apply the joint value
if ( transform.sid && transform.sid.indexOf( jointIndex ) !== - 1 ) {
switch ( joint.type ) {
case 'revolute':
matrix.multiply( m0.makeRotationAxis( axis, MathUtils.degToRad( value ) ) );
break;
case 'prismatic':
matrix.multiply( m0.makeTranslation( axis.x * value, axis.y * value, axis.z * value ) );
break;
default:
console.warn( 'THREE.ColladaLoader: Unknown joint type: ' + joint.type );
break;
}
} else {
switch ( transform.type ) {
case 'matrix':
matrix.multiply( transform.obj );
break;
case 'translate':
matrix.multiply( m0.makeTranslation( transform.obj.x, transform.obj.y, transform.obj.z ) );
break;
case 'scale':
matrix.scale( transform.obj );
break;
case 'rotate':
matrix.multiply( m0.makeRotationAxis( transform.obj, transform.angle ) );
break;
}
}
}
object.matrix.copy( matrix );
object.matrix.decompose( object.position, object.quaternion, object.scale );
jointMap[ jointIndex ].position = value;
}
} else {
console.log( 'THREE.ColladaLoader: ' + jointIndex + ' does not exist.' );
}
}
};
}
function buildTransformList( node ) {
const transforms = [];
const xml = collada.querySelector( '[id="' + node.id + '"]' );
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
let array, vector;
switch ( child.nodeName ) {
case 'matrix':
array = parseFloats( child.textContent );
const matrix = new Matrix4().fromArray( array ).transpose();
transforms.push( {
sid: child.getAttribute( 'sid' ),
type: child.nodeName,
obj: matrix
} );
break;
case 'translate':
case 'scale':
array = parseFloats( child.textContent );
vector = new Vector3().fromArray( array );
transforms.push( {
sid: child.getAttribute( 'sid' ),
type: child.nodeName,
obj: vector
} );
break;
case 'rotate':
array = parseFloats( child.textContent );
vector = new Vector3().fromArray( array );
const angle = MathUtils.degToRad( array[ 3 ] );
transforms.push( {
sid: child.getAttribute( 'sid' ),
type: child.nodeName,
obj: vector,
angle: angle
} );
break;
}
}
return transforms;
}
// nodes
function prepareNodes( xml ) {
const elements = xml.getElementsByTagName( 'node' );
// ensure all node elements have id attributes
for ( let i = 0; i < elements.length; i ++ ) {
const element = elements[ i ];
if ( element.hasAttribute( 'id' ) === false ) {
element.setAttribute( 'id', generateId() );
}
}
}
const matrix = new Matrix4();
const vector = new Vector3();
function parseNode( xml ) {
const data = {
name: xml.getAttribute( 'name' ) || '',
type: xml.getAttribute( 'type' ),
id: xml.getAttribute( 'id' ),
sid: xml.getAttribute( 'sid' ),
matrix: new Matrix4(),
nodes: [],
instanceCameras: [],
instanceControllers: [],
instanceLights: [],
instanceGeometries: [],
instanceNodes: [],
transforms: {}
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
if ( child.nodeType !== 1 ) continue;
let array;
switch ( child.nodeName ) {
case 'node':
data.nodes.push( child.getAttribute( 'id' ) );
parseNode( child );
break;
case 'instance_camera':
data.instanceCameras.push( parseId( child.getAttribute( 'url' ) ) );
break;
case 'instance_controller':
data.instanceControllers.push( parseNodeInstance( child ) );
break;
case 'instance_light':
data.instanceLights.push( parseId( child.getAttribute( 'url' ) ) );
break;
case 'instance_geometry':
data.instanceGeometries.push( parseNodeInstance( child ) );
break;
case 'instance_node':
data.instanceNodes.push( parseId( child.getAttribute( 'url' ) ) );
break;
case 'matrix':
array = parseFloats( child.textContent );
data.matrix.multiply( matrix.fromArray( array ).transpose() );
data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
break;
case 'translate':
array = parseFloats( child.textContent );
vector.fromArray( array );
data.matrix.multiply( matrix.makeTranslation( vector.x, vector.y, vector.z ) );
data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
break;
case 'rotate':
array = parseFloats( child.textContent );
const angle = MathUtils.degToRad( array[ 3 ] );
data.matrix.multiply( matrix.makeRotationAxis( vector.fromArray( array ), angle ) );
data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
break;
case 'scale':
array = parseFloats( child.textContent );
data.matrix.scale( vector.fromArray( array ) );
data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName;
break;
case 'extra':
break;
default:
console.log( child );
}
}
if ( hasNode( data.id ) ) {
console.warn( 'THREE.ColladaLoader: There is already a node with ID %s. Exclude current node from further processing.', data.id );
} else {
library.nodes[ data.id ] = data;
}
return data;
}
function parseNodeInstance( xml ) {
const data = {
id: parseId( xml.getAttribute( 'url' ) ),
materials: {},
skeletons: []
};
for ( let i = 0; i < xml.childNodes.length; i ++ ) {
const child = xml.childNodes[ i ];
switch ( child.nodeName ) {
case 'bind_material':
const instances = child.getElementsByTagName( 'instance_material' );
for ( let j = 0; j < instances.length; j ++ ) {
const instance = instances[ j ];
const symbol = instance.getAttribute( 'symbol' );
const target = instance.getAttribute( 'target' );
data.materials[ symbol ] = parseId( target );
}
break;
case 'skeleton':
data.skeletons.push( parseId( child.textContent ) );
break;
default:
break;
}
}
return data;
}
function buildSkeleton( skeletons, joints ) {
const boneData = [];
const sortedBoneData = [];
let i, j, data;
// a skeleton can have multiple root bones. collada expresses this
// situtation with multiple "skeleton" tags per controller instance
for ( i = 0; i < skeletons.length; i ++ ) {
const skeleton = skeletons[ i ];
let root;
if ( hasNode( skeleton ) ) {
root = getNode( skeleton );
buildBoneHierarchy( root, joints, boneData );
} else if ( hasVisualScene( skeleton ) ) {
// handle case where the skeleton refers to the visual scene (#13335)
const visualScene = library.visualScenes[ skeleton ];
const children = visualScene.children;
for ( let j = 0; j < children.length; j ++ ) {
const child = children[ j ];
if ( child.type === 'JOINT' ) {
const root = getNode( child.id );
buildBoneHierarchy( root, joints, boneData );
}
}
} else {
console.error( 'THREE.ColladaLoader: Unable to find root bone of skeleton with ID:', skeleton );
}
}
// sort bone data (the order is defined in the corresponding controller)
for ( i = 0; i < joints.length; i ++ ) {
for ( j = 0; j < boneData.length; j ++ ) {
data = boneData[ j ];
if ( data.bone.name === joints[ i ].name ) {
sortedBoneData[ i ] = data;
data.processed = true;
break;
}
}
}
// add unprocessed bone data at the end of the list
for ( i = 0; i < boneData.length; i ++ ) {
data = boneData[ i ];
if ( data.processed === false ) {
sortedBoneData.push( data );
data.processed = true;
}
}
// setup arrays for skeleton creation
const bones = [];
const boneInverses = [];
for ( i = 0; i < sortedBoneData.length; i ++ ) {
data = sortedBoneData[ i ];
bones.push( data.bone );
boneInverses.push( data.boneInverse );
}
return new Skeleton( bones, boneInverses );
}
function buildBoneHierarchy( root, joints, boneData ) {
// setup bone data from visual scene
root.traverse( function ( object ) {
if ( object.isBone === true ) {
let boneInverse;
// retrieve the boneInverse from the controller data
for ( let i = 0; i < joints.length; i ++ ) {
const joint = joints[ i ];
if ( joint.name === object.name ) {
boneInverse = joint.boneInverse;
break;
}
}
if ( boneInverse === undefined ) {
// Unfortunately, there can be joints in the visual scene that are not part of the
// corresponding controller. In this case, we have to create a dummy boneInverse matrix
// for the respective bone. This bone won't affect any vertices, because there are no skin indices
// and weights defined for it. But we still have to add the bone to the sorted bone list in order to
// ensure a correct animation of the model.
boneInverse = new Matrix4();
}
boneData.push( { bone: object, boneInverse: boneInverse, processed: false } );
}
} );
}
function buildNode( data ) {
const objects = [];
const matrix = data.matrix;
const nodes = data.nodes;
const type = data.type;
const instanceCameras = data.instanceCameras;
const instanceControllers = data.instanceControllers;
const instanceLights = data.instanceLights;
const instanceGeometries = data.instanceGeometries;
const instanceNodes = data.instanceNodes;
// nodes
for ( let i = 0, l = nodes.length; i < l; i ++ ) {
objects.push( getNode( nodes[ i ] ) );
}
// instance cameras
for ( let i = 0, l = instanceCameras.length; i < l; i ++ ) {
const instanceCamera = getCamera( instanceCameras[ i ] );
if ( instanceCamera !== null ) {
objects.push( instanceCamera.clone() );
}
}
// instance controllers
for ( let i = 0, l = instanceControllers.length; i < l; i ++ ) {
const instance = instanceControllers[ i ];
const controller = getController( instance.id );
const geometries = getGeometry( controller.id );
const newObjects = buildObjects( geometries, instance.materials );
const skeletons = instance.skeletons;
const joints = controller.skin.joints;
const skeleton = buildSkeleton( skeletons, joints );
for ( let j = 0, jl = newObjects.length; j < jl; j ++ ) {
const object = newObjects[ j ];
if ( object.isSkinnedMesh ) {
object.bind( skeleton, controller.skin.bindMatrix );
object.normalizeSkinWeights();
}
objects.push( object );
}
}
// instance lights
for ( let i = 0, l = instanceLights.length; i < l; i ++ ) {
const instanceLight = getLight( instanceLights[ i ] );
if ( instanceLight !== null ) {
objects.push( instanceLight.clone() );
}
}
// instance geometries
for ( let i = 0, l = instanceGeometries.length; i < l; i ++ ) {
const instance = instanceGeometries[ i ];
// a single geometry instance in collada can lead to multiple object3Ds.
// this is the case when primitives are combined like triangles and lines
const geometries = getGeometry( instance.id );
const newObjects = buildObjects( geometries, instance.materials );
for ( let j = 0, jl = newObjects.length; j < jl; j ++ ) {
objects.push( newObjects[ j ] );
}
}
// instance nodes
for ( let i = 0, l = instanceNodes.length; i < l; i ++ ) {
objects.push( getNode( instanceNodes[ i ] ).clone() );
}
let object;
if ( nodes.length === 0 && objects.length === 1 ) {
object = objects[ 0 ];
} else {
object = ( type === 'JOINT' ) ? new Bone() : new Group();
for ( let i = 0; i < objects.length; i ++ ) {
object.add( objects[ i ] );
}
}
object.name = ( type === 'JOINT' ) ? data.sid : data.name;
object.matrix.copy( matrix );
object.matrix.decompose( object.position, object.quaternion, object.scale );
return object;
}
const fallbackMaterial = new MeshBasicMaterial( { color: 0xff00ff } );
function resolveMaterialBinding( keys, instanceMaterials ) {
const materials = [];
for ( let i = 0, l = keys.length; i < l; i ++ ) {
const id = instanceMaterials[ keys[ i ] ];
if ( id === undefined ) {
console.warn( 'THREE.ColladaLoader: Material with key %s not found. Apply fallback material.', keys[ i ] );
materials.push( fallbackMaterial );
} else {
materials.push( getMaterial( id ) );
}
}
return materials;
}
function buildObjects( geometries, instanceMaterials ) {
const objects = [];
for ( const type in geometries ) {
const geometry = geometries[ type ];
const materials = resolveMaterialBinding( geometry.materialKeys, instanceMaterials );
// handle case if no materials are defined
if ( materials.length === 0 ) {
if ( type === 'lines' || type === 'linestrips' ) {
materials.push( new LineBasicMaterial() );
} else {
materials.push( new MeshPhongMaterial() );
}
}
// regard skinning
const skinning = ( geometry.data.attributes.skinIndex !== undefined );
// choose between a single or multi materials (material array)
const material = ( materials.length === 1 ) ? materials[ 0 ] : materials;
// now create a specific 3D object
let object;
switch ( type ) {
case 'lines':
object = new LineSegments( geometry.data, material );
break;
case 'linestrips':
object = new Line( geometry.data, material );
break;
case 'triangles':
case 'polylist':
if ( skinning ) {
object = new SkinnedMesh( geometry.data, material );
} else {
object = new Mesh( geometry.data, material );
}
break;
}
objects.push( object );
}
return objects;
}
function hasNode( id ) {
return library.nodes[ id ] !== undefined;
}
function getNode( id ) {
return getBuild( library.nodes[ id ], buildNode );
}
// visual scenes
function parseVisualScene( xml ) {
const data = {
name: xml.getAttribute( 'name' ),
children: []
};
prepareNodes( xml );
const elements = getElementsByTagName( xml, 'node' );
for ( let i = 0; i < elements.length; i ++ ) {
data.children.push( parseNode( elements[ i ] ) );
}
library.visualScenes[ xml.getAttribute( 'id' ) ] = data;
}
function buildVisualScene( data ) {
const group = new Group();
group.name = data.name;
const children = data.children;
for ( let i = 0; i < children.length; i ++ ) {
const child = children[ i ];
group.add( getNode( child.id ) );
}
return group;
}
function hasVisualScene( id ) {
return library.visualScenes[ id ] !== undefined;
}
function getVisualScene( id ) {
return getBuild( library.visualScenes[ id ], buildVisualScene );
}
// scenes
function parseScene( xml ) {
const instance = getElementsByTagName( xml, 'instance_visual_scene' )[ 0 ];
return getVisualScene( parseId( instance.getAttribute( 'url' ) ) );
}
function setupAnimations() {
const clips = library.clips;
if ( isEmpty( clips ) === true ) {
if ( isEmpty( library.animations ) === false ) {
// if there are animations but no clips, we create a default clip for playback
const tracks = [];
for ( const id in library.animations ) {
const animationTracks = getAnimation( id );
for ( let i = 0, l = animationTracks.length; i < l; i ++ ) {
tracks.push( animationTracks[ i ] );
}
}
animations.push( new AnimationClip( 'default', - 1, tracks ) );
}
} else {
for ( const id in clips ) {
animations.push( getAnimationClip( id ) );
}
}
}
// convert the parser error element into text with each child elements text
// separated by new lines.
function parserErrorToText( parserError ) {
let result = '';
const stack = [ parserError ];
while ( stack.length ) {
const node = stack.shift();
if ( node.nodeType === Node.TEXT_NODE ) {
result += node.textContent;
} else {
result += '\n';
stack.push.apply( stack, node.childNodes );
}
}
return result.trim();
}
if ( text.length === 0 ) {
return { scene: new Scene() };
}
const xml = new DOMParser().parseFromString( text, 'application/xml' );
const collada = getElementsByTagName( xml, 'COLLADA' )[ 0 ];
const parserError = xml.getElementsByTagName( 'parsererror' )[ 0 ];
if ( parserError !== undefined ) {
// Chrome will return parser error with a div in it
const errorElement = getElementsByTagName( parserError, 'div' )[ 0 ];
let errorText;
if ( errorElement ) {
errorText = errorElement.textContent;
} else {
errorText = parserErrorToText( parserError );
}
console.error( 'THREE.ColladaLoader: Failed to parse collada file.\n', errorText );
return null;
}
// metadata
const version = collada.getAttribute( 'version' );
console.log( 'THREE.ColladaLoader: File version', version );
const asset = parseAsset( getElementsByTagName( collada, 'asset' )[ 0 ] );
const textureLoader = new TextureLoader( this.manager );
textureLoader.setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
let tgaLoader;
if ( TGALoader ) {
tgaLoader = new TGALoader( this.manager );
tgaLoader.setPath( this.resourcePath || path );
}
//
const tempColor = new Color();
const animations = [];
let kinematics = {};
let count = 0;
//
const library = {
animations: {},
clips: {},
controllers: {},
images: {},
effects: {},
materials: {},
cameras: {},
lights: {},
geometries: {},
nodes: {},
visualScenes: {},
kinematicsModels: {},
physicsModels: {},
kinematicsScenes: {}
};
parseLibrary( collada, 'library_animations', 'animation', parseAnimation );
parseLibrary( collada, 'library_animation_clips', 'animation_clip', parseAnimationClip );
parseLibrary( collada, 'library_controllers', 'controller', parseController );
parseLibrary( collada, 'library_images', 'image', parseImage );
parseLibrary( collada, 'library_effects', 'effect', parseEffect );
parseLibrary( collada, 'library_materials', 'material', parseMaterial );
parseLibrary( collada, 'library_cameras', 'camera', parseCamera );
parseLibrary( collada, 'library_lights', 'light', parseLight );
parseLibrary( collada, 'library_geometries', 'geometry', parseGeometry );
parseLibrary( collada, 'library_nodes', 'node', parseNode );
parseLibrary( collada, 'library_visual_scenes', 'visual_scene', parseVisualScene );
parseLibrary( collada, 'library_kinematics_models', 'kinematics_model', parseKinematicsModel );
parseLibrary( collada, 'library_physics_models', 'physics_model', parsePhysicsModel );
parseLibrary( collada, 'scene', 'instance_kinematics_scene', parseKinematicsScene );
buildLibrary( library.animations, buildAnimation );
buildLibrary( library.clips, buildAnimationClip );
buildLibrary( library.controllers, buildController );
buildLibrary( library.images, buildImage );
buildLibrary( library.effects, buildEffect );
buildLibrary( library.materials, buildMaterial );
buildLibrary( library.cameras, buildCamera );
buildLibrary( library.lights, buildLight );
buildLibrary( library.geometries, buildGeometry );
buildLibrary( library.visualScenes, buildVisualScene );
setupAnimations();
setupKinematics();
const scene = parseScene( getElementsByTagName( collada, 'scene' )[ 0 ] );
scene.animations = animations;
if ( asset.upAxis === 'Z_UP' ) {
scene.quaternion.setFromEuler( new Euler( - Math.PI / 2, 0, 0 ) );
}
scene.scale.multiplyScalar( asset.unit );
return {
get animations() {
console.warn( 'THREE.ColladaLoader: Please access animations over scene.animations now.' );
return animations;
},
kinematics: kinematics,
library: library,
scene: scene
};
}
