diff --git a/ShadowEditor.Web/assets/js/loaders/ColladaLoader.js b/ShadowEditor.Web/assets/js/loaders/ColladaLoader.js new file mode 100644 index 00000000..32130233 --- /dev/null +++ b/ShadowEditor.Web/assets/js/loaders/ColladaLoader.js @@ -0,0 +1,3888 @@ +/** + * @author mrdoob / http://mrdoob.com/ + * @author Mugen87 / https://github.com/Mugen87 + */ + +THREE.ColladaLoader = function ( manager ) { + + this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; + +}; + +THREE.ColladaLoader.prototype = { + + constructor: THREE.ColladaLoader, + + crossOrigin: 'anonymous', + + load: function ( url, onLoad, onProgress, onError ) { + + var scope = this; + + var path = scope.path === undefined ? THREE.LoaderUtils.extractUrlBase( url ) : scope.path; + + var loader = new THREE.FileLoader( scope.manager ); + loader.load( url, function ( text ) { + + onLoad( scope.parse( text, path ) ); + + }, onProgress, onError ); + + }, + + setPath: function ( value ) { + + this.path = value; + return this; + + }, + + options: { + + set convertUpAxis( value ) { + + console.warn( 'THREE.ColladaLoader: options.convertUpAxis() has been removed. Up axis is converted automatically.' ); + + } + + }, + + setCrossOrigin: function ( value ) { + + this.crossOrigin = value; + return this; + + }, + + parse: function ( text, path ) { + + function getElementsByTagName( xml, name ) { + + // Non recursive xml.getElementsByTagName() ... + + var array = []; + var childNodes = xml.childNodes; + + for ( var i = 0, l = childNodes.length; i < l; i ++ ) { + + var child = childNodes[ i ]; + + if ( child.nodeName === name ) { + + array.push( child ); + + } + + } + + return array; + + } + + function parseStrings( text ) { + + if ( text.length === 0 ) return []; + + var parts = text.trim().split( /\s+/ ); + var array = new Array( parts.length ); + + for ( var i = 0, l = parts.length; i < l; i ++ ) { + + array[ i ] = parts[ i ]; + + } + + return array; + + } + + function parseFloats( text ) { + + if ( text.length === 0 ) return []; + + var parts = text.trim().split( /\s+/ ); + var array = new Array( parts.length ); + + for ( var i = 0, l = parts.length; i < l; i ++ ) { + + array[ i ] = parseFloat( parts[ i ] ); + + } + + return array; + + } + + function parseInts( text ) { + + if ( text.length === 0 ) return []; + + var parts = text.trim().split( /\s+/ ); + var array = new Array( parts.length ); + + for ( var 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 ) { + + var library = getElementsByTagName( xml, libraryName )[ 0 ]; + + if ( library !== undefined ) { + + var elements = getElementsByTagName( library, nodeName ); + + for ( var i = 0; i < elements.length; i ++ ) { + + parser( elements[ i ] ); + + } + + } + + } + + function buildLibrary( data, builder ) { + + for ( var name in data ) { + + var 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 ) { + + var data = { + sources: {}, + samplers: {}, + channels: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + var 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; + + default: + console.log( child ); + + } + + } + + library.animations[ xml.getAttribute( 'id' ) ] = data; + + } + + function parseAnimationSampler( xml ) { + + var data = { + inputs: {}, + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'input': + var id = parseId( child.getAttribute( 'source' ) ); + var semantic = child.getAttribute( 'semantic' ); + data.inputs[ semantic ] = id; + break; + + } + + } + + return data; + + } + + function parseAnimationChannel( xml ) { + + var data = {}; + + var target = xml.getAttribute( 'target' ); + + // parsing SID Addressing Syntax + + var parts = target.split( '/' ); + + var id = parts.shift(); + var sid = parts.shift(); + + // check selection syntax + + var arraySyntax = ( sid.indexOf( '(' ) !== - 1 ); + var 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. + + var indices = sid.split( '(' ); + sid = indices.shift(); + + for ( var 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 ) { + + var tracks = []; + + var channels = data.channels; + var samplers = data.samplers; + var sources = data.sources; + + for ( var target in channels ) { + + if ( channels.hasOwnProperty( target ) ) { + + var channel = channels[ target ]; + var sampler = samplers[ channel.sampler ]; + + var inputId = sampler.inputs.INPUT; + var outputId = sampler.inputs.OUTPUT; + + var inputSource = sources[ inputId ]; + var outputSource = sources[ outputId ]; + + var animation = buildAnimationChannel( channel, inputSource, outputSource ); + + createKeyframeTracks( animation, tracks ); + + } + + } + + return tracks; + + } + + function getAnimation( id ) { + + return getBuild( library.animations[ id ], buildAnimation ); + + } + + function buildAnimationChannel( channel, inputSource, outputSource ) { + + var node = library.nodes[ channel.id ]; + var object3D = getNode( node.id ); + + var transform = node.transforms[ channel.sid ]; + var defaultMatrix = node.matrix.clone().transpose(); + + var time, stride; + var i, il, j, jl; + + var 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 ) { + + var value = outputSource.array[ stride ]; + var 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; + + } + + var keyframes = prepareAnimationData( data, defaultMatrix ); + + var animation = { + name: object3D.uuid, + keyframes: keyframes + }; + + return animation; + + } + + function prepareAnimationData( data, defaultMatrix ) { + + var keyframes = []; + + // transfer data into a sortable array + + for ( var 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 ( var 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; + + } + + } + + var position = new THREE.Vector3(); + var scale = new THREE.Vector3(); + var quaternion = new THREE.Quaternion(); + + function createKeyframeTracks( animation, tracks ) { + + var keyframes = animation.keyframes; + var name = animation.name; + + var times = []; + var positionData = []; + var quaternionData = []; + var scaleData = []; + + for ( var i = 0, l = keyframes.length; i < l; i ++ ) { + + var keyframe = keyframes[ i ]; + + var time = keyframe.time; + var 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 THREE.VectorKeyframeTrack( name + '.position', times, positionData ) ); + if ( quaternionData.length > 0 ) tracks.push( new THREE.QuaternionKeyframeTrack( name + '.quaternion', times, quaternionData ) ); + if ( scaleData.length > 0 ) tracks.push( new THREE.VectorKeyframeTrack( name + '.scale', times, scaleData ) ); + + return tracks; + + } + + function transformAnimationData( keyframes, property, defaultValue ) { + + var keyframe; + + var empty = true; + var 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 ) { + + var prev, next; + + for ( var i = 0, l = keyframes.length; i < l; i ++ ) { + + var 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 ) { + + var keyframe = keyframes[ i ]; + + if ( keyframe.value[ property ] !== null ) return keyframe; + + i --; + + } + + return null; + + } + + function getNext( keyframes, i, property ) { + + while ( i < keyframes.length ) { + + var 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 ) { + + var data = { + name: xml.getAttribute( 'id' ) || 'default', + start: parseFloat( xml.getAttribute( 'start' ) || 0 ), + end: parseFloat( xml.getAttribute( 'end' ) || 0 ), + animations: [] + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var tracks = []; + + var name = data.name; + var duration = ( data.end - data.start ) || - 1; + var animations = data.animations; + + for ( var i = 0, il = animations.length; i < il; i ++ ) { + + var animationTracks = getAnimation( animations[ i ] ); + + for ( var j = 0, jl = animationTracks.length; j < jl; j ++ ) { + + tracks.push( animationTracks[ j ] ); + + } + + } + + return new THREE.AnimationClip( name, duration, tracks ); + + } + + function getAnimationClip( id ) { + + return getBuild( library.clips[ id ], buildAnimationClip ); + + } + + // controller + + function parseController( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = { + sources: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'bind_shape_matrix': + data.bindShapeMatrix = parseFloats( child.textContent ); + break; + + case 'source': + var 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 ) { + + var data = { + inputs: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'input': + var semantic = child.getAttribute( 'semantic' ); + var id = parseId( child.getAttribute( 'source' ) ); + data.inputs[ semantic ] = id; + break; + + } + + } + + return data; + + } + + function parseVertexWeights( xml ) { + + var data = { + inputs: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'input': + var semantic = child.getAttribute( 'semantic' ); + var id = parseId( child.getAttribute( 'source' ) ); + var 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 ) { + + var build = { + id: data.id + }; + + var 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 ) { + + var BONE_LIMIT = 4; + + var build = { + joints: [], // this must be an array to preserve the joint order + indices: { + array: [], + stride: BONE_LIMIT + }, + weights: { + array: [], + stride: BONE_LIMIT + } + }; + + var sources = data.sources; + var vertexWeights = data.vertexWeights; + + var vcount = vertexWeights.vcount; + var v = vertexWeights.v; + var jointOffset = vertexWeights.inputs.JOINT.offset; + var weightOffset = vertexWeights.inputs.WEIGHT.offset; + + var jointSource = data.sources[ data.joints.inputs.JOINT ]; + var inverseSource = data.sources[ data.joints.inputs.INV_BIND_MATRIX ]; + + var weights = sources[ vertexWeights.inputs.WEIGHT.id ].array; + var stride = 0; + + var i, j, l; + + // procces skin data for each vertex + + for ( i = 0, l = vcount.length; i < l; i ++ ) { + + var jointCount = vcount[ i ]; // this is the amount of joints that affect a single vertex + var vertexSkinData = []; + + for ( j = 0; j < jointCount; j ++ ) { + + var skinIndex = v[ stride + jointOffset ]; + var weightId = v[ stride + weightOffset ]; + var 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 ++ ) { + + var 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 THREE.Matrix4().fromArray( data.bindShapeMatrix ).transpose(); + + } else { + + build.bindMatrix = new THREE.Matrix4().identity(); + + } + + // process bones and inverse bind matrix data + + for ( i = 0, l = jointSource.array.length; i < l; i ++ ) { + + var name = jointSource.array[ i ]; + var boneInverse = new THREE.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 ) { + + var 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 ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = { + surfaces: {}, + samplers: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var sid = xml.getAttribute( 'sid' ); + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'source': + data.source = child.textContent; + break; + + } + + } + + return data; + + } + + function parseEffectTechnique( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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; + + } + + } + + return data; + + } + + function parseEffectParameters( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'emission': + case 'diffuse': + case 'specular': + case 'shininess': + case 'transparency': + data[ child.nodeName ] = parseEffectParameter( child ); + break; + case 'transparent': + data[ child.nodeName ] = { + opaque: child.getAttribute( 'opaque' ), + data: parseEffectParameter( child ) + }; + break; + + } + + } + + return data; + + } + + function parseEffectParameter( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = { + technique: {} + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'technique': + parseEffectParameterTextureExtraTechnique( child, data ); + break; + + } + + } + + } + + function parseEffectParameterTextureExtraTechnique( xml, data ) { + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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; + + } + + } + + } + + function parseEffectExtra( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'technique': + data.technique = parseEffectExtraTechnique( child ); + break; + + } + + } + + return data; + + } + + function parseEffectExtraTechnique( xml ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'double_sided': + data[ child.nodeName ] = parseInt( child.textContent ); + break; + + } + + } + + return data; + + } + + function buildEffect( data ) { + + return data; + + } + + function getEffect( id ) { + + return getBuild( library.effects[ id ], buildEffect ); + + } + + // material + + function parseMaterial( xml ) { + + var data = { + name: xml.getAttribute( 'name' ) + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var loader; + + var 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 ) { + + var effect = getEffect( data.url ); + var technique = effect.profile.technique; + var extra = effect.profile.extra; + + var material; + + switch ( technique.type ) { + + case 'phong': + case 'blinn': + material = new THREE.MeshPhongMaterial(); + break; + + case 'lambert': + material = new THREE.MeshLambertMaterial(); + break; + + default: + material = new THREE.MeshBasicMaterial(); + break; + + } + + material.name = data.name; + + function getTexture( textureObject ) { + + var sampler = effect.profile.samplers[ textureObject.id ]; + var image = null; + + // get image + + if ( sampler !== undefined ) { + + var 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 ) { + + var loader = getTextureLoader( image ); + + if ( loader !== undefined ) { + + var texture = loader.load( image ); + + var extra = textureObject.extra; + + if ( extra !== undefined && extra.technique !== undefined && isEmpty( extra.technique ) === false ) { + + var technique = extra.technique; + + texture.wrapS = technique.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; + texture.wrapT = technique.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; + + texture.offset.set( technique.offsetU || 0, technique.offsetV || 0 ); + texture.repeat.set( technique.repeatU || 1, technique.repeatV || 1 ); + + } else { + + texture.wrapS = THREE.RepeatWrapping; + texture.wrapT = THREE.RepeatWrapping; + + } + + 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; + + } + + } + + var parameters = technique.parameters; + + for ( var key in parameters ) { + + var parameter = parameters[ key ]; + + switch ( key ) { + + case 'diffuse': + if ( parameter.color ) material.color.fromArray( parameter.color ); + if ( parameter.texture ) material.map = getTexture( parameter.texture ); + break; + case 'specular': + if ( parameter.color && material.specular ) material.specular.fromArray( parameter.color ); + if ( parameter.texture ) material.specularMap = getTexture( parameter.texture ); + 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 ); + break; + + } + + } + + // + + var transparent = parameters[ 'transparent' ]; + var transparency = parameters[ 'transparency' ]; + + // does not exist but + + if ( transparency === undefined && transparent ) { + + transparency = { + float: 1 + }; + + } + + // does not exist but + + 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 { + + var 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 ( extra !== undefined && extra.technique !== undefined && extra.technique.double_sided === 1 ) { + + material.side = THREE.DoubleSide; + + } + + return material; + + } + + function getMaterial( id ) { + + return getBuild( library.materials[ id ], buildMaterial ); + + } + + // camera + + function parseCamera( xml ) { + + var data = { + name: xml.getAttribute( 'name' ) + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + switch ( child.nodeName ) { + + case 'technique_common': + return parseCameraTechnique( child ); + + } + + } + + return {}; + + } + + function parseCameraTechnique( xml ) { + + var data = {}; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var camera; + + switch ( data.optics.technique ) { + + case 'perspective': + camera = new THREE.PerspectiveCamera( + data.optics.parameters.yfov, + data.optics.parameters.aspect_ratio, + data.optics.parameters.znear, + data.optics.parameters.zfar + ); + break; + + case 'orthographic': + var ymag = data.optics.parameters.ymag; + var xmag = data.optics.parameters.xmag; + var 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 THREE.OrthographicCamera( + - xmag, xmag, ymag, - ymag, // left, right, top, bottom + data.optics.parameters.znear, + data.optics.parameters.zfar + ); + break; + + default: + camera = new THREE.PerspectiveCamera(); + break; + + } + + camera.name = data.name; + + return camera; + + } + + function getCamera( id ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var 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 ) { + + var data = {}; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'color': + var array = parseFloats( child.textContent ); + data.color = new THREE.Color().fromArray( array ); + break; + + case 'falloff_angle': + data.falloffAngle = parseFloat( child.textContent ); + break; + + case 'quadratic_attenuation': + var f = parseFloat( child.textContent ); + data.distance = f ? Math.sqrt( 1 / f ) : 0; + break; + + } + + } + + return data; + + } + + function buildLight( data ) { + + var light; + + switch ( data.technique ) { + + case 'directional': + light = new THREE.DirectionalLight(); + break; + + case 'point': + light = new THREE.PointLight(); + break; + + case 'spot': + light = new THREE.SpotLight(); + break; + + case 'ambient': + light = new THREE.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 ) { + + var 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 ) { + + var data = { + name: xml.getAttribute( 'name' ), + sources: {}, + vertices: {}, + primitives: [] + }; + + var 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 ( var i = 0; i < mesh.childNodes.length; i ++ ) { + + var child = mesh.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + var 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 ) { + + var data = { + array: [], + stride: 3 + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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': + var accessor = getElementsByTagName( child, 'accessor' )[ 0 ]; + + if ( accessor !== undefined ) { + + data.stride = parseInt( accessor.getAttribute( 'stride' ) ); + + } + break; + + } + + } + + return data; + + } + + function parseGeometryVertices( xml ) { + + var data = {}; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + data[ child.getAttribute( 'semantic' ) ] = parseId( child.getAttribute( 'source' ) ); + + } + + return data; + + } + + function parseGeometryPrimitive( xml ) { + + var primitive = { + type: xml.nodeName, + material: xml.getAttribute( 'material' ), + count: parseInt( xml.getAttribute( 'count' ) ), + inputs: {}, + stride: 0, + hasUV: false + }; + + for ( var i = 0, l = xml.childNodes.length; i < l; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'input': + var id = parseId( child.getAttribute( 'source' ) ); + var semantic = child.getAttribute( 'semantic' ); + var offset = parseInt( child.getAttribute( 'offset' ) ); + primitive.inputs[ semantic ] = { 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 ) { + + var build = {}; + + for ( var i = 0; i < primitives.length; i ++ ) { + + var primitive = primitives[ i ]; + + if ( build[ primitive.type ] === undefined ) build[ primitive.type ] = []; + + build[ primitive.type ].push( primitive ); + + } + + return build; + + } + + function checkUVCoordinates( primitives ) { + + var count = 0; + + for ( var i = 0, l = primitives.length; i < l; i ++ ) { + + var primitive = primitives[ i ]; + + if ( primitive.hasUV === true ) { + + count ++; + + } + + } + + if ( count > 0 && count < primitives.length ) { + + primitives.uvsNeedsFix = true; + + } + + } + + function buildGeometry( data ) { + + var build = {}; + + var sources = data.sources; + var vertices = data.vertices; + var 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 + + var groupedPrimitives = groupPrimitives( primitives ); + + for ( var type in groupedPrimitives ) { + + var 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 ) { + + var build = {}; + + var position = { array: [], stride: 0 }; + var normal = { array: [], stride: 0 }; + var uv = { array: [], stride: 0 }; + var color = { array: [], stride: 0 }; + + var skinIndex = { array: [], stride: 4 }; + var skinWeight = { array: [], stride: 4 }; + + var geometry = new THREE.BufferGeometry(); + + var materialKeys = []; + + var start = 0; + + for ( var p = 0; p < primitives.length; p ++ ) { + + var primitive = primitives[ p ]; + var inputs = primitive.inputs; + + // groups + + var count = 0; + + switch ( primitive.type ) { + + case 'lines': + case 'linestrips': + count = primitive.count * 2; + break; + + case 'triangles': + count = primitive.count * 3; + break; + + case 'polylist': + + for ( var g = 0; g < primitive.count; g ++ ) { + + var 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 ( var name in inputs ) { + + var input = inputs[ name ]; + + switch ( name ) { + + case 'VERTEX': + for ( var key in vertices ) { + + var id = vertices[ key ]; + + switch ( key ) { + + case 'POSITION': + var 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 ) { + + var count = ( position.array.length - prevLength ) / position.stride; + + for ( var 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; + + 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 ); + 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; + + } + + } + + } + + // build geometry + + if ( position.array.length > 0 ) geometry.addAttribute( 'position', new THREE.Float32BufferAttribute( position.array, position.stride ) ); + if ( normal.array.length > 0 ) geometry.addAttribute( 'normal', new THREE.Float32BufferAttribute( normal.array, normal.stride ) ); + if ( color.array.length > 0 ) geometry.addAttribute( 'color', new THREE.Float32BufferAttribute( color.array, color.stride ) ); + if ( uv.array.length > 0 ) geometry.addAttribute( 'uv', new THREE.Float32BufferAttribute( uv.array, uv.stride ) ); + + if ( skinIndex.array.length > 0 ) geometry.addAttribute( 'skinIndex', new THREE.Float32BufferAttribute( skinIndex.array, skinIndex.stride ) ); + if ( skinWeight.array.length > 0 ) geometry.addAttribute( 'skinWeight', new THREE.Float32BufferAttribute( skinWeight.array, skinWeight.stride ) ); + + build.data = geometry; + build.type = primitives[ 0 ].type; + build.materialKeys = materialKeys; + + return build; + + } + + function buildGeometryData( primitive, source, offset, array ) { + + var indices = primitive.p; + var stride = primitive.stride; + var vcount = primitive.vcount; + + function pushVector( i ) { + + var index = indices[ i + offset ] * sourceStride; + var length = index + sourceStride; + + for ( ; index < length; index ++ ) { + + array.push( sourceArray[ index ] ); + + } + + } + + var sourceArray = source.array; + var sourceStride = source.stride; + + if ( primitive.vcount !== undefined ) { + + var index = 0; + + for ( var i = 0, l = vcount.length; i < l; i ++ ) { + + var count = vcount[ i ]; + + if ( count === 4 ) { + + var a = index + stride * 0; + var b = index + stride * 1; + var c = index + stride * 2; + var d = index + stride * 3; + + pushVector( a ); pushVector( b ); pushVector( d ); + pushVector( b ); pushVector( c ); pushVector( d ); + + } else if ( count === 3 ) { + + var a = index + stride * 0; + var b = index + stride * 1; + var c = index + stride * 2; + + pushVector( a ); pushVector( b ); pushVector( c ); + + } else if ( count > 4 ) { + + for ( var k = 1, kl = ( count - 2 ); k <= kl; k ++ ) { + + var a = index + stride * 0; + var b = index + stride * k; + var c = index + stride * ( k + 1 ); + + pushVector( a ); pushVector( b ); pushVector( c ); + + } + + } + + index += stride * count; + + } + + } else { + + for ( var i = 0, l = indices.length; i < l; i += stride ) { + + pushVector( i ); + + } + + } + + } + + function getGeometry( id ) { + + return getBuild( library.geometries[ id ], buildGeometry ); + + } + + // kinematics + + function parseKinematicsModel( xml ) { + + var data = { + name: xml.getAttribute( 'name' ) || '', + joints: {}, + links: [] + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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, data ) { + + var data = { + sid: xml.getAttribute( 'sid' ), + name: xml.getAttribute( 'name' ) || '', + axis: new THREE.Vector3(), + limits: { + min: 0, + max: 0 + }, + type: xml.nodeName, + static: false, + zeroPosition: 0, + middlePosition: 0 + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'axis': + var array = parseFloats( child.textContent ); + data.axis.fromArray( array ); + break; + case 'limits': + var max = child.getElementsByTagName( 'max' )[ 0 ]; + var 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 ) { + + var data = { + sid: xml.getAttribute( 'sid' ), + name: xml.getAttribute( 'name' ) || '', + attachments: [], + transforms: [] + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data = { + joint: xml.getAttribute( 'joint' ).split( '/' ).pop(), + transforms: [], + links: [] + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data = { + type: xml.nodeName + }; + + var array = parseFloats( xml.textContent ); + + switch ( data.type ) { + + case 'matrix': + data.obj = new THREE.Matrix4(); + data.obj.fromArray( array ).transpose(); + break; + + case 'translate': + data.obj = new THREE.Vector3(); + data.obj.fromArray( array ); + break; + + case 'rotate': + data.obj = new THREE.Vector3(); + data.obj.fromArray( array ); + data.angle = THREE.Math.degToRad( array[ 3 ] ); + break; + + } + + return data; + + } + + // physics + + function parsePhysicsModel( xml ) { + + var data = { + name: xml.getAttribute( 'name' ) || '', + rigidBodies: {} + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'technique_common': + parsePhysicsTechniqueCommon( child, data ); + break; + + } + + } + + } + + function parsePhysicsTechniqueCommon( xml, data ) { + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data = { + bindJointAxis: [] + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var 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 ) { + + var data = { + target: xml.getAttribute( 'target' ).split( '/' ).pop() + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'axis': + var param = child.getElementsByTagName( 'param' )[ 0 ]; + data.axis = param.textContent; + var 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() { + + var kinematicsModelId = Object.keys( library.kinematicsModels )[ 0 ]; + var kinematicsSceneId = Object.keys( library.kinematicsScenes )[ 0 ]; + var visualSceneId = Object.keys( library.visualScenes )[ 0 ]; + + if ( kinematicsModelId === undefined || kinematicsSceneId === undefined ) return; + + var kinematicsModel = getKinematicsModel( kinematicsModelId ); + var kinematicsScene = getKinematicsScene( kinematicsSceneId ); + var visualScene = getVisualScene( visualSceneId ); + + var bindJointAxis = kinematicsScene.bindJointAxis; + var jointMap = {}; + + for ( var i = 0, l = bindJointAxis.length; i < l; i ++ ) { + + var axis = bindJointAxis[ i ]; + + // the result of the following query is an element of type 'translate', 'rotate','scale' or 'matrix' + + var targetElement = collada.querySelector( '[sid="' + axis.target + '"]' ); + + if ( targetElement ) { + + // get the parent of the transfrom element + + var 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 ) { + + var visualElementName = visualElement.getAttribute( 'name' ); + var joint = kinematicsModel.joints[ jointIndex ]; + + visualScene.traverse( function ( object ) { + + if ( object.name === visualElementName ) { + + jointMap[ jointIndex ] = { + object: object, + transforms: buildTransformList( visualElement ), + joint: joint, + position: joint.zeroPosition + }; + + } + + } ); + + } + + var m0 = new THREE.Matrix4(); + + kinematics = { + + joints: kinematicsModel && kinematicsModel.joints, + + getJointValue: function ( jointIndex ) { + + var jointData = jointMap[ jointIndex ]; + + if ( jointData ) { + + return jointData.position; + + } else { + + console.warn( 'THREE.ColladaLoader: Joint ' + jointIndex + ' doesn\'t exist.' ); + + } + + }, + + setJointValue: function ( jointIndex, value ) { + + var jointData = jointMap[ jointIndex ]; + + if ( jointData ) { + + var 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 { + + var object = jointData.object; + var axis = joint.axis; + var transforms = jointData.transforms; + + matrix.identity(); + + // each update, we have to apply all transforms in the correct order + + for ( var i = 0; i < transforms.length; i ++ ) { + + var 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, THREE.Math.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 ) { + + var transforms = []; + + var xml = collada.querySelector( '[id="' + node.id + '"]' ); + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + switch ( child.nodeName ) { + + case 'matrix': + var array = parseFloats( child.textContent ); + var matrix = new THREE.Matrix4().fromArray( array ).transpose(); + transforms.push( { + sid: child.getAttribute( 'sid' ), + type: child.nodeName, + obj: matrix + } ); + break; + + case 'translate': + case 'scale': + var array = parseFloats( child.textContent ); + var vector = new THREE.Vector3().fromArray( array ); + transforms.push( { + sid: child.getAttribute( 'sid' ), + type: child.nodeName, + obj: vector + } ); + break; + + case 'rotate': + var array = parseFloats( child.textContent ); + var vector = new THREE.Vector3().fromArray( array ); + var angle = THREE.Math.degToRad( array[ 3 ] ); + transforms.push( { + sid: child.getAttribute( 'sid' ), + type: child.nodeName, + obj: vector, + angle: angle + } ); + break; + + } + + } + + return transforms; + + } + + // nodes + + function prepareNodes( xml ) { + + var elements = xml.getElementsByTagName( 'node' ); + + // ensure all node elements have id attributes + + for ( var i = 0; i < elements.length; i ++ ) { + + var element = elements[ i ]; + + if ( element.hasAttribute( 'id' ) === false ) { + + element.setAttribute( 'id', generateId() ); + + } + + } + + } + + var matrix = new THREE.Matrix4(); + var vector = new THREE.Vector3(); + + function parseNode( xml ) { + + var data = { + name: xml.getAttribute( 'name' ) || '', + type: xml.getAttribute( 'type' ), + id: xml.getAttribute( 'id' ), + sid: xml.getAttribute( 'sid' ), + matrix: new THREE.Matrix4(), + nodes: [], + instanceCameras: [], + instanceControllers: [], + instanceLights: [], + instanceGeometries: [], + instanceNodes: [], + transforms: {} + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + if ( child.nodeType !== 1 ) continue; + + 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': + var array = parseFloats( child.textContent ); + data.matrix.multiply( matrix.fromArray( array ).transpose() ); + data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName; + break; + + case 'translate': + var 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': + var array = parseFloats( child.textContent ); + var angle = THREE.Math.degToRad( array[ 3 ] ); + data.matrix.multiply( matrix.makeRotationAxis( vector.fromArray( array ), angle ) ); + data.transforms[ child.getAttribute( 'sid' ) ] = child.nodeName; + break; + + case 'scale': + var 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 ) { + + var data = { + id: parseId( xml.getAttribute( 'url' ) ), + materials: {}, + skeletons: [] + }; + + for ( var i = 0; i < xml.childNodes.length; i ++ ) { + + var child = xml.childNodes[ i ]; + + switch ( child.nodeName ) { + + case 'bind_material': + var instances = child.getElementsByTagName( 'instance_material' ); + + for ( var j = 0; j < instances.length; j ++ ) { + + var instance = instances[ j ]; + var symbol = instance.getAttribute( 'symbol' ); + var 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 ) { + + var boneData = []; + var sortedBoneData = []; + + var 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 ++ ) { + + var skeleton = skeletons[ i ]; + + var 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) + + var visualScene = library.visualScenes[ skeleton ]; + var children = visualScene.children; + + for ( var j = 0; j < children.length; j ++ ) { + + var child = children[ j ]; + + if ( child.type === 'JOINT' ) { + + var 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 + + var bones = []; + var boneInverses = []; + + for ( i = 0; i < sortedBoneData.length; i ++ ) { + + data = sortedBoneData[ i ]; + + bones.push( data.bone ); + boneInverses.push( data.boneInverse ); + + } + + return new THREE.Skeleton( bones, boneInverses ); + + } + + function buildBoneHierarchy( root, joints, boneData ) { + + // setup bone data from visual scene + + root.traverse( function ( object ) { + + if ( object.isBone === true ) { + + var boneInverse; + + // retrieve the boneInverse from the controller data + + for ( var i = 0; i < joints.length; i ++ ) { + + var 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 THREE.Matrix4(); + + } + + boneData.push( { bone: object, boneInverse: boneInverse, processed: false } ); + + } + + } ); + + } + + function buildNode( data ) { + + var objects = []; + + var matrix = data.matrix; + var nodes = data.nodes; + var type = data.type; + var instanceCameras = data.instanceCameras; + var instanceControllers = data.instanceControllers; + var instanceLights = data.instanceLights; + var instanceGeometries = data.instanceGeometries; + var instanceNodes = data.instanceNodes; + + // nodes + + for ( var i = 0, l = nodes.length; i < l; i ++ ) { + + objects.push( getNode( nodes[ i ] ) ); + + } + + // instance cameras + + for ( var i = 0, l = instanceCameras.length; i < l; i ++ ) { + + var instanceCamera = getCamera( instanceCameras[ i ] ); + + if ( instanceCamera !== null ) { + + objects.push( instanceCamera.clone() ); + + } + + } + + // instance controllers + + for ( var i = 0, l = instanceControllers.length; i < l; i ++ ) { + + var instance = instanceControllers[ i ]; + var controller = getController( instance.id ); + var geometries = getGeometry( controller.id ); + var newObjects = buildObjects( geometries, instance.materials ); + + var skeletons = instance.skeletons; + var joints = controller.skin.joints; + + var skeleton = buildSkeleton( skeletons, joints ); + + for ( var j = 0, jl = newObjects.length; j < jl; j ++ ) { + + var object = newObjects[ j ]; + + if ( object.isSkinnedMesh ) { + + object.bind( skeleton, controller.skin.bindMatrix ); + object.normalizeSkinWeights(); + + } + + objects.push( object ); + + } + + } + + // instance lights + + for ( var i = 0, l = instanceLights.length; i < l; i ++ ) { + + var instanceLight = getLight( instanceLights[ i ] ); + + if ( instanceLight !== null ) { + + objects.push( instanceLight.clone() ); + + } + + } + + // instance geometries + + for ( var i = 0, l = instanceGeometries.length; i < l; i ++ ) { + + var 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 + + var geometries = getGeometry( instance.id ); + var newObjects = buildObjects( geometries, instance.materials ); + + for ( var j = 0, jl = newObjects.length; j < jl; j ++ ) { + + objects.push( newObjects[ j ] ); + + } + + } + + // instance nodes + + for ( var i = 0, l = instanceNodes.length; i < l; i ++ ) { + + objects.push( getNode( instanceNodes[ i ] ).clone() ); + + } + + var object; + + if ( nodes.length === 0 && objects.length === 1 ) { + + object = objects[ 0 ]; + + } else { + + object = ( type === 'JOINT' ) ? new THREE.Bone() : new THREE.Group(); + + for ( var i = 0; i < objects.length; i ++ ) { + + object.add( objects[ i ] ); + + } + + } + + if ( object.name === '' ) { + + object.name = ( type === 'JOINT' ) ? data.sid : data.name; + + } + + object.matrix.copy( matrix ); + object.matrix.decompose( object.position, object.quaternion, object.scale ); + + return object; + + } + + var fallbackMaterial = new THREE.MeshBasicMaterial( { color: 0xff00ff } ); + + function resolveMaterialBinding( keys, instanceMaterials ) { + + var materials = []; + + for ( var i = 0, l = keys.length; i < l; i ++ ) { + + var 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 ) { + + var objects = []; + + for ( var type in geometries ) { + + var geometry = geometries[ type ]; + + var materials = resolveMaterialBinding( geometry.materialKeys, instanceMaterials ); + + // handle case if no materials are defined + + if ( materials.length === 0 ) { + + if ( type === 'lines' || type === 'linestrips' ) { + + materials.push( new THREE.LineBasicMaterial() ); + + } else { + + materials.push( new THREE.MeshPhongMaterial() ); + + } + + } + + // regard skinning + + var skinning = ( geometry.data.attributes.skinIndex !== undefined ); + + if ( skinning ) { + + for ( var i = 0, l = materials.length; i < l; i ++ ) { + + materials[ i ].skinning = true; + + } + + } + + // choose between a single or multi materials (material array) + + var material = ( materials.length === 1 ) ? materials[ 0 ] : materials; + + // now create a specific 3D object + + var object; + + switch ( type ) { + + case 'lines': + object = new THREE.LineSegments( geometry.data, material ); + break; + + case 'linestrips': + object = new THREE.Line( geometry.data, material ); + break; + + case 'triangles': + case 'polylist': + if ( skinning ) { + + object = new THREE.SkinnedMesh( geometry.data, material ); + + } else { + + object = new THREE.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 ) { + + var data = { + name: xml.getAttribute( 'name' ), + children: [] + }; + + prepareNodes( xml ); + + var elements = getElementsByTagName( xml, 'node' ); + + for ( var i = 0; i < elements.length; i ++ ) { + + data.children.push( parseNode( elements[ i ] ) ); + + } + + library.visualScenes[ xml.getAttribute( 'id' ) ] = data; + + } + + function buildVisualScene( data ) { + + var group = new THREE.Group(); + group.name = data.name; + + var children = data.children; + + for ( var i = 0; i < children.length; i ++ ) { + + var 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 ) { + + var instance = getElementsByTagName( xml, 'instance_visual_scene' )[ 0 ]; + return getVisualScene( parseId( instance.getAttribute( 'url' ) ) ); + + } + + function setupAnimations() { + + var 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 + + var tracks = []; + + for ( var id in library.animations ) { + + var animationTracks = getAnimation( id ); + + for ( var i = 0, l = animationTracks.length; i < l; i ++ ) { + + tracks.push( animationTracks[ i ] ); + + } + + } + + animations.push( new THREE.AnimationClip( 'default', - 1, tracks ) ); + + } + + } else { + + for ( var id in clips ) { + + animations.push( getAnimationClip( id ) ); + + } + + } + + } + + if ( text.length === 0 ) { + + return { scene: new THREE.Scene() }; + + } + + var xml = new DOMParser().parseFromString( text, 'application/xml' ); + + var collada = getElementsByTagName( xml, 'COLLADA' )[ 0 ]; + + // metadata + + var version = collada.getAttribute( 'version' ); + console.log( 'THREE.ColladaLoader: File version', version ); + + var asset = parseAsset( getElementsByTagName( collada, 'asset' )[ 0 ] ); + var textureLoader = new THREE.TextureLoader( this.manager ); + textureLoader.setPath( path ).setCrossOrigin( this.crossOrigin ); + + var tgaLoader; + + if ( THREE.TGALoader ) { + + tgaLoader = new THREE.TGALoader( this.manager ); + tgaLoader.setPath( path ); + + } + + // + + var animations = []; + var kinematics = {}; + var count = 0; + + // + + var 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(); + + var scene = parseScene( getElementsByTagName( collada, 'scene' )[ 0 ] ); + + if ( asset.upAxis === 'Z_UP' ) { + + scene.quaternion.setFromEuler( new THREE.Euler( - Math.PI / 2, 0, 0 ) ); + + } + + scene.scale.multiplyScalar( asset.unit ); + + return { + animations: animations, + kinematics: kinematics, + library: library, + scene: scene + }; + + } + +}; diff --git a/ShadowEditor.Web/assets/js/loaders/ColladaLoader2.js b/ShadowEditor.Web/assets/js/loaders/ColladaLoader2.js deleted file mode 100644 index da962a37..00000000 --- a/ShadowEditor.Web/assets/js/loaders/ColladaLoader2.js +++ /dev/null @@ -1,1594 +0,0 @@ -/** - * @author mrdoob / http://mrdoob.com/ - */ - -THREE.ColladaLoader = function (manager) { - - this.manager = (manager !== undefined) ? manager : THREE.DefaultLoadingManager; - -}; - -THREE.ColladaLoader.prototype = { - - constructor: THREE.ColladaLoader, - - load: function (url, onLoad, onProgress, onError) { - - var scope = this; - - var loader = new THREE.FileLoader(scope.manager); - loader.load(url, function (text) { - - onLoad(scope.parse(text)); - - }, onProgress, onError); - - }, - - options: { - - set convertUpAxis(value) { - - console.log('ColladaLoder.options.convertUpAxis: TODO'); - - } - - }, - - setCrossOrigin: function (value) { - - this.crossOrigin = value; - - }, - - parse: function (text) { - - function getElementsByTagName(xml, name) { - - // Non recursive xml.getElementsByTagName() ... - - var array = []; - var childNodes = xml.childNodes; - - for (var i = 0, l = childNodes.length; i < l; i++) { - - var child = childNodes[i]; - - if (child.nodeName === name) { - - array.push(child); - - } - - } - - return array; - - } - - function parseFloats(text) { - - if (text.length === 0) return []; - - var parts = text.trim().split(/\s+/); - var array = new Array(parts.length); - - for (var i = 0, l = parts.length; i < l; i++) { - - array[i] = parseFloat(parts[i]); - - } - - return array; - - } - - function parseInts(text) { - - if (text.length === 0) return []; - - var parts = text.trim().split(/\s+/); - var array = new Array(parts.length); - - for (var i = 0, l = parts.length; i < l; i++) { - - array[i] = parseInt(parts[i]); - - } - - return array; - - } - - function parseId(text) { - - return text.substring(1); - - } - - // asset - - function parseAsset(xml) { - - return { - unit: parseAssetUnit(getElementsByTagName(xml, 'unit')[0]), - upAxis: parseAssetUpAxis(getElementsByTagName(xml, 'up_axis')[0]) - }; - - } - - function parseAssetUnit(xml) { - - return xml !== undefined ? parseFloat(xml.getAttribute('meter')) : 1; - - } - - function parseAssetUpAxis(xml) { - - return xml !== undefined ? xml.textContent : 'Y_UP'; - - } - - // library - - function parseLibrary(xml, libraryName, nodeName, parser) { - - var library = getElementsByTagName(xml, libraryName)[0]; - - if (library !== undefined) { - - var elements = getElementsByTagName(library, nodeName); - - for (var i = 0; i < elements.length; i++) { - - parser(elements[i]); - - } - - } - - } - - function buildLibrary(data, builder) { - - for (var name in data) { - - var 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; - - } - - // image - - function parseImage(xml) { - - var 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 new Image(); - - } - - function getImage(id) { - - return getBuild(library.images[id], buildImage); - - } - - // effect - - function parseEffect(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = { - surfaces: {}, - samplers: {} - }; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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; - - } - - } - - return data; - - } - - function parseEffectNewparam(xml, data) { - - var sid = xml.getAttribute('sid'); - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'source': - data.source = child.textContent; - break; - - } - - } - - return data; - - } - - function parseEffectTechnique(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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; - - } - - } - - return data; - - } - - function parseEffectParameters(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'emission': - case 'diffuse': - case 'specular': - case 'shininess': - case 'transparent': - case 'transparency': - data[child.nodeName] = parseEffectParameter(child); - break; - - } - - } - - return data; - - } - - function parseEffectParameter(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'extra': - data = parseEffectParameterTextureExtra(child); - break; - - } - - } - - return data; - - } - - function parseEffectParameterTextureExtra(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'technique': - data[child.nodeName] = parseEffectParameterTextureExtraTechnique(child); - break; - - } - - } - - return data; - - } - - function parseEffectParameterTextureExtraTechnique(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'repeatU': - case 'repeatV': - case 'offsetU': - case 'offsetV': - data[child.nodeName] = parseFloat(child.textContent); - break; - - case 'wrapU': - case 'wrapV': - data[child.nodeName] = parseInt(child.textContent); - break; - - } - - } - - return data; - - } - - function buildEffect(data) { - - return data; - - } - - function getEffect(id) { - - return getBuild(library.effects[id], buildEffect); - - } - - // material - - function parseMaterial(xml) { - - var data = { - name: xml.getAttribute('name') - }; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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 buildMaterial(data) { - - var effect = getEffect(data.url); - var technique = effect.profile.technique; - - var material; - - switch (technique.type) { - - case 'phong': - case 'blinn': - material = new THREE.MeshPhongMaterial(); - break; - - case 'lambert': - material = new THREE.MeshLambertMaterial(); - break; - - default: - material = new THREE.MeshBasicMaterial(); - break; - - } - - material.name = data.name; - - function getTexture(textureObject) { - - var sampler = effect.profile.samplers[textureObject.id]; - - if (sampler !== undefined) { - - var surface = effect.profile.surfaces[sampler.source]; - - var texture = new THREE.Texture(getImage(surface.init_from)); - - var extra = textureObject.extra; - - if (extra !== undefined && extra.technique !== undefined) { - - var technique = extra.technique; - - texture.wrapS = technique.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; - texture.wrapT = technique.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; - - texture.offset.set(technique.offsetU, technique.offsetV); - texture.repeat.set(technique.repeatU, technique.repeatV); - - } else { - - texture.wrapS = THREE.RepeatWrapping; - texture.wrapT = THREE.RepeatWrapping; - - } - - texture.needsUpdate = true; - - return texture; - - } - - console.error('ColladaLoder: Undefined sampler', textureObject.id); - - return null; - - } - - var parameters = technique.parameters; - - for (var key in parameters) { - - var parameter = parameters[key]; - - switch (key) { - - case 'diffuse': - if (parameter.color) material.color.fromArray(parameter.color); - if (parameter.texture) material.map = getTexture(parameter.texture); - break; - case 'specular': - if (parameter.color && material.specular) - material.specular.fromArray(parameter.color); - 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); - break; - case 'transparent': - // if ( parameter.texture ) material.alphaMap = getTexture( parameter.texture ); - material.transparent = true; - break; - case 'transparency': - if (parameter.float !== undefined) material.opacity = parameter.float; - material.transparent = true; - break; - - } - - } - - return material; - - } - - function getMaterial(id) { - - return getBuild(library.materials[id], buildMaterial); - - } - - // camera - - function parseCamera(xml) { - - var data = { - name: xml.getAttribute('name') - }; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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 (var i = 0; i < xml.childNodes.length; i++) { - - var child = xml.childNodes[i]; - - switch (child.nodeName) { - - case 'technique_common': - return parseCameraTechnique(child); - - } - - } - - return {}; - - } - - function parseCameraTechnique(xml) { - - var data = {}; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var 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) { - - var data = {}; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var 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) { - - var camera; - - switch (data.optics.technique) { - - case 'perspective': - camera = new THREE.PerspectiveCamera( - data.optics.parameters.yfov, - data.optics.parameters.aspect_ratio, - data.optics.parameters.znear, - data.optics.parameters.zfar - ); - break; - - case 'orthographic': - camera = new THREE.OrthographicCamera( /* TODO */); - break; - - default: - camera = new THREE.PerspectiveCamera(); - break; - - } - - camera.name = data.name; - - return camera; - - } - - function getCamera(id) { - - return getBuild(library.cameras[id], buildCamera); - - } - - // light - - function parseLight(xml) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var 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) { - - var data = {}; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'color': - var array = parseFloats(child.textContent); - data.color = new THREE.Color().fromArray(array); - break; - - case 'falloff_angle': - data.falloffAngle = parseFloat(child.textContent); - break; - - case 'quadratic_attenuation': - var f = parseFloat(child.textContent); - data.distance = f ? Math.sqrt(1 / f) : 0; - break; - - } - - } - - return data; - - } - - function buildLight(data) { - - var light; - - switch (data.technique) { - - case 'directional': - light = new THREE.DirectionalLight(); - break; - - case 'point': - light = new THREE.PointLight(); - break; - - case 'spot': - light = new THREE.SpotLight(); - break; - - case 'ambient': - light = new THREE.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) { - - return getBuild(library.lights[id], buildLight); - - } - - // geometry - - function parseGeometry(xml) { - - var data = { - name: xml.getAttribute('name'), - sources: {}, - vertices: {}, - primitives: [] - }; - - var mesh = getElementsByTagName(xml, 'mesh')[0]; - - for (var i = 0; i < mesh.childNodes.length; i++) { - - var child = mesh.childNodes[i]; - - if (child.nodeType !== 1) continue; - - var id = child.getAttribute('id'); - - switch (child.nodeName) { - - case 'source': - data.sources[id] = parseGeometrySource(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('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 parseGeometrySource(xml) { - - var data = { - array: [], - stride: 3 - }; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'float_array': - data.array = parseFloats(child.textContent); - break; - - case 'technique_common': - var accessor = getElementsByTagName(child, 'accessor')[0]; - - if (accessor !== undefined) { - - data.stride = parseInt(accessor.getAttribute('stride')); - - } - break; - - default: - console.log(child); - - } - - } - - return data; - - } - - function parseGeometryVertices(xml) { - - var data = {}; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - data[child.getAttribute('semantic')] = parseId(child.getAttribute('source')); - - } - - return data; - - } - - function parseGeometryPrimitive(xml) { - - var primitive = { - type: xml.nodeName, - material: xml.getAttribute('material'), - inputs: {}, - stride: 0 - }; - - for (var i = 0, l = xml.childNodes.length; i < l; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'input': - var id = parseId(child.getAttribute('source')); - var semantic = child.getAttribute('semantic'); - var offset = parseInt(child.getAttribute('offset')); - primitive.inputs[semantic] = { id: id, offset: offset }; - primitive.stride = Math.max(primitive.stride, offset + 1); - break; - - case 'vcount': - primitive.vcount = parseInts(child.textContent); - break; - - case 'p': - primitive.p = parseInts(child.textContent); - break; - - } - - } - - return primitive; - - } - - var DEFAULT_LINEMATERIAL = new THREE.LineBasicMaterial(); - var DEFAULT_MESHMATERIAL = new THREE.MeshPhongMaterial(); - - function buildGeometry(data) { - - var group = {}; - - var sources = data.sources; - var vertices = data.vertices; - var primitives = data.primitives; - - if (primitives.length === 0) return group; - - for (var p = 0; p < primitives.length; p++) { - - var primitive = primitives[p]; - var inputs = primitive.inputs; - - var geometry = new THREE.BufferGeometry(); - - if (data.name) geometry.name = data.name; - - for (var name in inputs) { - - var input = inputs[name]; - - switch (name) { - - case 'VERTEX': - for (var key in vertices) { - - geometry.addAttribute(key.toLowerCase(), buildGeometryAttribute(primitive, sources[vertices[key]], input.offset)); - - } - break; - - case 'NORMAL': - geometry.addAttribute('normal', buildGeometryAttribute(primitive, sources[input.id], input.offset)); - break; - - case 'COLOR': - geometry.addAttribute('color', buildGeometryAttribute(primitive, sources[input.id], input.offset)); - break; - - case 'TEXCOORD': - geometry.addAttribute('uv', buildGeometryAttribute(primitive, sources[input.id], input.offset)); - break; - - } - - } - - var object; - - switch (primitive.type) { - - case 'lines': - object = new THREE.LineSegments(geometry, DEFAULT_LINEMATERIAL); - break; - - case 'linestrips': - object = new THREE.Line(geometry, DEFAULT_LINEMATERIAL); - break; - - case 'triangles': - case 'polylist': - object = new THREE.Mesh(geometry, DEFAULT_MESHMATERIAL); - break; - - } - - group[primitive.material] = object; - - } - - return group; - - } - - function buildGeometryAttribute(primitive, source, offset) { - - var indices = primitive.p; - var stride = primitive.stride; - var vcount = primitive.vcount; - - function pushVector(i) { - - var index = indices[i + offset] * sourceStride; - var length = index + sourceStride; - - for (; index < length; index++) { - - array.push(sourceArray[index]); - - } - - } - - var maxcount = 0; - - var sourceArray = source.array; - var sourceStride = source.stride; - - var array = []; - - if (primitive.vcount !== undefined) { - - var index = 0; - - for (var i = 0, l = vcount.length; i < l; i++) { - - var count = vcount[i]; - - if (count === 4) { - - var a = index + stride * 0; - var b = index + stride * 1; - var c = index + stride * 2; - var d = index + stride * 3; - - pushVector(a); pushVector(b); pushVector(d); - pushVector(b); pushVector(c); pushVector(d); - - } else if (count === 3) { - - var a = index + stride * 0; - var b = index + stride * 1; - var c = index + stride * 2; - - pushVector(a); pushVector(b); pushVector(c); - - } else { - - maxcount = Math.max(maxcount, count); - - } - - index += stride * count; - - } - - if (maxcount > 0) { - - console.log('ColladaLoader: Geometry has faces with more than 4 vertices.'); - - } - - } else { - - for (var i = 0, l = indices.length; i < l; i += stride) { - - pushVector(i); - - } - - } - - return new THREE.Float32BufferAttribute(array, sourceStride); - - } - - function getGeometry(id) { - - return getBuild(library.geometries[id], buildGeometry); - - } - - // nodes - - var matrix = new THREE.Matrix4(); - var vector = new THREE.Vector3(); - - function parseNode(xml) { - - var data = { - name: xml.getAttribute('name'), - matrix: new THREE.Matrix4(), - nodes: [], - instanceCameras: [], - instanceLights: [], - instanceGeometries: [], - instanceNodes: [] - }; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeType !== 1) continue; - - switch (child.nodeName) { - - case 'node': - - if (child.hasAttribute('id')) { - - data.nodes.push(child.getAttribute('id')); - parseNode(child); - - } - - break; - - case 'instance_camera': - data.instanceCameras.push(parseId(child.getAttribute('url'))); - break; - - case 'instance_light': - data.instanceLights.push(parseId(child.getAttribute('url'))); - break; - - case 'instance_geometry': - data.instanceGeometries.push(parseNodeInstanceGeometry(child)); - break; - - case 'instance_node': - data.instanceNodes.push(parseId(child.getAttribute('url'))); - break; - - case 'matrix': - var array = parseFloats(child.textContent); - data.matrix.multiply(matrix.fromArray(array).transpose()); // .transpose() when Z_UP? - break; - - case 'translate': - var array = parseFloats(child.textContent); - vector.fromArray(array); - data.matrix.multiply(matrix.makeTranslation(vector.x, vector.y, vector.z)); - break; - - case 'rotate': - var array = parseFloats(child.textContent); - var angle = THREE.Math.degToRad(array[3]); - data.matrix.multiply(matrix.makeRotationAxis(vector.fromArray(array), angle)); - break; - - case 'scale': - var array = parseFloats(child.textContent); - data.matrix.scale(vector.fromArray(array)); - break; - - case 'extra': - break; - - default: - console.log(child); - - } - - } - - if (xml.hasAttribute('id')) { - - library.nodes[xml.getAttribute('id')] = data; - - } - - return data; - - } - - function parseNodeInstanceGeometry(xml) { - - var data = { - id: parseId(xml.getAttribute('url')), - materials: {} - }; - - for (var i = 0; i < xml.childNodes.length; i++) { - - var child = xml.childNodes[i]; - - if (child.nodeName === 'bind_material') { - - var instances = child.getElementsByTagName('instance_material'); - - for (var j = 0; j < instances.length; j++) { - - var instance = instances[j]; - var symbol = instance.getAttribute('symbol'); - var target = instance.getAttribute('target'); - - data.materials[symbol] = parseId(target); - - } - - break; - - } - - } - - return data; - - } - - function buildNode(data) { - - var objects = []; - - var matrix = data.matrix; - var nodes = data.nodes; - var instanceCameras = data.instanceCameras; - var instanceLights = data.instanceLights; - var instanceGeometries = data.instanceGeometries; - var instanceNodes = data.instanceNodes; - - for (var i = 0, l = nodes.length; i < l; i++) { - - objects.push(getNode(nodes[i]).clone()); - - } - - for (var i = 0, l = instanceCameras.length; i < l; i++) { - - objects.push(getCamera(instanceCameras[i]).clone()); - - } - - for (var i = 0, l = instanceLights.length; i < l; i++) { - - objects.push(getLight(instanceLights[i]).clone()); - - } - - for (var i = 0, l = instanceGeometries.length; i < l; i++) { - - var instance = instanceGeometries[i]; - var geometries = getGeometry(instance.id); - - for (var key in geometries) { - - var object = geometries[key].clone(); - - if (instance.materials[key] !== undefined) { - - object.material = getMaterial(instance.materials[key]); - - } - - objects.push(object); - - } - - } - - for (var i = 0, l = instanceNodes.length; i < l; i++) { - - objects.push(getNode(instanceNodes[i]).clone()); - - } - - var object; - - if (nodes.length === 0 && objects.length === 1) { - - object = objects[0]; - - } else { - - object = new THREE.Group(); - - for (var i = 0; i < objects.length; i++) { - - object.add(objects[i]); - - } - - } - - object.name = data.name; - matrix.decompose(object.position, object.quaternion, object.scale); - - return object; - - } - - function getNode(id) { - - return getBuild(library.nodes[id], buildNode); - - } - - // visual scenes - - function parseVisualScene(xml) { - - var data = { - name: xml.getAttribute('name'), - children: [] - }; - - var elements = getElementsByTagName(xml, 'node'); - - for (var i = 0; i < elements.length; i++) { - - data.children.push(parseNode(elements[i])); - - } - - library.visualScenes[xml.getAttribute('id')] = data; - - } - - function buildVisualScene(data) { - - var group = new THREE.Group(); - group.name = data.name; - - var children = data.children; - - for (var i = 0; i < children.length; i++) { - - group.add(buildNode(children[i])); - - } - - return group; - - } - - function getVisualScene(id) { - - return getBuild(library.visualScenes[id], buildVisualScene); - - } - - // scenes - - function parseScene(xml) { - - var instance = getElementsByTagName(xml, 'instance_visual_scene')[0]; - return getVisualScene(parseId(instance.getAttribute('url'))); - - } - - console.time('ColladaLoader'); - - if (text.length === 0) { - - return { scene: new THREE.Scene() }; - - } - - console.time('ColladaLoader: DOMParser'); - - var xml = new DOMParser().parseFromString(text, 'application/xml'); - - console.timeEnd('ColladaLoader: DOMParser'); - - var collada = getElementsByTagName(xml, 'COLLADA')[0]; - - // metadata - - var version = collada.getAttribute('version'); - console.log('ColladaLoader: File version', version); - - var asset = parseAsset(getElementsByTagName(collada, 'asset')[0]); - - // - - var library = { - images: {}, - effects: {}, - materials: {}, - cameras: {}, - lights: {}, - geometries: {}, - nodes: {}, - visualScenes: {} - }; - - console.time('ColladaLoader: Parse'); - - 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); - - console.timeEnd('ColladaLoader: Parse'); - - console.time('ColladaLoader: Build'); - - 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.nodes, buildNode ); - buildLibrary(library.visualScenes, buildVisualScene); - - console.timeEnd('ColladaLoader: Build'); - - // console.log( library ); - - var scene = parseScene(getElementsByTagName(collada, 'scene')[0]); - - if (asset.upAxis === 'Z_UP') { - - scene.rotation.x = - Math.PI / 2; - - } - - scene.scale.multiplyScalar(asset.unit); - - console.timeEnd('ColladaLoader'); - - // console.log( scene ); - - return { - animations: [], - kinematics: { joints: [] }, - library: library, - scene: scene - }; - - } - -}; \ No newline at end of file diff --git a/ShadowEditor.Web/assets/js/loaders/TGALoader.js b/ShadowEditor.Web/assets/js/loaders/TGALoader.js index 2ca2ab82..94937dd7 100644 --- a/ShadowEditor.Web/assets/js/loaders/TGALoader.js +++ b/ShadowEditor.Web/assets/js/loaders/TGALoader.js @@ -22,6 +22,7 @@ THREE.TGALoader.prototype = { var loader = new THREE.FileLoader( this.manager ); loader.setResponseType( 'arraybuffer' ); + loader.setPath( this.path ); loader.load( url, function ( buffer ) { @@ -535,6 +536,13 @@ THREE.TGALoader.prototype = { return canvas; + }, + + setPath: function ( value ) { + + this.path = value; + return this; + } }; diff --git a/ShadowEditor.Web/index.html b/ShadowEditor.Web/index.html index 3be2d9a3..28cf4931 100644 --- a/ShadowEditor.Web/index.html +++ b/ShadowEditor.Web/index.html @@ -110,7 +110,7 @@ - + diff --git a/ShadowEditor.Web/src/loader/ColladaLoader.js b/ShadowEditor.Web/src/loader/ColladaLoader.js index 482ee5b2..3df97028 100644 --- a/ShadowEditor.Web/src/loader/ColladaLoader.js +++ b/ShadowEditor.Web/src/loader/ColladaLoader.js @@ -22,17 +22,34 @@ ColladaLoader.prototype.load = function (url, options) { if (child instanceof THREE.Mesh) { child.material.flatShading = true; } + if (child.isSkinnedMesh) { + child.frustumCulled = false; + } }); - dae.scale.x = dae.scale.y = dae.scale.z = 10.0; - - dae.updateMatrix(); + if (isNaN(dae.scale.x) || isNaN(dae.scale.y) || isNaN(dae.scale.z)) { + dae.scale.x = dae.scale.y = dae.scale.z = 10.0; + dae.updateMatrix(); + } Object.assign(dae.userData, { obj: collada, root: dae }); + if (collada.animations && collada.animations.length > 0) { + Object.assign(dae.userData, { + animNames: collada.animations.map(n => n.name), + scripts: [{ + id: null, + name: `${options.Name}动画`, + type: 'javascript', + source: this.createScripts(options.Name), + uuid: THREE.Math.generateUUID() + }] + }); + } + resolve(dae); }, undefined, () => { resolve(null); @@ -40,4 +57,13 @@ ColladaLoader.prototype.load = function (url, options) { }); }; +ColladaLoader.prototype.createScripts = function (name) { + return `var mesh = this.getObjectByName('${name}');\n\n` + + `var obj = mesh.userData.obj;\n\n` + + `var root = mesh.userData.root;\n\n` + + `var mixer = new THREE.AnimationMixer(root);\n\n` + + `mixer.clipAction(obj.animations[0]).play();\n\n` + + `function update(clock, deltaTime) { \n mixer.update(deltaTime); \n}`; +}; + export default ColladaLoader; \ No newline at end of file