BVHLoader.js 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414
  1. /**
  2. * @author herzig / http://github.com/herzig
  3. * @author Mugen87 / https://github.com/Mugen87
  4. *
  5. * Description: reads BVH files and outputs a single THREE.Skeleton and an THREE.AnimationClip
  6. *
  7. * Currently only supports bvh files containing a single root.
  8. *
  9. */
  10. THREE.BVHLoader = function ( manager ) {
  11. this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
  12. this.animateBonePositions = true;
  13. this.animateBoneRotations = true;
  14. };
  15. THREE.BVHLoader.prototype = {
  16. constructor: THREE.BVHLoader,
  17. load: function ( url, onLoad, onProgress, onError ) {
  18. var scope = this;
  19. var loader = new THREE.FileLoader( scope.manager );
  20. loader.setPath( scope.path );
  21. loader.load( url, function ( text ) {
  22. onLoad( scope.parse( text ) );
  23. }, onProgress, onError );
  24. },
  25. setPath: function ( value ) {
  26. this.path = value;
  27. return this;
  28. },
  29. parse: function ( text ) {
  30. /*
  31. reads a string array (lines) from a BVH file
  32. and outputs a skeleton structure including motion data
  33. returns thee root node:
  34. { name: '', channels: [], children: [] }
  35. */
  36. function readBvh( lines ) {
  37. // read model structure
  38. if ( nextLine( lines ) !== 'HIERARCHY' ) {
  39. console.error( 'THREE.BVHLoader: HIERARCHY expected.' );
  40. }
  41. var list = []; // collects flat array of all bones
  42. var root = readNode( lines, nextLine( lines ), list );
  43. // read motion data
  44. if ( nextLine( lines ) !== 'MOTION' ) {
  45. console.error( 'THREE.BVHLoader: MOTION expected.' );
  46. }
  47. // number of frames
  48. var tokens = nextLine( lines ).split( /[\s]+/ );
  49. var numFrames = parseInt( tokens[ 1 ] );
  50. if ( isNaN( numFrames ) ) {
  51. console.error( 'THREE.BVHLoader: Failed to read number of frames.' );
  52. }
  53. // frame time
  54. tokens = nextLine( lines ).split( /[\s]+/ );
  55. var frameTime = parseFloat( tokens[ 2 ] );
  56. if ( isNaN( frameTime ) ) {
  57. console.error( 'THREE.BVHLoader: Failed to read frame time.' );
  58. }
  59. // read frame data line by line
  60. for ( var i = 0; i < numFrames; i ++ ) {
  61. tokens = nextLine( lines ).split( /[\s]+/ );
  62. readFrameData( tokens, i * frameTime, root );
  63. }
  64. return list;
  65. }
  66. /*
  67. Recursively reads data from a single frame into the bone hierarchy.
  68. The passed bone hierarchy has to be structured in the same order as the BVH file.
  69. keyframe data is stored in bone.frames.
  70. - data: splitted string array (frame values), values are shift()ed so
  71. this should be empty after parsing the whole hierarchy.
  72. - frameTime: playback time for this keyframe.
  73. - bone: the bone to read frame data from.
  74. */
  75. function readFrameData( data, frameTime, bone ) {
  76. // end sites have no motion data
  77. if ( bone.type === 'ENDSITE' ) return;
  78. // add keyframe
  79. var keyframe = {
  80. time: frameTime,
  81. position: new THREE.Vector3(),
  82. rotation: new THREE.Quaternion()
  83. };
  84. bone.frames.push( keyframe );
  85. var quat = new THREE.Quaternion();
  86. var vx = new THREE.Vector3( 1, 0, 0 );
  87. var vy = new THREE.Vector3( 0, 1, 0 );
  88. var vz = new THREE.Vector3( 0, 0, 1 );
  89. // parse values for each channel in node
  90. for ( var i = 0; i < bone.channels.length; i ++ ) {
  91. switch ( bone.channels[ i ] ) {
  92. case 'Xposition':
  93. keyframe.position.x = parseFloat( data.shift().trim() );
  94. break;
  95. case 'Yposition':
  96. keyframe.position.y = parseFloat( data.shift().trim() );
  97. break;
  98. case 'Zposition':
  99. keyframe.position.z = parseFloat( data.shift().trim() );
  100. break;
  101. case 'Xrotation':
  102. quat.setFromAxisAngle( vx, parseFloat( data.shift().trim() ) * Math.PI / 180 );
  103. keyframe.rotation.multiply( quat );
  104. break;
  105. case 'Yrotation':
  106. quat.setFromAxisAngle( vy, parseFloat( data.shift().trim() ) * Math.PI / 180 );
  107. keyframe.rotation.multiply( quat );
  108. break;
  109. case 'Zrotation':
  110. quat.setFromAxisAngle( vz, parseFloat( data.shift().trim() ) * Math.PI / 180 );
  111. keyframe.rotation.multiply( quat );
  112. break;
  113. default:
  114. console.warn( 'THREE.BVHLoader: Invalid channel type.' );
  115. }
  116. }
  117. // parse child nodes
  118. for ( var i = 0; i < bone.children.length; i ++ ) {
  119. readFrameData( data, frameTime, bone.children[ i ] );
  120. }
  121. }
  122. /*
  123. Recursively parses the HIERACHY section of the BVH file
  124. - lines: all lines of the file. lines are consumed as we go along.
  125. - firstline: line containing the node type and name e.g. 'JOINT hip'
  126. - list: collects a flat list of nodes
  127. returns: a BVH node including children
  128. */
  129. function readNode( lines, firstline, list ) {
  130. var node = { name: '', type: '', frames: [] };
  131. list.push( node );
  132. // parse node type and name
  133. var tokens = firstline.split( /[\s]+/ );
  134. if ( tokens[ 0 ].toUpperCase() === 'END' && tokens[ 1 ].toUpperCase() === 'SITE' ) {
  135. node.type = 'ENDSITE';
  136. node.name = 'ENDSITE'; // bvh end sites have no name
  137. } else {
  138. node.name = tokens[ 1 ];
  139. node.type = tokens[ 0 ].toUpperCase();
  140. }
  141. if ( nextLine( lines ) !== '{' ) {
  142. console.error( 'THREE.BVHLoader: Expected opening { after type & name' );
  143. }
  144. // parse OFFSET
  145. tokens = nextLine( lines ).split( /[\s]+/ );
  146. if ( tokens[ 0 ] !== 'OFFSET' ) {
  147. console.error( 'THREE.BVHLoader: Expected OFFSET but got: ' + tokens[ 0 ] );
  148. }
  149. if ( tokens.length !== 4 ) {
  150. console.error( 'THREE.BVHLoader: Invalid number of values for OFFSET.' );
  151. }
  152. var offset = new THREE.Vector3(
  153. parseFloat( tokens[ 1 ] ),
  154. parseFloat( tokens[ 2 ] ),
  155. parseFloat( tokens[ 3 ] )
  156. );
  157. if ( isNaN( offset.x ) || isNaN( offset.y ) || isNaN( offset.z ) ) {
  158. console.error( 'THREE.BVHLoader: Invalid values of OFFSET.' );
  159. }
  160. node.offset = offset;
  161. // parse CHANNELS definitions
  162. if ( node.type !== 'ENDSITE' ) {
  163. tokens = nextLine( lines ).split( /[\s]+/ );
  164. if ( tokens[ 0 ] !== 'CHANNELS' ) {
  165. console.error( 'THREE.BVHLoader: Expected CHANNELS definition.' );
  166. }
  167. var numChannels = parseInt( tokens[ 1 ] );
  168. node.channels = tokens.splice( 2, numChannels );
  169. node.children = [];
  170. }
  171. // read children
  172. while ( true ) {
  173. var line = nextLine( lines );
  174. if ( line === '}' ) {
  175. return node;
  176. } else {
  177. node.children.push( readNode( lines, line, list ) );
  178. }
  179. }
  180. }
  181. /*
  182. recursively converts the internal bvh node structure to a THREE.Bone hierarchy
  183. source: the bvh root node
  184. list: pass an empty array, collects a flat list of all converted THREE.Bones
  185. returns the root THREE.Bone
  186. */
  187. function toTHREEBone( source, list ) {
  188. var bone = new THREE.Bone();
  189. list.push( bone );
  190. bone.position.add( source.offset );
  191. bone.name = source.name;
  192. if ( source.type !== 'ENDSITE' ) {
  193. for ( var i = 0; i < source.children.length; i ++ ) {
  194. bone.add( toTHREEBone( source.children[ i ], list ) );
  195. }
  196. }
  197. return bone;
  198. }
  199. /*
  200. builds a THREE.AnimationClip from the keyframe data saved in each bone.
  201. bone: bvh root node
  202. returns: a THREE.AnimationClip containing position and quaternion tracks
  203. */
  204. function toTHREEAnimation( bones ) {
  205. var tracks = [];
  206. // create a position and quaternion animation track for each node
  207. for ( var i = 0; i < bones.length; i ++ ) {
  208. var bone = bones[ i ];
  209. if ( bone.type === 'ENDSITE' )
  210. continue;
  211. // track data
  212. var times = [];
  213. var positions = [];
  214. var rotations = [];
  215. for ( var j = 0; j < bone.frames.length; j ++ ) {
  216. var frame = bone.frames[ j ];
  217. times.push( frame.time );
  218. // the animation system animates the position property,
  219. // so we have to add the joint offset to all values
  220. positions.push( frame.position.x + bone.offset.x );
  221. positions.push( frame.position.y + bone.offset.y );
  222. positions.push( frame.position.z + bone.offset.z );
  223. rotations.push( frame.rotation.x );
  224. rotations.push( frame.rotation.y );
  225. rotations.push( frame.rotation.z );
  226. rotations.push( frame.rotation.w );
  227. }
  228. if ( scope.animateBonePositions ) {
  229. tracks.push( new THREE.VectorKeyframeTrack( '.bones[' + bone.name + '].position', times, positions ) );
  230. }
  231. if ( scope.animateBoneRotations ) {
  232. tracks.push( new THREE.QuaternionKeyframeTrack( '.bones[' + bone.name + '].quaternion', times, rotations ) );
  233. }
  234. }
  235. return new THREE.AnimationClip( 'animation', - 1, tracks );
  236. }
  237. /*
  238. returns the next non-empty line in lines
  239. */
  240. function nextLine( lines ) {
  241. var line;
  242. // skip empty lines
  243. while ( ( line = lines.shift().trim() ).length === 0 ) { }
  244. return line;
  245. }
  246. var scope = this;
  247. var lines = text.split( /[\r\n]+/g );
  248. var bones = readBvh( lines );
  249. var threeBones = [];
  250. toTHREEBone( bones[ 0 ], threeBones );
  251. var threeClip = toTHREEAnimation( bones );
  252. return {
  253. skeleton: new THREE.Skeleton( threeBones ),
  254. clip: threeClip
  255. };
  256. }
  257. };