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

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

游戏引擎

开发平台：

C++ Builder

llfloaterimagepreview.cpp：源码内容
  1. /** 
  2.  * @file llfloaterimagepreview.cpp
  3.  * @brief LLFloaterImagePreview 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 "llfloaterimagepreview.h"
  37. #include "llimagebmp.h"
  38. #include "llimagetga.h"
  39. #include "llimagejpeg.h"
  40. #include "llimagepng.h"
  42. #include "llagent.h"
  43. #include "llbutton.h"
  44. #include "llcombobox.h"
  45. #include "lldrawable.h"
  46. #include "lldrawpoolavatar.h"
  47. #include "llrender.h"
  48. #include "llface.h"
  49. #include "llfocusmgr.h"
  50. #include "lltextbox.h"
  51. #include "lltoolmgr.h"
  52. #include "llui.h"
  53. #include "llviewercamera.h"
  54. #include "llviewerwindow.h"
  55. #include "llviewerobjectlist.h"
  56. #include "llvoavatar.h"
  57. #include "pipeline.h"
  58. #include "lluictrlfactory.h"
  59. #include "llviewertexturelist.h"
  60. #include "llstring.h"
  62. const S32 PREVIEW_BORDER_WIDTH = 2;
  63. const S32 PREVIEW_RESIZE_HANDLE_SIZE = S32(RESIZE_HANDLE_WIDTH * OO_SQRT2) + PREVIEW_BORDER_WIDTH;
  64. const S32 PREVIEW_HPAD = PREVIEW_RESIZE_HANDLE_SIZE;
  65. const S32 PREF_BUTTON_HEIGHT = 16 + 7 + 16;
  66. const S32 PREVIEW_TEXTURE_HEIGHT = 300;
  69. //-----------------------------------------------------------------------------
  70. // LLFloaterImagePreview()
  71. //-----------------------------------------------------------------------------
  72. LLFloaterImagePreview::LLFloaterImagePreview(const std::string& filename) : 
  73. LLFloaterNameDesc(filename),
  75. mAvatarPreview(NULL),
  76. mSculptedPreview(NULL),
  77. mLastMouseX(0),
  78. mLastMouseY(0),
  79. mImagep(NULL)
  80. {
  81. loadImage(mFilenameAndPath);
  82. }
  84. //-----------------------------------------------------------------------------
  85. // postBuild()
  86. //-----------------------------------------------------------------------------
  87. BOOL LLFloaterImagePreview::postBuild()
  88. {
  89. if (!LLFloaterNameDesc::postBuild())
  90. {
  91. return FALSE;
  92. }
  94. LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
  95. if (iface)
  96. {
  97. iface->selectFirstItem();
  98. }
  99. childSetCommitCallback("clothing_type_combo", onPreviewTypeCommit, this);
  101. mPreviewRect.set(PREVIEW_HPAD, 
  102. PREVIEW_TEXTURE_HEIGHT,
  103. getRect().getWidth() - PREVIEW_HPAD, 
  104. PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  105. mPreviewImageRect.set(0.f, 1.f, 1.f, 0.f);
  107. childHide("bad_image_text");
  109. if (mRawImagep.notNull() && gAgent.getRegion() != NULL)
  110. {
  111. mAvatarPreview = new LLImagePreviewAvatar(256, 256);
  112. mAvatarPreview->setPreviewTarget("mPelvis", "mUpperBodyMesh0", mRawImagep, 2.f, FALSE);
  114. mSculptedPreview = new LLImagePreviewSculpted(256, 256);
  115. mSculptedPreview->setPreviewTarget(mRawImagep, 2.0f);
  117. if (mRawImagep->getWidth() * mRawImagep->getHeight () <= LL_IMAGE_REZ_LOSSLESS_CUTOFF * LL_IMAGE_REZ_LOSSLESS_CUTOFF)
  118. childEnable("lossless_check");
  119. }
  120. else
  121. {
  122. mAvatarPreview = NULL;
  123. mSculptedPreview = NULL;
  124. childShow("bad_image_text");
  125. childDisable("clothing_type_combo");
  126. childDisable("ok_btn");
  127. }
  129. getChild<LLUICtrl>("ok_btn")->setCommitCallback(boost::bind(&LLFloaterNameDesc::onBtnOK, this));
  131. return TRUE;
  132. }
  134. //-----------------------------------------------------------------------------
  135. // LLFloaterImagePreview()
  136. //-----------------------------------------------------------------------------
  137. LLFloaterImagePreview::~LLFloaterImagePreview()
  138. {
  139. clearAllPreviewTextures();
  141. mRawImagep = NULL;
  142. mImagep = NULL ;
  143. }
  145. //static 
  146. //-----------------------------------------------------------------------------
  147. // onPreviewTypeCommit()
  148. //-----------------------------------------------------------------------------
  149. void LLFloaterImagePreview::onPreviewTypeCommit(LLUICtrl* ctrl, void* userdata)
  150. {
  151. LLFloaterImagePreview *fp =(LLFloaterImagePreview *)userdata;
  153. if (!fp->mAvatarPreview || !fp->mSculptedPreview)
  154. {
  155. return;
  156. }
  158. S32 which_mode = 0;
  160. LLCtrlSelectionInterface* iface = fp->childGetSelectionInterface("clothing_type_combo");
  161. if (iface)
  162. {
  163. which_mode = iface->getFirstSelectedIndex();
  164. }
  166. switch(which_mode)
  167. {
  168. case 0:
  169. break;
  170. case 1:
  171. fp->mAvatarPreview->setPreviewTarget("mSkull", "mHairMesh0", fp->mRawImagep, 0.4f, FALSE);
  172. break;
  173. case 2:
  174. fp->mAvatarPreview->setPreviewTarget("mSkull", "mHeadMesh0", fp->mRawImagep, 0.4f, FALSE);
  175. break;
  176. case 3:
  177. fp->mAvatarPreview->setPreviewTarget("mChest", "mUpperBodyMesh0", fp->mRawImagep, 1.0f, FALSE);
  178. break;
  179. case 4:
  180. fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mLowerBodyMesh0", fp->mRawImagep, 1.2f, FALSE);
  181. break;
  182. case 5:
  183. fp->mAvatarPreview->setPreviewTarget("mSkull", "mHeadMesh0", fp->mRawImagep, 0.4f, TRUE);
  184. break;
  185. case 6:
  186. fp->mAvatarPreview->setPreviewTarget("mChest", "mUpperBodyMesh0", fp->mRawImagep, 1.2f, TRUE);
  187. break;
  188. case 7:
  189. fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mLowerBodyMesh0", fp->mRawImagep, 1.2f, TRUE);
  190. break;
  191. case 8:
  192. fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mSkirtMesh0", fp->mRawImagep, 1.3f, FALSE);
  193. break;
  194. case 9:
  195. fp->mSculptedPreview->setPreviewTarget(fp->mRawImagep, 2.0f);
  196. break;
  197. default:
  198. break;
  199. }
  201. fp->mAvatarPreview->refresh();
  202. fp->mSculptedPreview->refresh();
  203. }
  206. //-----------------------------------------------------------------------------
  207. // clearAllPreviewTextures()
  208. //-----------------------------------------------------------------------------
  209. void LLFloaterImagePreview::clearAllPreviewTextures()
  210. {
  211. if (mAvatarPreview)
  212. {
  213. mAvatarPreview->clearPreviewTexture("mHairMesh0");
  214. mAvatarPreview->clearPreviewTexture("mUpperBodyMesh0");
  215. mAvatarPreview->clearPreviewTexture("mLowerBodyMesh0");
  216. mAvatarPreview->clearPreviewTexture("mHeadMesh0");
  217. mAvatarPreview->clearPreviewTexture("mUpperBodyMesh0");
  218. mAvatarPreview->clearPreviewTexture("mLowerBodyMesh0");
  219. mAvatarPreview->clearPreviewTexture("mSkirtMesh0");
  220. }
  221. }
  223. //-----------------------------------------------------------------------------
  224. // draw()
  225. //-----------------------------------------------------------------------------
  226. void LLFloaterImagePreview::draw()
  227. {
  228. LLFloater::draw();
  229. LLRect r = getRect();
  231. if (mRawImagep.notNull())
  232. {
  233. LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
  234. U32 selected = 0;
  235. if (iface)
  236. selected = iface->getFirstSelectedIndex();
  238. if (selected <= 0)
  239. {
  240. gl_rect_2d_checkerboard(mPreviewRect);
  241. LLGLDisable gls_alpha(GL_ALPHA_TEST);
  243. if(mImagep.notNull())
  244. {
  245. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mImagep->getTexName());
  246. }
  247. else
  248. {
  249. mImagep = LLViewerTextureManager::getLocalTexture(mRawImagep.get(), FALSE) ;
  251. gGL.getTexUnit(0)->unbind(mImagep->getTarget()) ;
  252. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mImagep->getTexName());
  253. stop_glerror();
  255. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
  257. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
  258. if (mAvatarPreview)
  259. {
  260. mAvatarPreview->setTexture(mImagep->getTexName());
  261. mSculptedPreview->setTexture(mImagep->getTexName());
  262. }
  263. }
  265. gGL.color3f(1.f, 1.f, 1.f);
  266. gGL.begin( LLRender::QUADS );
  267. {
  268. gGL.texCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mTop);
  269. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  270. gGL.texCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mBottom);
  271. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  272. gGL.texCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mBottom);
  273. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  274. gGL.texCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mTop);
  275. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  276. }
  277. gGL.end();
  279. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  281. stop_glerror();
  282. }
  283. else
  284. {
  285. if ((mAvatarPreview) && (mSculptedPreview))
  286. {
  287. gGL.color3f(1.f, 1.f, 1.f);
  289. if (selected == 9)
  290. {
  291. gGL.getTexUnit(0)->bind(mSculptedPreview);
  292. }
  293. else
  294. {
  295. gGL.getTexUnit(0)->bind(mAvatarPreview);
  296. }
  298. gGL.begin( LLRender::QUADS );
  299. {
  300. gGL.texCoord2f(0.f, 1.f);
  301. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  302. gGL.texCoord2f(0.f, 0.f);
  303. gGL.vertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  304. gGL.texCoord2f(1.f, 0.f);
  305. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
  306. gGL.texCoord2f(1.f, 1.f);
  307. gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
  308. }
  309. gGL.end();
  311. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  312. }
  313. }
  314. }
  315. }
  318. //-----------------------------------------------------------------------------
  319. // loadImage()
  320. //-----------------------------------------------------------------------------
  321. bool LLFloaterImagePreview::loadImage(const std::string& src_filename)
  322. {
  323. std::string exten = gDirUtilp->getExtension(src_filename);
  325. U32 codec = IMG_CODEC_INVALID;
  326. std::string temp_str;
  327. if( exten == "bmp")
  328. {
  329. codec = IMG_CODEC_BMP;
  330. }
  331. else if( exten == "tga")
  332. {
  333. codec = IMG_CODEC_TGA;
  334. }
  335. else if( exten == "jpg" || exten == "jpeg")
  336. {
  337. codec = IMG_CODEC_JPEG;
  338. }
  339. else if( exten == "png" )
  340. {
  341. codec = IMG_CODEC_PNG;
  342. }
  344. LLPointer<LLImageRaw> raw_image = new LLImageRaw;
  346. switch (codec)
  347. {
  348. case IMG_CODEC_BMP:
  349. {
  350. LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
  352. if (!bmp_image->load(src_filename))
  353. {
  354. return false;
  355. }
  357. if (!bmp_image->decode(raw_image, 0.0f))
  358. {
  359. return false;
  360. }
  361. }
  362. break;
  363. case IMG_CODEC_TGA:
  364. {
  365. LLPointer<LLImageTGA> tga_image = new LLImageTGA;
  367. if (!tga_image->load(src_filename))
  368. {
  369. return false;
  370. }
  372. if (!tga_image->decode(raw_image))
  373. {
  374. return false;
  375. }
  377. if( (tga_image->getComponents() != 3) &&
  378. (tga_image->getComponents() != 4) )
  379. {
  380. tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
  381. return false;
  382. }
  383. }
  384. break;
  385. case IMG_CODEC_JPEG:
  386. {
  387. LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
  389. if (!jpeg_image->load(src_filename))
  390. {
  391. return false;
  392. }
  394. if (!jpeg_image->decode(raw_image, 0.0f))
  395. {
  396. return false;
  397. }
  398. }
  399. break;
  400. case IMG_CODEC_PNG:
  401. {
  402. LLPointer<LLImagePNG> png_image = new LLImagePNG;
  404. if (!png_image->load(src_filename))
  405. {
  406. return false;
  407. }
  409. if (!png_image->decode(raw_image, 0.0f))
  410. {
  411. return false;
  412. }
  413. }
  414. break;
  415. default:
  416. return false;
  417. }
  419. raw_image->biasedScaleToPowerOfTwo(1024);
  420. mRawImagep = raw_image;
  422. return true;
  423. }
  425. //-----------------------------------------------------------------------------
  426. // handleMouseDown()
  427. //-----------------------------------------------------------------------------
  428. BOOL LLFloaterImagePreview::handleMouseDown(S32 x, S32 y, MASK mask)
  429. {
  430. if (mPreviewRect.pointInRect(x, y))
  431. {
  432. bringToFront( x, y );
  433. gFocusMgr.setMouseCapture(this);
  434. gViewerWindow->hideCursor();
  435. mLastMouseX = x;
  436. mLastMouseY = y;
  437. return TRUE;
  438. }
  440. return LLFloater::handleMouseDown(x, y, mask);
  441. }
  443. //-----------------------------------------------------------------------------
  444. // handleMouseUp()
  445. //-----------------------------------------------------------------------------
  446. BOOL LLFloaterImagePreview::handleMouseUp(S32 x, S32 y, MASK mask)
  447. {
  448. gFocusMgr.setMouseCapture(FALSE);
  449. gViewerWindow->showCursor();
  450. return LLFloater::handleMouseUp(x, y, mask);
  451. }
  453. //-----------------------------------------------------------------------------
  454. // handleHover()
  455. //-----------------------------------------------------------------------------
  456. BOOL LLFloaterImagePreview::handleHover(S32 x, S32 y, MASK mask)
  457. {
  458. MASK local_mask = mask & ~MASK_ALT;
  460. if (mAvatarPreview && hasMouseCapture())
  461. {
  462. if (local_mask == MASK_PAN)
  463. {
  464. // pan here
  465. LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
  466. if (iface && iface->getFirstSelectedIndex() <= 0)
  467. {
  468. mPreviewImageRect.translate((F32)(x - mLastMouseX) * -0.005f * mPreviewImageRect.getWidth(), 
  469. (F32)(y - mLastMouseY) * -0.005f * mPreviewImageRect.getHeight());
  470. }
  471. else
  472. {
  473. mAvatarPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f);
  474. mSculptedPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f);
  475. }
  476. }
  477. else if (local_mask == MASK_ORBIT)
  478. {
  479. F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
  480. F32 pitch_radians = (F32)(y - mLastMouseY) * 0.02f;
  482. mAvatarPreview->rotate(yaw_radians, pitch_radians);
  483. mSculptedPreview->rotate(yaw_radians, pitch_radians);
  484. }
  485. else 
  486. {
  487. LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
  488. if (iface && iface->getFirstSelectedIndex() <= 0)
  489. {
  490. F32 zoom_amt = (F32)(y - mLastMouseY) * -0.002f;
  491. mPreviewImageRect.stretch(zoom_amt);
  492. }
  493. else
  494. {
  495. F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
  496. F32 zoom_amt = (F32)(y - mLastMouseY) * 0.02f;
  498. mAvatarPreview->rotate(yaw_radians, 0.f);
  499. mAvatarPreview->zoom(zoom_amt);
  500. mSculptedPreview->rotate(yaw_radians, 0.f);
  501. mSculptedPreview->zoom(zoom_amt);
  502. }
  503. }
  505. LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
  506. if (iface && iface->getFirstSelectedIndex() <= 0)
  507. {
  508. if (mPreviewImageRect.getWidth() > 1.f)
  509. {
  510. mPreviewImageRect.stretch((1.f - mPreviewImageRect.getWidth()) * 0.5f);
  511. }
  512. else if (mPreviewImageRect.getWidth() < 0.1f)
  513. {
  514. mPreviewImageRect.stretch((0.1f - mPreviewImageRect.getWidth()) * 0.5f);
  515. }
  517. if (mPreviewImageRect.getHeight() > 1.f)
  518. {
  519. mPreviewImageRect.stretch((1.f - mPreviewImageRect.getHeight()) * 0.5f);
  520. }
  521. else if (mPreviewImageRect.getHeight() < 0.1f)
  522. {
  523. mPreviewImageRect.stretch((0.1f - mPreviewImageRect.getHeight()) * 0.5f);
  524. }
  526. if (mPreviewImageRect.mLeft < 0.f)
  527. {
  528. mPreviewImageRect.translate(-mPreviewImageRect.mLeft, 0.f);
  529. }
  530. else if (mPreviewImageRect.mRight > 1.f)
  531. {
  532. mPreviewImageRect.translate(1.f - mPreviewImageRect.mRight, 0.f);
  533. }
  535. if (mPreviewImageRect.mBottom < 0.f)
  536. {
  537. mPreviewImageRect.translate(0.f, -mPreviewImageRect.mBottom);
  538. }
  539. else if (mPreviewImageRect.mTop > 1.f)
  540. {
  541. mPreviewImageRect.translate(0.f, 1.f - mPreviewImageRect.mTop);
  542. }
  543. }
  544. else
  545. {
  546. mAvatarPreview->refresh();
  547. mSculptedPreview->refresh();
  548. }
  550. LLUI::setMousePositionLocal(this, mLastMouseX, mLastMouseY);
  551. }
  553. if (!mPreviewRect.pointInRect(x, y) || !mAvatarPreview || !mSculptedPreview)
  554. {
  555. return LLFloater::handleHover(x, y, mask);
  556. }
  557. else if (local_mask == MASK_ORBIT)
  558. {
  559. gViewerWindow->setCursor(UI_CURSOR_TOOLCAMERA);
  560. }
  561. else if (local_mask == MASK_PAN)
  562. {
  563. gViewerWindow->setCursor(UI_CURSOR_TOOLPAN);
  564. }
  565. else
  566. {
  567. gViewerWindow->setCursor(UI_CURSOR_TOOLZOOMIN);
  568. }
  570. return TRUE;
  571. }
  573. //-----------------------------------------------------------------------------
  574. // handleScrollWheel()
  575. //-----------------------------------------------------------------------------
  576. BOOL LLFloaterImagePreview::handleScrollWheel(S32 x, S32 y, S32 clicks)
  577. {
  578. if (mPreviewRect.pointInRect(x, y) && mAvatarPreview)
  579. {
  580. mAvatarPreview->zoom((F32)clicks * -0.2f);
  581. mAvatarPreview->refresh();
  583. mSculptedPreview->zoom((F32)clicks * -0.2f);
  584. mSculptedPreview->refresh();
  585. }
  587. return TRUE;
  588. }
  590. //-----------------------------------------------------------------------------
  591. // onMouseCaptureLost()
  592. //-----------------------------------------------------------------------------
  593. // static
  594. void LLFloaterImagePreview::onMouseCaptureLostImagePreview(LLMouseHandler* handler)
  595. {
  596. gViewerWindow->showCursor();
  597. }
  600. //-----------------------------------------------------------------------------
  601. // LLImagePreviewAvatar
  602. //-----------------------------------------------------------------------------
  603. LLImagePreviewAvatar::LLImagePreviewAvatar(S32 width, S32 height) : LLViewerDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
  604. {
  605. mNeedsUpdate = TRUE;
  606. mTargetJoint = NULL;
  607. mTargetMesh = NULL;
  608. mCameraDistance = 0.f;
  609. mCameraYaw = 0.f;
  610. mCameraPitch = 0.f;
  611. mCameraZoom = 1.f;
  613. mDummyAvatar = (LLVOAvatar*)gObjectList.createObjectViewer(LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
  614. mDummyAvatar->initInstance();
  615. mDummyAvatar->createDrawable(&gPipeline);
  616. mDummyAvatar->mIsDummy = TRUE;
  617. mDummyAvatar->mSpecialRenderMode = 2;
  618. mDummyAvatar->setPositionAgent(LLVector3::zero);
  619. mDummyAvatar->slamPosition();
  620. mDummyAvatar->updateJointLODs();
  621. mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
  622. // gPipeline.markVisible(mDummyAvatar->mDrawable, *LLViewerCamera::getInstance());
  624. mTextureName = 0;
  625. }
  628. LLImagePreviewAvatar::~LLImagePreviewAvatar()
  629. {
  630. mDummyAvatar->markDead();
  631. }
  634. void LLImagePreviewAvatar::setPreviewTarget(const std::string& joint_name, const std::string& mesh_name, LLImageRaw* imagep, F32 distance, BOOL male) 
  635. { 
  636. mTargetJoint = mDummyAvatar->mRoot.findJoint(joint_name);
  637. // clear out existing test mesh
  638. if (mTargetMesh)
  639. {
  640. mTargetMesh->setTestTexture(0);
  641. }
  643. if (male)
  644. {
  645. mDummyAvatar->setVisualParamWeight( "male", 1.f );
  646. mDummyAvatar->updateVisualParams();
  647. mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
  648. }
  649. else
  650. {
  651. mDummyAvatar->setVisualParamWeight( "male", 0.f );
  652. mDummyAvatar->updateVisualParams();
  653. mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
  654. }
  655. mDummyAvatar->mRoot.setVisible(FALSE, TRUE);
  657. mTargetMesh = (LLViewerJointMesh*)mDummyAvatar->mRoot.findJoint(mesh_name);
  658. mTargetMesh->setTestTexture(mTextureName);
  659. mTargetMesh->setVisible(TRUE, FALSE);
  660. mCameraDistance = distance;
  661. mCameraZoom = 1.f;
  662. mCameraPitch = 0.f;
  663. mCameraYaw = 0.f;
  664. mCameraOffset.clearVec();
  665. }
  667. //-----------------------------------------------------------------------------
  668. // clearPreviewTexture()
  669. //-----------------------------------------------------------------------------
  670. void LLImagePreviewAvatar::clearPreviewTexture(const std::string& mesh_name)
  671. {
  672. if (mDummyAvatar)
  673. {
  674. LLViewerJointMesh *mesh = (LLViewerJointMesh*)mDummyAvatar->mRoot.findJoint(mesh_name);
  675. // clear out existing test mesh
  676. if (mesh)
  677. {
  678. mesh->setTestTexture(0);
  679. }
  680. }
  681. }
  683. //-----------------------------------------------------------------------------
  684. // update()
  685. //-----------------------------------------------------------------------------
  686. BOOL LLImagePreviewAvatar::render()
  687. {
  688. mNeedsUpdate = FALSE;
  689. LLVOAvatar* avatarp = mDummyAvatar;
  691. glMatrixMode(GL_PROJECTION);
  692. gGL.pushMatrix();
  693. glLoadIdentity();
  694. glOrtho(0.0f, mFullWidth, 0.0f, mFullHeight, -1.0f, 1.0f);
  696. glMatrixMode(GL_MODELVIEW);
  697. gGL.pushMatrix();
  698. glLoadIdentity();
  700. LLGLSUIDefault def;
  701. gGL.color4f(0.15f, 0.2f, 0.3f, 1.f);
  703. gl_rect_2d_simple( mFullWidth, mFullHeight );
  705. glMatrixMode(GL_PROJECTION);
  706. gGL.popMatrix();
  708. glMatrixMode(GL_MODELVIEW);
  709. gGL.popMatrix();
  711. gGL.flush();
  712. LLVector3 target_pos = mTargetJoint->getWorldPosition();
  714. LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) * 
  715. LLQuaternion(mCameraYaw, LLVector3::z_axis);
  717. LLQuaternion av_rot = avatarp->mPelvisp->getWorldRotation() * camera_rot;
  718. LLViewerCamera::getInstance()->setOriginAndLookAt(
  719. target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot), // camera
  720. LLVector3::z_axis, // up
  721. target_pos + (mCameraOffset  * av_rot) ); // point of interest
  723. stop_glerror();
  725. LLViewerCamera::getInstance()->setAspect((F32)mFullWidth / mFullHeight);
  726. LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / mCameraZoom);
  727. LLViewerCamera::getInstance()->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mFullWidth, mFullHeight, FALSE);
  729. LLVertexBuffer::unbind();
  730. avatarp->updateLOD();
  733. if (avatarp->mDrawable.notNull())
  734. {
  735. LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
  736. // make sure alpha=0 shows avatar material color
  737. LLGLDisable no_blend(GL_BLEND);
  739. LLDrawPoolAvatar *avatarPoolp = (LLDrawPoolAvatar *)avatarp->mDrawable->getFace(0)->getPool();
  741. avatarPoolp->renderAvatars(avatarp);  // renders only one avatar
  742. }
  744. gGL.color4f(1,1,1,1);
  745. return TRUE;
  746. }
  748. //-----------------------------------------------------------------------------
  749. // refresh()
  750. //-----------------------------------------------------------------------------
  751. void LLImagePreviewAvatar::refresh()
  752. { 
  753. mNeedsUpdate = TRUE; 
  754. }
  756. //-----------------------------------------------------------------------------
  757. // rotate()
  758. //-----------------------------------------------------------------------------
  759. void LLImagePreviewAvatar::rotate(F32 yaw_radians, F32 pitch_radians)
  760. {
  761. mCameraYaw = mCameraYaw + yaw_radians;
  763. mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
  764. }
  766. //-----------------------------------------------------------------------------
  767. // zoom()
  768. //-----------------------------------------------------------------------------
  769. void LLImagePreviewAvatar::zoom(F32 zoom_amt)
  770. {
  771. mCameraZoom = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
  772. }
  774. void LLImagePreviewAvatar::pan(F32 right, F32 up)
  775. {
  776. mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
  777. mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
  778. }
  781. //-----------------------------------------------------------------------------
  782. // LLImagePreviewSculpted
  783. //-----------------------------------------------------------------------------
  785. LLImagePreviewSculpted::LLImagePreviewSculpted(S32 width, S32 height) : LLViewerDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
  786. {
  787. mNeedsUpdate = TRUE;
  788. mCameraDistance = 0.f;
  789. mCameraYaw = 0.f;
  790. mCameraPitch = 0.f;
  791. mCameraZoom = 1.f;
  792. mTextureName = 0;
  794. LLVolumeParams volume_params;
  795. volume_params.setType(LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_CIRCLE);
  796. volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_SPHERE);
  798. F32 const HIGHEST_LOD = 4.0f;
  799. mVolume = new LLVolume(volume_params,  HIGHEST_LOD);
  800. }
  803. LLImagePreviewSculpted::~LLImagePreviewSculpted()
  804. {
  805. }
  808. void LLImagePreviewSculpted::setPreviewTarget(LLImageRaw* imagep, F32 distance)
  809. { 
  810. mCameraDistance = distance;
  811. mCameraZoom = 1.f;
  812. mCameraPitch = 0.f;
  813. mCameraYaw = 0.f;
  814. mCameraOffset.clearVec();
  816. if (imagep)
  817. {
  818. mVolume->sculpt(imagep->getWidth(), imagep->getHeight(), imagep->getComponents(), imagep->getData(), 0);
  819. }
  821. const LLVolumeFace &vf = mVolume->getVolumeFace(0);
  822. U32 num_indices = vf.mIndices.size();
  823. U32 num_vertices = vf.mVertices.size();
  825. mVertexBuffer = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL, 0);
  826. mVertexBuffer->allocateBuffer(num_vertices, num_indices, TRUE);
  828. LLStrider<LLVector3> vertex_strider;
  829. LLStrider<LLVector3> normal_strider;
  830. LLStrider<U16> index_strider;
  832. mVertexBuffer->getVertexStrider(vertex_strider);
  833. mVertexBuffer->getNormalStrider(normal_strider);
  834. mVertexBuffer->getIndexStrider(index_strider);
  836. // build vertices and normals
  837. for (U32 i = 0; i < num_vertices; i++)
  838. {
  839. *(vertex_strider++) = vf.mVertices[i].mPosition;
  840. LLVector3 normal = vf.mVertices[i].mNormal;
  841. normal.normalize();
  842. *(normal_strider++) = normal;
  843. }
  845. // build indices
  846. for (U16 i = 0; i < num_indices; i++)
  847. {
  848. *(index_strider++) = vf.mIndices[i];
  849. }
  850. }
  853. //-----------------------------------------------------------------------------
  854. // render()
  855. //-----------------------------------------------------------------------------
  856. BOOL LLImagePreviewSculpted::render()
  857. {
  858. mNeedsUpdate = FALSE;
  860. LLGLSUIDefault def;
  861. LLGLDisable no_blend(GL_BLEND);
  862. LLGLEnable cull(GL_CULL_FACE);
  863. LLGLDepthTest depth(GL_TRUE);
  865. glMatrixMode(GL_PROJECTION);
  866. gGL.pushMatrix();
  867. glLoadIdentity();
  868. glOrtho(0.0f, mFullWidth, 0.0f, mFullHeight, -1.0f, 1.0f);
  870. glMatrixMode(GL_MODELVIEW);
  871. gGL.pushMatrix();
  872. glLoadIdentity();
  874. gGL.color4f(0.15f, 0.2f, 0.3f, 1.f);
  876. gl_rect_2d_simple( mFullWidth, mFullHeight );
  878. glMatrixMode(GL_PROJECTION);
  879. gGL.popMatrix();
  881. glMatrixMode(GL_MODELVIEW);
  882. gGL.popMatrix();
  884. glClear(GL_DEPTH_BUFFER_BIT);
  886. LLVector3 target_pos(0, 0, 0);
  888. LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) * 
  889. LLQuaternion(mCameraYaw, LLVector3::z_axis);
  891. LLQuaternion av_rot = camera_rot;
  892. LLViewerCamera::getInstance()->setOriginAndLookAt(
  893. target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot), // camera
  894. LLVector3::z_axis, // up
  895. target_pos + (mCameraOffset  * av_rot) ); // point of interest
  897. stop_glerror();
  899. LLViewerCamera::getInstance()->setAspect((F32) mFullWidth / mFullHeight);
  900. LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / mCameraZoom);
  901. LLViewerCamera::getInstance()->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mFullWidth, mFullHeight, FALSE);
  903. const LLVolumeFace &vf = mVolume->getVolumeFace(0);
  904. U32 num_indices = vf.mIndices.size();
  906. mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL);
  908. gPipeline.enableLightsAvatar();
  909. gGL.pushMatrix();
  910. const F32 SCALE = 1.25f;
  911. gGL.scalef(SCALE, SCALE, SCALE);
  912. const F32 BRIGHTNESS = 0.9f;
  913. gGL.color3f(BRIGHTNESS, BRIGHTNESS, BRIGHTNESS);
  914. mVertexBuffer->draw(LLRender::TRIANGLES, num_indices, 0);
  916. gGL.popMatrix();
  918. return TRUE;
  919. }
  921. //-----------------------------------------------------------------------------
  922. // refresh()
  923. //-----------------------------------------------------------------------------
  924. void LLImagePreviewSculpted::refresh()
  925. { 
  926. mNeedsUpdate = TRUE; 
  927. }
  929. //-----------------------------------------------------------------------------
  930. // rotate()
  931. //-----------------------------------------------------------------------------
  932. void LLImagePreviewSculpted::rotate(F32 yaw_radians, F32 pitch_radians)
  933. {
  934. mCameraYaw = mCameraYaw + yaw_radians;
  936. mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
  937. }
  939. //-----------------------------------------------------------------------------
  940. // zoom()
  941. //-----------------------------------------------------------------------------
  942. void LLImagePreviewSculpted::zoom(F32 zoom_amt)
  943. {
  944. mCameraZoom = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
  945. }
  947. void LLImagePreviewSculpted::pan(F32 right, F32 up)
  948. {
  949. mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
  950. mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
  951. }