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

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

游戏引擎

开发平台：

C++ Builder

llfloateranimpreview.cpp：源码内容
  1. /** 
  2.  * @file llfloateranimpreview.cpp
  3.  * @brief LLFloaterAnimPreview class implementation
  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 "llviewerprecompiledheaders.h"
  35. #include "llfloateranimpreview.h"
  37. #include "llbvhloader.h"
  38. #include "lldatapacker.h"
  39. #include "lldir.h"
  40. #include "lleconomy.h"
  41. #include "llnotificationsutil.h"
  42. #include "llvfile.h"
  43. #include "llapr.h"
  44. #include "llstring.h"
  46. #include "llagent.h"
  47. #include "llanimationstates.h"
  48. #include "llbbox.h"
  49. #include "llbutton.h"
  50. #include "llcheckboxctrl.h"
  51. #include "llcombobox.h"
  52. #include "lldrawable.h"
  53. #include "lldrawpoolavatar.h"
  54. #include "llrender.h"
  55. #include "llface.h"
  56. #include "llfocusmgr.h"
  57. #include "llkeyframemotion.h"
  58. #include "lllineeditor.h"
  59. #include "llfloaterperms.h"
  60. #include "llsliderctrl.h"
  61. #include "llspinctrl.h"
  62. #include "lltextbox.h"
  63. #include "lltoolmgr.h"
  64. #include "llui.h"
  65. #include "llviewercamera.h"
  66. #include "llviewerobjectlist.h"
  67. #include "llviewerwindow.h"
  68. #include "llviewermenufile.h" // upload_new_resource()
  69. #include "llvoavatar.h"
  70. #include "pipeline.h"
  71. #include "lluictrlfactory.h"
  72. #include "lltrans.h"
  74. const S32 PREVIEW_BORDER_WIDTH = 2;
  75. const S32 PREVIEW_RESIZE_HANDLE_SIZE = S32(RESIZE_HANDLE_WIDTH * OO_SQRT2) + PREVIEW_BORDER_WIDTH;
  76. const S32 PREVIEW_HPAD = PREVIEW_RESIZE_HANDLE_SIZE;
  77. const S32 PREF_BUTTON_HEIGHT = 16;
  78. const S32 PREVIEW_TEXTURE_HEIGHT = 300;
  80. const F32 PREVIEW_CAMERA_DISTANCE = 4.f;
  82. const F32 MIN_CAMERA_ZOOM = 0.5f;
  83. const F32 MAX_CAMERA_ZOOM = 10.f;
  85. const F32 BASE_ANIM_TIME_OFFSET = 5.f;
  87. std::string STATUS[] =
  88. {
  89. "E_ST_OK",
  90. "E_ST_EOF",
  91. "E_ST_NO_CONSTRAINT",
  92. "E_ST_NO_FILE",
  93. "E_ST_NO_HIER",
  94. "E_ST_NO_JOINT",
  95. "E_ST_NO_NAME",
  96. "E_ST_NO_OFFSET",
  97. "E_ST_NO_CHANNELS",
  98. "E_ST_NO_ROTATION",
  99. "E_ST_NO_AXIS",
  100. "E_ST_NO_MOTION",
  101. "E_ST_NO_FRAMES",
  102. "E_ST_NO_FRAME_TIME",
  103. "E_ST_NO_POS",
  104. "E_ST_NO_ROT",
  105. "E_ST_NO_XLT_FILE",
  106. "E_ST_NO_XLT_HEADER",
  107. "E_ST_NO_XLT_NAME",
  108. "E_ST_NO_XLT_IGNORE",
  109. "E_ST_NO_XLT_RELATIVE",
  110. "E_ST_NO_XLT_OUTNAME",
  111. "E_ST_NO_XLT_MATRIX",
  112. "E_ST_NO_XLT_MERGECHILD",
  113. "E_ST_NO_XLT_MERGEPARENT",
  114. "E_ST_NO_XLT_PRIORITY",
  115. "E_ST_NO_XLT_LOOP",
  116. "E_ST_NO_XLT_EASEIN",
  117. "E_ST_NO_XLT_EASEOUT",
  118. "E_ST_NO_XLT_HAND",
  119. "E_ST_NO_XLT_EMOTE",
  120. "E_ST_BAD_ROOT"
  121. };
  123. //-----------------------------------------------------------------------------
  124. // LLFloaterAnimPreview()
  125. //-----------------------------------------------------------------------------
  126. LLFloaterAnimPreview::LLFloaterAnimPreview(const std::string& filename) : 
  127. LLFloaterNameDesc(filename)
  128. {
  129. mLastMouseX = 0;
  130. mLastMouseY = 0;
  132. mIDList["Standing"] = ANIM_AGENT_STAND;
  133. mIDList["Walking"] = ANIM_AGENT_FEMALE_WALK;
  134. mIDList["Sitting"] = ANIM_AGENT_SIT_FEMALE;
  135. mIDList["Flying"] = ANIM_AGENT_HOVER;
  137. mIDList["[None]"] = LLUUID::null;
  138. mIDList["Aaaaah"] = ANIM_AGENT_EXPRESS_OPEN_MOUTH;
  139. mIDList["Afraid"] = ANIM_AGENT_EXPRESS_AFRAID;
  140. mIDList["Angry"] = ANIM_AGENT_EXPRESS_ANGER;
  141. mIDList["Big Smile"] = ANIM_AGENT_EXPRESS_TOOTHSMILE;
  142. mIDList["Bored"] = ANIM_AGENT_EXPRESS_BORED;
  143. mIDList["Cry"] = ANIM_AGENT_EXPRESS_CRY;
  144. mIDList["Disdain"] = ANIM_AGENT_EXPRESS_DISDAIN;
  145. mIDList["Embarrassed"] = ANIM_AGENT_EXPRESS_EMBARRASSED;
  146. mIDList["Frown"] = ANIM_AGENT_EXPRESS_FROWN;
  147. mIDList["Kiss"] = ANIM_AGENT_EXPRESS_KISS;
  148. mIDList["Laugh"] = ANIM_AGENT_EXPRESS_LAUGH;
  149. mIDList["Plllppt"] = ANIM_AGENT_EXPRESS_TONGUE_OUT;
  150. mIDList["Repulsed"] = ANIM_AGENT_EXPRESS_REPULSED;
  151. mIDList["Sad"] = ANIM_AGENT_EXPRESS_SAD;
  152. mIDList["Shrug"] = ANIM_AGENT_EXPRESS_SHRUG;
  153. mIDList["Smile"] = ANIM_AGENT_EXPRESS_SMILE;
  154. mIDList["Surprise"] = ANIM_AGENT_EXPRESS_SURPRISE;
  155. mIDList["Wink"] = ANIM_AGENT_EXPRESS_WINK;
  156. mIDList["Worry"] = ANIM_AGENT_EXPRESS_WORRY;
  157. }
  159. //-----------------------------------------------------------------------------
  160. // setAnimCallbacks()
  161. //-----------------------------------------------------------------------------
  162. void LLFloaterAnimPreview::setAnimCallbacks()
  163. {
  164. childSetCommitCallback("playback_slider", onSliderMove, this);
  166. childSetCommitCallback("preview_base_anim", onCommitBaseAnim, this);
  167. childSetValue("preview_base_anim", "Standing");
  169. childSetCommitCallback("priority", onCommitPriority, this);
  170. childSetCommitCallback("loop_check", onCommitLoop, this);
  171. childSetCommitCallback("loop_in_point", onCommitLoopIn, this);
  172. childSetValidate("loop_in_point", boost::bind(&LLFloaterAnimPreview::validateLoopIn, this, _1));
  173. childSetCommitCallback("loop_out_point", onCommitLoopOut, this);
  174. childSetValidate("loop_out_point", boost::bind(&LLFloaterAnimPreview::validateLoopOut, this, _1));
  176. childSetCommitCallback("hand_pose_combo", onCommitHandPose, this);
  178. childSetCommitCallback("emote_combo", onCommitEmote, this);
  179. childSetValue("emote_combo", "[None]");
  181. childSetCommitCallback("ease_in_time", onCommitEaseIn, this);
  182. childSetValidate("ease_in_time", boost::bind(&LLFloaterAnimPreview::validateEaseIn, this, _1));
  183. childSetCommitCallback("ease_out_time", onCommitEaseOut, this);
  184. childSetValidate("ease_out_time", boost::bind(&LLFloaterAnimPreview::validateEaseOut, this, _1));
  185. }
  187. //-----------------------------------------------------------------------------
  188. // postBuild()
  189. //-----------------------------------------------------------------------------
  190. BOOL LLFloaterAnimPreview::postBuild()
  191. {
  192. LLKeyframeMotion* motionp = NULL;
  193. LLBVHLoader* loaderp = NULL;
  195. if (!LLFloaterNameDesc::postBuild())
  196. {
  197. return FALSE;
  198. }
  200. childSetCommitCallback("name_form", onCommitName, this);
  202. childSetAction("ok_btn", onBtnOK, this);
  203. setDefaultBtn();
  205. mPreviewRect.set(PREVIEW_HPAD, 
  206. PREVIEW_TEXTURE_HEIGHT,
  207. getRect().getWidth() - PREVIEW_HPAD, 
  208. PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  209. mPreviewImageRect.set(0.f, 1.f, 1.f, 0.f);
  211. mPlayButton = getChild<LLButton>( "play_btn");
  212. mPlayButton->setClickedCallback(onBtnPlay, this);
  213. mPlayButton->setVisible(true);
  215. mPauseButton = getChild<LLButton>( "pause_btn");
  216. mPauseButton->setClickedCallback(onBtnPause, this);
  217. mPauseButton->setVisible(false);
  219. mStopButton = getChild<LLButton>( "stop_btn");
  220. mStopButton->setClickedCallback(onBtnStop, this);
  222. childHide("bad_animation_text");
  224. std::string exten = gDirUtilp->getExtension(mFilename);
  225. if (exten == "bvh")
  226. {
  227. // loading a bvh file
  229. // now load bvh file
  230. S32 file_size;
  232. LLAPRFile infile ;
  233. infile.open(mFilenameAndPath, LL_APR_RB, NULL, &file_size);
  235. if (!infile.getFileHandle())
  236. {
  237. llwarns << "Can't open BVH file:" << mFilename << llendl;
  238. }
  239. else
  240. {
  241. char* file_buffer;
  243. file_buffer = new char[file_size + 1];
  245. if (file_size == infile.read(file_buffer, file_size))
  246. {
  247. file_buffer[file_size] = '';
  248. llinfos << "Loading BVH file " << mFilename << llendl;
  249. ELoadStatus load_status = E_ST_OK;
  250. S32 line_number = 0; 
  251. loaderp = new LLBVHLoader(file_buffer, load_status, line_number);
  252. std::string status = getString(STATUS[load_status]);
  254. if(load_status == E_ST_NO_XLT_FILE)
  255. {
  256. llwarns << "NOTE: No translation table found." << llendl;
  257. }
  258. else
  259. {
  260. llwarns << "ERROR: [line: " << line_number << "] " << status << llendl;
  261. }
  262. }
  264. infile.close() ;
  265. delete[] file_buffer;
  266. }
  267. }
  269. if (loaderp && loaderp->isInitialized() && loaderp->getDuration() <= MAX_ANIM_DURATION)
  270. {
  271. // generate unique id for this motion
  272. mTransactionID.generate();
  273. mMotionID = mTransactionID.makeAssetID(gAgent.getSecureSessionID());
  275. mAnimPreview = new LLPreviewAnimation(256, 256);
  277. // motion will be returned, but it will be in a load-pending state, as this is a new motion
  278. // this motion will not request an asset transfer until next update, so we have a chance to 
  279. // load the keyframe data locally
  280. motionp = (LLKeyframeMotion*)mAnimPreview->getDummyAvatar()->createMotion(mMotionID);
  282. // create data buffer for keyframe initialization
  283. S32 buffer_size = loaderp->getOutputSize();
  284. U8* buffer = new U8[buffer_size];
  286. LLDataPackerBinaryBuffer dp(buffer, buffer_size);
  288. // pass animation data through memory buffer
  289. loaderp->serialize(dp);
  290. dp.reset();
  291. BOOL success = motionp && motionp->deserialize(dp);
  293. delete []buffer;
  295. if (success)
  296. {
  297. setAnimCallbacks() ;
  299. const LLBBoxLocal &pelvis_bbox = motionp->getPelvisBBox();
  301. LLVector3 temp = pelvis_bbox.getCenter();
  302. // only consider XY?
  303. //temp.mV[VZ] = 0.f;
  304. F32 pelvis_offset = temp.magVec();
  306. temp = pelvis_bbox.getExtent();
  307. //temp.mV[VZ] = 0.f;
  308. F32 pelvis_max_displacement = pelvis_offset + (temp.magVec() * 0.5f) + 1.f;
  310. F32 camera_zoom = LLViewerCamera::getInstance()->getDefaultFOV() / (2.f * atan(pelvis_max_displacement / PREVIEW_CAMERA_DISTANCE));
  312. mAnimPreview->setZoom(camera_zoom);
  314. motionp->setName(childGetValue("name_form").asString());
  315. mAnimPreview->getDummyAvatar()->startMotion(mMotionID);
  317. getChild<LLSlider>("playback_slider")->setMinValue(0.0);
  318. getChild<LLSlider>("playback_slider")->setMaxValue(1.0);
  320. childSetValue("loop_check", LLSD(motionp->getLoop()));
  321. childSetValue("loop_in_point", LLSD(motionp->getLoopIn() / motionp->getDuration() * 100.f));
  322. childSetValue("loop_out_point", LLSD(motionp->getLoopOut() / motionp->getDuration() * 100.f));
  323. childSetValue("priority", LLSD((F32)motionp->getPriority()));
  324. childSetValue("hand_pose_combo", LLHandMotion::getHandPoseName(motionp->getHandPose()));
  325. childSetValue("ease_in_time", LLSD(motionp->getEaseInDuration()));
  326. childSetValue("ease_out_time", LLSD(motionp->getEaseOutDuration()));
  327. setEnabled(TRUE);
  328. std::string seconds_string;
  329. seconds_string = llformat(" - %.2f seconds", motionp->getDuration());
  331. setTitle(mFilename + std::string(seconds_string));
  332. }
  333. else
  334. {
  335. mAnimPreview = NULL;
  336. mMotionID.setNull();
  337. childSetValue("bad_animation_text", getString("failed_to_initialize"));
  338. }
  339. }
  340. else
  341. {
  342. if ( loaderp )
  343. {
  344. if (loaderp->getDuration() > MAX_ANIM_DURATION)
  345. {
  346. LLUIString out_str = getString("anim_too_long");
  347. out_str.setArg("[LENGTH]", llformat("%.1f", loaderp->getDuration()));
  348. out_str.setArg("[MAX_LENGTH]", llformat("%.1f", MAX_ANIM_DURATION));
  349. childSetValue("bad_animation_text", out_str.getString());
  350. }
  351. else
  352. {
  353. LLUIString out_str = getString("failed_file_read");
  354. out_str.setArg("[STATUS]", getString(STATUS[loaderp->getStatus()])); 
  355. childSetValue("bad_animation_text", out_str.getString());
  356. }
  357. }
  359. //setEnabled(FALSE);
  360. mMotionID.setNull();
  361. mAnimPreview = NULL;
  362. }
  364. refresh();
  366. delete loaderp;
  368. return TRUE;
  369. }
  371. //-----------------------------------------------------------------------------
  372. // LLFloaterAnimPreview()
  373. //-----------------------------------------------------------------------------
  374. LLFloaterAnimPreview::~LLFloaterAnimPreview()
  375. {
  376. mAnimPreview = NULL;
  378. setEnabled(FALSE);
  379. }
  381. //-----------------------------------------------------------------------------
  382. // draw()
  383. //-----------------------------------------------------------------------------
  384. void LLFloaterAnimPreview::draw()
  385. {
  386. LLFloater::draw();
  387. LLRect r = getRect();
  389. refresh();
  391. if (mMotionID.notNull() && mAnimPreview)
  392. {
  393. gGL.color3f(1.f, 1.f, 1.f);
  395. gGL.getTexUnit(0)->bind(mAnimPreview);
  397. gGL.begin( LLRender::QUADS );
  398. {
  399. gGL.texCoord2f(0.f, 1.f);
  400. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  401. gGL.texCoord2f(0.f, 0.f);
  402. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  403. gGL.texCoord2f(1.f, 0.f);
  404. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  405. gGL.texCoord2f(1.f, 1.f);
  406. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  407. }
  408. gGL.end();
  410. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  412. LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
  413. if (!avatarp->areAnimationsPaused())
  414. {
  415. mAnimPreview->requestUpdate();
  416. }
  417. }
  418. }
  420. //-----------------------------------------------------------------------------
  421. // resetMotion()
  422. //-----------------------------------------------------------------------------
  423. void LLFloaterAnimPreview::resetMotion()
  424. {
  425. LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
  426. BOOL paused = avatarp->areAnimationsPaused();
  428. // *TODO: Fix awful casting hack
  429. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID);
  431. // Set emotion
  432. std::string emote = childGetValue("emote_combo").asString();
  433. motionp->setEmote(mIDList[emote]);
  435. LLUUID base_id = mIDList[childGetValue("preview_base_anim").asString()];
  436. avatarp->deactivateAllMotions();
  437. avatarp->startMotion(mMotionID, 0.0f);
  438. avatarp->startMotion(base_id, BASE_ANIM_TIME_OFFSET);
  439. childSetValue("playback_slider", 0.0f);
  441. // Set pose
  442. std::string handpose = childGetValue("hand_pose_combo").asString();
  443. avatarp->startMotion( ANIM_AGENT_HAND_MOTION, 0.0f );
  444. motionp->setHandPose(LLHandMotion::getHandPose(handpose));
  446. if (paused)
  447. {
  448. mPauseRequest = avatarp->requestPause();
  449. }
  450. else
  451. {
  452. mPauseRequest = NULL;
  453. }
  454. }
  456. //-----------------------------------------------------------------------------
  457. // handleMouseDown()
  458. //-----------------------------------------------------------------------------
  459. BOOL LLFloaterAnimPreview::handleMouseDown(S32 x, S32 y, MASK mask)
  460. {
  461. if (mPreviewRect.pointInRect(x, y))
  462. {
  463. bringToFront( x, y );
  464. gFocusMgr.setMouseCapture(this);
  465. gViewerWindow->hideCursor();
  466. mLastMouseX = x;
  467. mLastMouseY = y;
  468. return TRUE;
  469. }
  471. return LLFloater::handleMouseDown(x, y, mask);
  472. }
  474. //-----------------------------------------------------------------------------
  475. // handleMouseUp()
  476. //-----------------------------------------------------------------------------
  477. BOOL LLFloaterAnimPreview::handleMouseUp(S32 x, S32 y, MASK mask)
  478. {
  479. gFocusMgr.setMouseCapture(FALSE);
  480. gViewerWindow->showCursor();
  481. return LLFloater::handleMouseUp(x, y, mask);
  482. }
  484. //-----------------------------------------------------------------------------
  485. // handleHover()
  486. //-----------------------------------------------------------------------------
  487. BOOL LLFloaterAnimPreview::handleHover(S32 x, S32 y, MASK mask)
  488. {
  489. MASK local_mask = mask & ~MASK_ALT;
  491. if (mAnimPreview && hasMouseCapture())
  492. {
  493. if (local_mask == MASK_PAN)
  494. {
  495. // pan here
  496. mAnimPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f);
  497. }
  498. else if (local_mask == MASK_ORBIT)
  499. {
  500. F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
  501. F32 pitch_radians = (F32)(y - mLastMouseY) * 0.02f;
  503. mAnimPreview->rotate(yaw_radians, pitch_radians);
  504. }
  505. else 
  506. {
  507. F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
  508. F32 zoom_amt = (F32)(y - mLastMouseY) * 0.02f;
  510. mAnimPreview->rotate(yaw_radians, 0.f);
  511. mAnimPreview->zoom(zoom_amt);
  512. }
  514. mAnimPreview->requestUpdate();
  516. LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY);
  517. }
  519. if (!mPreviewRect.pointInRect(x, y) || !mAnimPreview)
  520. {
  521. return LLFloater::handleHover(x, y, mask);
  522. }
  523. else if (local_mask == MASK_ORBIT)
  524. {
  525. gViewerWindow->setCursor(UI_CURSOR_TOOLCAMERA);
  526. }
  527. else if (local_mask == MASK_PAN)
  528. {
  529. gViewerWindow->setCursor(UI_CURSOR_TOOLPAN);
  530. }
  531. else
  532. {
  533. gViewerWindow->setCursor(UI_CURSOR_TOOLZOOMIN);
  534. }
  536. return TRUE;
  537. }
  539. //-----------------------------------------------------------------------------
  540. // handleScrollWheel()
  541. //-----------------------------------------------------------------------------
  542. BOOL LLFloaterAnimPreview::handleScrollWheel(S32 x, S32 y, S32 clicks)
  543. {
  544. mAnimPreview->zoom((F32)clicks * -0.2f);
  545. mAnimPreview->requestUpdate();
  547. return TRUE;
  548. }
  550. //-----------------------------------------------------------------------------
  551. // onMouseCaptureLost()
  552. //-----------------------------------------------------------------------------
  553. void LLFloaterAnimPreview::onMouseCaptureLost()
  554. {
  555. gViewerWindow->showCursor();
  556. }
  558. //-----------------------------------------------------------------------------
  559. // onBtnPlay()
  560. //-----------------------------------------------------------------------------
  561. void LLFloaterAnimPreview::onBtnPlay(void* user_data)
  562. {
  563. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
  564. if (!previewp->getEnabled())
  565. return;
  567. if (previewp->mMotionID.notNull() && previewp->mAnimPreview)
  568. {
  569. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  571. if(!avatarp->isMotionActive(previewp->mMotionID))
  572. {
  573. previewp->resetMotion();
  574. previewp->mPauseRequest = NULL;
  575. }
  576. else if (avatarp->areAnimationsPaused())
  577. {
  578. previewp->mPauseRequest = NULL;
  579. }
  580. }
  581. }
  583. //-----------------------------------------------------------------------------
  584. // onBtnPause()
  585. //-----------------------------------------------------------------------------
  586. void LLFloaterAnimPreview::onBtnPause(void* user_data)
  587. {
  588. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
  589. if (!previewp->getEnabled())
  590. return;
  592. if (previewp->mMotionID.notNull() && previewp->mAnimPreview)
  593. {
  594. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  596. if(avatarp->isMotionActive(previewp->mMotionID))
  597. {
  598. if (!avatarp->areAnimationsPaused())
  599. {
  600. previewp->mPauseRequest = avatarp->requestPause();
  601. }
  602. }
  603. }
  604. }
  606. //-----------------------------------------------------------------------------
  607. // onBtnStop()
  608. //-----------------------------------------------------------------------------
  609. void LLFloaterAnimPreview::onBtnStop(void* user_data)
  610. {
  611. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
  612. if (!previewp->getEnabled())
  613. return;
  615. if (previewp->mMotionID.notNull() && previewp->mAnimPreview)
  616. {
  617. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  618. previewp->resetMotion();
  619. previewp->mPauseRequest = avatarp->requestPause();
  620. }
  621. }
  623. //-----------------------------------------------------------------------------
  624. // onSliderMove()
  625. //-----------------------------------------------------------------------------
  626. void LLFloaterAnimPreview::onSliderMove(LLUICtrl* ctrl, void*user_data)
  627. {
  628. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data;
  629. if (!previewp->getEnabled())
  630. return;
  632. if (previewp->mAnimPreview)
  633. {
  634. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  635. F32 slider_value = (F32)previewp->childGetValue("playback_slider").asReal();
  636. LLUUID base_id = previewp->mIDList[previewp->childGetValue("preview_base_anim").asString()];
  637. LLMotion* motionp = avatarp->findMotion(previewp->mMotionID);
  638. F32 duration = motionp->getDuration();// + motionp->getEaseOutDuration();
  639. F32 delta_time = duration * slider_value;
  640. avatarp->deactivateAllMotions();
  641. avatarp->startMotion(base_id, delta_time + BASE_ANIM_TIME_OFFSET);
  642. avatarp->startMotion(previewp->mMotionID, delta_time);
  643. previewp->mPauseRequest = avatarp->requestPause();
  644. previewp->refresh();
  645. }
  647. }
  649. //-----------------------------------------------------------------------------
  650. // onCommitBaseAnim()
  651. //-----------------------------------------------------------------------------
  652. void LLFloaterAnimPreview::onCommitBaseAnim(LLUICtrl* ctrl, void* data)
  653. {
  654. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  655. if (!previewp->getEnabled())
  656. return;
  658. if (previewp->mAnimPreview)
  659. {
  660. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  662. BOOL paused = avatarp->areAnimationsPaused();
  664. // stop all other possible base motions
  665. avatarp->stopMotion(previewp->mIDList["Standing"], TRUE);
  666. avatarp->stopMotion(previewp->mIDList["Walking"], TRUE);
  667. avatarp->stopMotion(previewp->mIDList["Sitting"], TRUE);
  668. avatarp->stopMotion(previewp->mIDList["Flying"], TRUE);
  670. previewp->resetMotion();
  672. if (!paused)
  673. {
  674. previewp->mPauseRequest = NULL;
  675. }
  676. }
  677. }
  679. //-----------------------------------------------------------------------------
  680. // onCommitLoop()
  681. //-----------------------------------------------------------------------------
  682. void LLFloaterAnimPreview::onCommitLoop(LLUICtrl* ctrl, void* data)
  683. {
  684. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  685. if (!previewp->getEnabled())
  686. return;
  688. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  689. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  691. if (motionp)
  692. {
  693. motionp->setLoop(previewp->childGetValue("loop_check").asBoolean());
  694. motionp->setLoopIn((F32)previewp->childGetValue("loop_in_point").asReal() * 0.01f * motionp->getDuration());
  695. motionp->setLoopOut((F32)previewp->childGetValue("loop_out_point").asReal() * 0.01f * motionp->getDuration());
  696. }
  697. }
  699. //-----------------------------------------------------------------------------
  700. // onCommitLoopIn()
  701. //-----------------------------------------------------------------------------
  702. void LLFloaterAnimPreview::onCommitLoopIn(LLUICtrl* ctrl, void* data)
  703. {
  704. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  705. if (!previewp->getEnabled())
  706. return;
  708. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  709. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  711. if (motionp)
  712. {
  713. motionp->setLoopIn((F32)previewp->childGetValue("loop_in_point").asReal() / 100.f);
  714. previewp->resetMotion();
  715. previewp->childSetValue("loop_check", LLSD(TRUE));
  716. onCommitLoop(ctrl, data);
  717. }
  718. }
  720. //-----------------------------------------------------------------------------
  721. // onCommitLoopOut()
  722. //-----------------------------------------------------------------------------
  723. void LLFloaterAnimPreview::onCommitLoopOut(LLUICtrl* ctrl, void* data)
  724. {
  725. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  726. if (!previewp->getEnabled())
  727. return;
  729. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  730. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  732. if (motionp)
  733. {
  734. motionp->setLoopOut((F32)previewp->childGetValue("loop_out_point").asReal() * 0.01f * motionp->getDuration());
  735. previewp->resetMotion();
  736. previewp->childSetValue("loop_check", LLSD(TRUE));
  737. onCommitLoop(ctrl, data);
  738. }
  739. }
  741. //-----------------------------------------------------------------------------
  742. // onCommitName()
  743. //-----------------------------------------------------------------------------
  744. void LLFloaterAnimPreview::onCommitName(LLUICtrl* ctrl, void* data)
  745. {
  746. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  747. if (!previewp->getEnabled())
  748. return;
  750. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  751. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  753. if (motionp)
  754. {
  755. motionp->setName(previewp->childGetValue("name_form").asString());
  756. }
  758. previewp->doCommit();
  759. }
  761. //-----------------------------------------------------------------------------
  762. // onCommitHandPose()
  763. //-----------------------------------------------------------------------------
  764. void LLFloaterAnimPreview::onCommitHandPose(LLUICtrl* ctrl, void* data)
  765. {
  766. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  767. if (!previewp->getEnabled())
  768. return;
  770. previewp->resetMotion(); // sets hand pose
  771. }
  773. //-----------------------------------------------------------------------------
  774. // onCommitEmote()
  775. //-----------------------------------------------------------------------------
  776. void LLFloaterAnimPreview::onCommitEmote(LLUICtrl* ctrl, void* data)
  777. {
  778. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  779. if (!previewp->getEnabled())
  780. return;
  782. previewp->resetMotion(); // ssts emote
  783. }
  785. //-----------------------------------------------------------------------------
  786. // onCommitPriority()
  787. //-----------------------------------------------------------------------------
  788. void LLFloaterAnimPreview::onCommitPriority(LLUICtrl* ctrl, void* data)
  789. {
  790. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  791. if (!previewp->getEnabled())
  792. return;
  794. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  795. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  797. motionp->setPriority(llfloor((F32)previewp->childGetValue("priority").asReal()));
  798. }
  800. //-----------------------------------------------------------------------------
  801. // onCommitEaseIn()
  802. //-----------------------------------------------------------------------------
  803. void LLFloaterAnimPreview::onCommitEaseIn(LLUICtrl* ctrl, void* data)
  804. {
  805. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  806. if (!previewp->getEnabled())
  807. return;
  809. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  810. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  812. motionp->setEaseIn((F32)previewp->childGetValue("ease_in_time").asReal());
  813. previewp->resetMotion();
  814. }
  816. //-----------------------------------------------------------------------------
  817. // onCommitEaseOut()
  818. //-----------------------------------------------------------------------------
  819. void LLFloaterAnimPreview::onCommitEaseOut(LLUICtrl* ctrl, void* data)
  820. {
  821. LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data;
  822. if (!previewp->getEnabled())
  823. return;
  825. LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar();
  826. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID);
  828. motionp->setEaseOut((F32)previewp->childGetValue("ease_out_time").asReal());
  829. previewp->resetMotion();
  830. }
  832. //-----------------------------------------------------------------------------
  833. // validateEaseIn()
  834. //-----------------------------------------------------------------------------
  835. bool LLFloaterAnimPreview::validateEaseIn(const LLSD& data)
  836. {
  837. if (!getEnabled())
  838. return false;
  840. LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
  841. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID);
  843. if (!motionp->getLoop())
  844. {
  845. F32 new_ease_in = llclamp((F32)childGetValue("ease_in_time").asReal(), 0.f, motionp->getDuration() - motionp->getEaseOutDuration());
  846. childSetValue("ease_in_time", LLSD(new_ease_in));
  847. }
  849. return true;
  850. }
  852. //-----------------------------------------------------------------------------
  853. // validateEaseOut()
  854. //-----------------------------------------------------------------------------
  855. bool LLFloaterAnimPreview::validateEaseOut(const LLSD& data)
  856. {
  857. if (!getEnabled())
  858. return false;
  860. LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
  861. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID);
  863. if (!motionp->getLoop())
  864. {
  865. F32 new_ease_out = llclamp((F32)childGetValue("ease_out_time").asReal(), 0.f, motionp->getDuration() - motionp->getEaseInDuration());
  866. childSetValue("ease_out_time", LLSD(new_ease_out));
  867. }
  869. return true;
  870. }
  872. //-----------------------------------------------------------------------------
  873. // validateLoopIn()
  874. //-----------------------------------------------------------------------------
  875. bool LLFloaterAnimPreview::validateLoopIn(const LLSD& data)
  876. {
  877. if (!getEnabled())
  878. return false;
  880. F32 loop_in_value = (F32)childGetValue("loop_in_point").asReal();
  881. F32 loop_out_value = (F32)childGetValue("loop_out_point").asReal();
  883. if (loop_in_value < 0.f)
  884. {
  885. loop_in_value = 0.f;
  886. }
  887. else if (loop_in_value > 100.f)
  888. {
  889. loop_in_value = 100.f;
  890. }
  891. else if (loop_in_value > loop_out_value)
  892. {
  893. loop_in_value = loop_out_value;
  894. }
  896. childSetValue("loop_in_point", LLSD(loop_in_value));
  897. return true;
  898. }
  900. //-----------------------------------------------------------------------------
  901. // validateLoopOut()
  902. //-----------------------------------------------------------------------------
  903. bool LLFloaterAnimPreview::validateLoopOut(const LLSD& data)
  904. {
  905. if (!getEnabled())
  906. return false;
  908. F32 loop_out_value = (F32)childGetValue("loop_out_point").asReal();
  909. F32 loop_in_value = (F32)childGetValue("loop_in_point").asReal();
  911. if (loop_out_value < 0.f)
  912. {
  913. loop_out_value = 0.f;
  914. }
  915. else if (loop_out_value > 100.f)
  916. {
  917. loop_out_value = 100.f;
  918. }
  919. else if (loop_out_value < loop_in_value)
  920. {
  921. loop_out_value = loop_in_value;
  922. }
  924. childSetValue("loop_out_point", LLSD(loop_out_value));
  925. return true;
  926. }
  929. //-----------------------------------------------------------------------------
  930. // refresh()
  931. //-----------------------------------------------------------------------------
  932. void LLFloaterAnimPreview::refresh()
  933. {
  934. // Are we showing the play button (default) or the pause button?
  935. bool show_play = true;
  936. if (!mAnimPreview)
  937. {
  938. childShow("bad_animation_text");
  939. // play button visible but disabled
  940. mPlayButton->setEnabled(FALSE);
  941. mStopButton->setEnabled(FALSE);
  942. childDisable("ok_btn");
  943. }
  944. else
  945. {
  946. childHide("bad_animation_text");
  947. // re-enabled in case previous animation was bad
  948. mPlayButton->setEnabled(TRUE);
  949. mStopButton->setEnabled(TRUE);
  950. LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
  951. if (avatarp->isMotionActive(mMotionID))
  952. {
  953. mStopButton->setEnabled(TRUE);
  954. LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID);
  955. if (!avatarp->areAnimationsPaused())
  956. {
  957. // animation is playing
  958. if (motionp)
  959. {
  960. F32 fraction_complete = motionp->getLastUpdateTime() / motionp->getDuration();
  961. childSetValue("playback_slider", fraction_complete);
  962. }
  963. show_play = false;
  964. }
  965. }
  966. else
  967. {
  968. // Motion just finished playing
  969. mPauseRequest = avatarp->requestPause();
  970. }
  971. childEnable("ok_btn");
  972. mAnimPreview->requestUpdate();
  973. }
  974. mPlayButton->setVisible(show_play);
  975. mPauseButton->setVisible(!show_play);
  976. }
  978. //-----------------------------------------------------------------------------
  979. // onBtnOK()
  980. //-----------------------------------------------------------------------------
  981. void LLFloaterAnimPreview::onBtnOK(void* userdata)
  982. {
  983. LLFloaterAnimPreview* floaterp = (LLFloaterAnimPreview*)userdata;
  984. if (!floaterp->getEnabled()) return;
  986. if (floaterp->mAnimPreview)
  987. {
  988. LLKeyframeMotion* motionp = (LLKeyframeMotion*)floaterp->mAnimPreview->getDummyAvatar()->findMotion(floaterp->mMotionID);
  990. S32 file_size = motionp->getFileSize();
  991. U8* buffer = new U8[file_size];
  993. LLDataPackerBinaryBuffer dp(buffer, file_size);
  994. if (motionp->serialize(dp))
  995. {
  996. LLVFile file(gVFS, motionp->getID(), LLAssetType::AT_ANIMATION, LLVFile::APPEND);
  998. S32 size = dp.getCurrentSize();
  999. file.setMaxSize(size);
  1000. if (file.write((U8*)buffer, size))
  1001. {
  1002. std::string name = floaterp->childGetValue("name_form").asString();
  1003. std::string desc = floaterp->childGetValue("description_form").asString();
  1004. LLAssetStorage::LLStoreAssetCallback callback = NULL;
  1005. S32 expected_upload_cost = LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
  1006. void *userdata = NULL;
  1007. upload_new_resource(floaterp->mTransactionID, // tid
  1008.     LLAssetType::AT_ANIMATION,
  1009.     name,
  1010.     desc,
  1011.     0,
  1012.     LLFolderType::FT_NONE,
  1013.     LLInventoryType::IT_ANIMATION,
  1014.     LLFloaterPerms::getNextOwnerPerms(), LLFloaterPerms::getGroupPerms(), LLFloaterPerms::getEveryonePerms(),
  1015.     name,
  1016.     callback, expected_upload_cost, userdata);
  1017. }
  1018. else
  1019. {
  1020. llwarns << "Failure writing animation data." << llendl;
  1021. LLNotificationsUtil::add("WriteAnimationFail");
  1022. }
  1023. }
  1025. delete [] buffer;
  1026. // clear out cache for motion data
  1027. floaterp->mAnimPreview->getDummyAvatar()->removeMotion(floaterp->mMotionID);
  1028. LLKeyframeDataCache::removeKeyframeData(floaterp->mMotionID);
  1029. }
  1031. floaterp->closeFloater(false);
  1032. }
  1034. //-----------------------------------------------------------------------------
  1035. // LLPreviewAnimation
  1036. //-----------------------------------------------------------------------------
  1037. LLPreviewAnimation::LLPreviewAnimation(S32 width, S32 height) : LLViewerDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
  1038. {
  1039. mNeedsUpdate = TRUE;
  1040. mCameraDistance = PREVIEW_CAMERA_DISTANCE;
  1041. mCameraYaw = 0.f;
  1042. mCameraPitch = 0.f;
  1043. mCameraZoom = 1.f;
  1045. mDummyAvatar = (LLVOAvatar*)gObjectList.createObjectViewer(LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
  1046. mDummyAvatar->createDrawable(&gPipeline);
  1047. mDummyAvatar->mIsDummy = TRUE;
  1048. mDummyAvatar->mSpecialRenderMode = 1;
  1049. mDummyAvatar->setPositionAgent(LLVector3::zero);
  1050. mDummyAvatar->slamPosition();
  1051. mDummyAvatar->updateJointLODs();
  1052. mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
  1053. mDummyAvatar->startMotion(ANIM_AGENT_STAND, BASE_ANIM_TIME_OFFSET);
  1054. mDummyAvatar->hideSkirt();
  1055. gPipeline.markVisible(mDummyAvatar->mDrawable, *LLViewerCamera::getInstance());
  1057. // stop extraneous animations
  1058. mDummyAvatar->stopMotion( ANIM_AGENT_HEAD_ROT, TRUE );
  1059. mDummyAvatar->stopMotion( ANIM_AGENT_EYE, TRUE );
  1060. mDummyAvatar->stopMotion( ANIM_AGENT_BODY_NOISE, TRUE );
  1061. mDummyAvatar->stopMotion( ANIM_AGENT_BREATHE_ROT, TRUE );
  1062. }
  1064. //-----------------------------------------------------------------------------
  1065. // LLPreviewAnimation()
  1066. //-----------------------------------------------------------------------------
  1067. LLPreviewAnimation::~LLPreviewAnimation()
  1068. {
  1069. mDummyAvatar->markDead();
  1070. }
  1072. //-----------------------------------------------------------------------------
  1073. // update()
  1074. //-----------------------------------------------------------------------------
  1075. BOOL LLPreviewAnimation::render()
  1076. {
  1077. mNeedsUpdate = FALSE;
  1078. LLVOAvatar* avatarp = mDummyAvatar;
  1080. glMatrixMode(GL_PROJECTION);
  1081. gGL.pushMatrix();
  1082. glLoadIdentity();
  1083. glOrtho(0.0f, mFullWidth, 0.0f, mFullHeight, -1.0f, 1.0f);
  1085. glMatrixMode(GL_MODELVIEW);
  1086. gGL.pushMatrix();
  1087. glLoadIdentity();
  1089. LLGLSUIDefault def;
  1090. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1091. gGL.color4f(0.15f, 0.2f, 0.3f, 1.f);
  1093. gl_rect_2d_simple( mFullWidth, mFullHeight );
  1095. glMatrixMode(GL_PROJECTION);
  1096. gGL.popMatrix();
  1098. glMatrixMode(GL_MODELVIEW);
  1099. gGL.popMatrix();
  1101. gGL.flush();
  1103. LLVector3 target_pos = avatarp->mRoot.getWorldPosition();
  1105. LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) * 
  1106. LLQuaternion(mCameraYaw, LLVector3::z_axis);
  1108. LLQuaternion av_rot = avatarp->mRoot.getWorldRotation() * camera_rot;
  1109. LLViewerCamera::getInstance()->setOriginAndLookAt(
  1110. target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot), // camera
  1111. LLVector3::z_axis, // up
  1112. target_pos + (mCameraOffset  * av_rot) ); // point of interest
  1114. LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / mCameraZoom);
  1115. LLViewerCamera::getInstance()->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mFullWidth, mFullHeight, FALSE);
  1117. mCameraRelPos = LLViewerCamera::getInstance()->getOrigin() - avatarp->mHeadp->getWorldPosition();
  1119. //avatarp->setAnimationData("LookAtPoint", (void *)&mCameraRelPos);
  1121. //SJB: Animation is updated in LLVOAvatar::updateCharacter
  1123. if (avatarp->mDrawable.notNull())
  1124. {
  1125. avatarp->updateLOD();
  1127. LLVertexBuffer::unbind();
  1128. LLGLDepthTest gls_depth(GL_TRUE);
  1130. LLDrawPoolAvatar *avatarPoolp = (LLDrawPoolAvatar *)avatarp->mDrawable->getFace(0)->getPool();
  1131. avatarp->dirtyMesh();
  1132. avatarPoolp->renderAvatars(avatarp);  // renders only one avatar
  1133. }
  1135. gGL.color4f(1,1,1,1);
  1136. return TRUE;
  1137. }
  1139. //-----------------------------------------------------------------------------
  1140. // requestUpdate()
  1141. //-----------------------------------------------------------------------------
  1142. void LLPreviewAnimation::requestUpdate()
  1143. { 
  1144. mNeedsUpdate = TRUE; 
  1145. }
  1147. //-----------------------------------------------------------------------------
  1148. // rotate()
  1149. //-----------------------------------------------------------------------------
  1150. void LLPreviewAnimation::rotate(F32 yaw_radians, F32 pitch_radians)
  1151. {
  1152. mCameraYaw = mCameraYaw + yaw_radians;
  1154. mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
  1155. }
  1157. //-----------------------------------------------------------------------------
  1158. // zoom()
  1159. //-----------------------------------------------------------------------------
  1160. void LLPreviewAnimation::zoom(F32 zoom_delta)
  1161. {
  1162. setZoom(mCameraZoom + zoom_delta);
  1163. }
  1165. //-----------------------------------------------------------------------------
  1166. // setZoom()
  1167. //-----------------------------------------------------------------------------
  1168. void LLPreviewAnimation::setZoom(F32 zoom_amt)
  1169. {
  1170. mCameraZoom = llclamp(zoom_amt, MIN_CAMERA_ZOOM, MAX_CAMERA_ZOOM);
  1171. }
  1173. //-----------------------------------------------------------------------------
  1174. // pan()
  1175. //-----------------------------------------------------------------------------
  1176. void LLPreviewAnimation::pan(F32 right, F32 up)
  1177. {
  1178. mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
  1179. mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
  1180. }