开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llbvhloader.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：47k
源码类别：

游戏引擎

开发平台：

C++ Builder

llbvhloader.cpp：源码内容
  1. /** 
  2.  * @file llbvhloader.cpp
  3.  * @brief Translates a BVH files to LindenLabAnimation format.
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include "llbvhloader.h"
  37. #include <boost/tokenizer.hpp>
  39. #include "lldatapacker.h"
  40. #include "lldir.h"
  41. #include "llkeyframemotion.h"
  42. #include "llquantize.h"
  43. #include "llstl.h"
  44. #include "llapr.h"
  47. using namespace std;
  49. #define INCHES_TO_METERS 0.02540005f
  51. const F32 POSITION_KEYFRAME_THRESHOLD = 0.03f;
  52. const F32 ROTATION_KEYFRAME_THRESHOLD = 0.01f;
  54. const F32 POSITION_MOTION_THRESHOLD = 0.001f;
  55. const F32 ROTATION_MOTION_THRESHOLD = 0.001f;
  57. char gInFile[1024]; /* Flawfinder: ignore */
  58. char gOutFile[1024]; /* Flawfinder: ignore */
  59. /*
  60. //------------------------------------------------------------------------
  61. // Status Codes
  62. //------------------------------------------------------------------------
  63. const char *LLBVHLoader::ST_OK = "Ok";
  64. const char *LLBVHLoader::ST_EOF = "Premature end of file.";
  65. const char *LLBVHLoader::ST_NO_CONSTRAINT = "Can't read constraint definition.";
  66. const char *LLBVHLoader::ST_NO_FILE = "Can't open BVH file.";
  67. const char *LLBVHLoader::ST_NO_HIER = "Invalid HIERARCHY header.";
  68. const char *LLBVHLoader::ST_NO_JOINT = "Can't find ROOT or JOINT.";
  69. const char *LLBVHLoader::ST_NO_NAME = "Can't get JOINT name.";
  70. const char *LLBVHLoader::ST_NO_OFFSET = "Can't find OFFSET.";
  71. const char *LLBVHLoader::ST_NO_CHANNELS = "Can't find CHANNELS.";
  72. const char *LLBVHLoader::ST_NO_ROTATION = "Can't get rotation order.";
  73. const char *LLBVHLoader::ST_NO_AXIS = "Can't get rotation axis.";
  74. const char *LLBVHLoader::ST_NO_MOTION = "Can't find MOTION.";
  75. const char *LLBVHLoader::ST_NO_FRAMES = "Can't get number of frames.";
  76. const char *LLBVHLoader::ST_NO_FRAME_TIME = "Can't get frame time.";
  77. const char *LLBVHLoader::ST_NO_POS = "Can't get position values.";
  78. const char *LLBVHLoader::ST_NO_ROT = "Can't get rotation values.";
  79. const char *LLBVHLoader::ST_NO_XLT_FILE = "Can't open translation file.";
  80. const char *LLBVHLoader::ST_NO_XLT_HEADER = "Can't read translation header.";
  81. const char *LLBVHLoader::ST_NO_XLT_NAME = "Can't read translation names.";
  82. const char *LLBVHLoader::ST_NO_XLT_IGNORE = "Can't read translation ignore value.";
  83. const char *LLBVHLoader::ST_NO_XLT_RELATIVE = "Can't read translation relative value.";
  84. const char *LLBVHLoader::ST_NO_XLT_OUTNAME = "Can't read translation outname value.";
  85. const char *LLBVHLoader::ST_NO_XLT_MATRIX = "Can't read translation matrix.";
  86. const char *LLBVHLoader::ST_NO_XLT_MERGECHILD = "Can't get mergechild name.";
  87. const char *LLBVHLoader::ST_NO_XLT_MERGEPARENT = "Can't get mergeparent name.";
  88. const char *LLBVHLoader::ST_NO_XLT_PRIORITY = "Can't get priority value.";
  89. const char *LLBVHLoader::ST_NO_XLT_LOOP = "Can't get loop value.";
  90. const char *LLBVHLoader::ST_NO_XLT_EASEIN = "Can't get easeIn values.";
  91. const char *LLBVHLoader::ST_NO_XLT_EASEOUT = "Can't get easeOut values.";
  92. const char *LLBVHLoader::ST_NO_XLT_HAND = "Can't get hand morph value.";
  93. const char *LLBVHLoader::ST_NO_XLT_EMOTE = "Can't read emote name.";
  94. const char *LLBVHLoader::ST_BAD_ROOT        = "Illegal ROOT joint.";
  95. */
  97. //------------------------------------------------------------------------
  98. // find_next_whitespace()
  99. //------------------------------------------------------------------------
  100. const char *find_next_whitespace(const char *p)
  101. {
  102. while(*p && isspace(*p)) p++;
  103. while(*p && !isspace(*p)) p++;
  104. return p;
  105. }
  108. //------------------------------------------------------------------------
  109. // bvhStringToOrder()
  110. //
  111. // XYZ order in BVH files must be passed to mayaQ() as ZYX.
  112. // This function reverses the input string before passing it on
  113. // to StringToOrder().
  114. //------------------------------------------------------------------------
  115. LLQuaternion::Order bvhStringToOrder( char *str )
  116. {
  117. char order[4]; /* Flawfinder: ignore */
  118. order[0] = str[2];
  119. order[1] = str[1];
  120. order[2] = str[0];
  121. order[3] = 0;
  122. LLQuaternion::Order retVal = StringToOrder( order );
  123. return retVal;
  124. }
  126. //-----------------------------------------------------------------------------
  127. // LLBVHLoader()
  128. //-----------------------------------------------------------------------------
  130. /*
  131.  LLBVHLoader::LLBVHLoader(const char* buffer)
  132. {
  133. reset();
  135. mStatus = loadTranslationTable("anim.ini");
  137. if (mStatus == LLBVHLoader::ST_NO_XLT_FILE)
  138. {
  139. llwarns << "NOTE: No translation table found." << llendl;
  140. return;
  141. }
  142. else
  143. {
  144. if (mStatus != LLBVHLoader::ST_OK)
  145. {
  146. llwarns << "ERROR: [line: " << getLineNumber() << "] " << mStatus << llendl;
  147. return;
  148. }
  149. }
  151. char error_text[128]; // Flawfinder: ignore 
  152. S32 error_line;
  153. mStatus = loadBVHFile(buffer, error_text, error_line);
  154. if (mStatus != LLBVHLoader::ST_OK)
  155. {
  156. llwarns << "ERROR: [line: " << getLineNumber() << "] " << mStatus << llendl;
  157. return;
  158. }
  160. applyTranslations();
  161. optimize();
  163. mInitialized = TRUE;
  164. }
  165. */
  166. LLBVHLoader::LLBVHLoader(const char* buffer, ELoadStatus &loadStatus, S32 &errorLine)
  167. {
  168. reset();
  169. errorLine = 0;
  170. mStatus = loadTranslationTable("anim.ini");
  171. loadStatus = mStatus;
  172. llinfos<<"Load Status 00 : "<< loadStatus << llendl;
  173. if (mStatus == E_ST_NO_XLT_FILE)
  174. {
  175. //llwarns << "NOTE: No translation table found." << llendl;
  176. loadStatus = mStatus;
  177. return;
  178. }
  179. else
  180. {
  181. if (mStatus != E_ST_OK)
  182. {
  183. //llwarns << "ERROR: [line: " << getLineNumber() << "] " << mStatus << llendl;
  184. errorLine = getLineNumber();
  185. loadStatus = mStatus;
  186. return;
  187. }
  188. }
  190. char error_text[128]; /* Flawfinder: ignore */
  191. S32 error_line;
  192. mStatus = loadBVHFile(buffer, error_text, error_line);
  194. if (mStatus != E_ST_OK)
  195. {
  196. //llwarns << "ERROR: [line: " << getLineNumber() << "] " << mStatus << llendl;
  197. loadStatus = mStatus;
  198. errorLine = getLineNumber();
  199. return;
  200. }
  202. applyTranslations();
  203. optimize();
  205. mInitialized = TRUE;
  206. }
  209. LLBVHLoader::~LLBVHLoader()
  210. {
  211. std::for_each(mJoints.begin(),mJoints.end(),DeletePointer());
  212. }
  214. //------------------------------------------------------------------------
  215. // LLBVHLoader::loadTranslationTable()
  216. //------------------------------------------------------------------------
  217. ELoadStatus LLBVHLoader::loadTranslationTable(const char *fileName)
  218. {
  219. mLineNumber = 0;
  220. mTranslations.clear();
  221. mConstraints.clear();
  223. //--------------------------------------------------------------------
  224. // open file
  225. //--------------------------------------------------------------------
  226. std::string path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,fileName);
  228. LLAPRFile infile ;
  229. infile.open(path, LL_APR_R);
  230. apr_file_t *fp = infile.getFileHandle();
  231. if (!fp)
  232. return E_ST_NO_XLT_FILE;
  234. llinfos << "NOTE: Loading translation table: " << fileName << llendl;
  236. //--------------------------------------------------------------------
  237. // register file to be closed on function exit
  238. //--------------------------------------------------------------------
  240. //--------------------------------------------------------------------
  241. // load header
  242. //--------------------------------------------------------------------
  243. if ( ! getLine(fp) )
  244. return E_ST_EOF;
  245. if ( strncmp(mLine, "Translations 1.0", 16) )
  246. return E_ST_NO_XLT_HEADER;
  248. //--------------------------------------------------------------------
  249. // load data one line at a time
  250. //--------------------------------------------------------------------
  251. BOOL loadingGlobals = FALSE;
  252. Translation *trans = NULL;
  253. while ( getLine(fp) )
  254. {
  255. //----------------------------------------------------------------
  256. // check the 1st token on the line to determine if it's empty or a comment
  257. //----------------------------------------------------------------
  258. char token[128]; /* Flawfinder: ignore */
  259. if ( sscanf(mLine, " %127s", token) != 1 ) /* Flawfinder: ignore */
  260. continue;
  262. if (token[0] == '#')
  263. continue;
  265. //----------------------------------------------------------------
  266. // check if a [jointName] or [GLOBALS] was specified.
  267. //----------------------------------------------------------------
  268. if (token[0] == '[')
  269. {
  270. char name[128]; /* Flawfinder: ignore */
  271. if ( sscanf(mLine, " [%127[^]]", name) != 1 )
  272. return E_ST_NO_XLT_NAME;
  274. if (strcmp(name, "GLOBALS")==0)
  275. {
  276. loadingGlobals = TRUE;
  277. continue;
  278. }
  279. else
  280. {
  281. loadingGlobals = FALSE;
  282. Translation &newTrans = mTranslations[ name ];
  283. trans = &newTrans;
  284. continue;
  285. }
  286. }
  288. //----------------------------------------------------------------
  289. // check for optional emote 
  290. //----------------------------------------------------------------
  291. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "emote")==0)
  292. {
  293. char emote_str[1024]; /* Flawfinder: ignore */
  294. if ( sscanf(mLine, " %*s = %1023s", emote_str) != 1 ) /* Flawfinder: ignore */
  295. return E_ST_NO_XLT_EMOTE;
  297. mEmoteName.assign( emote_str );
  298. // llinfos << "NOTE: Emote: " << mEmoteName.c_str() << llendl;
  299. continue;
  300. }
  303. //----------------------------------------------------------------
  304. // check for global priority setting
  305. //----------------------------------------------------------------
  306. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "priority")==0)
  307. {
  308. S32 priority;
  309. if ( sscanf(mLine, " %*s = %d", &priority) != 1 )
  310. return E_ST_NO_XLT_PRIORITY;
  312. mPriority = priority;
  313. // llinfos << "NOTE: Priority: " << mPriority << llendl;
  314. continue;
  315. }
  317. //----------------------------------------------------------------
  318. // check for global loop setting
  319. //----------------------------------------------------------------
  320. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "loop")==0)
  321. {
  322. char trueFalse[128]; /* Flawfinder: ignore */
  323. trueFalse[0] = '';
  325. F32 loop_in = 0.f;
  326. F32 loop_out = 1.f;
  328. if ( sscanf(mLine, " %*s = %f %f", &loop_in, &loop_out) == 2 )
  329. {
  330. mLoop = TRUE;
  331. }
  332. else if ( sscanf(mLine, " %*s = %127s", trueFalse) == 1 ) /* Flawfinder: ignore */
  333. {
  334. mLoop = (LLStringUtil::compareInsensitive(trueFalse, "true")==0);
  335. }
  336. else
  337. {
  338. return E_ST_NO_XLT_LOOP;
  339. }
  341. mLoopInPoint = loop_in * mDuration;
  342. mLoopOutPoint = loop_out * mDuration;
  344. continue;
  345. }
  347. //----------------------------------------------------------------
  348. // check for global easeIn setting
  349. //----------------------------------------------------------------
  350. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "easein")==0)
  351. {
  352. F32 duration;
  353. char type[128]; /* Flawfinder: ignore */
  354. if ( sscanf(mLine, " %*s = %f %127s", &duration, type) != 2 ) /* Flawfinder: ignore */
  355. return E_ST_NO_XLT_EASEIN;
  357. mEaseIn = duration;
  358. continue;
  359. }
  361. //----------------------------------------------------------------
  362. // check for global easeOut setting
  363. //----------------------------------------------------------------
  364. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "easeout")==0)
  365. {
  366. F32 duration;
  367. char type[128]; /* Flawfinder: ignore */
  368. if ( sscanf(mLine, " %*s = %f %127s", &duration, type) != 2 ) /* Flawfinder: ignore */
  369. return E_ST_NO_XLT_EASEOUT;
  371. mEaseOut = duration;
  372. continue;
  373. }
  375. //----------------------------------------------------------------
  376. // check for global handMorph setting
  377. //----------------------------------------------------------------
  378. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "hand")==0)
  379. {
  380. S32 handMorph;
  381. if (sscanf(mLine, " %*s = %d", &handMorph) != 1)
  382. return E_ST_NO_XLT_HAND;
  384. mHand = handMorph;
  385. continue;
  386. }
  388. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "constraint")==0)
  389. {
  390. Constraint constraint;
  392. // try reading optional target direction
  393. if(sscanf( /* Flawfinder: ignore */
  394. mLine,
  395. " %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f %f %f %f", 
  396. &constraint.mChainLength,
  397. &constraint.mEaseInStart,
  398. &constraint.mEaseInStop,
  399. &constraint.mEaseOutStart,
  400. &constraint.mEaseOutStop,
  401. constraint.mSourceJointName,
  402. &constraint.mSourceOffset.mV[VX],
  403. &constraint.mSourceOffset.mV[VY],
  404. &constraint.mSourceOffset.mV[VZ],
  405. constraint.mTargetJointName,
  406. &constraint.mTargetOffset.mV[VX],
  407. &constraint.mTargetOffset.mV[VY],
  408. &constraint.mTargetOffset.mV[VZ],
  409. &constraint.mTargetDir.mV[VX],
  410. &constraint.mTargetDir.mV[VY],
  411. &constraint.mTargetDir.mV[VZ]) != 16)
  412. {
  413. if(sscanf( /* Flawfinder: ignore */
  414. mLine,
  415. " %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f", 
  416. &constraint.mChainLength,
  417. &constraint.mEaseInStart,
  418. &constraint.mEaseInStop,
  419. &constraint.mEaseOutStart,
  420. &constraint.mEaseOutStop,
  421. constraint.mSourceJointName,
  422. &constraint.mSourceOffset.mV[VX],
  423. &constraint.mSourceOffset.mV[VY],
  424. &constraint.mSourceOffset.mV[VZ],
  425. constraint.mTargetJointName,
  426. &constraint.mTargetOffset.mV[VX],
  427. &constraint.mTargetOffset.mV[VY],
  428. &constraint.mTargetOffset.mV[VZ]) != 13)
  429. {
  430. return E_ST_NO_CONSTRAINT;
  431. }
  432. }
  433. else
  434. {
  435. // normalize direction
  436. if (!constraint.mTargetDir.isExactlyZero())
  437. {
  438. constraint.mTargetDir.normVec();
  439. }
  441. }
  443. constraint.mConstraintType = CONSTRAINT_TYPE_POINT;
  444. mConstraints.push_back(constraint);
  445. continue;
  446. }
  448. if (loadingGlobals && LLStringUtil::compareInsensitive(token, "planar_constraint")==0)
  449. {
  450. Constraint constraint;
  452. // try reading optional target direction
  453. if(sscanf( /* Flawfinder: ignore */
  454. mLine,
  455. " %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f %f %f %f", 
  456. &constraint.mChainLength,
  457. &constraint.mEaseInStart,
  458. &constraint.mEaseInStop,
  459. &constraint.mEaseOutStart,
  460. &constraint.mEaseOutStop,
  461. constraint.mSourceJointName,
  462. &constraint.mSourceOffset.mV[VX],
  463. &constraint.mSourceOffset.mV[VY],
  464. &constraint.mSourceOffset.mV[VZ],
  465. constraint.mTargetJointName,
  466. &constraint.mTargetOffset.mV[VX],
  467. &constraint.mTargetOffset.mV[VY],
  468. &constraint.mTargetOffset.mV[VZ],
  469. &constraint.mTargetDir.mV[VX],
  470. &constraint.mTargetDir.mV[VY],
  471. &constraint.mTargetDir.mV[VZ]) != 16)
  472. {
  473. if(sscanf( /* Flawfinder: ignore */
  474. mLine,
  475. " %*s = %d %f %f %f %f %15s %f %f %f %15s %f %f %f", 
  476. &constraint.mChainLength,
  477. &constraint.mEaseInStart,
  478. &constraint.mEaseInStop,
  479. &constraint.mEaseOutStart,
  480. &constraint.mEaseOutStop,
  481. constraint.mSourceJointName,
  482. &constraint.mSourceOffset.mV[VX],
  483. &constraint.mSourceOffset.mV[VY],
  484. &constraint.mSourceOffset.mV[VZ],
  485. constraint.mTargetJointName,
  486. &constraint.mTargetOffset.mV[VX],
  487. &constraint.mTargetOffset.mV[VY],
  488. &constraint.mTargetOffset.mV[VZ]) != 13)
  489. {
  490. return E_ST_NO_CONSTRAINT;
  491. }
  492. }
  493. else
  494. {
  495. // normalize direction
  496. if (!constraint.mTargetDir.isExactlyZero())
  497. {
  498. constraint.mTargetDir.normVec();
  499. }
  501. }
  503. constraint.mConstraintType = CONSTRAINT_TYPE_PLANE;
  504. mConstraints.push_back(constraint);
  505. continue;
  506. }
  509. //----------------------------------------------------------------
  510. // at this point there must be a valid trans pointer
  511. //----------------------------------------------------------------
  512. if ( ! trans )
  513. return E_ST_NO_XLT_NAME;
  515. //----------------------------------------------------------------
  516. // check for ignore flag
  517. //----------------------------------------------------------------
  518. if ( LLStringUtil::compareInsensitive(token, "ignore")==0 )
  519. {
  520. char trueFalse[128]; /* Flawfinder: ignore */
  521. if ( sscanf(mLine, " %*s = %127s", trueFalse) != 1 ) /* Flawfinder: ignore */
  522. return E_ST_NO_XLT_IGNORE;
  524. trans->mIgnore = (LLStringUtil::compareInsensitive(trueFalse, "true")==0);
  525. continue;
  526. }
  528. //----------------------------------------------------------------
  529. // check for relativepos flag
  530. //----------------------------------------------------------------
  531. if ( LLStringUtil::compareInsensitive(token, "relativepos")==0 )
  532. {
  533. F32 x, y, z;
  534. char relpos[128]; /* Flawfinder: ignore */
  535. if ( sscanf(mLine, " %*s = %f %f %f", &x, &y, &z) == 3 )
  536. {
  537. trans->mRelativePosition.setVec( x, y, z );
  538. }
  539. else if ( sscanf(mLine, " %*s = %127s", relpos) == 1 ) /* Flawfinder: ignore */
  540. {
  541. if ( LLStringUtil::compareInsensitive(relpos, "firstkey")==0 )
  542. {
  543. trans->mRelativePositionKey = TRUE;
  544. }
  545. else
  546. {
  547. return E_ST_NO_XLT_RELATIVE;
  548. }
  549. }
  550. else
  551. {
  552. return E_ST_NO_XLT_RELATIVE;
  553. }
  555. continue;
  556. }
  558. //----------------------------------------------------------------
  559. // check for relativerot flag
  560. //----------------------------------------------------------------
  561. if ( LLStringUtil::compareInsensitive(token, "relativerot")==0 )
  562. {
  563. //F32 x, y, z;
  564. char relpos[128]; /* Flawfinder: ignore */
  565. if ( sscanf(mLine, " %*s = %127s", relpos) == 1 ) /* Flawfinder: ignore */
  566. {
  567. if ( LLStringUtil::compareInsensitive(relpos, "firstkey")==0 )
  568. {
  569. trans->mRelativeRotationKey = TRUE;
  570. }
  571. else
  572. {
  573. return E_ST_NO_XLT_RELATIVE;
  574. }
  575. }
  576. else
  577. {
  578. return E_ST_NO_XLT_RELATIVE;
  579. }
  581. continue;
  582. }
  584. //----------------------------------------------------------------
  585. // check for outname value
  586. //----------------------------------------------------------------
  587. if ( LLStringUtil::compareInsensitive(token, "outname")==0 )
  588. {
  589. char outName[128]; /* Flawfinder: ignore */
  590. if ( sscanf(mLine, " %*s = %127s", outName) != 1 ) /* Flawfinder: ignore */
  591. return E_ST_NO_XLT_OUTNAME;
  593. trans->mOutName = outName;
  594. continue;
  595. }
  597. //----------------------------------------------------------------
  598. // check for frame matrix value
  599. //----------------------------------------------------------------
  600. if ( LLStringUtil::compareInsensitive(token, "frame")==0 )
  601. {
  602. LLMatrix3 fm;
  603. if ( sscanf(mLine, " %*s = %f %f %f, %f %f %f, %f %f %f",
  604. &fm.mMatrix[0][0], &fm.mMatrix[0][1], &fm.mMatrix[0][2],
  605. &fm.mMatrix[1][0], &fm.mMatrix[1][1], &fm.mMatrix[1][2],
  606. &fm.mMatrix[2][0], &fm.mMatrix[2][1], &fm.mMatrix[2][2] ) != 9 )
  607. return E_ST_NO_XLT_MATRIX;
  609. trans->mFrameMatrix = fm;
  610. continue;
  611. }
  613. //----------------------------------------------------------------
  614. // check for offset matrix value
  615. //----------------------------------------------------------------
  616. if ( LLStringUtil::compareInsensitive(token, "offset")==0 )
  617. {
  618. LLMatrix3 om;
  619. if ( sscanf(mLine, " %*s = %f %f %f, %f %f %f, %f %f %f",
  620. &om.mMatrix[0][0], &om.mMatrix[0][1], &om.mMatrix[0][2],
  621. &om.mMatrix[1][0], &om.mMatrix[1][1], &om.mMatrix[1][2],
  622. &om.mMatrix[2][0], &om.mMatrix[2][1], &om.mMatrix[2][2] ) != 9 )
  623. return E_ST_NO_XLT_MATRIX;
  625. trans->mOffsetMatrix = om;
  626. continue;
  627. }
  629. //----------------------------------------------------------------
  630. // check for mergeparent value
  631. //----------------------------------------------------------------
  632. if ( LLStringUtil::compareInsensitive(token, "mergeparent")==0 )
  633. {
  634. char mergeParentName[128]; /* Flawfinder: ignore */
  635. if ( sscanf(mLine, " %*s = %127s", mergeParentName) != 1 ) /* Flawfinder: ignore */
  636. return E_ST_NO_XLT_MERGEPARENT;
  638. trans->mMergeParentName = mergeParentName;
  639. continue;
  640. }
  642. //----------------------------------------------------------------
  643. // check for mergechild value
  644. //----------------------------------------------------------------
  645. if ( LLStringUtil::compareInsensitive(token, "mergechild")==0 )
  646. {
  647. char mergeChildName[128]; /* Flawfinder: ignore */
  648. if ( sscanf(mLine, " %*s = %127s", mergeChildName) != 1 ) /* Flawfinder: ignore */
  649. return E_ST_NO_XLT_MERGECHILD;
  651. trans->mMergeChildName = mergeChildName;
  652. continue;
  653. }
  655. //----------------------------------------------------------------
  656. // check for per-joint priority
  657. //----------------------------------------------------------------
  658. if ( LLStringUtil::compareInsensitive(token, "priority")==0 )
  659. {
  660. S32 priority;
  661. if ( sscanf(mLine, " %*s = %d", &priority) != 1 )
  662. return E_ST_NO_XLT_PRIORITY;
  664. trans->mPriorityModifier = priority;
  665. continue;
  666. }
  668. }
  670. infile.close() ;
  671. return E_ST_OK;
  672. }
  675. //------------------------------------------------------------------------
  676. // LLBVHLoader::loadBVHFile()
  677. //------------------------------------------------------------------------
  678. ELoadStatus LLBVHLoader::loadBVHFile(const char *buffer, char* error_text, S32 &err_line)
  679. {
  680. std::string line;
  682. err_line = 0;
  683. error_text[127] = '';
  685. std::string str(buffer);
  686. typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  687. boost::char_separator<char> sep("rn");
  688. tokenizer tokens(str, sep);
  689. tokenizer::iterator iter = tokens.begin();
  691. mLineNumber = 0;
  692. mJoints.clear();
  694. std::vector<S32> parent_joints;
  696. //--------------------------------------------------------------------
  697. // consume  hierarchy
  698. //--------------------------------------------------------------------
  699. if (iter == tokens.end())
  700. return E_ST_EOF;
  701. line = (*(iter++));
  702. err_line++;
  704. if ( !strstr(line.c_str(), "HIERARCHY") )
  705. {
  706. // llinfos << line << llendl;
  707. return E_ST_NO_HIER;
  708. }
  710. //--------------------------------------------------------------------
  711. // consume joints
  712. //--------------------------------------------------------------------
  713. while (TRUE)
  714. {
  715. //----------------------------------------------------------------
  716. // get next line
  717. //----------------------------------------------------------------
  718. if (iter == tokens.end())
  719. return E_ST_EOF;
  720. line = (*(iter++));
  721. err_line++;
  723. //----------------------------------------------------------------
  724. // consume }
  725. //----------------------------------------------------------------
  726. if ( strstr(line.c_str(), "}") )
  727. {
  728. if (parent_joints.size() > 0)
  729. {
  730. parent_joints.pop_back();
  731. }
  732. continue;
  733. }
  735. //----------------------------------------------------------------
  736. // if MOTION, break out
  737. //----------------------------------------------------------------
  738. if ( strstr(line.c_str(), "MOTION") )
  739. break;
  741. //----------------------------------------------------------------
  742. // it must be either ROOT or JOINT or EndSite
  743. //----------------------------------------------------------------
  744. if ( strstr(line.c_str(), "ROOT") )
  745. {
  746. }
  747. else if ( strstr(line.c_str(), "JOINT") )
  748. {
  749. }
  750. else if ( strstr(line.c_str(), "End Site") )
  751. {
  752. iter++; // {
  753. iter++; //     OFFSET
  754. S32 depth = 0;
  755. for (S32 j = (S32)parent_joints.size() - 1; j >= 0; j--)
  756. {
  757. Joint *joint = mJoints[parent_joints[j]];
  758. if (depth > joint->mChildTreeMaxDepth)
  759. {
  760. joint->mChildTreeMaxDepth = depth;
  761. }
  762. depth++;
  763. }
  764. continue;
  765. }
  766. else
  767. {
  768. strncpy(error_text, line.c_str(), 127); /* Flawfinder: ignore */
  769. return E_ST_NO_JOINT;
  770. }
  772. //----------------------------------------------------------------
  773. // get the joint name
  774. //----------------------------------------------------------------
  775. char jointName[80]; /* Flawfinder: ignore */
  776. if ( sscanf(line.c_str(), "%*s %79s", jointName) != 1 ) /* Flawfinder: ignore */
  777. {
  778. strncpy(error_text, line.c_str(), 127); /* Flawfinder: ignore */
  779. return E_ST_NO_NAME;
  780. }
  782. //---------------------------------------------------------------
  783. // we require the root joint be "hip" - DEV-26188
  784. //---------------------------------------------------------------
  785. const char* FORCED_ROOT_NAME = "hip";
  786. if ( (mJoints.size() == 0 ) && ( !strstr(jointName, FORCED_ROOT_NAME) ) )
  787. {
  788. strncpy(error_text, line.c_str(), 127); /* Flawfinder: ignore */
  789. return E_ST_BAD_ROOT;
  790. }
  793. //----------------------------------------------------------------
  794. // add a set of keyframes for this joint
  795. //----------------------------------------------------------------
  796. mJoints.push_back( new Joint( jointName ) );
  797. Joint *joint = mJoints.back();
  799. S32 depth = 1;
  800. for (S32 j = (S32)parent_joints.size() - 1; j >= 0; j--)
  801. {
  802. Joint *pjoint = mJoints[parent_joints[j]];
  803. if (depth > pjoint->mChildTreeMaxDepth)
  804. {
  805. pjoint->mChildTreeMaxDepth = depth;
  806. }
  807. depth++;
  808. }
  810. //----------------------------------------------------------------
  811. // get next line
  812. //----------------------------------------------------------------
  813. if (iter == tokens.end())
  814. {
  815. return E_ST_EOF;
  816. }
  817. line = (*(iter++));
  818. err_line++;
  820. //----------------------------------------------------------------
  821. // it must be {
  822. //----------------------------------------------------------------
  823. if ( !strstr(line.c_str(), "{") )
  824. {
  825. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  826. return E_ST_NO_OFFSET;
  827. }
  828. else
  829. {
  830. parent_joints.push_back((S32)mJoints.size() - 1);
  831. }
  833. //----------------------------------------------------------------
  834. // get next line
  835. //----------------------------------------------------------------
  836. if (iter == tokens.end())
  837. {
  838. return E_ST_EOF;
  839. }
  840. line = (*(iter++));
  841. err_line++;
  843. //----------------------------------------------------------------
  844. // it must be OFFSET
  845. //----------------------------------------------------------------
  846. if ( !strstr(line.c_str(), "OFFSET") )
  847. {
  848. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  849. return E_ST_NO_OFFSET;
  850. }
  852. //----------------------------------------------------------------
  853. // get next line
  854. //----------------------------------------------------------------
  855. if (iter == tokens.end())
  856. {
  857. return E_ST_EOF;
  858. }
  859. line = (*(iter++));
  860. err_line++;
  862. //----------------------------------------------------------------
  863. // it must be CHANNELS
  864. //----------------------------------------------------------------
  865. if ( !strstr(line.c_str(), "CHANNELS") )
  866. {
  867. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  868. return E_ST_NO_CHANNELS;
  869. }
  871. //----------------------------------------------------------------
  872. // get rotation order
  873. //----------------------------------------------------------------
  874. const char *p = line.c_str();
  875. for (S32 i=0; i<3; i++)
  876. {
  877. p = strstr(p, "rotation");
  878. if (!p)
  879. {
  880. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  881. return E_ST_NO_ROTATION;
  882. }
  884. const char axis = *(p - 1);
  885. if ((axis != 'X') && (axis != 'Y') && (axis != 'Z'))
  886. {
  887. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  888. return E_ST_NO_AXIS;
  889. }
  891. joint->mOrder[i] = axis;
  893. p++;
  894. }
  895. }
  897. //--------------------------------------------------------------------
  898. // consume motion
  899. //--------------------------------------------------------------------
  900. if ( !strstr(line.c_str(), "MOTION") )
  901. {
  902. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  903. return E_ST_NO_MOTION;
  904. }
  906. //--------------------------------------------------------------------
  907. // get number of frames
  908. //--------------------------------------------------------------------
  909. if (iter == tokens.end())
  910. {
  911. return E_ST_EOF;
  912. }
  913. line = (*(iter++));
  914. err_line++;
  916. if ( !strstr(line.c_str(), "Frames:") )
  917. {
  918. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  919. return E_ST_NO_FRAMES;
  920. }
  922. if ( sscanf(line.c_str(), "Frames: %d", &mNumFrames) != 1 )
  923. {
  924. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  925. return E_ST_NO_FRAMES;
  926. }
  928. //--------------------------------------------------------------------
  929. // get frame time
  930. //--------------------------------------------------------------------
  931. if (iter == tokens.end())
  932. {
  933. return E_ST_EOF;
  934. }
  935. line = (*(iter++));
  936. err_line++;
  938. if ( !strstr(line.c_str(), "Frame Time:") )
  939. {
  940. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  941. return E_ST_NO_FRAME_TIME;
  942. }
  944. if ( sscanf(line.c_str(), "Frame Time: %f", &mFrameTime) != 1 )
  945. {
  946. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  947. return E_ST_NO_FRAME_TIME;
  948. }
  950. mDuration = (F32)mNumFrames * mFrameTime;
  951. if (!mLoop)
  952. {
  953. mLoopOutPoint = mDuration;
  954. }
  956. //--------------------------------------------------------------------
  957. // load frames
  958. //--------------------------------------------------------------------
  959. for (S32 i=0; i<mNumFrames; i++)
  960. {
  961. // get next line
  962. if (iter == tokens.end())
  963. {
  964. return E_ST_EOF;
  965. }
  966. line = (*(iter++));
  967. err_line++;
  969. // read and store values
  970. const char *p = line.c_str();
  971. for (U32 j=0; j<mJoints.size(); j++)
  972. {
  973. Joint *joint = mJoints[j];
  974. joint->mKeys.push_back( Key() );
  975. Key &key = joint->mKeys.back();
  977. // get 3 pos values for root joint only
  978. if (j==0)
  979. {
  980. if ( sscanf(p, "%f %f %f", key.mPos, key.mPos+1, key.mPos+2) != 3 )
  981. {
  982. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  983. return E_ST_NO_POS;
  984. }
  985. }
  987. // skip to next 3 values in the line
  988. p = find_next_whitespace(p);
  989. if (!p) 
  990. {
  991. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  992. return E_ST_NO_ROT;
  993. }
  994. p = find_next_whitespace(++p);
  995. if (!p) 
  996. {
  997. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  998. return E_ST_NO_ROT;
  999. }
  1000. p = find_next_whitespace(++p);
  1001. if (!p)
  1002. {
  1003. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  1004. return E_ST_NO_ROT;
  1005. }
  1007. // get 3 rot values for joint
  1008. F32 rot[3];
  1009. if ( sscanf(p, " %f %f %f", rot, rot+1, rot+2) != 3 )
  1010. {
  1011. strncpy(error_text, line.c_str(), 127); /*Flawfinder: ignore*/
  1012. return E_ST_NO_ROT;
  1013. }
  1015. p++;
  1017. key.mRot[ joint->mOrder[0]-'X' ] = rot[0];
  1018. key.mRot[ joint->mOrder[1]-'X' ] = rot[1];
  1019. key.mRot[ joint->mOrder[2]-'X' ] = rot[2];
  1020. }
  1021. }
  1023. return E_ST_OK;
  1024. }
  1027. //------------------------------------------------------------------------
  1028. // LLBVHLoader::applyTranslation()
  1029. //------------------------------------------------------------------------
  1030. void LLBVHLoader::applyTranslations()
  1031. {
  1032. JointVector::iterator ji;
  1033. for (ji = mJoints.begin(); ji != mJoints.end(); ++ji )
  1034. {
  1035. Joint *joint = *ji;
  1036. //----------------------------------------------------------------
  1037. // Look for a translation for this joint.
  1038. // If none, skip to next joint
  1039. //----------------------------------------------------------------
  1040. TranslationMap::iterator ti = mTranslations.find( joint->mName );
  1041. if ( ti == mTranslations.end() )
  1042. {
  1043. continue;
  1044. }
  1046. Translation &trans = ti->second;
  1048. //----------------------------------------------------------------
  1049. // Set the ignore flag if necessary
  1050. //----------------------------------------------------------------
  1051. if ( trans.mIgnore )
  1052. {
  1053. //llinfos << "NOTE: Ignoring " << joint->mName.c_str() << llendl;
  1054. joint->mIgnore = TRUE;
  1055. continue;
  1056. }
  1058. //----------------------------------------------------------------
  1059. // Set the output name
  1060. //----------------------------------------------------------------
  1061. if ( ! trans.mOutName.empty() )
  1062. {
  1063. //llinfos << "NOTE: Changing " << joint->mName.c_str() << " to " << trans.mOutName.c_str() << llendl;
  1064. joint->mOutName = trans.mOutName;
  1065. }
  1067. //----------------------------------------------------------------
  1068. // Set the ignorepos flag if necessary
  1069. //----------------------------------------------------------------
  1070. if ( joint->mOutName == std::string("mPelvis") )
  1071. {
  1072. joint->mIgnorePositions = FALSE;
  1073. }
  1075. //----------------------------------------------------------------
  1076. // Set the relativepos flags if necessary
  1077. //----------------------------------------------------------------
  1078. if ( trans.mRelativePositionKey )
  1079. {
  1080. // llinfos << "NOTE: Removing 1st position offset from all keys for " << joint->mOutName.c_str() << llendl;
  1081. joint->mRelativePositionKey = TRUE;
  1082. }
  1084. if ( trans.mRelativeRotationKey )
  1085. {
  1086. // llinfos << "NOTE: Removing 1st rotation from all keys for " << joint->mOutName.c_str() << llendl;
  1087. joint->mRelativeRotationKey = TRUE;
  1088. }
  1090. if ( trans.mRelativePosition.magVec() > 0.0f )
  1091. {
  1092. joint->mRelativePosition = trans.mRelativePosition;
  1093. // llinfos << "NOTE: Removing " <<
  1094. // joint->mRelativePosition.mV[0] << " " <<
  1095. // joint->mRelativePosition.mV[1] << " " <<
  1096. // joint->mRelativePosition.mV[2] <<
  1097. // " from all position keys in " <<
  1098. // joint->mOutName.c_str() << llendl;
  1099. }
  1101. //----------------------------------------------------------------
  1102. // Set change of coordinate frame
  1103. //----------------------------------------------------------------
  1104. joint->mFrameMatrix = trans.mFrameMatrix;
  1105. joint->mOffsetMatrix = trans.mOffsetMatrix;
  1107. //----------------------------------------------------------------
  1108. // Set mergeparent name
  1109. //----------------------------------------------------------------
  1110. if ( ! trans.mMergeParentName.empty() )
  1111. {
  1112. // llinfos << "NOTE: Merging "  << joint->mOutName.c_str() << 
  1113. // " with parent " << 
  1114. // trans.mMergeParentName.c_str() << llendl;
  1115. joint->mMergeParentName = trans.mMergeParentName;
  1116. }
  1118. //----------------------------------------------------------------
  1119. // Set mergechild name
  1120. //----------------------------------------------------------------
  1121. if ( ! trans.mMergeChildName.empty() )
  1122. {
  1123. // llinfos << "NOTE: Merging " << joint->mName.c_str() <<
  1124. // " with child " << trans.mMergeChildName.c_str() << llendl;
  1125. joint->mMergeChildName = trans.mMergeChildName;
  1126. }
  1128. //----------------------------------------------------------------
  1129. // Set joint priority
  1130. //----------------------------------------------------------------
  1131. joint->mPriority = mPriority + trans.mPriorityModifier;
  1133. }
  1134. }
  1136. //-----------------------------------------------------------------------------
  1137. // LLBVHLoader::optimize()
  1138. //-----------------------------------------------------------------------------
  1139. void LLBVHLoader::optimize()
  1140. {
  1141. //RN: assumes motion blend, which is the default now
  1142. if (!mLoop && mEaseIn + mEaseOut > mDuration && mDuration != 0.f)
  1143. {
  1144. F32 factor = mDuration / (mEaseIn + mEaseOut);
  1145. mEaseIn *= factor;
  1146. mEaseOut *= factor;
  1147. }
  1149. JointVector::iterator ji;
  1150. for (ji = mJoints.begin(); ji != mJoints.end(); ++ji)
  1151. {
  1152. Joint *joint = *ji;
  1153. BOOL pos_changed = FALSE;
  1154. BOOL rot_changed = FALSE;
  1156. if ( ! joint->mIgnore )
  1157. {
  1158. joint->mNumPosKeys = 0;
  1159. joint->mNumRotKeys = 0;
  1160. LLQuaternion::Order order = bvhStringToOrder( joint->mOrder );
  1162. KeyVector::iterator first_key = joint->mKeys.begin();
  1164. // no keys?
  1165. if (first_key == joint->mKeys.end())
  1166. {
  1167. joint->mIgnore = TRUE;
  1168. continue;
  1169. }
  1171. LLVector3 first_frame_pos(first_key->mPos);
  1172. LLQuaternion first_frame_rot = mayaQ( first_key->mRot[0], first_key->mRot[1], first_key->mRot[2], order);
  1174. // skip first key
  1175. KeyVector::iterator ki = joint->mKeys.begin();
  1176. if (joint->mKeys.size() == 1)
  1177. {
  1178. // *FIX: use single frame to move pelvis
  1179. // if only one keyframe force output for this joint
  1180. rot_changed = TRUE;
  1181. }
  1182. else
  1183. {
  1184. // if more than one keyframe, use first frame as reference and skip to second
  1185. first_key->mIgnorePos = TRUE;
  1186. first_key->mIgnoreRot = TRUE;
  1187. ++ki;
  1188. }
  1190. KeyVector::iterator ki_prev = ki;
  1191. KeyVector::iterator ki_last_good_pos = ki;
  1192. KeyVector::iterator ki_last_good_rot = ki;
  1193. S32 numPosFramesConsidered = 2;
  1194. S32 numRotFramesConsidered = 2;
  1196. F32 rot_threshold = ROTATION_KEYFRAME_THRESHOLD / llmax((F32)joint->mChildTreeMaxDepth * 0.33f, 1.f);
  1198. double diff_max = 0;
  1199. KeyVector::iterator ki_max = ki;
  1200. for (; ki != joint->mKeys.end(); ++ki)
  1201. {
  1202. if (ki_prev == ki_last_good_pos)
  1203. {
  1204. joint->mNumPosKeys++;
  1205. if (dist_vec(LLVector3(ki_prev->mPos), first_frame_pos) > POSITION_MOTION_THRESHOLD)
  1206. {
  1207. pos_changed = TRUE;
  1208. }
  1209. }
  1210. else
  1211. {
  1212. //check position for noticeable effect
  1213. LLVector3 test_pos(ki_prev->mPos);
  1214. LLVector3 last_good_pos(ki_last_good_pos->mPos);
  1215. LLVector3 current_pos(ki->mPos);
  1216. LLVector3 interp_pos = lerp(current_pos, last_good_pos, 1.f / (F32)numPosFramesConsidered);
  1218. if (dist_vec(current_pos, first_frame_pos) > POSITION_MOTION_THRESHOLD)
  1219. {
  1220. pos_changed = TRUE;
  1221. }
  1223. if (dist_vec(interp_pos, test_pos) < POSITION_KEYFRAME_THRESHOLD)
  1224. {
  1225. ki_prev->mIgnorePos = TRUE;
  1226. numPosFramesConsidered++;
  1227. }
  1228. else
  1229. {
  1230. numPosFramesConsidered = 2;
  1231. ki_last_good_pos = ki_prev;
  1232. joint->mNumPosKeys++;
  1233. }
  1234. }
  1236. if (ki_prev == ki_last_good_rot)
  1237. {
  1238. joint->mNumRotKeys++;
  1239. LLQuaternion test_rot = mayaQ( ki_prev->mRot[0], ki_prev->mRot[1], ki_prev->mRot[2], order);
  1240. F32 x_delta = dist_vec(LLVector3::x_axis * first_frame_rot, LLVector3::x_axis * test_rot);
  1241. F32 y_delta = dist_vec(LLVector3::y_axis * first_frame_rot, LLVector3::y_axis * test_rot);
  1242. F32 rot_test = x_delta + y_delta;
  1244. if (rot_test > ROTATION_MOTION_THRESHOLD)
  1245. {
  1246. rot_changed = TRUE;
  1247. }
  1248. }
  1249. else
  1250. {
  1251. //check rotation for noticeable effect
  1252. LLQuaternion test_rot = mayaQ( ki_prev->mRot[0], ki_prev->mRot[1], ki_prev->mRot[2], order);
  1253. LLQuaternion last_good_rot = mayaQ( ki_last_good_rot->mRot[0], ki_last_good_rot->mRot[1], ki_last_good_rot->mRot[2], order);
  1254. LLQuaternion current_rot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
  1255. LLQuaternion interp_rot = lerp(1.f / (F32)numRotFramesConsidered, current_rot, last_good_rot);
  1257. F32 x_delta;
  1258. F32 y_delta;
  1259. F32 rot_test;
  1261. // Test if the rotation has changed significantly since the very first frame.  If false
  1262. // for all frames, then we'll just throw out this joint's rotation entirely.
  1263. x_delta = dist_vec(LLVector3::x_axis * first_frame_rot, LLVector3::x_axis * test_rot);
  1264. y_delta = dist_vec(LLVector3::y_axis * first_frame_rot, LLVector3::y_axis * test_rot);
  1265. rot_test = x_delta + y_delta;
  1266. if (rot_test > ROTATION_MOTION_THRESHOLD)
  1267. {
  1268. rot_changed = TRUE;
  1269. }
  1270. x_delta = dist_vec(LLVector3::x_axis * interp_rot, LLVector3::x_axis * test_rot);
  1271. y_delta = dist_vec(LLVector3::y_axis * interp_rot, LLVector3::y_axis * test_rot);
  1272. rot_test = x_delta + y_delta;
  1274. // Draw a line between the last good keyframe and current.  Test the distance between the last frame (current-1, i.e. ki_prev)
  1275. // and the line.  If it's greater than some threshold, then it represents a significant frame and we want to include it.
  1276. if (rot_test >= rot_threshold ||
  1277. (ki+1 == joint->mKeys.end() && numRotFramesConsidered > 2))
  1278. {
  1279. // Add the current test keyframe (which is technically the previous key, i.e. ki_prev).
  1280. numRotFramesConsidered = 2;
  1281. ki_last_good_rot = ki_prev;
  1282. joint->mNumRotKeys++;
  1284. // Add another keyframe between the last good keyframe and current, at whatever point was the most "significant" (i.e.
  1285. // had the largest deviation from the earlier tests).  Note that a more robust approach would be test all intermediate
  1286. // keyframes against the line between the last good keyframe and current, but we're settling for this other method
  1287. // because it's significantly faster.
  1288. if (diff_max > 0)
  1289. {
  1290. if (ki_max->mIgnoreRot == TRUE)
  1291. {
  1292. ki_max->mIgnoreRot = FALSE;
  1293. joint->mNumRotKeys++;
  1294. }
  1295. diff_max = 0;
  1296. }
  1297. }
  1298. else
  1299. {
  1300. // This keyframe isn't significant enough, throw it away.
  1301. ki_prev->mIgnoreRot = TRUE;
  1302. numRotFramesConsidered++;
  1303. // Store away the keyframe that has the largest deviation from the interpolated line, for insertion later.
  1304. if (rot_test > diff_max)
  1305. {
  1306. diff_max = rot_test;
  1307. ki_max = ki;
  1308. }
  1309. }
  1310. }
  1312. ki_prev = ki;
  1313. }
  1314. }
  1316. // don't output joints with no motion
  1317. if (!(pos_changed || rot_changed))
  1318. {
  1319. //llinfos << "Ignoring joint " << joint->mName << llendl;
  1320. joint->mIgnore = TRUE;
  1321. }
  1322. }
  1323. }
  1325. void LLBVHLoader::reset()
  1326. {
  1327. mLineNumber = 0;
  1328. mNumFrames = 0;
  1329. mFrameTime = 0.0f;
  1330. mDuration = 0.0f;
  1332. mPriority = 2;
  1333. mLoop = FALSE;
  1334. mLoopInPoint = 0.f;
  1335. mLoopOutPoint = 0.f;
  1336. mEaseIn = 0.3f;
  1337. mEaseOut = 0.3f;
  1338. mHand = 1;
  1339. mInitialized = FALSE;
  1341. mEmoteName = "";
  1342. }
  1344. //------------------------------------------------------------------------
  1345. // LLBVHLoader::getLine()
  1346. //------------------------------------------------------------------------
  1347. BOOL LLBVHLoader::getLine(apr_file_t* fp)
  1348. {
  1349. if (apr_file_eof(fp) == APR_EOF)
  1350. {
  1351. return FALSE;
  1352. }
  1353. if ( apr_file_gets(mLine, BVH_PARSER_LINE_SIZE, fp) == APR_SUCCESS)
  1354. {
  1355. mLineNumber++;
  1356. return TRUE;
  1357. }
  1359. return FALSE;
  1360. }
  1362. // returns required size of output buffer
  1363. U32 LLBVHLoader::getOutputSize()
  1364. {
  1365. LLDataPackerBinaryBuffer dp;
  1366. serialize(dp);
  1368. return dp.getCurrentSize();
  1369. }
  1371. // writes contents to datapacker
  1372. BOOL LLBVHLoader::serialize(LLDataPacker& dp)
  1373. {
  1374. JointVector::iterator ji;
  1375. KeyVector::iterator ki;
  1376. F32 time;
  1378. // count number of non-ignored joints
  1379. S32 numJoints = 0;
  1380. for (ji=mJoints.begin(); ji!=mJoints.end(); ++ji)
  1381. {
  1382. Joint *joint = *ji;
  1383. if ( ! joint->mIgnore )
  1384. numJoints++;
  1385. }
  1387. // print header
  1388. dp.packU16(KEYFRAME_MOTION_VERSION, "version");
  1389. dp.packU16(KEYFRAME_MOTION_SUBVERSION, "sub_version");
  1390. dp.packS32(mPriority, "base_priority");
  1391. dp.packF32(mDuration, "duration");
  1392. dp.packString(mEmoteName, "emote_name");
  1393. dp.packF32(mLoopInPoint, "loop_in_point");
  1394. dp.packF32(mLoopOutPoint, "loop_out_point");
  1395. dp.packS32(mLoop, "loop");
  1396. dp.packF32(mEaseIn, "ease_in_duration");
  1397. dp.packF32(mEaseOut, "ease_out_duration");
  1398. dp.packU32(mHand, "hand_pose");
  1399. dp.packU32(numJoints, "num_joints");
  1401. for ( ji = mJoints.begin();
  1402. ji != mJoints.end();
  1403. ++ji )
  1404. {
  1405. Joint *joint = *ji;
  1406. // if ignored, skip it
  1407. if ( joint->mIgnore )
  1408. continue;
  1410. LLQuaternion first_frame_rot;
  1411. LLQuaternion fixup_rot;
  1413. dp.packString(joint->mOutName, "joint_name");
  1414. dp.packS32(joint->mPriority, "joint_priority");
  1416. // compute coordinate frame rotation
  1417. LLQuaternion frameRot( joint->mFrameMatrix );
  1418. LLQuaternion frameRotInv = ~frameRot;
  1420. LLQuaternion offsetRot( joint->mOffsetMatrix );
  1422. // find mergechild and mergeparent joints, if specified
  1423. LLQuaternion mergeParentRot;
  1424. LLQuaternion mergeChildRot;
  1425. Joint *mergeParent = NULL;
  1426. Joint *mergeChild = NULL;
  1428. JointVector::iterator mji;
  1429. for (mji=mJoints.begin(); mji!=mJoints.end(); ++mji)
  1430. {
  1431. Joint *mjoint = *mji;
  1432. if ( !joint->mMergeParentName.empty() && (mjoint->mName == joint->mMergeParentName) )
  1433. {
  1434. mergeParent = *mji;
  1435. }
  1436. if ( !joint->mMergeChildName.empty() && (mjoint->mName == joint->mMergeChildName) )
  1437. {
  1438. mergeChild = *mji;
  1439. }
  1440. }
  1442. dp.packS32(joint->mNumRotKeys, "num_rot_keys");
  1444. LLQuaternion::Order order = bvhStringToOrder( joint->mOrder );
  1445. S32 outcount = 0;
  1446. S32 frame = 1;
  1447. for ( ki = joint->mKeys.begin();
  1448. ki != joint->mKeys.end();
  1449. ++ki )
  1450. {
  1451. if ((frame == 1) && joint->mRelativeRotationKey)
  1452. {
  1453. first_frame_rot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
  1455. fixup_rot.shortestArc(LLVector3::z_axis * first_frame_rot * frameRot, LLVector3::z_axis);
  1456. }
  1458. if (ki->mIgnoreRot)
  1459. {
  1460. frame++;
  1461. continue;
  1462. }
  1464. time = (F32)frame * mFrameTime;
  1466. if (mergeParent)
  1467. {
  1468. mergeParentRot = mayaQ( mergeParent->mKeys[frame-1].mRot[0], 
  1469. mergeParent->mKeys[frame-1].mRot[1],
  1470. mergeParent->mKeys[frame-1].mRot[2],
  1471. bvhStringToOrder(mergeParent->mOrder) );
  1472. LLQuaternion parentFrameRot( mergeParent->mFrameMatrix );
  1473. LLQuaternion parentOffsetRot( mergeParent->mOffsetMatrix );
  1474. mergeParentRot = ~parentFrameRot * mergeParentRot * parentFrameRot * parentOffsetRot;
  1475. }
  1476. else
  1477. {
  1478. mergeParentRot.loadIdentity();
  1479. }
  1481. if (mergeChild)
  1482. {
  1483. mergeChildRot = mayaQ( mergeChild->mKeys[frame-1].mRot[0], 
  1484. mergeChild->mKeys[frame-1].mRot[1],
  1485. mergeChild->mKeys[frame-1].mRot[2],
  1486. bvhStringToOrder(mergeChild->mOrder) );
  1487. LLQuaternion childFrameRot( mergeChild->mFrameMatrix );
  1488. LLQuaternion childOffsetRot( mergeChild->mOffsetMatrix );
  1489. mergeChildRot = ~childFrameRot * mergeChildRot * childFrameRot * childOffsetRot;
  1491. }
  1492. else
  1493. {
  1494. mergeChildRot.loadIdentity();
  1495. }
  1497. LLQuaternion inRot = mayaQ( ki->mRot[0], ki->mRot[1], ki->mRot[2], order);
  1499. LLQuaternion outRot =  frameRotInv* mergeChildRot * inRot * mergeParentRot * ~first_frame_rot * frameRot * offsetRot;
  1501. U16 time_short = F32_to_U16(time, 0.f, mDuration);
  1502. dp.packU16(time_short, "time");
  1503. U16 x, y, z;
  1504. LLVector3 rot_vec = outRot.packToVector3();
  1505. rot_vec.quantize16(-1.f, 1.f, -1.f, 1.f);
  1506. x = F32_to_U16(rot_vec.mV[VX], -1.f, 1.f);
  1507. y = F32_to_U16(rot_vec.mV[VY], -1.f, 1.f);
  1508. z = F32_to_U16(rot_vec.mV[VZ], -1.f, 1.f);
  1509. dp.packU16(x, "rot_angle_x");
  1510. dp.packU16(y, "rot_angle_y");
  1511. dp.packU16(z, "rot_angle_z");
  1512. outcount++;
  1513. frame++;
  1514. }
  1516. // output position keys (only for 1st joint)
  1517. if ( ji == mJoints.begin() && !joint->mIgnorePositions )
  1518. {
  1519. dp.packS32(joint->mNumPosKeys, "num_pos_keys");
  1521. LLVector3 relPos = joint->mRelativePosition;
  1522. LLVector3 relKey;
  1524. frame = 1;
  1525. for ( ki = joint->mKeys.begin();
  1526. ki != joint->mKeys.end();
  1527. ++ki )
  1528. {
  1529. if ((frame == 1) && joint->mRelativePositionKey)
  1530. {
  1531. relKey.setVec(ki->mPos);
  1532. }
  1534. if (ki->mIgnorePos)
  1535. {
  1536. frame++;
  1537. continue;
  1538. }
  1540. time = (F32)frame * mFrameTime;
  1542. LLVector3 inPos = (LLVector3(ki->mPos) - relKey) * ~first_frame_rot;// * fixup_rot;
  1543. LLVector3 outPos = inPos * frameRot * offsetRot;
  1545. outPos *= INCHES_TO_METERS;
  1547. outPos -= relPos;
  1548. outPos.clamp(-LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
  1550. U16 time_short = F32_to_U16(time, 0.f, mDuration);
  1551. dp.packU16(time_short, "time");
  1553. U16 x, y, z;
  1554. outPos.quantize16(-LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET, -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
  1555. x = F32_to_U16(outPos.mV[VX], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
  1556. y = F32_to_U16(outPos.mV[VY], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
  1557. z = F32_to_U16(outPos.mV[VZ], -LL_MAX_PELVIS_OFFSET, LL_MAX_PELVIS_OFFSET);
  1558. dp.packU16(x, "pos_x");
  1559. dp.packU16(y, "pos_y");
  1560. dp.packU16(z, "pos_z");
  1562. frame++;
  1563. }
  1564. }
  1565. else
  1566. {
  1567. dp.packS32(0, "num_pos_keys");
  1568. }
  1569. }
  1571. S32 num_constraints = (S32)mConstraints.size();
  1572. dp.packS32(num_constraints, "num_constraints");
  1574. for (ConstraintVector::iterator constraint_it = mConstraints.begin();
  1575. constraint_it != mConstraints.end();
  1576. constraint_it++)
  1577. {
  1578. U8 byte = constraint_it->mChainLength;
  1579. dp.packU8(byte, "chain_lenght");
  1581. byte = constraint_it->mConstraintType;
  1582. dp.packU8(byte, "constraint_type");
  1583. dp.packBinaryDataFixed((U8*)constraint_it->mSourceJointName, 16, "source_volume");
  1584. dp.packVector3(constraint_it->mSourceOffset, "source_offset");
  1585. dp.packBinaryDataFixed((U8*)constraint_it->mTargetJointName, 16, "target_volume");
  1586. dp.packVector3(constraint_it->mTargetOffset, "target_offset");
  1587. dp.packVector3(constraint_it->mTargetDir, "target_dir");
  1588. dp.packF32(constraint_it->mEaseInStart, "ease_in_start");
  1589. dp.packF32(constraint_it->mEaseInStop, "ease_in_stop");
  1590. dp.packF32(constraint_it->mEaseOutStart, "ease_out_start");
  1591. dp.packF32(constraint_it->mEaseOutStop, "ease_out_stop");
  1592. }
  1594. return TRUE;
  1595. }