three
Version:
JavaScript 3D library
3,045 lines • 66.7 kB
JavaScript
import {
AmbientLight,
AnimationClip,
Bone,
BufferGeometry,
ClampToEdgeWrapping,
Color,
ColorManagement,
DirectionalLight,
DoubleSide,
Float32BufferAttribute,
FrontSide,
Group,
InterpolateBezier,
InterpolateDiscrete,
Line,
LineBasicMaterial,
LineSegments,
Loader,
MathUtils,
Matrix4,
Mesh,
MeshBasicMaterial,
MeshLambertMaterial,
MeshPhongMaterial,
OrthographicCamera,
PerspectiveCamera,
PointLight,
Quaternion,
QuaternionKeyframeTrack,
RepeatWrapping,
Skeleton,
SkinnedMesh,
SpotLight,
Triangle,
Vector2,
Vector3,
VectorKeyframeTrack,
SRGBColorSpace,
ShapeUtils
} from 'three';
import { getElementsByTagName, parseFloats } from './ColladaParser.js';
/**
* ColladaComposer converts parsed library data into Three.js objects.
*/
class ColladaComposer {
constructor( library, collada, textureLoader, tgaLoader ) {
this.library = library;
this.collada = collada;
this.textureLoader = textureLoader;
this.tgaLoader = tgaLoader;
this.tempColor = new Color();
this.animations = [];
this.kinematics = {};
// Reusable objects for animation
this.position = new Vector3();
this.scale = new Vector3();
this.quaternion = new Quaternion();
this.matrix = new Matrix4();
// Storage for deferred pivot animation data
// Nodes with pivot transforms need all their animation channels collected
// before building tracks, as channels may be split across animation elements
this.deferredPivotAnimations = {};
// Storage for transform node hierarchy
// Maps nodeId -> transformSid -> Object3D for animation targeting
this.transformNodes = {};
}
compose() {
const library = this.library;
this.buildLibrary( library.animations, this.buildAnimation.bind( this ) );
this.buildLibrary( library.clips, this.buildAnimationClip.bind( this ) );
this.buildLibrary( library.controllers, this.buildController.bind( this ) );
this.buildLibrary( library.images, this.buildImage.bind( this ) );
this.buildLibrary( library.effects, this.buildEffect.bind( this ) );
this.buildLibrary( library.materials, this.buildMaterial.bind( this ) );
this.buildLibrary( library.cameras, this.buildCamera.bind( this ) );
this.buildLibrary( library.lights, this.buildLight.bind( this ) );
this.buildLibrary( library.geometries, this.buildGeometry.bind( this ) );
this.buildLibrary( library.visualScenes, this.buildVisualScene.bind( this ) );
this.setupAnimations();
this.setupKinematics();
const scene = this.parseScene( getElementsByTagName( this.collada, 'scene' )[ 0 ] );
scene.animations = this.animations;
return {
scene: scene,
animations: this.animations,
kinematics: this.kinematics
};
}
buildLibrary( data, builder ) {
for ( const name in data ) {
const object = data[ name ];
object.build = builder( data[ name ] );
}
}
getBuild( data, builder ) {
if ( data.build !== undefined ) return data.build;
data.build = builder( data );
return data.build;
}
isEmpty( object ) {
return Object.keys( object ).length === 0;
}
buildAnimation( data ) {
const tracks = [];
const channels = data.channels;
const samplers = data.samplers;
const sources = data.sources;
const aggregated = this.aggregateAnimationChannels( channels, samplers, sources );
for ( const nodeId in aggregated ) {
const nodeData = this.library.nodes[ nodeId ];
if ( ! nodeData ) continue;
const nodeChannels = aggregated[ nodeId ];
if ( this.hasPivotTransforms( nodeData ) ) {
// Defer - nodes haven't been built yet
this.collectDeferredPivotAnimation( nodeId, nodeChannels );
} else {
const object3D = this.getNode( nodeId );
let rotationTrackBuilt = false;
for ( const sid in nodeChannels ) {
const transformType = nodeData.transforms[ sid ];
const transformInfo = nodeData.transformData[ sid ];
const channelData = nodeChannels[ sid ];
switch ( transformType ) {
case 'matrix':
this.buildMatrixTracks( object3D, channelData, nodeData, tracks );
break;
case 'translate':
this.buildTranslateTrack( object3D, channelData, transformInfo, tracks );
break;
case 'rotate':
if ( ! rotationTrackBuilt ) {
this.buildRotateTrack( object3D, sid, channelData, transformInfo, nodeData, tracks );
rotationTrackBuilt = true;
}
break;
case 'scale':
this.buildScaleTrack( object3D, channelData, transformInfo, tracks );
break;
}
}
}
}
return tracks;
}
collectDeferredPivotAnimation( nodeId, nodeChannels ) {
if ( ! this.deferredPivotAnimations[ nodeId ] ) {
this.deferredPivotAnimations[ nodeId ] = {};
}
const deferred = this.deferredPivotAnimations[ nodeId ];
for ( const sid in nodeChannels ) {
if ( ! deferred[ sid ] ) {
deferred[ sid ] = {};
}
for ( const member in nodeChannels[ sid ] ) {
deferred[ sid ][ member ] = nodeChannels[ sid ][ member ];
}
}
}
hasPivotTransforms( nodeData ) {
const pivotSids = [
'rotatePivot', 'rotatePivotInverse', 'rotatePivotTranslation',
'scalePivot', 'scalePivotInverse', 'scalePivotTranslation'
];
for ( const sid of pivotSids ) {
if ( nodeData.transforms[ sid ] !== undefined ) {
return true;
}
}
return false;
}
getAnimation( id ) {
return this.getBuild( this.library.animations[ id ], this.buildAnimation.bind( this ) );
}
aggregateAnimationChannels( channels, samplers, sources ) {
const aggregated = {};
for ( const target in channels ) {
if ( ! channels.hasOwnProperty( target ) ) continue;
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 interpolationId = sampler.inputs.INTERPOLATION;
const inTangentId = sampler.inputs.IN_TANGENT;
const outTangentId = sampler.inputs.OUT_TANGENT;
const interpolationSource = interpolationId ? sources[ interpolationId ] : null;
const inTangentSource = inTangentId ? sources[ inTangentId ] : null;
const outTangentSource = outTangentId ? sources[ outTangentId ] : null;
const nodeId = channel.id;
const sid = channel.sid;
const member = channel.member || 'default';
if ( ! aggregated[ nodeId ] ) aggregated[ nodeId ] = {};
if ( ! aggregated[ nodeId ][ sid ] ) aggregated[ nodeId ][ sid ] = {};
aggregated[ nodeId ][ sid ][ member ] = {
times: inputSource.array,
values: outputSource.array,
stride: outputSource.stride,
arraySyntax: channel.arraySyntax,
indices: channel.indices,
interpolation: interpolationSource ? interpolationSource.array : null,
inTangent: inTangentSource ? inTangentSource.array : null,
outTangent: outTangentSource ? outTangentSource.array : null,
inTangentStride: inTangentSource ? inTangentSource.stride : 0,
outTangentStride: outTangentSource ? outTangentSource.stride : 0
};
}
return aggregated;
}
buildMatrixTracks( object3D, channelData, nodeData, tracks ) {
const defaultMatrix = nodeData.matrix.clone().transpose();
const data = {};
for ( const member in channelData ) {
const component = channelData[ member ];
const times = component.times;
const values = component.values;
const stride = component.stride;
for ( let i = 0, il = times.length; i < il; i ++ ) {
const time = times[ i ];
const valueOffset = i * stride;
if ( data[ time ] === undefined ) data[ time ] = {};
if ( component.arraySyntax === true ) {
const value = values[ valueOffset ];
const index = component.indices[ 0 ] + 4 * component.indices[ 1 ];
data[ time ][ index ] = value;
} else {
for ( let j = 0; j < stride; j ++ ) {
data[ time ][ j ] = values[ valueOffset + j ];
}
}
}
}
const keyframes = this.prepareAnimationData( data, defaultMatrix );
const animation = { name: object3D.uuid, keyframes: keyframes };
this.createKeyframeTracks( animation, tracks );
}
buildTranslateTrack( object3D, channelData, transformInfo, tracks ) {
if ( channelData.default && channelData.default.stride === 3 ) {
const data = channelData.default;
const times = Array.from( data.times );
const values = Array.from( data.values );
const track = new VectorKeyframeTrack(
object3D.uuid + '.position',
times,
values
);
const interpolationInfo = this.getInterpolationInfo( channelData );
this.applyInterpolation( track, interpolationInfo, channelData );
tracks.push( track );
return;
}
const times = this.getTimesForAllAxes( channelData );
if ( times.length === 0 ) return;
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
const x = this.getValueAtTime( channelData.X, time, transformInfo.x );
const y = this.getValueAtTime( channelData.Y, time, transformInfo.y );
const z = this.getValueAtTime( channelData.Z, time, transformInfo.z );
values.push( x, y, z );
}
const track = new VectorKeyframeTrack(
object3D.uuid + '.position',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
buildRotateTrack( object3D, sid, channelData, transformInfo, nodeData, tracks ) {
const angleData = channelData.ANGLE || channelData.default;
if ( ! angleData ) return;
const times = Array.from( angleData.times );
if ( times.length === 0 ) return;
// Collect all rotations to compose them in order
const rotations = [];
for ( const transformSid of nodeData.transformOrder ) {
const transformType = nodeData.transforms[ transformSid ];
if ( transformType === 'rotate' ) {
const info = nodeData.transformData[ transformSid ];
rotations.push( {
sid: transformSid,
axis: new Vector3( info.axis[ 0 ], info.axis[ 1 ], info.axis[ 2 ] ),
defaultAngle: info.angle
} );
}
}
const quaternion = new Quaternion();
const prevQuaternion = new Quaternion();
const tempQuat = new Quaternion();
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
quaternion.identity();
for ( const rotation of rotations ) {
let angleDegrees;
if ( rotation.sid === sid ) {
angleDegrees = this.getValueAtTime( angleData, time, rotation.defaultAngle );
} else {
angleDegrees = rotation.defaultAngle;
}
const angleRadians = MathUtils.degToRad( angleDegrees );
tempQuat.setFromAxisAngle( rotation.axis, angleRadians );
quaternion.multiply( tempQuat );
}
// Ensure quaternion continuity
if ( i > 0 && prevQuaternion.dot( quaternion ) < 0 ) {
quaternion.x = - quaternion.x;
quaternion.y = - quaternion.y;
quaternion.z = - quaternion.z;
quaternion.w = - quaternion.w;
}
prevQuaternion.copy( quaternion );
values.push( quaternion.x, quaternion.y, quaternion.z, quaternion.w );
}
const track = new QuaternionKeyframeTrack(
object3D.uuid + '.quaternion',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
buildScaleTrack( object3D, channelData, transformInfo, tracks ) {
if ( channelData.default && channelData.default.stride === 3 ) {
const data = channelData.default;
const times = Array.from( data.times );
const values = Array.from( data.values );
const track = new VectorKeyframeTrack(
object3D.uuid + '.scale',
times,
values
);
const interpolationInfo = this.getInterpolationInfo( channelData );
this.applyInterpolation( track, interpolationInfo, channelData );
tracks.push( track );
return;
}
const times = this.getTimesForAllAxes( channelData );
if ( times.length === 0 ) return;
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
const x = this.getValueAtTime( channelData.X, time, transformInfo.x );
const y = this.getValueAtTime( channelData.Y, time, transformInfo.y );
const z = this.getValueAtTime( channelData.Z, time, transformInfo.z );
values.push( x, y, z );
}
const track = new VectorKeyframeTrack(
object3D.uuid + '.scale',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
getTimesForAllAxes( channelData ) {
let times = [];
if ( channelData.X ) times = times.concat( Array.from( channelData.X.times ) );
if ( channelData.Y ) times = times.concat( Array.from( channelData.Y.times ) );
if ( channelData.Z ) times = times.concat( Array.from( channelData.Z.times ) );
if ( channelData.ANGLE ) times = times.concat( Array.from( channelData.ANGLE.times ) );
if ( channelData.default ) times = times.concat( Array.from( channelData.default.times ) );
times = [ ...new Set( times ) ].sort( ( a, b ) => a - b );
return times;
}
getValueAtTime( componentData, time, defaultValue ) {
if ( ! componentData ) return defaultValue;
const times = componentData.times;
const values = componentData.values;
const interpolation = componentData.interpolation;
for ( let i = 0; i < times.length; i ++ ) {
if ( times[ i ] === time ) {
return values[ i ];
}
if ( times[ i ] > time ) {
if ( i === 0 ) {
return values[ 0 ];
}
const i0 = i - 1;
const i1 = i;
const t0 = times[ i0 ];
const t1 = times[ i1 ];
const v0 = values[ i0 ];
const v1 = values[ i1 ];
const interp = interpolation ? interpolation[ i0 ] : 'LINEAR';
if ( interp === 'STEP' ) {
return v0;
} else if ( interp === 'BEZIER' && componentData.inTangent && componentData.outTangent ) {
return this.evaluateBezierComponent( componentData, i0, i1, t0, t1, time );
} else {
const t = ( time - t0 ) / ( t1 - t0 );
return v0 + t * ( v1 - v0 );
}
}
}
return values[ values.length - 1 ];
}
evaluateBezierComponent( componentData, i0, i1, t0, t1, time ) {
const values = componentData.values;
const inTangent = componentData.inTangent;
const outTangent = componentData.outTangent;
const tangentStride = componentData.inTangentStride || 1;
const v0 = values[ i0 ];
const v1 = values[ i1 ];
let c0x, c0y, c1x, c1y;
if ( tangentStride === 2 ) {
c0x = outTangent[ i0 * 2 ];
c0y = outTangent[ i0 * 2 + 1 ];
c1x = inTangent[ i1 * 2 ];
c1y = inTangent[ i1 * 2 + 1 ];
} else {
c0x = t0 + ( t1 - t0 ) / 3;
c0y = outTangent[ i0 ];
c1x = t1 - ( t1 - t0 ) / 3;
c1y = inTangent[ i1 ];
}
// Newton-Raphson to solve Bx(s) = time
let s = ( time - t0 ) / ( t1 - t0 );
for ( let iter = 0; iter < 8; iter ++ ) {
const s2 = s * s;
const s3 = s2 * s;
const oneMinusS = 1 - s;
const oneMinusS2 = oneMinusS * oneMinusS;
const oneMinusS3 = oneMinusS2 * oneMinusS;
const bx = oneMinusS3 * t0 + 3 * oneMinusS2 * s * c0x + 3 * oneMinusS * s2 * c1x + s3 * t1;
const dbx = 3 * oneMinusS2 * ( c0x - t0 ) + 6 * oneMinusS * s * ( c1x - c0x ) + 3 * s2 * ( t1 - c1x );
if ( Math.abs( dbx ) < 1e-10 ) break;
const error = bx - time;
if ( Math.abs( error ) < 1e-10 ) break;
s = s - error / dbx;
s = Math.max( 0, Math.min( 1, s ) );
}
const s2 = s * s;
const s3 = s2 * s;
const oneMinusS = 1 - s;
const oneMinusS2 = oneMinusS * oneMinusS;
const oneMinusS3 = oneMinusS2 * oneMinusS;
return oneMinusS3 * v0 + 3 * oneMinusS2 * s * c0y + 3 * oneMinusS * s2 * c1y + s3 * v1;
}
getInterpolationInfo( channelData ) {
const components = [ 'X', 'Y', 'Z', 'ANGLE', 'default' ];
let interpolationType = null;
let isUniform = true;
for ( const comp of components ) {
const data = channelData[ comp ];
if ( ! data || ! data.interpolation ) continue;
const interpArray = data.interpolation;
for ( let i = 0; i < interpArray.length; i ++ ) {
const interp = interpArray[ i ];
if ( interpolationType === null ) {
interpolationType = interp;
} else if ( interp !== interpolationType ) {
isUniform = false;
}
}
}
return {
type: interpolationType || 'LINEAR',
uniform: isUniform
};
}
applyInterpolation( track, interpolationInfo, channelData = null ) {
if ( interpolationInfo.type === 'STEP' && interpolationInfo.uniform ) {
track.setInterpolation( InterpolateDiscrete );
} else if ( interpolationInfo.type === 'BEZIER' && interpolationInfo.uniform && channelData ) {
const data = channelData.default;
if ( data && data.inTangent && data.outTangent ) {
track.setInterpolation( InterpolateBezier );
track.settings = {
inTangents: new Float32Array( data.inTangent ),
outTangents: new Float32Array( data.outTangent )
};
}
}
}
prepareAnimationData( data, defaultMatrix ) {
const keyframes = [];
for ( const time in data ) {
keyframes.push( { time: parseFloat( time ), value: data[ time ] } );
}
keyframes.sort( ( a, b ) => a.time - b.time );
for ( let i = 0; i < 16; i ++ ) {
this.transformAnimationData( keyframes, i, defaultMatrix.elements[ i ] );
}
return keyframes;
}
createKeyframeTracks( animation, tracks ) {
const keyframes = animation.keyframes;
const name = animation.name;
const times = [];
const positionData = [];
const quaternionData = [];
const scaleData = [];
const position = this.position;
const quaternion = this.quaternion;
const scale = this.scale;
const matrix = this.matrix;
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;
}
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
this.createMissingKeyframes( keyframes, property );
}
}
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 = this.getPrev( keyframes, i, property );
next = this.getNext( keyframes, i, property );
if ( prev === null ) {
keyframe.value[ property ] = next.value[ property ];
continue;
}
if ( next === null ) {
keyframe.value[ property ] = prev.value[ property ];
continue;
}
this.interpolate( keyframe, prev, next, property );
}
}
}
getPrev( keyframes, i, property ) {
while ( i >= 0 ) {
const keyframe = keyframes[ i ];
if ( keyframe.value[ property ] !== null ) return keyframe;
i --;
}
return null;
}
getNext( keyframes, i, property ) {
while ( i < keyframes.length ) {
const keyframe = keyframes[ i ];
if ( keyframe.value[ property ] !== null ) return keyframe;
i ++;
}
return null;
}
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 ];
}
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 = this.getAnimation( animations[ i ] );
for ( let j = 0, jl = animationTracks.length; j < jl; j ++ ) {
tracks.push( animationTracks[ j ] );
}
}
return new AnimationClip( name, duration, tracks );
}
getAnimationClip( id ) {
return this.getBuild( this.library.clips[ id ], this.buildAnimationClip.bind( this ) );
}
buildController( data ) {
const build = {
id: data.id
};
const geometry = this.library.geometries[ build.id ];
if ( data.skin !== undefined ) {
build.skin = this.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;
}
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;
// process 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 proceed 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;
}
}
getController( id ) {
return this.getBuild( this.library.controllers[ id ], this.buildController.bind( this ) );
}
buildImage( data ) {
if ( data.build !== undefined ) return data.build;
return data.init_from;
}
getImage( id ) {
const data = this.library.images[ id ];
if ( data !== undefined ) {
return this.getBuild( data, this.buildImage.bind( this ) );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find image with ID:', id );
return null;
}
buildEffect( data ) {
return data;
}
getEffect( id ) {
return this.getBuild( this.library.effects[ id ], this.buildEffect.bind( this ) );
}
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 = this.tgaLoader;
break;
default:
loader = this.textureLoader;
}
return loader;
}
buildMaterial( data ) {
const effect = this.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 || '';
const self = this;
function getTexture( textureObject, colorSpace = null ) {
const sampler = effect.profile.samplers[ textureObject.id ];
let image = null;
// get image
if ( sampler !== undefined ) {
const surface = effect.profile.surfaces[ sampler.source ];
image = self.getImage( surface.init_from );
} else {
console.warn( 'THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530).' );
image = self.getImage( textureObject.id );
}
// create texture if image is available
if ( image !== null ) {
const loader = self.getTextureLoader( image );
if ( loader !== undefined ) {
const texture = loader.load( image );
const extra = textureObject.extra;
if ( extra !== undefined && extra.technique !== undefined && self.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 ( colorSpace !== null ) {
texture.colorSpace = colorSpace;
}
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, SRGBColorSpace );
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, SRGBColorSpace );
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, SRGBColorSpace );
break;
}
}
ColorManagement.colorSpaceToWorking( material.color, SRGBColorSpace );
if ( material.specular ) ColorManagement.colorSpaceToWorking( material.specular, SRGBColorSpace );
if ( material.emissive ) ColorManagement.colorSpaceToWorking( material.emissive, SRGBColorSpace );
//
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;
}
getMaterial( id ) {
return this.getBuild( this.library.materials[ id ], this.buildMaterial.bind( this ) );
}
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;
}
getCamera( id ) {
const data = this.library.cameras[ id ];
if ( data !== undefined ) {
return this.getBuild( data, this.buildCamera.bind( this ) );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find camera with ID:', id );
return null;
}
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;
if ( data.parameters.falloffAngle ) light.angle = MathUtils.degToRad( data.parameters.falloffAngle );
return light;
}
getLight( id ) {
const data = this.library.lights[ id ];
if ( data !== undefined ) {
return this.getBuild( data, this.buildLight.bind( this ) );
}
console.warn( 'THREE.ColladaLoader: Couldn\'t find light with ID:', id );
return null;
}
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;
}
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;
}
}
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 = this.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)
this.checkUVCoordinates( primitiveType );
// third, create a buffer geometry for each type of primitives
build[ type ] = this.buildGeometryType( primitiveType, sources, vertices );
}
return build;
}
buildGeometryType( primitives, sources, vertices ) {
const build = {};
const position = { array: [], stride: 0 };
const normal = { array: [], stride: 0 };
const uv = { array: [], stride: 0 };
const uv1 = { 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 'polygons':
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: Unknown 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;
this.buildGeometryData( primitive, sources[ id ], input.offset, position.array );
position.stride = sources[ id ].stride;
if ( sources.skinWeights && sources.skinIndices ) {
this.buildGeometryData( primitive, sources.skinIndices, input.offset, skinIndex.array );
this.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':
this.buildGeometryData( primitive, sources[ id ], input.offset, normal.array );
normal.stride = sources[ id ].stride;
break;
case 'COLOR':
this.buildGeometryData( primitive, sources[ id ], input.offset, color.array );
color.stride = sources[ id ].stride;
break;
case 'TEXCOORD':
this.buildGeometryData( primitive, sources[ id ], input.offset, uv.array );
uv.stride = sources[ id ].stride;
break;
case 'TEXCOORD1':
this.buildGeometryData( primitive, sources[ id ], input.offset, uv1.array );
uv.stride = sources[ id ].stride;
break;
default:
console.warn( 'THREE.ColladaLoader: Semantic "%s" not handled in geometry build process.', key );
}
}
break;
case 'NORMAL':
this.buildGeometryData( primitive, sources[ input.id ], input.offset, normal.array );
normal.stride = sources[ input.id ].stride;
break;
case 'COLOR':
this.buildGeometryData( primitive, sources[ input.id ], input.offset, color.array, true );
color.stride = sources[ input.id ].stride;
break;
case 'TEXCOORD':
this.buildGeometryData( primitive, sources[ input.id ], input.offset, uv.array );
uv.stride = sources[ input.id ].stride;
break;
case 'TEXCOORD1':
this.buildGeometryData( primitive, sources[ input.id ], input.offset, uv1.array );
uv1.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 ( uv1.array.length > 0 ) geometry.setAttribute( 'uv1', new Float32BufferAttribute( uv1.array, uv1.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;
}
buildGeometryData( primitive, source, offset, array, isColor = false ) {
const indices = primitive.p;
const stride = primitive.stride;
const vcount = primitive.vcount;
const tempColor = this.tempColor;
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 ],
SRGBColorSpace
);
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 ) {
const vertices = [];
// prepare vertices which represent the polygon's contour
for ( let k = 0; k < count; k ++ ) {
const a = index + stride * k;
const positionIndex = indices[ a ] * sourceStride;
const x = sourceArray[ positionIndex ];
const y = sourceArray[ positionIndex + 1 ];
const z = sourceArray[ positionIndex + 2 ];
vertices.push( new Vector3( x, y, z ) );
}
// determine surface normal
const normal = new Vector3();
const _triangle = new Triangle();
_triangle.a = vertices[ 0 ];
_triangle.b = vertices[ 1 ];
_triangle.c = vertices[ 2 ];
_triangle.getNormal( normal );
// project to 2D and triangulate
const vertices2D = [];
if ( Math.abs( normal.x ) > Math.abs( normal.y ) && Math.abs( normal.x ) > Math.abs( normal.z ) ) {
for ( let k = 0; k < count; k ++ ) {
vertices2D.push( new Vector2( vertices[ k ].y, vertices[ k ].z ) );
}
} else if ( Math.abs( normal.y ) > Math.abs( normal.z ) ) {
for ( let k = 0; k < count; k ++ ) {
vertices2D.push( new Vector2( vertices[ k ].x, vertices[ k ].z ) );
}
} else {
for ( let k = 0; k < count; k ++ ) {
vertices2D.push( new Vector2( vertices[ k ].x, vertices[ k ].y ) );
}
}
const isClockWise = ShapeUtils.isClockWise( vertices2D );
if ( isClockWise === true ) {
vertices2D.reverse();
}
const faces = ShapeUtils.triangulateShape( vertices2D, [] );
// build indices
for ( let k = 0; k < faces.length; k ++ ) {
const face = faces[ k ];
let i0, i1, i2;
if ( isClockWise === false ) {
i0 = face[ 0 ];
i1 = face[ 1 ];
i2 = face[ 2 ];
} else {
i0 = count - 1 - face[ 0 ];
i1 = count - 1 - face[ 2 ];
i2 = count - 1 - face[ 1 ];
}
const a = index + stride * i0;
const b = index + stride * i1;
const c = index + stride * i2;
pushVector( a );
pushVector( b );
pushVector( c );
}
}
index += stride * count;
}
} else {
for ( let i = 0, l = indices.length; i < l; i += stride ) {
pushVector( i );
}
}
}
getGeometry( id ) {
return this.getBuild( this.library.geometries[ id ], this.buildGeometry.bind( this ) );
}
buildKinematicsModel( data ) {
if ( data.build !== undefined ) return data.build;
return data;
}
getKinematicsModel( id ) {
return this.getBuild( this.library.kinematicsModels[ id ], this.buildKinematicsModel.bind( this ) );
}
buildKinematicsScene( data ) {
if ( data.build !== undefined ) return data.build;
return data;
}
getKinematicsScene( id ) {
return this.getBuild( this.library.kinematicsScenes[ id ], this.buildKinematicsScene.bind( this ) );
}
setupKinematics() {
const kinematicsModelId = Object.keys( this.library.kinematicsModels )[ 0 ];
const kinematicsSceneId = Object.keys( this.library.kinematicsScenes )[ 0 ];
const visualSceneId = Object.keys( this.library.visualScenes )[ 0 ];
if ( kinematicsModelId === undefined || kinematicsSceneId === undefined ) return;
const kinematicsModel = this.getKinematicsModel( kinematicsModelId );
const kinematicsScene = this.getKinematicsScene( kinematicsSceneId );
const visualScene = this.getVisualScene( visualSceneId );
const bindJointAxis = kinematicsScene.bindJointAxis;
const jointMap = {};
const collada = this.collada;
const self = this;
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 ];
const transforms = self.buildTransformList( visualElement );
visualScene.traverse( function ( object ) {
if ( object.name === visualElementName ) {
jointMap[ jointIndex ] = {
object: object,
transforms: transforms,
joint: joint,
position: joint.zeroPosition
};
}
} );
}
const m0 = new Matrix4();
const matrix = this.matrix;
this.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.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' does not exist.' );
}
}
};
}
buildTransformList( node ) {
const transforms = [];
const xml = this.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;
}
buildSkeleton( skeletons, joints ) {
const boneData = [];
const sortedBoneData = [];
let i, j, data;
// a skeleton can have multiple root bones. collada expresses this
// situation with multiple "skeleton" tags per controller instance
for ( i = 0; i < skeletons.length; i ++ ) {
const skeleton = skeletons[ i ];
let root;
if ( this.hasNode( skeleton ) ) {
root = this.getNode( skeleton );
this.buildBoneHierarchy( root, joints, boneData );
} else if ( this.hasVisualScene( skeleton ) ) {
// handle case where the skeleton refers to the visual scene (#13335)
const visualScene = this.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 = this.getNode( child.id );
this.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 );
}
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 } );
}
} );
}
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( this.getNode( nodes[ i ] ) );
}
// instance cameras
for ( let i = 0, l = instanceCameras.length; i < l; i ++ ) {
const instanceCamera = this.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 = this.getController( instance.id );
const geometries = this.getGeometry( controller.id );
const newObjects = this.buildObjects( geometries, instance.materials );
const skeletons = instance.skeletons;
const joints = controller.skin.joints;
const skeleton = this.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 = this.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 = this.getGeometry( instance.id );
const newObjects = this.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( this.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;
if ( type !== 'JOINT' && this.hasPivotTransforms( data ) ) {
return this.wrapWithTransformHierarchy( object, data );
}
object.matrix.copy( matrix );
object.matrix.decompose( object.position, object.quaternion, object.scale );
return object;
}
wrapWithTransformHierarchy( contentObject, nodeData ) {
const nodeId = nodeData.id;
this.transformNodes[ nodeId ] = {};
const transformOrder = nodeData.transformOrder;
const transformData = nodeData.transformData;
const rootNode = new Group();
rootNode.name = nodeData.name;
let currentParent = rootNode;
for ( let i = 0; i < transformOrder.length; i ++ ) {
const sid = transformOrder[ i ];
const info = transformData[ sid ];
const transformNode = new Group();
transformNode.name = nodeData.name + '_' + sid;
switch ( info.type ) {
case 'translate':
transformNode.position.set( info.x, info.y, info.z );
break;
case 'rotate': {
const axis = new Vector3( info.axis[ 0 ], info.axis[ 1 ], info.axis[ 2 ] );
const angle = MathUtils.degToRad( info.angle );
transformNode.quaternion.setFromAxisAngle( axis, angle );
transformNode.userData.rotationAxis = axis;
break;
}
case 'scale':
transformNode.scale.set( info.x, info.y, info.z );
break;
case 'matrix': {
const matrix = new Matrix4().fromArray( info.array ).transpose();
matrix.decompose( transformNode.position, transformNode.quaternion, transformNode.scale );
break;
}
}
this.transformNodes[ nodeId ][ sid ] = transformNode;
currentParent.add( transformNode );
currentParent = transformNode;
}
currentParent.add( contentObject );
return rootNode;
}
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( this.fallbackMaterial );
} else {
materials.push( this.getMaterial( id ) );
}
}
return materials;
}
get fallbackMaterial() {
if ( this._fallbackMaterial === undefined ) {
this._fallbackMaterial = new MeshBasicMaterial( {
name: Loader.DEFAULT_MATERIAL_NAME,
color: 0xff00ff
} );
}
return this._fallbackMaterial;
}
buildObjects( geometries, instanceMaterials ) {
const objects = [];
for ( const type in geometries ) {
const geometry = geometries[ type ];
const materials = this.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() );
}
}
// Collada allows to use phong and lambert materials with lines. Replacing these cases with LineBasicMaterial.
if ( type === 'lines' || type === 'linestrips' ) {
for ( let i = 0, l = materials.length; i < l; i ++ ) {
const material = materials[ i ];
if ( material.isMeshPhongMaterial === true || material.isMeshLambertMaterial === true ) {
const lineMaterial = new LineBasicMaterial();
// copy compatible properties
lineMaterial.color.copy( material.color );
lineMaterial.opacity = material.opacity;
lineMaterial.transparent = material.transparent;
// replace material
materials[ i ] = lineMaterial;
}
}
}
// 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 'polygons':
case 'polylist':
if ( skinning ) {
object = new SkinnedMesh( geometry.data, material );
} else {
object = new Mesh( geometry.data, material );
}
break;
}
objects.push( object );
}
return objects;
}
hasNode( id ) {
return this.library.nodes[ id ] !== undefined;
}
getNode( id ) {
return this.getBuild( this.library.nodes[ id ], this.buildNode.bind( this ) );
}
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( this.getNode( child.id ) );
}
return group;
}
hasVisualScene( id ) {
return this.library.visualScenes[ id ] !== undefined;
}
getVisualScene( id ) {
return this.getBuild( this.library.visualScenes[ id ], this.buildVisualScene.bind( this ) );
}
parseScene( xml ) {
const instance = getElementsByTagName( xml, 'instance_visual_scene' )[ 0 ];
return this.getVisualScene( this.parseId( instance.getAttribute( 'url' ) ) );
}
parseId( text ) {
return text.substring( 1 );
}
setupAnimations() {
const clips = this.library.clips;
if ( this.isEmpty( clips ) === true ) {
if ( this.isEmpty( this.library.animations ) === false ) {
// if there are animations but no clips, we create a default clip for playback
const tracks = [];
for ( const id in this.library.animations ) {
const animationTracks = this.getAnimation( id );
for ( let i = 0, l = animationTracks.length; i < l; i ++ ) {
tracks.push( animationTracks[ i ] );
}
}
this.buildDeferredPivotAnimationTracks( tracks );
this.animations.push( new AnimationClip( 'default', - 1, tracks ) );
}
} else {
for ( const id in clips ) {
this.animations.push( this.getAnimationClip( id ) );
}
}
}
buildDeferredPivotAnimationTracks( tracks ) {
for ( const nodeId in this.deferredPivotAnimations ) {
const nodeData = this.library.nodes[ nodeId ];
if ( ! nodeData ) continue;
const mergedChannels = this.deferredPivotAnimations[ nodeId ];
this.buildTransformHierarchyTracks( nodeId, mergedChannels, nodeData, tracks );
}
}
buildTransformHierarchyTracks( nodeId, nodeChannels, nodeData, tracks ) {
const transformNodes = this.transformNodes[ nodeId ];
if ( ! transformNodes ) {
console.warn( 'THREE.ColladaLoader: Transform hierarchy not found for node:', nodeId );
return;
}
for ( const sid in nodeChannels ) {
const transformNode = transformNodes[ sid ];
if ( ! transformNode ) continue;
const transformType = nodeData.transforms[ sid ];
const transformInfo = nodeData.transformData[ sid ];
const channelData = nodeChannels[ sid ];
switch ( transformType ) {
case 'translate':
this.buildHierarchyTranslateTrack( transformNode, channelData, transformInfo, tracks );
break;
case 'rotate':
this.buildHierarchyRotateTrack( transformNode, channelData, transformInfo, tracks );
break;
case 'scale':
this.buildHierarchyScaleTrack( transformNode, channelData, transformInfo, tracks );
break;
}
}
}
buildHierarchyTranslateTrack( transformNode, channelData, transformInfo, tracks ) {
if ( channelData.default && channelData.default.stride === 3 ) {
const data = channelData.default;
const track = new VectorKeyframeTrack(
transformNode.uuid + '.position',
Array.from( data.times ),
Array.from( data.values )
);
const interpolationInfo = this.getInterpolationInfo( channelData );
this.applyInterpolation( track, interpolationInfo, channelData );
tracks.push( track );
return;
}
const times = this.getTimesForAllAxes( channelData );
if ( times.length === 0 ) return;
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
const x = this.getValueAtTime( channelData.X, time, transformInfo.x );
const y = this.getValueAtTime( channelData.Y, time, transformInfo.y );
const z = this.getValueAtTime( channelData.Z, time, transformInfo.z );
values.push( x, y, z );
}
const track = new VectorKeyframeTrack(
transformNode.uuid + '.position',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
buildHierarchyRotateTrack( transformNode, channelData, transformInfo, tracks ) {
const angleData = channelData.ANGLE || channelData.default;
if ( ! angleData ) return;
const times = Array.from( angleData.times );
if ( times.length === 0 ) return;
const axis = transformNode.userData.rotationAxis ||
new Vector3( transformInfo.axis[ 0 ], transformInfo.axis[ 1 ], transformInfo.axis[ 2 ] );
const quaternion = new Quaternion();
const prevQuaternion = new Quaternion();
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
const angleDegrees = this.getValueAtTime( angleData, time, transformInfo.angle );
const angleRadians = MathUtils.degToRad( angleDegrees );
quaternion.setFromAxisAngle( axis, angleRadians );
// Ensure quaternion continuity
if ( i > 0 && prevQuaternion.dot( quaternion ) < 0 ) {
quaternion.x = - quaternion.x;
quaternion.y = - quaternion.y;
quaternion.z = - quaternion.z;
quaternion.w = - quaternion.w;
}
prevQuaternion.copy( quaternion );
values.push( quaternion.x, quaternion.y, quaternion.z, quaternion.w );
}
const track = new QuaternionKeyframeTrack(
transformNode.uuid + '.quaternion',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
buildHierarchyScaleTrack( transformNode, channelData, transformInfo, tracks ) {
if ( channelData.default && channelData.default.stride === 3 ) {
const data = channelData.default;
const track = new VectorKeyframeTrack(
transformNode.uuid + '.scale',
Array.from( data.times ),
Array.from( data.values )
);
const interpolationInfo = this.getInterpolationInfo( channelData );
this.applyInterpolation( track, interpolationInfo, channelData );
tracks.push( track );
return;
}
const times = this.getTimesForAllAxes( channelData );
if ( times.length === 0 ) return;
const values = [];
const interpolationInfo = this.getInterpolationInfo( channelData );
for ( let i = 0; i < times.length; i ++ ) {
const time = times[ i ];
const x = this.getValueAtTime( channelData.X, time, transformInfo.x );
const y = this.getValueAtTime( channelData.Y, time, transformInfo.y );
const z = this.getValueAtTime( channelData.Z, time, transformInfo.z );
values.push( x, y, z );
}
const track = new VectorKeyframeTrack(
transformNode.uuid + '.scale',
times,
values
);
this.applyInterpolation( track, interpolationInfo );
tracks.push( track );
}
}
export { ColladaComposer };