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

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

游戏引擎

开发平台：

C++ Builder

llvovolume.cpp：源码内容
  1. /** 
  2.  * @file llvovolume.cpp
  3.  * @brief LLVOVolume class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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. // A "volume" is a box, cylinder, sphere, or other primitive shape.
  35. #include "llviewerprecompiledheaders.h"
  37. #include "llvovolume.h"
  39. #include "llviewercontrol.h"
  40. #include "lldir.h"
  41. #include "llflexibleobject.h"
  42. #include "llmaterialtable.h"
  43. #include "llprimitive.h"
  44. #include "llvolume.h"
  45. #include "llvolumemgr.h"
  46. #include "llvolumemessage.h"
  47. #include "material_codes.h"
  48. #include "message.h"
  49. #include "llpluginclassmedia.h" // for code in the mediaEvent handler
  50. #include "object_flags.h"
  51. #include "llagentconstants.h"
  52. #include "lldrawable.h"
  53. #include "lldrawpoolbump.h"
  54. #include "llface.h"
  55. #include "llspatialpartition.h"
  56. #include "llhudmanager.h"
  57. #include "llflexibleobject.h"
  58. #include "llsky.h"
  59. #include "lltexturefetch.h"
  60. #include "llviewercamera.h"
  61. #include "llviewertexturelist.h"
  62. #include "llviewerregion.h"
  63. #include "llviewertextureanim.h"
  64. #include "llworld.h"
  65. #include "llselectmgr.h"
  66. #include "pipeline.h"
  67. #include "llsdutil.h"
  68. #include "llmediaentry.h"
  69. #include "llmediadataclient.h"
  70. #include "llagent.h"
  71. #include "llviewermediafocus.h"
  73. const S32 MIN_QUIET_FRAMES_COALESCE = 30;
  74. const F32 FORCE_SIMPLE_RENDER_AREA = 512.f;
  75. const F32 FORCE_CULL_AREA = 8.f;
  76. const F32 MAX_LOD_DISTANCE = 24.f;
  79. BOOL gAnimateTextures = TRUE;
  80. //extern BOOL gHideSelectedObjects;
  82. F32 LLVOVolume::sLODFactor = 1.f;
  83. F32 LLVOVolume::sLODSlopDistanceFactor = 0.5f; //Changing this to zero, effectively disables the LOD transition slop 
  84. F32 LLVOVolume::sDistanceFactor = 1.0f;
  85. S32 LLVOVolume::sNumLODChanges = 0;
  86. LLPointer<LLObjectMediaDataClient> LLVOVolume::sObjectMediaClient = NULL;
  87. LLPointer<LLObjectMediaNavigateClient> LLVOVolume::sObjectMediaNavigateClient = NULL;
  89. static LLFastTimer::DeclareTimer FTM_GEN_TRIANGLES("Generate Triangles");
  90. static LLFastTimer::DeclareTimer FTM_GEN_VOLUME("Generate Volumes");
  92. // Implementation class of LLMediaDataClientObject.  See llmediadataclient.h
  93. class LLMediaDataClientObjectImpl : public LLMediaDataClientObject
  94. {
  95. public:
  96. LLMediaDataClientObjectImpl(LLVOVolume *obj, bool isNew) : mObject(obj), mNew(isNew) {}
  97. LLMediaDataClientObjectImpl() { mObject = NULL; }
  99. virtual U8 getMediaDataCount() const 
  100. { return mObject->getNumTEs(); }
  102. virtual LLSD getMediaDataLLSD(U8 index) const 
  103. {
  104. LLSD result;
  105. LLTextureEntry *te = mObject->getTE(index); 
  106. if (NULL != te)
  107. {
  108. llassert((te->getMediaData() != NULL) == te->hasMedia());
  109. if (te->getMediaData() != NULL)
  110. {
  111. result = te->getMediaData()->asLLSD();
  112. // XXX HACK: workaround bug in asLLSD() where whitelist is not set properly
  113. // See DEV-41949
  114. if (!result.has(LLMediaEntry::WHITELIST_KEY))
  115. {
  116. result[LLMediaEntry::WHITELIST_KEY] = LLSD::emptyArray();
  117. }
  118. }
  119. }
  120. return result;
  121. }
  123. virtual LLUUID getID() const
  124. { return mObject->getID(); }
  126. virtual void mediaNavigateBounceBack(U8 index)
  127. { mObject->mediaNavigateBounceBack(index); }
  129. virtual bool hasMedia() const
  130. { return mObject->hasMedia(); }
  132. virtual void updateObjectMediaData(LLSD const &data, const std::string &version_string) 
  133. { mObject->updateObjectMediaData(data, version_string); }
  135. virtual F64 getMediaInterest() const 
  136. { 
  137. F64 interest = mObject->getTotalMediaInterest();
  138. if (interest < (F64)0.0)
  139. {
  140. // media interest not valid yet, try pixel area
  141. interest = mObject->getPixelArea();
  142. // HACK: force recalculation of pixel area if interest is the "magic default" of 1024.
  143. if (interest == 1024.f)
  144. {
  145. const_cast<LLVOVolume*>(static_cast<LLVOVolume*>(mObject))->setPixelAreaAndAngle(gAgent);
  146. interest = mObject->getPixelArea();
  147. }
  148. }
  149. return interest; 
  150. }
  152. virtual bool isInterestingEnough() const
  153. {
  154. return LLViewerMedia::isInterestingEnough(mObject, getMediaInterest());
  155. }
  157. virtual std::string getCapabilityUrl(const std::string &name) const
  158. { return mObject->getRegion()->getCapability(name); }
  160. virtual bool isDead() const
  161. { return mObject->isDead(); }
  163. virtual U32 getMediaVersion() const
  164. { return LLTextureEntry::getVersionFromMediaVersionString(mObject->getMediaURL()); }
  166. virtual bool isNew() const
  167. { return mNew; }
  169. private:
  170. LLPointer<LLVOVolume> mObject;
  171. bool mNew;
  172. };
  175. LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
  176. : LLViewerObject(id, pcode, regionp),
  177.   mVolumeImpl(NULL)
  178. {
  179. mTexAnimMode = 0;
  180. mRelativeXform.setIdentity();
  181. mRelativeXformInvTrans.setIdentity();
  183. mFaceMappingChanged = FALSE;
  184. mLOD = MIN_LOD;
  185. mTextureAnimp = NULL;
  186. mVolumeChanged = FALSE;
  187. mVObjRadius = LLVector3(1,1,0.5f).length();
  188. mNumFaces = 0;
  189. mLODChanged = FALSE;
  190. mSculptChanged = FALSE;
  191. mSpotLightPriority = 0.f;
  193. mMediaImplList.resize(getNumTEs());
  194. mLastFetchedMediaVersion = -1;
  195. mIndexInTex = 0;
  196. }
  198. LLVOVolume::~LLVOVolume()
  199. {
  200. delete mTextureAnimp;
  201. mTextureAnimp = NULL;
  202. delete mVolumeImpl;
  203. mVolumeImpl = NULL;
  205. if(!mMediaImplList.empty())
  206. {
  207. for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
  208. {
  209. if(mMediaImplList[i].notNull())
  210. {
  211. mMediaImplList[i]->removeObject(this) ;
  212. }
  213. }
  214. }
  215. }
  217. void LLVOVolume::markDead()
  218. {
  219. if (!mDead)
  220. {
  221. LLMediaDataClientObject::ptr_t obj = new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false);
  222. if (sObjectMediaClient) sObjectMediaClient->removeFromQueue(obj);
  223. if (sObjectMediaNavigateClient) sObjectMediaNavigateClient->removeFromQueue(obj);
  225. // Detach all media impls from this object
  226. for(U32 i = 0 ; i < mMediaImplList.size() ; i++)
  227. {
  228. removeMediaImpl(i);
  229. }
  231. if (mSculptTexture.notNull())
  232. {
  233. mSculptTexture->removeVolume(this);
  234. }
  235. }
  237. LLViewerObject::markDead();
  238. }
  241. // static
  242. void LLVOVolume::initClass()
  243. {
  244. // gSavedSettings better be around
  245. if (gSavedSettings.getBOOL("PrimMediaMasterEnabled"))
  246. {
  247. const F32 queue_timer_delay = gSavedSettings.getF32("PrimMediaRequestQueueDelay");
  248. const F32 retry_timer_delay = gSavedSettings.getF32("PrimMediaRetryTimerDelay");
  249. const U32 max_retries = gSavedSettings.getU32("PrimMediaMaxRetries");
  250. const U32 max_sorted_queue_size = gSavedSettings.getU32("PrimMediaMaxSortedQueueSize");
  251. const U32 max_round_robin_queue_size = gSavedSettings.getU32("PrimMediaMaxRoundRobinQueueSize");
  252. sObjectMediaClient = new LLObjectMediaDataClient(queue_timer_delay, retry_timer_delay, max_retries, 
  253.  max_sorted_queue_size, max_round_robin_queue_size);
  254. sObjectMediaNavigateClient = new LLObjectMediaNavigateClient(queue_timer_delay, retry_timer_delay, 
  255.  max_retries, max_sorted_queue_size, max_round_robin_queue_size);
  256. }
  257. }
  259. // static
  260. void LLVOVolume::cleanupClass()
  261. {
  262.     sObjectMediaClient = NULL;
  263.     sObjectMediaNavigateClient = NULL;
  264. }
  266. U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
  267.   void **user_data,
  268.   U32 block_num, EObjectUpdateType update_type,
  269.   LLDataPacker *dp)
  270. {
  271. LLColor4U color;
  272. const S32 teDirtyBits = (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR|TEM_CHANGE_MEDIA);
  274. // Do base class updates...
  275. U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
  277. LLUUID sculpt_id;
  278. U8 sculpt_type = 0;
  279. if (isSculpted())
  280. {
  281. LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  282. sculpt_id = sculpt_params->getSculptTexture();
  283. sculpt_type = sculpt_params->getSculptType();
  284. }
  286. if (!dp)
  287. {
  288. if (update_type == OUT_FULL)
  289. {
  290. ////////////////////////////////
  291. //
  292. // Unpack texture animation data
  293. //
  294. //
  296. if (mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureAnim))
  297. {
  298. if (!mTextureAnimp)
  299. {
  300. mTextureAnimp = new LLViewerTextureAnim();
  301. }
  302. else
  303. {
  304. if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
  305. {
  306. mTextureAnimp->reset();
  307. }
  308. }
  309. mTexAnimMode = 0;
  310. mTextureAnimp->unpackTAMessage(mesgsys, block_num);
  311. }
  312. else
  313. {
  314. if (mTextureAnimp)
  315. {
  316. delete mTextureAnimp;
  317. mTextureAnimp = NULL;
  318. gPipeline.markTextured(mDrawable);
  319. mFaceMappingChanged = TRUE;
  320. mTexAnimMode = 0;
  321. }
  322. }
  324. // Unpack volume data
  325. LLVolumeParams volume_params;
  326. LLVolumeMessage::unpackVolumeParams(&volume_params, mesgsys, _PREHASH_ObjectData, block_num);
  327. volume_params.setSculptID(sculpt_id, sculpt_type);
  329. if (setVolume(volume_params, 0))
  330. {
  331. markForUpdate(TRUE);
  332. }
  333. }
  335. // Sigh, this needs to be done AFTER the volume is set as well, otherwise bad stuff happens...
  336. ////////////////////////////
  337. //
  338. // Unpack texture entry data
  339. //
  340. S32 result = unpackTEMessage(mesgsys, _PREHASH_ObjectData, block_num);
  341. if (result & teDirtyBits)
  342. {
  343. updateTEData();
  344. }
  345. if (result & TEM_CHANGE_MEDIA)
  346. {
  347. retval |= MEDIA_FLAGS_CHANGED;
  348. }
  349. }
  350. else
  351. {
  352. // CORY TO DO: Figure out how to get the value here
  353. if (update_type != OUT_TERSE_IMPROVED)
  354. {
  355. LLVolumeParams volume_params;
  356. BOOL res = LLVolumeMessage::unpackVolumeParams(&volume_params, *dp);
  357. if (!res)
  358. {
  359. llwarns << "Bogus volume parameters in object " << getID() << llendl;
  360. llwarns << getRegion()->getOriginGlobal() << llendl;
  361. }
  363. volume_params.setSculptID(sculpt_id, sculpt_type);
  365. if (setVolume(volume_params, 0))
  366. {
  367. markForUpdate(TRUE);
  368. }
  369. S32 res2 = unpackTEMessage(*dp);
  370. if (TEM_INVALID == res2)
  371. {
  372. // Well, crap, there's something bogus in the data that we're unpacking.
  373. dp->dumpBufferToLog();
  374. llwarns << "Flushing cache files" << llendl;
  375. std::string mask;
  376. mask = gDirUtilp->getDirDelimiter() + "*.slc";
  377. gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,""), mask);
  378. //  llerrs << "Bogus TE data in " << getID() << ", crashing!" << llendl;
  379. llwarns << "Bogus TE data in " << getID() << llendl;
  380. }
  381. else 
  382. {
  383. if (res2 & teDirtyBits) 
  384. {
  385. updateTEData();
  386. }
  387. if (res2 & TEM_CHANGE_MEDIA)
  388. {
  389. retval |= MEDIA_FLAGS_CHANGED;
  390. }
  391. }
  393. U32 value = dp->getPassFlags();
  395. if (value & 0x40)
  396. {
  397. if (!mTextureAnimp)
  398. {
  399. mTextureAnimp = new LLViewerTextureAnim();
  400. }
  401. else
  402. {
  403. if (!(mTextureAnimp->mMode & LLTextureAnim::SMOOTH))
  404. {
  405. mTextureAnimp->reset();
  406. }
  407. }
  408. mTexAnimMode = 0;
  409. mTextureAnimp->unpackTAMessage(*dp);
  410. }
  411. else if (mTextureAnimp)
  412. {
  413. delete mTextureAnimp;
  414. mTextureAnimp = NULL;
  415. gPipeline.markTextured(mDrawable);
  416. mFaceMappingChanged = TRUE;
  417. mTexAnimMode = 0;
  418. }
  419. }
  420. else
  421. {
  422. S32 texture_length = mesgsys->getSizeFast(_PREHASH_ObjectData, block_num, _PREHASH_TextureEntry);
  423. if (texture_length)
  424. {
  425. U8 tdpbuffer[1024];
  426. LLDataPackerBinaryBuffer tdp(tdpbuffer, 1024);
  427. mesgsys->getBinaryDataFast(_PREHASH_ObjectData, _PREHASH_TextureEntry, tdpbuffer, 0, block_num);
  428. S32 result = unpackTEMessage(tdp);
  429. if (result & teDirtyBits)
  430. {
  431. updateTEData();
  432. }
  433. if (result & TEM_CHANGE_MEDIA)
  434. {
  435. retval |= MEDIA_FLAGS_CHANGED;
  436. }
  437. }
  438. }
  439. }
  440. if (retval & (MEDIA_URL_REMOVED | MEDIA_URL_ADDED | MEDIA_URL_UPDATED | MEDIA_FLAGS_CHANGED)) 
  441. {
  442. // If only the media URL changed, and it isn't a media version URL,
  443. // ignore it
  444. if ( ! ( retval & (MEDIA_URL_ADDED | MEDIA_URL_UPDATED) &&
  445.  mMedia && ! mMedia->mMediaURL.empty() &&
  446.  ! LLTextureEntry::isMediaVersionString(mMedia->mMediaURL) ) )
  447. {
  448. // If the media changed at all, request new media data
  449. LL_DEBUGS("MediaOnAPrim") << "Media update: " << getID() << ": retval=" << retval << " Media URL: " <<
  450.                 ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
  451. requestMediaDataUpdate(retval & MEDIA_FLAGS_CHANGED);
  452. }
  453.         else {
  454.             LL_INFOS("MediaOnAPrim") << "Ignoring media update for: " << getID() << " Media URL: " <<
  455.                 ((mMedia) ?  mMedia->mMediaURL : std::string("")) << LL_ENDL;
  456.         }
  457. }
  458. // ...and clean up any media impls
  459. cleanUpMediaImpls();
  461. return retval;
  462. }
  465. void LLVOVolume::animateTextures()
  466. {
  467. F32 off_s = 0.f, off_t = 0.f, scale_s = 1.f, scale_t = 1.f, rot = 0.f;
  468. S32 result = mTextureAnimp->animateTextures(off_s, off_t, scale_s, scale_t, rot);
  470. if (result)
  471. {
  472. if (!mTexAnimMode)
  473. {
  474. mFaceMappingChanged = TRUE;
  475. gPipeline.markTextured(mDrawable);
  476. }
  477. mTexAnimMode = result | mTextureAnimp->mMode;
  479. S32 start=0, end=mDrawable->getNumFaces()-1;
  480. if (mTextureAnimp->mFace >= 0 && mTextureAnimp->mFace <= end)
  481. {
  482. start = end = mTextureAnimp->mFace;
  483. }
  485. for (S32 i = start; i <= end; i++)
  486. {
  487. LLFace* facep = mDrawable->getFace(i);
  488. if(facep->getVirtualSize() <= MIN_TEX_ANIM_SIZE && facep->mTextureMatrix) continue;
  490. const LLTextureEntry* te = facep->getTextureEntry();
  492. if (!te)
  493. {
  494. continue;
  495. }
  497. if (!(result & LLViewerTextureAnim::ROTATE))
  498. {
  499. te->getRotation(&rot);
  500. }
  501. if (!(result & LLViewerTextureAnim::TRANSLATE))
  502. {
  503. te->getOffset(&off_s,&off_t);
  504. }
  505. if (!(result & LLViewerTextureAnim::SCALE))
  506. {
  507. te->getScale(&scale_s, &scale_t);
  508. }
  510. if (!facep->mTextureMatrix)
  511. {
  512. facep->mTextureMatrix = new LLMatrix4();
  513. }
  515. LLMatrix4& tex_mat = *facep->mTextureMatrix;
  516. tex_mat.setIdentity();
  517. LLVector3 trans ;
  519. if(facep->isAtlasInUse())
  520. {
  521. //
  522. //if use atlas for animated texture
  523. //apply the following transform to the animation matrix.
  524. //
  526. F32 tcoord_xoffset = 0.f ;
  527. F32 tcoord_yoffset = 0.f ;
  528. F32 tcoord_xscale = 1.f ;
  529. F32 tcoord_yscale = 1.f ;
  530. if(facep->isAtlasInUse())
  531. {
  532. const LLVector2* tmp = facep->getTexCoordOffset() ;
  533. tcoord_xoffset = tmp->mV[0] ; 
  534. tcoord_yoffset = tmp->mV[1] ;
  536. tmp = facep->getTexCoordScale() ;
  537. tcoord_xscale = tmp->mV[0] ; 
  538. tcoord_yscale = tmp->mV[1] ;
  539. }
  540. trans.set(LLVector3(tcoord_xoffset + tcoord_xscale * (off_s+0.5f), tcoord_yoffset + tcoord_yscale * (off_t+0.5f), 0.f));
  542. tex_mat.translate(LLVector3(-(tcoord_xoffset + tcoord_xscale * 0.5f), -(tcoord_yoffset + tcoord_yscale * 0.5f), 0.f));
  543. }
  544. else //non atlas
  545. {
  546. trans.set(LLVector3(off_s+0.5f, off_t+0.5f, 0.f));
  547. tex_mat.translate(LLVector3(-0.5f, -0.5f, 0.f));
  548. }
  550. LLVector3 scale(scale_s, scale_t, 1.f);
  551. LLQuaternion quat;
  552. quat.setQuat(rot, 0, 0, -1.f);
  554. tex_mat.rotate(quat);
  556. LLMatrix4 mat;
  557. mat.initAll(scale, LLQuaternion(), LLVector3());
  558. tex_mat *= mat;
  560. tex_mat.translate(trans);
  561. }
  562. }
  563. else
  564. {
  565. if (mTexAnimMode && mTextureAnimp->mRate == 0)
  566. {
  567. U8 start, count;
  569. if (mTextureAnimp->mFace == -1)
  570. {
  571. start = 0;
  572. count = getNumTEs();
  573. }
  574. else
  575. {
  576. start = (U8) mTextureAnimp->mFace;
  577. count = 1;
  578. }
  580. for (S32 i = start; i < start + count; i++)
  581. {
  582. if (mTexAnimMode & LLViewerTextureAnim::TRANSLATE)
  583. {
  584. setTEOffset(i, mTextureAnimp->mOffS, mTextureAnimp->mOffT);
  585. }
  586. if (mTexAnimMode & LLViewerTextureAnim::SCALE)
  587. {
  588. setTEScale(i, mTextureAnimp->mScaleS, mTextureAnimp->mScaleT);
  589. }
  590. if (mTexAnimMode & LLViewerTextureAnim::ROTATE)
  591. {
  592. setTERotation(i, mTextureAnimp->mRot);
  593. }
  594. }
  596. gPipeline.markTextured(mDrawable);
  597. mFaceMappingChanged = TRUE;
  598. mTexAnimMode = 0;
  599. }
  600. }
  601. }
  602. BOOL LLVOVolume::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  603. {
  604. LLViewerObject::idleUpdate(agent, world, time);
  606. if (mDead || mDrawable.isNull())
  607. {
  608. return TRUE;
  609. }
  611. ///////////////////////
  612. //
  613. // Do texture animation stuff
  614. //
  616. if (mTextureAnimp && gAnimateTextures)
  617. {
  618. animateTextures();
  619. }
  621. // Dispatch to implementation
  622. if (mVolumeImpl)
  623. {
  624. mVolumeImpl->doIdleUpdate(agent, world, time);
  625. }
  627. return TRUE;
  628. }
  630. void LLVOVolume::updateTextures()
  631. {
  632. const F32 TEXTURE_AREA_REFRESH_TIME = 5.f; // seconds
  633. if (mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
  634. {
  635. updateTextureVirtualSize();
  636. }
  637. }
  639. void LLVOVolume::updateTextureVirtualSize()
  640. {
  641. // Update the pixel area of all faces
  643. if(mDrawable.isNull() || !mDrawable->isVisible())
  644. {
  645. return ;
  646. }
  648. if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SIMPLE))
  649. {
  650. return;
  651. }
  653. static LLCachedControl<bool> dont_load_textures(gSavedSettings,"TextureDisable");
  655. if (dont_load_textures || LLAppViewer::getTextureFetch()->mDebugPause) // || !mDrawable->isVisible())
  656. {
  657. return;
  658. }
  660. mTextureUpdateTimer.reset();
  662. F32 old_area = mPixelArea;
  663. mPixelArea = 0.f;
  665. const S32 num_faces = mDrawable->getNumFaces();
  666. F32 min_vsize=999999999.f, max_vsize=0.f;
  667. LLViewerCamera* camera = LLViewerCamera::getInstance();
  668. for (S32 i = 0; i < num_faces; i++)
  669. {
  670. LLFace* face = mDrawable->getFace(i);
  671. const LLTextureEntry *te = face->getTextureEntry();
  672. LLViewerTexture *imagep = face->getTexture();
  673. if (!imagep || !te ||
  674. face->mExtents[0] == face->mExtents[1])
  675. {
  676. continue;
  677. }
  679. F32 vsize;
  680. F32 old_size = face->getVirtualSize();
  682. if (isHUDAttachment())
  683. {
  684. F32 area = (F32) camera->getScreenPixelArea();
  685. vsize = area;
  686. imagep->setBoostLevel(LLViewerTexture::BOOST_HUD);
  687.   face->setPixelArea(area); // treat as full screen
  688. face->setVirtualSize(vsize);
  689. }
  690. else
  691. {
  692. vsize = face->getTextureVirtualSize();
  693. }
  695. mPixelArea = llmax(mPixelArea, face->getPixelArea());
  697. if (face->mTextureMatrix != NULL)
  698. {
  699. if ((vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE) ||
  700. (vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE))
  701. {
  702. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, FALSE);
  703. }
  704. }
  706. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
  707. {
  708. if (vsize < min_vsize) min_vsize = vsize;
  709. if (vsize > max_vsize) max_vsize = vsize;
  710. }
  711. else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
  712. {
  713. LLViewerFetchedTexture* img = LLViewerTextureManager::staticCastToFetchedTexture(imagep) ;
  714. if(img)
  715. {
  716. F32 pri = img->getDecodePriority();
  717. pri = llmax(pri, 0.0f);
  718. if (pri < min_vsize) min_vsize = pri;
  719. if (pri > max_vsize) max_vsize = pri;
  720. }
  721. }
  722. else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
  723. {
  724. F32 pri = mPixelArea;
  725. if (pri < min_vsize) min_vsize = pri;
  726. if (pri > max_vsize) max_vsize = pri;
  727. }
  728. }
  730. if (isSculpted())
  731. {
  732. LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  733. LLUUID id =  sculpt_params->getSculptTexture(); 
  735. updateSculptTexture();
  737. if (mSculptTexture.notNull())
  738. {
  739. mSculptTexture->setBoostLevel(llmax((S32)mSculptTexture->getBoostLevel(),
  740. (S32)LLViewerTexture::BOOST_SCULPTED));
  741. mSculptTexture->setForSculpt() ;
  743. if(!mSculptTexture->isCachedRawImageReady())
  744. {
  745. S32 lod = llmin(mLOD, 3);
  746. F32 lodf = ((F32)(lod + 1.0f)/4.f);
  747. F32 tex_size = lodf * LLViewerTexture::sMaxSculptRez ;
  748. mSculptTexture->addTextureStats(2.f * tex_size * tex_size, FALSE);
  750. //if the sculpty very close to the view point, load first
  751. {
  752. LLVector3 lookAt = getPositionAgent() - camera->getOrigin();
  753. F32 dist = lookAt.normVec() ;
  754. F32 cos_angle_to_view_dir = lookAt * camera->getXAxis() ;
  755. mSculptTexture->setAdditionalDecodePriority(0.8f * LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist)) ;
  756. }
  757. }
  759. S32 texture_discard = mSculptTexture->getDiscardLevel(); //try to match the texture
  760. S32 current_discard = getVolume() ? getVolume()->getSculptLevel() : -2 ;
  762. if (texture_discard >= 0 && //texture has some data available
  763. (texture_discard < current_discard || //texture has more data than last rebuild
  764. current_discard < 0)) //no previous rebuild
  765. {
  766. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
  767. mSculptChanged = TRUE;
  768. }
  770. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
  771. {
  772. setDebugText(llformat("T%d C%d V%dn%dx%d",
  773.   texture_discard, current_discard, getVolume()->getSculptLevel(),
  774.   mSculptTexture->getHeight(), mSculptTexture->getWidth()));
  775. }
  776. }
  777. }
  779. if (getLightTextureID().notNull())
  780. {
  781. LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
  782. LLUUID id = params->getLightTexture();
  783. mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
  784. if (mLightTexture.notNull())
  785. {
  786. F32 rad = getLightRadius();
  787. mLightTexture->addTextureStats(gPipeline.calcPixelArea(getPositionAgent(), 
  788. LLVector3(rad,rad,rad),
  789. *camera));
  790. }
  791. }
  793. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
  794. {
  795. setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
  796. }
  797.   else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
  798.   {
  799.   setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
  800.   }
  801. else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
  802. {
  803. setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
  804. }
  806. if (mPixelArea == 0)
  807. { //flexi phasing issues make this happen
  808. mPixelArea = old_area;
  809. }
  810. }
  812. BOOL LLVOVolume::isActive() const
  813. {
  814. return !mStatic || mTextureAnimp || (mVolumeImpl && mVolumeImpl->isActive());
  815. }
  817. BOOL LLVOVolume::setMaterial(const U8 material)
  818. {
  819. BOOL res = LLViewerObject::setMaterial(material);
  821. return res;
  822. }
  824. void LLVOVolume::setTexture(const S32 face)
  825. {
  826. llassert(face < getNumTEs());
  827. gGL.getTexUnit(0)->bind(getTEImage(face));
  828. }
  830. void LLVOVolume::setScale(const LLVector3 &scale, BOOL damped)
  831. {
  832. if (scale != getScale())
  833. {
  834. // store local radius
  835. LLViewerObject::setScale(scale);
  837. if (mVolumeImpl)
  838. {
  839. mVolumeImpl->onSetScale(scale, damped);
  840. }
  842. updateRadius();
  844. //since drawable transforms do not include scale, changing volume scale
  845. //requires an immediate rebuild of volume verts.
  846. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION, TRUE);
  847. }
  848. }
  850. LLFace* LLVOVolume::addFace(S32 f)
  851. {
  852. const LLTextureEntry* te = getTE(f);
  853. LLViewerTexture* imagep = getTEImage(f);
  854. return mDrawable->addFace(te, imagep);
  855. }
  857. LLDrawable *LLVOVolume::createDrawable(LLPipeline *pipeline)
  858. {
  859. pipeline->allocDrawable(this);
  861. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_VOLUME);
  863. S32 max_tes_to_set = getNumTEs();
  864. for (S32 i = 0; i < max_tes_to_set; i++)
  865. {
  866. addFace(i);
  867. }
  868. mNumFaces = max_tes_to_set;
  870. if (isAttachment())
  871. {
  872. mDrawable->makeActive();
  873. }
  875. if (getIsLight())
  876. {
  877. // Add it to the pipeline mLightSet
  878. gPipeline.setLight(mDrawable, TRUE);
  879. }
  881. updateRadius();
  882. bool force_update = true; // avoid non-alpha mDistance update being optimized away
  883. mDrawable->updateDistance(*LLViewerCamera::getInstance(), force_update);
  885. return mDrawable;
  886. }
  888. BOOL LLVOVolume::setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume)
  889. {
  890. // Check if we need to change implementations
  891. bool is_flexible = (volume_params.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE);
  892. if (is_flexible)
  893. {
  894. setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, false);
  895. if (!mVolumeImpl)
  896. {
  897. LLFlexibleObjectData* data = (LLFlexibleObjectData*)getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
  898. mVolumeImpl = new LLVolumeImplFlexible(this, data);
  899. }
  900. }
  901. else
  902. {
  903. // Mark the parameter not in use
  904. setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, false);
  905. if (mVolumeImpl)
  906. {
  907. delete mVolumeImpl;
  908. mVolumeImpl = NULL;
  909. if (mDrawable.notNull())
  910. {
  911. // Undo the damage we did to this matrix
  912. mDrawable->updateXform(FALSE);
  913. }
  914. }
  915. }
  917. if ((LLPrimitive::setVolume(volume_params, mLOD, (mVolumeImpl && mVolumeImpl->isVolumeUnique()))) || mSculptChanged)
  918. {
  919. mFaceMappingChanged = TRUE;
  921. if (mVolumeImpl)
  922. {
  923. mVolumeImpl->onSetVolume(volume_params, detail);
  924. }
  926. updateSculptTexture();
  928. if (isSculpted())
  929. {
  930. updateSculptTexture();
  932. if (mSculptTexture.notNull())
  933. {
  934. sculpt();
  935. }
  936. }
  938. return TRUE;
  939. }
  940. return FALSE;
  941. }
  943. void LLVOVolume::updateSculptTexture()
  944. {
  945. LLPointer<LLViewerFetchedTexture> old_sculpt = mSculptTexture;
  947. if (isSculpted())
  948. {
  949. LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  950. LLUUID id =  sculpt_params->getSculptTexture(); 
  951. mSculptTexture = LLViewerTextureManager::getFetchedTexture(id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  952. }
  953. else
  954. {
  955. mSculptTexture = NULL;
  956. }
  958. if (mSculptTexture != old_sculpt)
  959. {
  960. if (old_sculpt.notNull())
  961. {
  962. old_sculpt->removeVolume(this);
  963. }
  964. if (mSculptTexture.notNull())
  965. {
  966. mSculptTexture->addVolume(this);
  967. }
  968. }
  970. }
  972. // sculpt replaces generate() for sculpted surfaces
  973. void LLVOVolume::sculpt()
  974. {
  975. if (mSculptTexture.notNull())
  976. {
  977. U16 sculpt_height = 0;
  978. U16 sculpt_width = 0;
  979. S8 sculpt_components = 0;
  980. const U8* sculpt_data = NULL;
  982. S32 discard_level = mSculptTexture->getDiscardLevel() ;
  983. LLImageRaw* raw_image = mSculptTexture->getCachedRawImage() ;
  985. S32 max_discard = mSculptTexture->getMaxDiscardLevel();
  986. if (discard_level > max_discard)
  987. discard_level = max_discard;    // clamp to the best we can do
  989. S32 current_discard = getVolume()->getSculptLevel() ;
  990. if(current_discard < -2)
  991. {
  992. llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
  993. << " is less than -2." << llendl;
  995. // corrupted volume... don't update the sculpty
  996. return;
  997. }
  998. else if (current_discard > MAX_DISCARD_LEVEL)
  999. {
  1000. llwarns << "WARNING!!: Current discard of sculpty at " << current_discard 
  1001. << " is more than than allowed max of " << MAX_DISCARD_LEVEL << llendl;
  1003. // corrupted volume... don't update the sculpty
  1004. return;
  1005. }
  1007. if (current_discard == discard_level)  // no work to do here
  1008. return;
  1010. if(!raw_image)
  1011. {
  1012. sculpt_width = 0;
  1013. sculpt_height = 0;
  1014. sculpt_data = NULL ;
  1016. if(LLViewerTextureManager::sTesterp)
  1017. {
  1018. LLViewerTextureManager::sTesterp->updateGrayTextureBinding();
  1019. }
  1020. }
  1021. else
  1022. {
  1023. sculpt_height = raw_image->getHeight();
  1024. sculpt_width = raw_image->getWidth();
  1025. sculpt_components = raw_image->getComponents();
  1026.    
  1027. sculpt_data = raw_image->getData();
  1029. if(LLViewerTextureManager::sTesterp)
  1030. {
  1031. mSculptTexture->updateBindStatsForTester() ;
  1032. }
  1033. }
  1034. getVolume()->sculpt(sculpt_width, sculpt_height, sculpt_components, sculpt_data, discard_level);
  1036. //notify rebuild any other VOVolumes that reference this sculpty volume
  1037. for (S32 i = 0; i < mSculptTexture->getNumVolumes(); ++i)
  1038. {
  1039. LLVOVolume* volume = (*(mSculptTexture->getVolumeList()))[i];
  1040. if (volume != this && volume->getVolume() == getVolume())
  1041. {
  1042. gPipeline.markRebuild(volume->mDrawable, LLDrawable::REBUILD_GEOMETRY, FALSE);
  1043. volume->mSculptChanged = TRUE;
  1044. }
  1045. }
  1046. }
  1047. }
  1049. S32 LLVOVolume::computeLODDetail(F32 distance, F32 radius)
  1050. {
  1051. S32 cur_detail;
  1052. if (LLPipeline::sDynamicLOD)
  1053. {
  1054. // We've got LOD in the profile, and in the twist.  Use radius.
  1055. F32 tan_angle = (LLVOVolume::sLODFactor*radius)/distance;
  1056. cur_detail = LLVolumeLODGroup::getDetailFromTan(llround(tan_angle, 0.01f));
  1057. }
  1058. else
  1059. {
  1060. cur_detail = llclamp((S32) (sqrtf(radius)*LLVOVolume::sLODFactor*4.f), 0, 3);
  1061. }
  1062. return cur_detail;
  1063. }
  1065. BOOL LLVOVolume::calcLOD()
  1066. {
  1067. if (mDrawable.isNull())
  1068. {
  1069. return FALSE;
  1070. }
  1072. S32 cur_detail = 0;
  1074. F32 radius = getVolume()->mLODScaleBias.scaledVec(getScale()).length();
  1075. F32 distance = llmin(mDrawable->mDistanceWRTCamera, MAX_LOD_DISTANCE);
  1076. distance *= sDistanceFactor;
  1078. F32 rampDist = LLVOVolume::sLODFactor * 2;
  1080. if (distance < rampDist)
  1081. {
  1082. // Boost LOD when you're REALLY close
  1083. distance *= 1.0f/rampDist;
  1084. distance *= distance;
  1085. distance *= rampDist;
  1086. }
  1088. // DON'T Compensate for field of view changing on FOV zoom.
  1089. distance *= F_PI/3.f;
  1091. cur_detail = computeLODDetail(llround(distance, 0.01f), 
  1092. llround(radius, 0.01f));
  1094. if (cur_detail != mLOD)
  1095. {
  1096. mAppAngle = llround((F32) atan2( mDrawable->getRadius(), mDrawable->mDistanceWRTCamera) * RAD_TO_DEG, 0.01f);
  1097. mLOD = cur_detail;
  1098. return TRUE;
  1099. }
  1100. else
  1101. {
  1102. return FALSE;
  1103. }
  1104. }
  1106. BOOL LLVOVolume::updateLOD()
  1107. {
  1108. if (mDrawable.isNull())
  1109. {
  1110. return FALSE;
  1111. }
  1113. BOOL lod_changed = calcLOD();
  1115. if (lod_changed)
  1116. {
  1117. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
  1118. mLODChanged = TRUE;
  1119. }
  1121. lod_changed |= LLViewerObject::updateLOD();
  1123. return lod_changed;
  1124. }
  1126. BOOL LLVOVolume::setDrawableParent(LLDrawable* parentp)
  1127. {
  1128. if (!LLViewerObject::setDrawableParent(parentp))
  1129. {
  1130. // no change in drawable parent
  1131. return FALSE;
  1132. }
  1134. if (!mDrawable->isRoot())
  1135. {
  1136. // rebuild vertices in parent relative space
  1137. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  1139. if (mDrawable->isActive() && !parentp->isActive())
  1140. {
  1141. parentp->makeActive();
  1142. }
  1143. else if (mDrawable->isStatic() && parentp->isActive())
  1144. {
  1145. mDrawable->makeActive();
  1146. }
  1147. }
  1149. return TRUE;
  1150. }
  1152. void LLVOVolume::updateFaceFlags()
  1153. {
  1154. for (S32 i = 0; i < getVolume()->getNumFaces(); i++)
  1155. {
  1156. LLFace *face = mDrawable->getFace(i);
  1157. BOOL fullbright = getTE(i)->getFullbright();
  1158. face->clearState(LLFace::FULLBRIGHT | LLFace::HUD_RENDER | LLFace::LIGHT);
  1160. if (fullbright || (mMaterial == LL_MCODE_LIGHT))
  1161. {
  1162. face->setState(LLFace::FULLBRIGHT);
  1163. }
  1164. if (mDrawable->isLight())
  1165. {
  1166. face->setState(LLFace::LIGHT);
  1167. }
  1168. if (isHUDAttachment())
  1169. {
  1170. face->setState(LLFace::HUD_RENDER);
  1171. }
  1172. }
  1173. }
  1175. BOOL LLVOVolume::setParent(LLViewerObject* parent)
  1176. {
  1177. BOOL ret = FALSE ;
  1178. if (parent != getParent())
  1179. {
  1180. ret = LLViewerObject::setParent(parent);
  1181. if (ret && mDrawable)
  1182. {
  1183. gPipeline.markMoved(mDrawable);
  1184. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  1185. }
  1186. }
  1188. return ret ;
  1189. }
  1191. // NOTE: regenFaces() MUST be followed by genTriangles()!
  1192. void LLVOVolume::regenFaces()
  1193. {
  1194. // remove existing faces
  1195. BOOL count_changed = mNumFaces != getNumTEs();
  1197. if (count_changed)
  1198. {
  1199. deleteFaces();
  1200. // add new faces
  1201. mNumFaces = getNumTEs();
  1202. }
  1204. for (S32 i = 0; i < mNumFaces; i++)
  1205. {
  1206. LLFace* facep = count_changed ? addFace(i) : mDrawable->getFace(i);
  1207. facep->setTEOffset(i);
  1208. facep->setTexture(getTEImage(i));
  1209. facep->setViewerObject(this);
  1211. // If the face had media on it, this will have broken the link between the LLViewerMediaTexture and the face.
  1212. // Re-establish the link.
  1213. if((int)mMediaImplList.size() > i)
  1214. {
  1215. if(mMediaImplList[i])
  1216. {
  1217. LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[i]->getMediaTextureID()) ;
  1218. if(media_tex)
  1219. {
  1220. media_tex->addMediaToFace(facep) ;
  1221. }
  1222. }
  1223. }
  1224. }
  1226. if (!count_changed)
  1227. {
  1228. updateFaceFlags();
  1229. }
  1230. }
  1232. BOOL LLVOVolume::genBBoxes(BOOL force_global)
  1233. {
  1234. BOOL res = TRUE;
  1236. LLVector3 min,max;
  1238. BOOL rebuild = mDrawable->isState(LLDrawable::REBUILD_VOLUME | LLDrawable::REBUILD_POSITION);
  1240. for (S32 i = 0; i < getVolume()->getNumFaces(); i++)
  1241. {
  1242. LLFace *face = mDrawable->getFace(i);
  1243. res &= face->genVolumeBBoxes(*getVolume(), i,
  1244. mRelativeXform, mRelativeXformInvTrans,
  1245. (mVolumeImpl && mVolumeImpl->isVolumeGlobal()) || force_global);
  1247. if (rebuild)
  1248. {
  1249. if (i == 0)
  1250. {
  1251. min = face->mExtents[0];
  1252. max = face->mExtents[1];
  1253. }
  1254. else
  1255. {
  1256. for (U32 i = 0; i < 3; i++)
  1257. {
  1258. if (face->mExtents[0].mV[i] < min.mV[i])
  1259. {
  1260. min.mV[i] = face->mExtents[0].mV[i];
  1261. }
  1262. if (face->mExtents[1].mV[i] > max.mV[i])
  1263. {
  1264. max.mV[i] = face->mExtents[1].mV[i];
  1265. }
  1266. }
  1267. }
  1268. }
  1269. }
  1271. if (rebuild)
  1272. {
  1273. mDrawable->setSpatialExtents(min,max);
  1274. mDrawable->setPositionGroup((min+max)*0.5f);
  1275. }
  1277. updateRadius();
  1278. mDrawable->movePartition();
  1280. return res;
  1281. }
  1283. void LLVOVolume::preRebuild()
  1284. {
  1285. if (mVolumeImpl != NULL)
  1286. {
  1287. mVolumeImpl->preRebuild();
  1288. }
  1289. }
  1291. void LLVOVolume::updateRelativeXform()
  1292. {
  1293. if (mVolumeImpl)
  1294. {
  1295. mVolumeImpl->updateRelativeXform();
  1296. return;
  1297. }
  1299. LLDrawable* drawable = mDrawable;
  1301. if (drawable->isActive())
  1302. {
  1303. // setup relative transforms
  1304. LLQuaternion delta_rot;
  1305. LLVector3 delta_pos, delta_scale;
  1307. //matrix from local space to parent relative/global space
  1308. delta_rot = drawable->isSpatialRoot() ? LLQuaternion() : mDrawable->getRotation();
  1309. delta_pos = drawable->isSpatialRoot() ? LLVector3(0,0,0) : mDrawable->getPosition();
  1310. delta_scale = mDrawable->getScale();
  1312. // Vertex transform (4x4)
  1313. LLVector3 x_axis = LLVector3(delta_scale.mV[VX], 0.f, 0.f) * delta_rot;
  1314. LLVector3 y_axis = LLVector3(0.f, delta_scale.mV[VY], 0.f) * delta_rot;
  1315. LLVector3 z_axis = LLVector3(0.f, 0.f, delta_scale.mV[VZ]) * delta_rot;
  1317. mRelativeXform.initRows(LLVector4(x_axis, 0.f),
  1318. LLVector4(y_axis, 0.f),
  1319. LLVector4(z_axis, 0.f),
  1320. LLVector4(delta_pos, 1.f));
  1323. // compute inverse transpose for normals
  1324. // mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
  1325. // mRelativeXformInvTrans.invert(); 
  1326. // mRelativeXformInvTrans.setRows(x_axis, y_axis, z_axis);
  1327. // grumble - invert is NOT a matrix invert, so we do it by hand:
  1329. LLMatrix3 rot_inverse = LLMatrix3(~delta_rot);
  1331. LLMatrix3 scale_inverse;
  1332. scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / delta_scale.mV[VX],
  1333.   LLVector3(0.0, 1.0, 0.0) / delta_scale.mV[VY],
  1334.   LLVector3(0.0, 0.0, 1.0) / delta_scale.mV[VZ]);
  1335.    
  1337. mRelativeXformInvTrans = rot_inverse * scale_inverse;
  1339. mRelativeXformInvTrans.transpose();
  1340. }
  1341. else
  1342. {
  1343. LLVector3 pos = getPosition();
  1344. LLVector3 scale = getScale();
  1345. LLQuaternion rot = getRotation();
  1347. if (mParent)
  1348. {
  1349. pos *= mParent->getRotation();
  1350. pos += mParent->getPosition();
  1351. rot *= mParent->getRotation();
  1352. }
  1354. //LLViewerRegion* region = getRegion();
  1355. //pos += region->getOriginAgent();
  1357. LLVector3 x_axis = LLVector3(scale.mV[VX], 0.f, 0.f) * rot;
  1358. LLVector3 y_axis = LLVector3(0.f, scale.mV[VY], 0.f) * rot;
  1359. LLVector3 z_axis = LLVector3(0.f, 0.f, scale.mV[VZ]) * rot;
  1361. mRelativeXform.initRows(LLVector4(x_axis, 0.f),
  1362. LLVector4(y_axis, 0.f),
  1363. LLVector4(z_axis, 0.f),
  1364. LLVector4(pos, 1.f));
  1366. // compute inverse transpose for normals
  1367. LLMatrix3 rot_inverse = LLMatrix3(~rot);
  1369. LLMatrix3 scale_inverse;
  1370. scale_inverse.setRows(LLVector3(1.0, 0.0, 0.0) / scale.mV[VX],
  1371.   LLVector3(0.0, 1.0, 0.0) / scale.mV[VY],
  1372.   LLVector3(0.0, 0.0, 1.0) / scale.mV[VZ]);
  1373.    
  1375. mRelativeXformInvTrans = rot_inverse * scale_inverse;
  1377. mRelativeXformInvTrans.transpose();
  1378. }
  1379. }
  1381. static LLFastTimer::DeclareTimer FTM_GEN_FLEX("Generate Flexies");
  1382. static LLFastTimer::DeclareTimer FTM_UPDATE_PRIMITIVES("Update Primitives");
  1384. BOOL LLVOVolume::updateGeometry(LLDrawable *drawable)
  1385. {
  1386. LLFastTimer t(FTM_UPDATE_PRIMITIVES);
  1388. if (mVolumeImpl != NULL)
  1389. {
  1390. BOOL res;
  1391. {
  1392. LLFastTimer t(FTM_GEN_FLEX);
  1393. res = mVolumeImpl->doUpdateGeometry(drawable);
  1394. }
  1395. updateFaceFlags();
  1396. return res;
  1397. }
  1399. dirtySpatialGroup();
  1401. BOOL compiled = FALSE;
  1403. updateRelativeXform();
  1405. if (mDrawable.isNull()) // Not sure why this is happening, but it is...
  1406. {
  1407. return TRUE; // No update to complete
  1408. }
  1410. if (mVolumeChanged || mFaceMappingChanged )
  1411. {
  1412. compiled = TRUE;
  1414. if (mVolumeChanged)
  1415. {
  1416. LLFastTimer ftm(FTM_GEN_VOLUME);
  1417. LLVolumeParams volume_params = getVolume()->getParams();
  1418. setVolume(volume_params, 0);
  1419. drawable->setState(LLDrawable::REBUILD_VOLUME);
  1420. }
  1422. {
  1423. LLFastTimer t(FTM_GEN_TRIANGLES);
  1424. regenFaces();
  1425. genBBoxes(FALSE);
  1426. }
  1427. }
  1428. else if ((mLODChanged) || (mSculptChanged))
  1429. {
  1430. LLVolume *old_volumep, *new_volumep;
  1431. F32 old_lod, new_lod;
  1432. S32 old_num_faces, new_num_faces ;
  1434. old_volumep = getVolume();
  1435. old_lod = old_volumep->getDetail();
  1436. old_num_faces = old_volumep->getNumFaces() ;
  1437. old_volumep = NULL ;
  1439. {
  1440. LLFastTimer ftm(FTM_GEN_VOLUME);
  1441. LLVolumeParams volume_params = getVolume()->getParams();
  1442. setVolume(volume_params, 0);
  1443. }
  1445. new_volumep = getVolume();
  1446. new_lod = new_volumep->getDetail();
  1447. new_num_faces = new_volumep->getNumFaces() ;
  1448. new_volumep = NULL ;
  1450. if ((new_lod != old_lod) || mSculptChanged)
  1451. {
  1452. compiled = TRUE;
  1453. sNumLODChanges += new_num_faces ;
  1455. drawable->setState(LLDrawable::REBUILD_VOLUME); // for face->genVolumeTriangles()
  1457. {
  1458. LLFastTimer t(FTM_GEN_TRIANGLES);
  1459. if (new_num_faces != old_num_faces)
  1460. {
  1461. regenFaces();
  1462. }
  1463. genBBoxes(FALSE);
  1464. }
  1465. }
  1466. }
  1467. // it has its own drawable (it's moved) or it has changed UVs or it has changed xforms from global<->local
  1468. else
  1469. {
  1470. compiled = TRUE;
  1471. // All it did was move or we changed the texture coordinate offset
  1472. LLFastTimer t(FTM_GEN_TRIANGLES);
  1473. genBBoxes(FALSE);
  1474. }
  1476. // Update face flags
  1477. updateFaceFlags();
  1479. if(compiled)
  1480. {
  1481. LLPipeline::sCompiles++;
  1482. }
  1484. mVolumeChanged = FALSE;
  1485. mLODChanged = FALSE;
  1486. mSculptChanged = FALSE;
  1487. mFaceMappingChanged = FALSE;
  1489. return LLViewerObject::updateGeometry(drawable);
  1490. }
  1492. void LLVOVolume::updateFaceSize(S32 idx)
  1493. {
  1494. LLFace* facep = mDrawable->getFace(idx);
  1495. if (idx >= getVolume()->getNumVolumeFaces())
  1496. {
  1497. facep->setSize(0,0);
  1498. }
  1499. else
  1500. {
  1501. const LLVolumeFace& vol_face = getVolume()->getVolumeFace(idx);
  1502. facep->setSize(vol_face.mVertices.size(), vol_face.mIndices.size());
  1503. }
  1504. }
  1506. BOOL LLVOVolume::isRootEdit() const
  1507. {
  1508. if (mParent && !((LLViewerObject*)mParent)->isAvatar())
  1509. {
  1510. return FALSE;
  1511. }
  1512. return TRUE;
  1513. }
  1515. //virtual
  1516. void LLVOVolume::setNumTEs(const U8 num_tes)
  1517. {
  1518. const U8 old_num_tes = getNumTEs() ;
  1520. if(old_num_tes && old_num_tes < num_tes) //new faces added
  1521. {
  1522. LLViewerObject::setNumTEs(num_tes) ;
  1524. if(mMediaImplList.size() >= old_num_tes && mMediaImplList[old_num_tes -1].notNull())//duplicate the last media textures if exists.
  1525. {
  1526. mMediaImplList.resize(num_tes) ;
  1527. const LLTextureEntry* te = getTE(old_num_tes - 1) ;
  1528. for(U8 i = old_num_tes; i < num_tes ; i++)
  1529. {
  1530. setTE(i, *te) ;
  1531. mMediaImplList[i] = mMediaImplList[old_num_tes -1] ;
  1532. }
  1533. mMediaImplList[old_num_tes -1]->setUpdated(TRUE) ;
  1534. }
  1535. }
  1536. else if(old_num_tes > num_tes && mMediaImplList.size() > num_tes) //old faces removed
  1537. {
  1538. U8 end = mMediaImplList.size() ;
  1539. for(U8 i = num_tes; i < end ; i++)
  1540. {
  1541. removeMediaImpl(i) ;
  1542. }
  1543. mMediaImplList.resize(num_tes) ;
  1545. LLViewerObject::setNumTEs(num_tes) ;
  1546. }
  1547. else
  1548. {
  1549. LLViewerObject::setNumTEs(num_tes) ;
  1550. }
  1552. return ;
  1553. }
  1555. void LLVOVolume::setTEImage(const U8 te, LLViewerTexture *imagep)
  1556. {
  1557. BOOL changed = (mTEImages[te] != imagep);
  1558. LLViewerObject::setTEImage(te, imagep);
  1559. if (changed)
  1560. {
  1561. gPipeline.markTextured(mDrawable);
  1562. mFaceMappingChanged = TRUE;
  1563. }
  1564. }
  1566. S32 LLVOVolume::setTETexture(const U8 te, const LLUUID &uuid)
  1567. {
  1568. S32 res = LLViewerObject::setTETexture(te, uuid);
  1569. if (res)
  1570. {
  1571. gPipeline.markTextured(mDrawable);
  1572. mFaceMappingChanged = TRUE;
  1573. }
  1574. return res;
  1575. }
  1577. S32 LLVOVolume::setTEColor(const U8 te, const LLColor3& color)
  1578. {
  1579. return setTEColor(te, LLColor4(color));
  1580. }
  1582. S32 LLVOVolume::setTEColor(const U8 te, const LLColor4& color)
  1583. {
  1584. S32 retval = 0;
  1585. const LLTextureEntry *tep = getTE(te);
  1586. if (!tep)
  1587. {
  1588. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1589. }
  1590. else if (color != tep->getColor())
  1591. {
  1592. if (color.mV[3] != tep->getColor().mV[3])
  1593. {
  1594. gPipeline.markTextured(mDrawable);
  1595. }
  1596. retval = LLPrimitive::setTEColor(te, color);
  1597. if (mDrawable.notNull() && retval)
  1598. {
  1599. // These should only happen on updates which are not the initial update.
  1600. mDrawable->setState(LLDrawable::REBUILD_COLOR);
  1601. dirtyMesh();
  1602. }
  1603. }
  1605. return  retval;
  1606. }
  1608. S32 LLVOVolume::setTEBumpmap(const U8 te, const U8 bumpmap)
  1609. {
  1610. S32 res = LLViewerObject::setTEBumpmap(te, bumpmap);
  1611. if (res)
  1612. {
  1613. gPipeline.markTextured(mDrawable);
  1614. mFaceMappingChanged = TRUE;
  1615. }
  1616. return  res;
  1617. }
  1619. S32 LLVOVolume::setTETexGen(const U8 te, const U8 texgen)
  1620. {
  1621. S32 res = LLViewerObject::setTETexGen(te, texgen);
  1622. if (res)
  1623. {
  1624. gPipeline.markTextured(mDrawable);
  1625. mFaceMappingChanged = TRUE;
  1626. }
  1627. return  res;
  1628. }
  1630. S32 LLVOVolume::setTEMediaTexGen(const U8 te, const U8 media)
  1631. {
  1632. S32 res = LLViewerObject::setTEMediaTexGen(te, media);
  1633. if (res)
  1634. {
  1635. gPipeline.markTextured(mDrawable);
  1636. mFaceMappingChanged = TRUE;
  1637. }
  1638. return  res;
  1639. }
  1641. S32 LLVOVolume::setTEShiny(const U8 te, const U8 shiny)
  1642. {
  1643. S32 res = LLViewerObject::setTEShiny(te, shiny);
  1644. if (res)
  1645. {
  1646. gPipeline.markTextured(mDrawable);
  1647. mFaceMappingChanged = TRUE;
  1648. }
  1649. return  res;
  1650. }
  1652. S32 LLVOVolume::setTEFullbright(const U8 te, const U8 fullbright)
  1653. {
  1654. S32 res = LLViewerObject::setTEFullbright(te, fullbright);
  1655. if (res)
  1656. {
  1657. gPipeline.markTextured(mDrawable);
  1658. mFaceMappingChanged = TRUE;
  1659. }
  1660. return  res;
  1661. }
  1663. S32 LLVOVolume::setTEBumpShinyFullbright(const U8 te, const U8 bump)
  1664. {
  1665. S32 res = LLViewerObject::setTEBumpShinyFullbright(te, bump);
  1666. if (res)
  1667. {
  1668. gPipeline.markTextured(mDrawable);
  1669. mFaceMappingChanged = TRUE;
  1670. }
  1671. return res;
  1672. }
  1674. S32 LLVOVolume::setTEMediaFlags(const U8 te, const U8 media_flags)
  1675. {
  1676. S32 res = LLViewerObject::setTEMediaFlags(te, media_flags);
  1677. if (res)
  1678. {
  1679. gPipeline.markTextured(mDrawable);
  1680. mFaceMappingChanged = TRUE;
  1681. }
  1682. return  res;
  1683. }
  1685. S32 LLVOVolume::setTEGlow(const U8 te, const F32 glow)
  1686. {
  1687. S32 res = LLViewerObject::setTEGlow(te, glow);
  1688. if (res)
  1689. {
  1690. gPipeline.markTextured(mDrawable);
  1691. mFaceMappingChanged = TRUE;
  1692. }
  1693. return  res;
  1694. }
  1696. S32 LLVOVolume::setTEScale(const U8 te, const F32 s, const F32 t)
  1697. {
  1698. S32 res = LLViewerObject::setTEScale(te, s, t);
  1699. if (res)
  1700. {
  1701. gPipeline.markTextured(mDrawable);
  1702. mFaceMappingChanged = TRUE;
  1703. }
  1704. return res;
  1705. }
  1707. S32 LLVOVolume::setTEScaleS(const U8 te, const F32 s)
  1708. {
  1709. S32 res = LLViewerObject::setTEScaleS(te, s);
  1710. if (res)
  1711. {
  1712. gPipeline.markTextured(mDrawable);
  1713. mFaceMappingChanged = TRUE;
  1714. }
  1715. return res;
  1716. }
  1718. S32 LLVOVolume::setTEScaleT(const U8 te, const F32 t)
  1719. {
  1720. S32 res = LLViewerObject::setTEScaleT(te, t);
  1721. if (res)
  1722. {
  1723. gPipeline.markTextured(mDrawable);
  1724. mFaceMappingChanged = TRUE;
  1725. }
  1726. return res;
  1727. }
  1729. void LLVOVolume::updateTEData()
  1730. {
  1731. /*if (mDrawable.notNull())
  1732. {
  1733. mFaceMappingChanged = TRUE;
  1734. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_MATERIAL, TRUE);
  1735. }*/
  1736. }
  1738. bool LLVOVolume::hasMedia() const
  1739. {
  1740. bool result = false;
  1741. const U8 numTEs = getNumTEs();
  1742. for (U8 i = 0; i < numTEs; i++)
  1743. {
  1744. const LLTextureEntry* te = getTE(i);
  1745. if(te->hasMedia())
  1746. {
  1747. result = true;
  1748. break;
  1749. }
  1750. }
  1751. return result;
  1752. }
  1754. LLVector3 LLVOVolume::getApproximateFaceNormal(U8 face_id)
  1755. {
  1756. LLVolume* volume = getVolume();
  1757. LLVector3 result;
  1759. if (volume && face_id < volume->getNumVolumeFaces())
  1760. {
  1761. const LLVolumeFace& face = volume->getVolumeFace(face_id);
  1762. for (S32 i = 0; i < (S32)face.mVertices.size(); ++i)
  1763. {
  1764. result += face.mVertices[i].mNormal;
  1765. }
  1767. result = volumeDirectionToAgent(result);
  1768. result.normVec();
  1769. }
  1771. return result;
  1772. }
  1774. void LLVOVolume::requestMediaDataUpdate(bool isNew)
  1775. {
  1776.     if (sObjectMediaClient)
  1777. sObjectMediaClient->fetchMedia(new LLMediaDataClientObjectImpl(this, isNew));
  1778. }
  1780. bool LLVOVolume::isMediaDataBeingFetched() const
  1781. {
  1782. // I know what I'm doing by const_casting this away: this is just 
  1783. // a wrapper class that is only going to do a lookup.
  1784. return (sObjectMediaClient) ? sObjectMediaClient->isInQueue(new LLMediaDataClientObjectImpl(const_cast<LLVOVolume*>(this), false)) : false;
  1785. }
  1787. void LLVOVolume::cleanUpMediaImpls()
  1788. {
  1789. // Iterate through our TEs and remove any Impls that are no longer used
  1790. const U8 numTEs = getNumTEs();
  1791. for (U8 i = 0; i < numTEs; i++)
  1792. {
  1793. const LLTextureEntry* te = getTE(i);
  1794. if( ! te->hasMedia())
  1795. {
  1796. // Delete the media IMPL!
  1797. removeMediaImpl(i) ;
  1798. }
  1799. }
  1800. }
  1802. void LLVOVolume::updateObjectMediaData(const LLSD &media_data_array, const std::string &media_version)
  1803. {
  1804. // media_data_array is an array of media entry maps
  1805. // media_version is the version string in the response.
  1806. U32 fetched_version = LLTextureEntry::getVersionFromMediaVersionString(media_version);
  1808. // Only update it if it is newer!
  1809. if ( (S32)fetched_version > mLastFetchedMediaVersion)
  1810. {
  1811. mLastFetchedMediaVersion = fetched_version;
  1812. //llinfos << "updating:" << this->getID() << " " << ll_pretty_print_sd(media_data_array) << llendl;
  1814. LLSD::array_const_iterator iter = media_data_array.beginArray();
  1815. LLSD::array_const_iterator end = media_data_array.endArray();
  1816. U8 texture_index = 0;
  1817. for (; iter != end; ++iter, ++texture_index)
  1818. {
  1819. syncMediaData(texture_index, *iter, false/*merge*/, false/*ignore_agent*/);
  1820. }
  1821. }
  1822. }
  1824. void LLVOVolume::syncMediaData(S32 texture_index, const LLSD &media_data, bool merge, bool ignore_agent)
  1825. {
  1826. if(mDead)
  1827. {
  1828. // If the object has been marked dead, don't process media updates.
  1829. return;
  1830. }
  1832. LLTextureEntry *te = getTE(texture_index);
  1833. LL_DEBUGS("MediaOnAPrim") << "BEFORE: texture_index = " << texture_index
  1834. << " hasMedia = " << te->hasMedia() << " : " 
  1835. << ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
  1837. std::string previous_url;
  1838. LLMediaEntry* mep = te->getMediaData();
  1839. if(mep)
  1840. {
  1841. // Save the "current url" from before the update so we can tell if
  1842. // it changes. 
  1843. previous_url = mep->getCurrentURL();
  1844. }
  1846. if (merge)
  1847. {
  1848. te->mergeIntoMediaData(media_data);
  1849. }
  1850. else {
  1851. // XXX Question: what if the media data is undefined LLSD, but the
  1852. // update we got above said that we have media flags?? Here we clobber
  1853. // that, assuming the data from the service is more up-to-date. 
  1854. te->updateMediaData(media_data);
  1855. }
  1857. mep = te->getMediaData();
  1858. if(mep)
  1859. {
  1860. bool update_from_self = false;
  1861. if (!ignore_agent) 
  1862. {
  1863. LLUUID updating_agent = LLTextureEntry::getAgentIDFromMediaVersionString(getMediaURL());
  1864. update_from_self = (updating_agent == gAgent.getID());
  1865. }
  1866. viewer_media_t media_impl = LLViewerMedia::updateMediaImpl(mep, previous_url, update_from_self);
  1868. addMediaImpl(media_impl, texture_index) ;
  1869. }
  1870. else
  1871. {
  1872. removeMediaImpl(texture_index);
  1873. }
  1875. LL_DEBUGS("MediaOnAPrim") << "AFTER: texture_index = " << texture_index
  1876. << " hasMedia = " << te->hasMedia() << " : " 
  1877. << ((NULL == te->getMediaData()) ? "NULL MEDIA DATA" : ll_pretty_print_sd(te->getMediaData()->asLLSD())) << llendl;
  1878. }
  1880. void LLVOVolume::mediaNavigateBounceBack(U8 texture_index)
  1881. {
  1882. // Find the media entry for this navigate
  1883. const LLMediaEntry* mep = NULL;
  1884. viewer_media_t impl = getMediaImpl(texture_index);
  1885. LLTextureEntry *te = getTE(texture_index);
  1886. if(te)
  1887. {
  1888. mep = te->getMediaData();
  1889. }
  1891. if (mep && impl)
  1892. {
  1893.         std::string url = mep->getCurrentURL();
  1894. // Look for a ":", if not there, assume "http://"
  1895. if (!url.empty() && std::string::npos == url.find(':')) 
  1896. {
  1897. url = "http://" + url;
  1898. }
  1899. // If the url we're trying to "bounce back" to is either empty or not
  1900. // allowed by the whitelist, try the home url.  If *that* doesn't work,
  1901. // set the media as failed and unload it
  1902.         if (url.empty() || !mep->checkCandidateUrl(url))
  1903.         {
  1904.             url = mep->getHomeURL();
  1905. // Look for a ":", if not there, assume "http://"
  1906. if (!url.empty() && std::string::npos == url.find(':')) 
  1907. {
  1908. url = "http://" + url;
  1909. }
  1910.         }
  1911.         if (url.empty() || !mep->checkCandidateUrl(url))
  1912. {
  1913. // The url to navigate back to is not good, and we have nowhere else
  1914. // to go.
  1915. LL_WARNS("MediaOnAPrim") << "FAILED to bounce back URL "" << url << "" -- unloading impl" << LL_ENDL;
  1916. impl->setMediaFailed(true);
  1917. }
  1918. else {
  1919. // Okay, navigate now
  1920.             LL_INFOS("MediaOnAPrim") << "bouncing back to URL: " << url << LL_ENDL;
  1921.             impl->navigateTo(url, "", false, true);
  1922.         }
  1923.     }
  1924. }
  1926. bool LLVOVolume::hasMediaPermission(const LLMediaEntry* media_entry, MediaPermType perm_type)
  1927. {
  1928.     // NOTE: This logic ALMOST duplicates the logic in the server (in particular, in llmediaservice.cpp).
  1929.     if (NULL == media_entry ) return false; // XXX should we assert here?
  1930.     
  1931.     // The agent has permissions if:
  1932.     // - world permissions are on, or
  1933.     // - group permissions are on, and agent_id is in the group, or
  1934.     // - agent permissions are on, and agent_id is the owner
  1935.     
  1936. // *NOTE: We *used* to check for modify permissions here (i.e. permissions were
  1937. // granted if permModify() was true).  However, this doesn't make sense in the
  1938. // viewer: we don't want to show controls or allow interaction if the author
  1939. // has deemed it so.  See DEV-42115.
  1941.     U8 media_perms = (perm_type == MEDIA_PERM_INTERACT) ? media_entry->getPermsInteract() : media_entry->getPermsControl();
  1942.     
  1943.     // World permissions
  1944.     if (0 != (media_perms & LLMediaEntry::PERM_ANYONE)) 
  1945.     {
  1946.         return true;
  1947.     }
  1948.     
  1949.     // Group permissions
  1950.     else if (0 != (media_perms & LLMediaEntry::PERM_GROUP) && permGroupOwner())
  1951.     {
  1952.         return true;
  1953.     }
  1954.     
  1955.     // Owner permissions
  1956.     else if (0 != (media_perms & LLMediaEntry::PERM_OWNER) && permYouOwner()) 
  1957.     {
  1958.         return true;
  1959.     }
  1960.     
  1961.     return false;
  1962.     
  1963. }
  1965. void LLVOVolume::mediaNavigated(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, std::string new_location)
  1966. {
  1967. bool block_navigation = false;
  1968. // FIXME: if/when we allow the same media impl to be used by multiple faces, the logic here will need to be fixed
  1969. // to deal with multiple face indices.
  1970. int face_index = getFaceIndexWithMediaImpl(impl, -1);
  1972. // Find the media entry for this navigate
  1973. LLMediaEntry* mep = NULL;
  1974. LLTextureEntry *te = getTE(face_index);
  1975. if(te)
  1976. {
  1977. mep = te->getMediaData();
  1978. }
  1980. if(mep)
  1981. {
  1982. if(!mep->checkCandidateUrl(new_location))
  1983. {
  1984. block_navigation = true;
  1985. }
  1986. if (!block_navigation && !hasMediaPermission(mep, MEDIA_PERM_INTERACT))
  1987. {
  1988. block_navigation = true;
  1989. }
  1990. }
  1991. else
  1992. {
  1993. llwarns << "Couldn't find media entry!" << llendl;
  1994. }
  1996. if(block_navigation)
  1997. {
  1998. llinfos << "blocking navigate to URI " << new_location << llendl;
  2000. // "bounce back" to the current URL from the media entry
  2001. mediaNavigateBounceBack(face_index);
  2002. }
  2003. else if (sObjectMediaNavigateClient)
  2004. {
  2006. llinfos << "broadcasting navigate with URI " << new_location << llendl;
  2008. sObjectMediaNavigateClient->navigate(new LLMediaDataClientObjectImpl(this, false), face_index, new_location);
  2009. }
  2010. }
  2012. void LLVOVolume::mediaEvent(LLViewerMediaImpl *impl, LLPluginClassMedia* plugin, LLViewerMediaObserver::EMediaEvent event)
  2013. {
  2014. switch(event)
  2015. {
  2017. case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
  2018. {
  2019. switch(impl->getNavState())
  2020. {
  2021. case LLViewerMediaImpl::MEDIANAVSTATE_FIRST_LOCATION_CHANGED:
  2022. {
  2023. // This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
  2024. mediaNavigated(impl, plugin, plugin->getLocation());
  2025. }
  2026. break;
  2028. case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED:
  2029. // This is the first location changed event after the start of a server-directed nav.  Don't broadcast it.
  2030. llinfos << " NOT broadcasting navigate (server-directed)" << llendl;
  2031. break;
  2033. default:
  2034. // This is a subsequent location-changed due to a redirect.  Don't broadcast.
  2035. llinfos << " NOT broadcasting navigate (redirect)" << llendl;
  2036. break;
  2037. }
  2038. }
  2039. break;
  2041. case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
  2042. {
  2043. switch(impl->getNavState())
  2044. {
  2045. case LLViewerMediaImpl::MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED:
  2046. {
  2047. // This is the first location changed event after the start of a non-server-directed nav.  It may need to be broadcast or bounced back.
  2048. mediaNavigated(impl, plugin, plugin->getNavigateURI());
  2049. }
  2050. break;
  2052. case LLViewerMediaImpl::MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED:
  2053. // This is the the navigate complete event from a server-directed nav.  Don't broadcast it.
  2054. llinfos << " NOT broadcasting navigate (server-directed)" << llendl;
  2055. break;
  2057. default:
  2058. // For all other states, the navigate should have been handled by LOCATION_CHANGED events already.
  2059. break;
  2060. }
  2061. }
  2062. break;
  2064. default:
  2065. break;
  2066. }
  2068. }
  2070. void LLVOVolume::sendMediaDataUpdate()
  2071. {
  2072.     if (sObjectMediaClient)
  2073. sObjectMediaClient->updateMedia(new LLMediaDataClientObjectImpl(this, false));
  2074. }
  2076. void LLVOVolume::removeMediaImpl(S32 texture_index)
  2077. {
  2078. if(mMediaImplList.size() <= (U32)texture_index || mMediaImplList[texture_index].isNull())
  2079. {
  2080. return ;
  2081. }
  2083. //make the face referencing to mMediaImplList[texture_index] to point back to the old texture.
  2084. if(mDrawable)
  2085. {
  2086. LLFace* facep = mDrawable->getFace(texture_index) ;
  2087. if(facep)
  2088. {
  2089. LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
  2090. if(media_tex)
  2091. {
  2092. media_tex->removeMediaFromFace(facep) ;
  2093. }
  2094. }
  2095. }
  2097. //check if some other face(s) of this object reference(s)to this media impl.
  2098. S32 i ;
  2099. S32 end = (S32)mMediaImplList.size() ;
  2100. for(i = 0; i < end ; i++)
  2101. {
  2102. if( i != texture_index && mMediaImplList[i] == mMediaImplList[texture_index])
  2103. {
  2104. break ;
  2105. }
  2106. }
  2108. if(i == end) //this object does not need this media impl.
  2109. {
  2110. mMediaImplList[texture_index]->removeObject(this) ;
  2111. }
  2113. mMediaImplList[texture_index] = NULL ;
  2114. return ;
  2115. }
  2117. void LLVOVolume::addMediaImpl(LLViewerMediaImpl* media_impl, S32 texture_index)
  2118. {
  2119. if((S32)mMediaImplList.size() < texture_index + 1)
  2120. {
  2121. mMediaImplList.resize(texture_index + 1) ;
  2122. }
  2124. if(mMediaImplList[texture_index].notNull())
  2125. {
  2126. if(mMediaImplList[texture_index] == media_impl)
  2127. {
  2128. return ;
  2129. }
  2131. removeMediaImpl(texture_index) ;
  2132. }
  2134. mMediaImplList[texture_index] = media_impl;
  2135. media_impl->addObject(this) ;
  2137. //add the face to show the media if it is in playing
  2138. if(mDrawable)
  2139. {
  2140. LLFace* facep = mDrawable->getFace(texture_index) ;
  2141. if(facep)
  2142. {
  2143. LLViewerMediaTexture* media_tex = LLViewerTextureManager::findMediaTexture(mMediaImplList[texture_index]->getMediaTextureID()) ;
  2144. if(media_tex)
  2145. {
  2146. media_tex->addMediaToFace(facep) ;
  2147. }
  2148. }
  2149. else //the face is not available now, start media on this face later.
  2150. {
  2151. media_impl->setUpdated(TRUE) ;
  2152. }
  2153. }
  2154. return ;
  2155. }
  2157. viewer_media_t LLVOVolume::getMediaImpl(U8 face_id) const
  2158. {
  2159. if(mMediaImplList.size() > face_id)
  2160. {
  2161. return mMediaImplList[face_id];
  2162. }
  2163. return NULL;
  2164. }
  2166. F64 LLVOVolume::getTotalMediaInterest() const
  2167. {
  2168. // If this object is currently focused, this object has "high" interest
  2169. if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == getID())
  2170. return F64_MAX;
  2172. F64 interest = (F64)-1.0;  // means not interested;
  2173.     
  2174. // If this object is selected, this object has "high" interest, but since 
  2175. // there can be more than one, we still add in calculated impl interest
  2176. // XXX Sadly, 'contains()' doesn't take a const :(
  2177. if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(this)))
  2178. interest = F64_MAX / 2.0;
  2180. int i = 0;
  2181. const int end = getNumTEs();
  2182. for ( ; i < end; ++i)
  2183. {
  2184. const viewer_media_t &impl = getMediaImpl(i);
  2185. if (!impl.isNull())
  2186. {
  2187. if (interest == (F64)-1.0) interest = (F64)0.0;
  2188. interest += impl->getInterest();
  2189. }
  2190. }
  2191. return interest;
  2192. }
  2194. S32 LLVOVolume::getFaceIndexWithMediaImpl(const LLViewerMediaImpl* media_impl, S32 start_face_id)
  2195. {
  2196. S32 end = (S32)mMediaImplList.size() ;
  2197. for(S32 face_id = start_face_id + 1; face_id < end; face_id++)
  2198. {
  2199. if(mMediaImplList[face_id] == media_impl)
  2200. {
  2201. return face_id ;
  2202. }
  2203. }
  2204. return -1 ;
  2205. }
  2207. //----------------------------------------------------------------------------
  2209. void LLVOVolume::setLightTextureID(LLUUID id)
  2210. {
  2211. if (id.notNull())
  2212. {
  2213. if (!hasLightTexture())
  2214. {
  2215. setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, TRUE, true);
  2216. }
  2217. LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
  2218. if (param_block && param_block->getLightTexture() != id)
  2219. {
  2220. param_block->setLightTexture(id);
  2221. parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
  2222. }
  2223. }
  2224. else
  2225. {
  2226. if (hasLightTexture())
  2227. {
  2228. setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, FALSE, true);
  2229. mLightTexture = NULL;
  2230. }
  2231. }
  2232. }
  2234. void LLVOVolume::setSpotLightParams(LLVector3 params)
  2235. {
  2236. LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
  2237. if (param_block && param_block->getParams() != params)
  2238. {
  2239. param_block->setParams(params);
  2240. parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
  2241. }
  2242. }
  2244. void LLVOVolume::setIsLight(BOOL is_light)
  2245. {
  2246. if (is_light != getIsLight())
  2247. {
  2248. if (is_light)
  2249. {
  2250. setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, TRUE, true);
  2251. }
  2252. else
  2253. {
  2254. setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT, FALSE, true);
  2255. }
  2257. if (is_light)
  2258. {
  2259. // Add it to the pipeline mLightSet
  2260. gPipeline.setLight(mDrawable, TRUE);
  2261. }
  2262. else
  2263. {
  2264. // Not a light.  Remove it from the pipeline's light set.
  2265. gPipeline.setLight(mDrawable, FALSE);
  2266. }
  2267. }
  2268. }
  2270. void LLVOVolume::setLightColor(const LLColor3& color)
  2271. {
  2272. LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2273. if (param_block)
  2274. {
  2275. if (param_block->getColor() != color)
  2276. {
  2277. param_block->setColor(LLColor4(color, param_block->getColor().mV[3]));
  2278. parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
  2279. gPipeline.markTextured(mDrawable);
  2280. mFaceMappingChanged = TRUE;
  2281. }
  2282. }
  2283. }
  2285. void LLVOVolume::setLightIntensity(F32 intensity)
  2286. {
  2287. LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2288. if (param_block)
  2289. {
  2290. if (param_block->getColor().mV[3] != intensity)
  2291. {
  2292. param_block->setColor(LLColor4(LLColor3(param_block->getColor()), intensity));
  2293. parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
  2294. }
  2295. }
  2296. }
  2298. void LLVOVolume::setLightRadius(F32 radius)
  2299. {
  2300. LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2301. if (param_block)
  2302. {
  2303. if (param_block->getRadius() != radius)
  2304. {
  2305. param_block->setRadius(radius);
  2306. parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
  2307. }
  2308. }
  2309. }
  2311. void LLVOVolume::setLightFalloff(F32 falloff)
  2312. {
  2313. LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2314. if (param_block)
  2315. {
  2316. if (param_block->getFalloff() != falloff)
  2317. {
  2318. param_block->setFalloff(falloff);
  2319. parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
  2320. }
  2321. }
  2322. }
  2324. void LLVOVolume::setLightCutoff(F32 cutoff)
  2325. {
  2326. LLLightParams *param_block = (LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2327. if (param_block)
  2328. {
  2329. if (param_block->getCutoff() != cutoff)
  2330. {
  2331. param_block->setCutoff(cutoff);
  2332. parameterChanged(LLNetworkData::PARAMS_LIGHT, true);
  2333. }
  2334. }
  2335. }
  2337. //----------------------------------------------------------------------------
  2339. BOOL LLVOVolume::getIsLight() const
  2340. {
  2341. return getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT);
  2342. }
  2344. LLColor3 LLVOVolume::getLightBaseColor() const
  2345. {
  2346. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2347. if (param_block)
  2348. {
  2349. return LLColor3(param_block->getColor());
  2350. }
  2351. else
  2352. {
  2353. return LLColor3(1,1,1);
  2354. }
  2355. }
  2357. LLColor3 LLVOVolume::getLightColor() const
  2358. {
  2359. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2360. if (param_block)
  2361. {
  2362. return LLColor3(param_block->getColor()) * param_block->getColor().mV[3];
  2363. }
  2364. else
  2365. {
  2366. return LLColor3(1,1,1);
  2367. }
  2368. }
  2370. LLUUID LLVOVolume::getLightTextureID() const
  2371. {
  2372. if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
  2373. {
  2374. const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
  2375. if (param_block)
  2376. {
  2377. return param_block->getLightTexture();
  2378. }
  2379. }
  2381. return LLUUID::null;
  2382. }
  2385. LLVector3 LLVOVolume::getSpotLightParams() const
  2386. {
  2387. if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
  2388. {
  2389. const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
  2390. if (param_block)
  2391. {
  2392. return param_block->getParams();
  2393. }
  2394. }
  2396. return LLVector3();
  2397. }
  2399. F32 LLVOVolume::getSpotLightPriority() const
  2400. {
  2401. return mSpotLightPriority;
  2402. }
  2404. void LLVOVolume::updateSpotLightPriority()
  2405. {
  2406. LLVector3 pos = mDrawable->getPositionAgent();
  2407. LLVector3 at(0,0,-1);
  2408. at *= getRenderRotation();
  2410. F32 r = getLightRadius()*0.5f;
  2412. pos += at * r;
  2414. at = LLViewerCamera::getInstance()->getAtAxis();
  2416. pos -= at * r;
  2418. mSpotLightPriority = gPipeline.calcPixelArea(pos, LLVector3(r,r,r), *LLViewerCamera::getInstance());
  2420. if (mLightTexture.notNull())
  2421. {
  2422. mLightTexture->addTextureStats(mSpotLightPriority);
  2423. mLightTexture->setBoostLevel(LLViewerTexture::BOOST_CLOUDS);
  2424. }
  2425. }
  2428. LLViewerTexture* LLVOVolume::getLightTexture()
  2429. {
  2430. LLUUID id = getLightTextureID();
  2432. if (id.notNull())
  2433. {
  2434. if (mLightTexture.isNull() || id != mLightTexture->getID())
  2435. {
  2436. mLightTexture = LLViewerTextureManager::getFetchedTexture(id);
  2437. }
  2438. }
  2439. else
  2440. {
  2441. mLightTexture = NULL;
  2442. }
  2444. return mLightTexture;
  2445. }
  2447. F32 LLVOVolume::getLightIntensity() const
  2448. {
  2449. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2450. if (param_block)
  2451. {
  2452. return param_block->getColor().mV[3];
  2453. }
  2454. else
  2455. {
  2456. return 1.f;
  2457. }
  2458. }
  2460. F32 LLVOVolume::getLightRadius() const
  2461. {
  2462. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2463. if (param_block)
  2464. {
  2465. return param_block->getRadius();
  2466. }
  2467. else
  2468. {
  2469. return 0.f;
  2470. }
  2471. }
  2473. F32 LLVOVolume::getLightFalloff() const
  2474. {
  2475. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2476. if (param_block)
  2477. {
  2478. return param_block->getFalloff();
  2479. }
  2480. else
  2481. {
  2482. return 0.f;
  2483. }
  2484. }
  2486. F32 LLVOVolume::getLightCutoff() const
  2487. {
  2488. const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
  2489. if (param_block)
  2490. {
  2491. return param_block->getCutoff();
  2492. }
  2493. else
  2494. {
  2495. return 0.f;
  2496. }
  2497. }
  2499. U32 LLVOVolume::getVolumeInterfaceID() const
  2500. {
  2501. if (mVolumeImpl)
  2502. {
  2503. return mVolumeImpl->getID();
  2504. }
  2506. return 0;
  2507. }
  2509. BOOL LLVOVolume::isFlexible() const
  2510. {
  2511. if (getParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE))
  2512. {
  2513. LLVolume* volume = getVolume();
  2514. if (volume && volume->getParams().getPathParams().getCurveType() != LL_PCODE_PATH_FLEXIBLE)
  2515. {
  2516. LLVolumeParams volume_params = getVolume()->getParams();
  2517. U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
  2518. volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
  2519. }
  2520. return TRUE;
  2521. }
  2522. else
  2523. {
  2524. return FALSE;
  2525. }
  2526. }
  2528. BOOL LLVOVolume::isSculpted() const
  2529. {
  2530. if (getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
  2531. {
  2532. return TRUE;
  2533. }
  2535. return FALSE;
  2536. }
  2538. BOOL LLVOVolume::hasLightTexture() const
  2539. {
  2540. if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
  2541. {
  2542. return TRUE;
  2543. }
  2545. return FALSE;
  2546. }
  2548. BOOL LLVOVolume::isVolumeGlobal() const
  2549. {
  2550. if (mVolumeImpl)
  2551. {
  2552. return mVolumeImpl->isVolumeGlobal() ? TRUE : FALSE;
  2553. }
  2554. return FALSE;
  2555. }
  2557. BOOL LLVOVolume::canBeFlexible() const
  2558. {
  2559. U8 path = getVolume()->getParams().getPathParams().getCurveType();
  2560. return (path == LL_PCODE_PATH_FLEXIBLE || path == LL_PCODE_PATH_LINE);
  2561. }
  2563. BOOL LLVOVolume::setIsFlexible(BOOL is_flexible)
  2564. {
  2565. BOOL res = FALSE;
  2566. BOOL was_flexible = isFlexible();
  2567. LLVolumeParams volume_params;
  2568. if (is_flexible)
  2569. {
  2570. if (!was_flexible)
  2571. {
  2572. volume_params = getVolume()->getParams();
  2573. U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
  2574. volume_params.setType(profile_and_hole, LL_PCODE_PATH_FLEXIBLE);
  2575. res = TRUE;
  2576. setFlags(FLAGS_USE_PHYSICS, FALSE);
  2577. setFlags(FLAGS_PHANTOM, TRUE);
  2578. setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, TRUE, true);
  2579. if (mDrawable)
  2580. {
  2581. mDrawable->makeActive();
  2582. }
  2583. }
  2584. }
  2585. else
  2586. {
  2587. if (was_flexible)
  2588. {
  2589. volume_params = getVolume()->getParams();
  2590. U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
  2591. volume_params.setType(profile_and_hole, LL_PCODE_PATH_LINE);
  2592. res = TRUE;
  2593. setFlags(FLAGS_PHANTOM, FALSE);
  2594. setParameterEntryInUse(LLNetworkData::PARAMS_FLEXIBLE, FALSE, true);
  2595. }
  2596. }
  2597. if (res)
  2598. {
  2599. res = setVolume(volume_params, 1);
  2600. if (res)
  2601. {
  2602. markForUpdate(TRUE);
  2603. }
  2604. }
  2605. return res;
  2606. }
  2608. //----------------------------------------------------------------------------
  2610. void LLVOVolume::generateSilhouette(LLSelectNode* nodep, const LLVector3& view_point)
  2611. {
  2612. LLVolume *volume = getVolume();
  2614. if (volume)
  2615. {
  2616. LLVector3 view_vector;
  2617. view_vector = view_point; 
  2619. //transform view vector into volume space
  2620. view_vector -= getRenderPosition();
  2621. mDrawable->mDistanceWRTCamera = view_vector.length();
  2622. LLQuaternion worldRot = getRenderRotation();
  2623. view_vector = view_vector * ~worldRot;
  2624. if (!isVolumeGlobal())
  2625. {
  2626. LLVector3 objScale = getScale();
  2627. LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
  2628. view_vector.scaleVec(invObjScale);
  2629. }
  2631. updateRelativeXform();
  2632. LLMatrix4 trans_mat = mRelativeXform;
  2633. if (mDrawable->isStatic())
  2634. {
  2635. trans_mat.translate(getRegion()->getOriginAgent());
  2636. }
  2638. volume->generateSilhouetteVertices(nodep->mSilhouetteVertices, nodep->mSilhouetteNormals, nodep->mSilhouetteSegments, view_vector, trans_mat, mRelativeXformInvTrans, nodep->getTESelectMask());
  2640. nodep->mSilhouetteExists = TRUE;
  2641. }
  2642. }
  2644. void LLVOVolume::deleteFaces()
  2645. {
  2646. S32 face_count = mNumFaces;
  2647. if (mDrawable.notNull())
  2648. {
  2649. mDrawable->deleteFaces(0, face_count);
  2650. }
  2652. mNumFaces = 0;
  2653. }
  2655. void LLVOVolume::updateRadius()
  2656. {
  2657. if (mDrawable.isNull())
  2658. {
  2659. return;
  2660. }
  2662. mVObjRadius = getScale().length();
  2663. mDrawable->setRadius(mVObjRadius);
  2664. }
  2667. BOOL LLVOVolume::isAttachment() const
  2668. {
  2669. if (mState == 0)
  2670. {
  2671. return FALSE;
  2672. }
  2673. else
  2674. {
  2675. return TRUE;
  2676. }
  2677. }
  2679. BOOL LLVOVolume::isHUDAttachment() const
  2680. {
  2681. // *NOTE: we assume hud attachment points are in defined range
  2682. // since this range is constant for backwards compatibility
  2683. // reasons this is probably a reasonable assumption to make
  2684. S32 attachment_id = ATTACHMENT_ID_FROM_STATE(mState);
  2685. return ( attachment_id >= 31 && attachment_id <= 38 );
  2686. }
  2689. const LLMatrix4 LLVOVolume::getRenderMatrix() const
  2690. {
  2691. if (mDrawable->isActive() && !mDrawable->isRoot())
  2692. {
  2693. return mDrawable->getParent()->getWorldMatrix();
  2694. }
  2695. return mDrawable->getWorldMatrix();
  2696. }
  2698. // Returns a base cost and adds textures to passed in set.
  2699. // total cost is returned value + 5 * size of the resulting set.
  2700. // Cannot include cost of textures, as they may be re-used in linked
  2701. // children, and cost should only be increased for unique textures  -Nyx
  2702. U32 LLVOVolume::getRenderCost(std::set<LLUUID> &textures) const
  2703. {
  2704. // base cost of each prim should be 10 points
  2705. static const U32 ARC_PRIM_COST = 10;
  2706. // per-prim costs
  2707. static const U32 ARC_INVISI_COST = 1;
  2708. static const U32 ARC_SHINY_COST = 1;
  2709. static const U32 ARC_GLOW_COST = 1;
  2710. static const U32 ARC_FLEXI_COST = 8;
  2711. static const U32 ARC_PARTICLE_COST = 16;
  2712. static const U32 ARC_BUMP_COST = 4;
  2714. // per-face costs
  2715. static const U32 ARC_PLANAR_COST = 1;
  2716. static const U32 ARC_ANIM_TEX_COST = 4;
  2717. static const U32 ARC_ALPHA_COST = 4;
  2719. U32 shame = ARC_PRIM_COST;
  2721. U32 invisi = 0;
  2722. U32 shiny = 0;
  2723. U32 glow = 0;
  2724. U32 alpha = 0;
  2725. U32 flexi = 0;
  2726. U32 animtex = 0;
  2727. U32 particles = 0;
  2728. U32 scale = 0;
  2729. U32 bump = 0;
  2730. U32 planar = 0;
  2732. if (isFlexible())
  2733. {
  2734. flexi = 1;
  2735. }
  2736. if (isParticleSource())
  2737. {
  2738. particles = 1;
  2739. }
  2741. const LLVector3& sc = getScale();
  2742. scale += (U32) sc.mV[0] + (U32) sc.mV[1] + (U32) sc.mV[2];
  2744. const LLDrawable* drawablep = mDrawable;
  2746. if (isSculpted())
  2747. {
  2748. const LLSculptParams *sculpt_params = (LLSculptParams *) getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  2749. LLUUID sculpt_id = sculpt_params->getSculptTexture();
  2750. textures.insert(sculpt_id);
  2751. }
  2753. for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
  2754. {
  2755. const LLFace* face = drawablep->getFace(i);
  2756. const LLTextureEntry* te = face->getTextureEntry();
  2757. const LLViewerTexture* img = face->getTexture();
  2759. if (img)
  2760. {
  2761. textures.insert(img->getID());
  2762. }
  2764. if (face->getPoolType() == LLDrawPool::POOL_ALPHA)
  2765. {
  2766. alpha++;
  2767. }
  2768. else if (img && img->getPrimaryFormat() == GL_ALPHA)
  2769. {
  2770. invisi = 1;
  2771. }
  2773. if (te)
  2774. {
  2775. if (te->getBumpmap())
  2776. {
  2777. bump = 1;
  2778. }
  2779. if (te->getShiny())
  2780. {
  2781. shiny = 1;
  2782. }
  2783. if (te->getGlow() > 0.f)
  2784. {
  2785. glow = 1;
  2786. }
  2787. if (face->mTextureMatrix != NULL)
  2788. {
  2789. animtex++;
  2790. }
  2791. if (te->getTexGen())
  2792. {
  2793. planar++;
  2794. }
  2795. }
  2796. }
  2799. shame += invisi * ARC_INVISI_COST;
  2800. shame += shiny * ARC_SHINY_COST;
  2801. shame += glow * ARC_GLOW_COST;
  2802. shame += alpha * ARC_ALPHA_COST;
  2803. shame += flexi * ARC_FLEXI_COST;
  2804. shame += animtex * ARC_ANIM_TEX_COST;
  2805. shame += particles * ARC_PARTICLE_COST;
  2806. shame += bump * ARC_BUMP_COST;
  2807. shame += planar * ARC_PLANAR_COST;
  2808. shame += scale;
  2810. LLViewerObject::const_child_list_t& child_list = getChildren();
  2811. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  2812.  iter != child_list.end(); 
  2813.  ++iter)
  2814. {
  2815. const LLViewerObject* child_objectp = *iter;
  2816. const LLDrawable* child_drawablep = child_objectp->mDrawable;
  2817. if (child_drawablep)
  2818. {
  2819. const LLVOVolume* child_volumep = child_drawablep->getVOVolume();
  2820. if (child_volumep)
  2821. {
  2822. shame += child_volumep->getRenderCost(textures);
  2823. }
  2824. }
  2825. }
  2827. return shame;
  2829. }
  2831. //static
  2832. void LLVOVolume::preUpdateGeom()
  2833. {
  2834. sNumLODChanges = 0;
  2835. }
  2837. void LLVOVolume::parameterChanged(U16 param_type, bool local_origin)
  2838. {
  2839. LLViewerObject::parameterChanged(param_type, local_origin);
  2840. }
  2842. void LLVOVolume::parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin)
  2843. {
  2844. LLViewerObject::parameterChanged(param_type, data, in_use, local_origin);
  2845. if (mVolumeImpl)
  2846. {
  2847. mVolumeImpl->onParameterChanged(param_type, data, in_use, local_origin);
  2848. }
  2849. if (mDrawable.notNull())
  2850. {
  2851. BOOL is_light = getIsLight();
  2852. if (is_light != mDrawable->isState(LLDrawable::LIGHT))
  2853. {
  2854. gPipeline.setLight(mDrawable, is_light);
  2855. }
  2856. }
  2857. }
  2859. void LLVOVolume::setSelected(BOOL sel)
  2860. {
  2861. LLViewerObject::setSelected(sel);
  2862. if (mDrawable.notNull())
  2863. {
  2864. markForUpdate(TRUE);
  2865. }
  2866. }
  2868. void LLVOVolume::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
  2869. {
  2870. }
  2872. F32 LLVOVolume::getBinRadius()
  2873. {
  2874. F32 radius;
  2876. const LLVector3* ext = mDrawable->getSpatialExtents();
  2878. BOOL shrink_wrap = mDrawable->isAnimating();
  2879. BOOL alpha_wrap = FALSE;
  2881. if (!isHUDAttachment())
  2882. {
  2883. for (S32 i = 0; i < mDrawable->getNumFaces(); i++)
  2884. {
  2885. LLFace* face = mDrawable->getFace(i);
  2886. if (face->getPoolType() == LLDrawPool::POOL_ALPHA &&
  2887. (!LLPipeline::sFastAlpha || 
  2888. face->getFaceColor().mV[3] != 1.f ||
  2889. !face->getTexture()->getIsAlphaMask()))
  2890. {
  2891. alpha_wrap = TRUE;
  2892. break;
  2893. }
  2894. }
  2895. }
  2896. else
  2897. {
  2898. shrink_wrap = FALSE;
  2899. }
  2901. if (alpha_wrap)
  2902. {
  2903. LLVector3 bounds = getScale();
  2904. radius = llmin(bounds.mV[1], bounds.mV[2]);
  2905. radius = llmin(radius, bounds.mV[0]);
  2906. radius *= 0.5f;
  2907. }
  2908. else if (shrink_wrap)
  2909. {
  2910. radius = (ext[1]-ext[0]).length()*0.5f;
  2911. }
  2912. else if (mDrawable->isStatic())
  2913. {
  2914. /*if (mDrawable->getRadius() < 2.0f)
  2915. {
  2916. radius = 16.f;
  2917. }
  2918. else
  2919. {
  2920. radius = llmax(mDrawable->getRadius(), 32.f);
  2921. }*/
  2923. radius = (((S32) mDrawable->getRadius())/2+1)*8;
  2924. }
  2925. else if (mDrawable->getVObj()->isAttachment())
  2926. {
  2927. radius = (((S32) (mDrawable->getRadius()*4)+1))*2;
  2928. }
  2929. else
  2930. {
  2931. radius = 8.f;
  2932. }
  2934. return llclamp(radius, 0.5f, 256.f);
  2935. }
  2937. const LLVector3 LLVOVolume::getPivotPositionAgent() const
  2938. {
  2939. if (mVolumeImpl)
  2940. {
  2941. return mVolumeImpl->getPivotPosition();
  2942. }
  2943. return LLViewerObject::getPivotPositionAgent();
  2944. }
  2946. void LLVOVolume::onShift(const LLVector3 &shift_vector)
  2947. {
  2948. if (mVolumeImpl)
  2949. {
  2950. mVolumeImpl->onShift(shift_vector);
  2951. }
  2953. updateRelativeXform();
  2954. }
  2956. const LLMatrix4& LLVOVolume::getWorldMatrix(LLXformMatrix* xform) const
  2957. {
  2958. if (mVolumeImpl)
  2959. {
  2960. return mVolumeImpl->getWorldMatrix(xform);
  2961. }
  2962. return xform->getWorldMatrix();
  2963. }
  2965. LLVector3 LLVOVolume::agentPositionToVolume(const LLVector3& pos) const
  2966. {
  2967. LLVector3 ret = pos - getRenderPosition();
  2968. ret = ret * ~getRenderRotation();
  2969. LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
  2970. LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
  2971. ret.scaleVec(invObjScale);
  2973. return ret;
  2974. }
  2976. LLVector3 LLVOVolume::agentDirectionToVolume(const LLVector3& dir) const
  2977. {
  2978. LLVector3 ret = dir * ~getRenderRotation();
  2980. LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
  2981. ret.scaleVec(objScale);
  2983. return ret;
  2984. }
  2986. LLVector3 LLVOVolume::volumePositionToAgent(const LLVector3& dir) const
  2987. {
  2988. LLVector3 ret = dir;
  2989. LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
  2990. ret.scaleVec(objScale);
  2991. ret = ret * getRenderRotation();
  2992. ret += getRenderPosition();
  2994. return ret;
  2995. }
  2997. LLVector3 LLVOVolume::volumeDirectionToAgent(const LLVector3& dir) const
  2998. {
  2999. LLVector3 ret = dir;
  3000. LLVector3 objScale = isVolumeGlobal() ? LLVector3(1,1,1) : getScale();
  3001. LLVector3 invObjScale(1.f / objScale.mV[VX], 1.f / objScale.mV[VY], 1.f / objScale.mV[VZ]);
  3002. ret.scaleVec(invObjScale);
  3003. ret = ret * getRenderRotation();
  3005. return ret;
  3006. }
  3009. BOOL LLVOVolume::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
  3010.   LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
  3012. {
  3013. if (!mbCanSelect 
  3014. || mDrawable->isDead() 
  3015. || !gPipeline.hasRenderType(mDrawable->getRenderType()))
  3016. {
  3017. return FALSE;
  3018. }
  3020. BOOL ret = FALSE;
  3022. LLVolume* volume = getVolume();
  3023. if (volume)
  3024. {
  3025. LLVector3 v_start, v_end, v_dir;
  3027. v_start = agentPositionToVolume(start);
  3028. v_end = agentPositionToVolume(end);
  3030. LLVector3 p;
  3031. LLVector3 n;
  3032. LLVector2 tc;
  3033. LLVector3 bn;
  3035. if (intersection != NULL)
  3036. {
  3037. p = *intersection;
  3038. }
  3040. if (tex_coord != NULL)
  3041. {
  3042. tc = *tex_coord;
  3043. }
  3045. if (normal != NULL)
  3046. {
  3047. n = *normal;
  3048. }
  3050. if (bi_normal != NULL)
  3051. {
  3052. bn = *bi_normal;
  3053. }
  3055. S32 face_hit = -1;
  3057. S32 start_face, end_face;
  3058. if (face == -1)
  3059. {
  3060. start_face = 0;
  3061. end_face = volume->getNumVolumeFaces();
  3062. }
  3063. else
  3064. {
  3065. start_face = face;
  3066. end_face = face+1;
  3067. }
  3069. for (S32 i = start_face; i < end_face; ++i)
  3070. {
  3071. face_hit = volume->lineSegmentIntersect(v_start, v_end, i,
  3072. &p, &tc, &n, &bn);
  3074. if (face_hit >= 0 && mDrawable->getNumFaces() > face_hit)
  3075. {
  3076. LLFace* face = mDrawable->getFace(face_hit);
  3078. if (pick_transparent || !face->getTexture() || !face->getTexture()->hasGLTexture() || face->getTexture()->getMask(face->surfaceToTexture(tc, p, n)))
  3079. {
  3080. v_end = p;
  3081. if (face_hitp != NULL)
  3082. {
  3083. *face_hitp = face_hit;
  3084. }
  3086. if (intersection != NULL)
  3087. {
  3088. *intersection = volumePositionToAgent(p);  // must map back to agent space
  3089. }
  3091. if (normal != NULL)
  3092. {
  3093. *normal = volumeDirectionToAgent(n);
  3094. (*normal).normVec();
  3095. }
  3097. if (bi_normal != NULL)
  3098. {
  3099. *bi_normal = volumeDirectionToAgent(bn);
  3100. (*bi_normal).normVec();
  3101. }
  3103. if (tex_coord != NULL)
  3104. {
  3105. *tex_coord = tc;
  3106. }
  3108. ret = TRUE;
  3109. }
  3110. }
  3111. }
  3112. }
  3114. return ret;
  3115. }
  3117. U32 LLVOVolume::getPartitionType() const
  3118. {
  3119. if (isHUDAttachment())
  3120. {
  3121. return LLViewerRegion::PARTITION_HUD;
  3122. }
  3124. return LLViewerRegion::PARTITION_VOLUME;
  3125. }
  3127. LLVolumePartition::LLVolumePartition()
  3128. : LLSpatialPartition(LLVOVolume::VERTEX_DATA_MASK, TRUE, GL_DYNAMIC_DRAW_ARB)
  3129. {
  3130. mLODPeriod = 32;
  3131. mDepthMask = FALSE;
  3132. mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
  3133. mPartitionType = LLViewerRegion::PARTITION_VOLUME;
  3134. mSlopRatio = 0.25f;
  3135. mBufferUsage = GL_DYNAMIC_DRAW_ARB;
  3136. }
  3138. LLVolumeBridge::LLVolumeBridge(LLDrawable* drawablep)
  3139. : LLSpatialBridge(drawablep, TRUE, LLVOVolume::VERTEX_DATA_MASK)
  3140. {
  3141. mDepthMask = FALSE;
  3142. mLODPeriod = 32;
  3143. mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
  3144. mPartitionType = LLViewerRegion::PARTITION_BRIDGE;
  3146. mBufferUsage = GL_DYNAMIC_DRAW_ARB;
  3148. mSlopRatio = 0.25f;
  3149. }
  3151. void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, U32 type)
  3152. {
  3153. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  3155. if (facep->getViewerObject()->isSelected() && LLSelectMgr::getInstance()->mHideSelectedObjects)
  3156. {
  3157. return;
  3158. }
  3160. //add face to drawmap
  3161. LLSpatialGroup::drawmap_elem_t& draw_vec = group->mDrawMap[type];
  3163. S32 idx = draw_vec.size()-1;
  3166. BOOL fullbright = (type == LLRenderPass::PASS_FULLBRIGHT) ||
  3167.   (type == LLRenderPass::PASS_INVISIBLE) ||
  3168.   (type == LLRenderPass::PASS_ALPHA ? facep->isState(LLFace::FULLBRIGHT) : FALSE);
  3170. if (!fullbright && type != LLRenderPass::PASS_GLOW && !facep->mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_NORMAL))
  3171. {
  3172. llwarns << "Non fullbright face has no normals!" << llendl;
  3173. return;
  3174. }
  3176. const LLMatrix4* tex_mat = NULL;
  3177. if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
  3178. {
  3179. tex_mat = facep->mTextureMatrix;
  3180. }
  3182. const LLMatrix4* model_mat = NULL;
  3184. LLDrawable* drawable = facep->getDrawable();
  3185. if (drawable->isActive())
  3186. {
  3187. model_mat = &(drawable->getRenderMatrix());
  3188. }
  3189. else
  3190. {
  3191. model_mat = &(drawable->getRegion()->mRenderMatrix);
  3192. }
  3194. U8 bump = (type == LLRenderPass::PASS_BUMP ? facep->getTextureEntry()->getBumpmap() : 0);
  3196. LLViewerTexture* tex = facep->getTexture();
  3198. U8 glow = 0;
  3200. if (type == LLRenderPass::PASS_GLOW)
  3201. {
  3202. glow = (U8) (facep->getTextureEntry()->getGlow() * 255);
  3203. }
  3205. if (facep->mVertexBuffer.isNull())
  3206. {
  3207. llerrs << "WTF?" << llendl;
  3208. }
  3210. if (idx >= 0 && 
  3211. draw_vec[idx]->mVertexBuffer == facep->mVertexBuffer &&
  3212. draw_vec[idx]->mEnd == facep->getGeomIndex()-1 &&
  3213. (LLPipeline::sTextureBindTest || draw_vec[idx]->mTexture == tex) &&
  3214. #if LL_DARWIN
  3215. draw_vec[idx]->mEnd - draw_vec[idx]->mStart + facep->getGeomCount() <= (U32) gGLManager.mGLMaxVertexRange &&
  3216. draw_vec[idx]->mCount + facep->getIndicesCount() <= (U32) gGLManager.mGLMaxIndexRange &&
  3217. #endif
  3218. draw_vec[idx]->mGlowColor.mV[3] == glow &&
  3219. draw_vec[idx]->mFullbright == fullbright &&
  3220. draw_vec[idx]->mBump == bump &&
  3221. draw_vec[idx]->mTextureMatrix == tex_mat &&
  3222. draw_vec[idx]->mModelMatrix == model_mat)
  3223. {
  3224. draw_vec[idx]->mCount += facep->getIndicesCount();
  3225. draw_vec[idx]->mEnd += facep->getGeomCount();
  3226. draw_vec[idx]->mVSize = llmax(draw_vec[idx]->mVSize, facep->getVirtualSize());
  3227. validate_draw_info(*draw_vec[idx]);
  3228. update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[0]);
  3229. update_min_max(draw_vec[idx]->mExtents[0], draw_vec[idx]->mExtents[1], facep->mExtents[1]);
  3230. }
  3231. else
  3232. {
  3233. U32 start = facep->getGeomIndex();
  3234. U32 end = start + facep->getGeomCount()-1;
  3235. U32 offset = facep->getIndicesStart();
  3236. U32 count = facep->getIndicesCount();
  3237. LLPointer<LLDrawInfo> draw_info = new LLDrawInfo(start,end,count,offset, tex, 
  3238. facep->mVertexBuffer, fullbright, bump); 
  3239. draw_info->mGroup = group;
  3240. draw_info->mVSize = facep->getVirtualSize();
  3241. draw_vec.push_back(draw_info);
  3242. draw_info->mTextureMatrix = tex_mat;
  3243. draw_info->mModelMatrix = model_mat;
  3244. draw_info->mGlowColor.setVec(0,0,0,glow);
  3245. if (type == LLRenderPass::PASS_ALPHA)
  3246. { //for alpha sorting
  3247. facep->setDrawInfo(draw_info);
  3248. }
  3249. draw_info->mExtents[0] = facep->mExtents[0];
  3250. draw_info->mExtents[1] = facep->mExtents[1];
  3251. validate_draw_info(*draw_info);
  3252. }
  3253. }
  3255. void LLVolumeGeometryManager::getGeometry(LLSpatialGroup* group)
  3256. {
  3258. }
  3260. static LLFastTimer::DeclareTimer FTM_REBUILD_VOLUME_VB("Volume");
  3261. static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
  3263. void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
  3264. {
  3265. llpushcallstacks ;
  3266. if (group->changeLOD())
  3267. {
  3268. group->mLastUpdateDistance = group->mDistance;
  3269. }
  3271. group->mLastUpdateViewAngle = group->mViewAngle;
  3273. if (!group->isState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY))
  3274. {
  3275. if (group->isState(LLSpatialGroup::MESH_DIRTY) && !LLPipeline::sDelayVBUpdate)
  3276. {
  3277. LLFastTimer ftm(FTM_REBUILD_VBO);
  3278. LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
  3280. rebuildMesh(group);
  3281. }
  3282. return;
  3283. }
  3285. group->mBuilt = 1.f;
  3286. LLFastTimer ftm(FTM_REBUILD_VBO);
  3288. LLFastTimer ftm2(FTM_REBUILD_VOLUME_VB);
  3290. group->clearDrawMap();
  3292. mFaceList.clear();
  3294. std::vector<LLFace*> fullbright_faces;
  3295. std::vector<LLFace*> bump_faces;
  3296. std::vector<LLFace*> simple_faces;
  3298. std::vector<LLFace*> alpha_faces;
  3299. U32 useage = group->mSpatialPartition->mBufferUsage;
  3301. U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcStride(group->mSpatialPartition->mVertexDataMask);
  3302. U32 max_total = (gSavedSettings.getS32("RenderMaxNodeSize")*1024)/LLVertexBuffer::calcStride(group->mSpatialPartition->mVertexDataMask);
  3303. max_vertices = llmin(max_vertices, (U32) 65535);
  3305. U32 cur_total = 0;
  3307. //get all the faces into a list
  3308. for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
  3309. {
  3310. LLDrawable* drawablep = *drawable_iter;
  3312. if (drawablep->isDead() || drawablep->isState(LLDrawable::FORCE_INVISIBLE) )
  3313. {
  3314. continue;
  3315. }
  3317. if (drawablep->isAnimating())
  3318. { //fall back to stream draw for animating verts
  3319. useage = GL_STREAM_DRAW_ARB;
  3320. }
  3322. LLVOVolume* vobj = drawablep->getVOVolume();
  3323. llassert_always(vobj);
  3324. vobj->updateTextureVirtualSize();
  3325. vobj->preRebuild();
  3327. drawablep->clearState(LLDrawable::HAS_ALPHA);
  3329. //for each face
  3330. for (S32 i = 0; i < drawablep->getNumFaces(); i++)
  3331. {
  3332. //sum up face verts and indices
  3333. drawablep->updateFaceSize(i);
  3334. LLFace* facep = drawablep->getFace(i);
  3336. if (cur_total > max_total)
  3337. {
  3338. facep->mVertexBuffer = NULL;
  3339. facep->mLastVertexBuffer = NULL;
  3340. continue;
  3341. }
  3343. cur_total += facep->getGeomCount();
  3345. if (facep->hasGeometry() && facep->mPixelArea > FORCE_CULL_AREA)
  3346. {
  3347. const LLTextureEntry* te = facep->getTextureEntry();
  3348. LLViewerTexture* tex = facep->getTexture();
  3350. if (facep->isState(LLFace::TEXTURE_ANIM))
  3351. {
  3352. if (!vobj->mTexAnimMode)
  3353. {
  3354. facep->clearState(LLFace::TEXTURE_ANIM);
  3355. }
  3356. }
  3358. BOOL force_simple = (facep->mPixelArea < FORCE_SIMPLE_RENDER_AREA);
  3359. U32 type = gPipeline.getPoolTypeFromTE(te, tex);
  3360. if (type != LLDrawPool::POOL_ALPHA && force_simple)
  3361. {
  3362. type = LLDrawPool::POOL_SIMPLE;
  3363. }
  3364. facep->setPoolType(type);
  3366. if (vobj->isHUDAttachment())
  3367. {
  3368. facep->setState(LLFace::FULLBRIGHT);
  3369. }
  3371. if (vobj->mTextureAnimp && vobj->mTexAnimMode)
  3372. {
  3373. if (vobj->mTextureAnimp->mFace <= -1)
  3374. {
  3375. S32 face;
  3376. for (face = 0; face < vobj->getNumTEs(); face++)
  3377. {
  3378. drawablep->getFace(face)->setState(LLFace::TEXTURE_ANIM);
  3379. }
  3380. }
  3381. else if (vobj->mTextureAnimp->mFace < vobj->getNumTEs())
  3382. {
  3383. drawablep->getFace(vobj->mTextureAnimp->mFace)->setState(LLFace::TEXTURE_ANIM);
  3384. }
  3385. }
  3387. if (type == LLDrawPool::POOL_ALPHA)
  3388. {
  3389. if (LLPipeline::sFastAlpha &&
  3390.     (te->getColor().mV[VW] == 1.0f) &&
  3391.     (!te->getFullbright()) && // hack: alpha masking renders fullbright faces invisible, need to figure out why - for now, avoid
  3392.     facep->getTexture()->getIsAlphaMask())
  3393. { //can be treated as alpha mask
  3394. simple_faces.push_back(facep);
  3395. }
  3396. else
  3397. {
  3398. drawablep->setState(LLDrawable::HAS_ALPHA);
  3399. alpha_faces.push_back(facep);
  3400. }
  3401. }
  3402. else
  3403. {
  3404. if (drawablep->isState(LLDrawable::REBUILD_VOLUME))
  3405. {
  3406. facep->mLastUpdateTime = gFrameTimeSeconds;
  3407. }
  3409. if (gPipeline.canUseWindLightShadersOnObjects()
  3410. && LLPipeline::sRenderBump)
  3411. {
  3412. if (te->getBumpmap())
  3413. { //needs normal + binormal
  3414. bump_faces.push_back(facep);
  3415. }
  3416. else if (te->getShiny() || !te->getFullbright())
  3417. { //needs normal
  3418. simple_faces.push_back(facep);
  3419. }
  3420. else 
  3421. { //doesn't need normal
  3422. facep->setState(LLFace::FULLBRIGHT);
  3423. fullbright_faces.push_back(facep);
  3424. }
  3425. }
  3426. else
  3427. {
  3428. if (te->getBumpmap() && LLPipeline::sRenderBump)
  3429. { //needs normal + binormal
  3430. bump_faces.push_back(facep);
  3431. }
  3432. else if ((te->getShiny() && LLPipeline::sRenderBump) ||
  3433. !te->getFullbright())
  3434. { //needs normal
  3435. simple_faces.push_back(facep);
  3436. }
  3437. else 
  3438. { //doesn't need normal
  3439. facep->setState(LLFace::FULLBRIGHT);
  3440. fullbright_faces.push_back(facep);
  3441. }
  3442. }
  3443. }
  3444. }
  3445. else
  3446. { //face has no renderable geometry
  3447. facep->mVertexBuffer = NULL;
  3448. facep->mLastVertexBuffer = NULL;
  3449. }
  3450. }
  3451. }
  3453. group->mBufferUsage = useage;
  3455. //PROCESS NON-ALPHA FACES
  3456. U32 simple_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
  3457. U32 alpha_mask = simple_mask | 0x80000000; //hack to give alpha verts their own VBO
  3458. U32 bump_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
  3459. U32 fullbright_mask = LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR;
  3461. if (LLPipeline::sRenderDeferred)
  3462. {
  3463. bump_mask |= LLVertexBuffer::MAP_BINORMAL;
  3464. }
  3466. genDrawInfo(group, simple_mask, simple_faces);
  3467. genDrawInfo(group, bump_mask, bump_faces);
  3468. genDrawInfo(group, fullbright_mask, fullbright_faces);
  3469. genDrawInfo(group, alpha_mask, alpha_faces, TRUE);
  3471. if (!LLPipeline::sDelayVBUpdate)
  3472. {
  3473. //drawables have been rebuilt, clear rebuild status
  3474. for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
  3475. {
  3476. LLDrawable* drawablep = *drawable_iter;
  3477. drawablep->clearState(LLDrawable::REBUILD_ALL);
  3478. }
  3479. }
  3481. group->mLastUpdateTime = gFrameTimeSeconds;
  3482. group->mBuilt = 1.f;
  3483. group->clearState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::ALPHA_DIRTY);
  3485. if (LLPipeline::sDelayVBUpdate)
  3486. {
  3487. group->setState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
  3488. }
  3490. mFaceList.clear();
  3491. }
  3493. static LLFastTimer::DeclareTimer FTM_VOLUME_GEOM("Volume Geometry");
  3494. void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
  3495. {
  3496. llpushcallstacks ;
  3497. llassert(group);
  3498. if (group && group->isState(LLSpatialGroup::MESH_DIRTY) && !group->isState(LLSpatialGroup::GEOM_DIRTY))
  3499. {
  3500. LLFastTimer tm(FTM_VOLUME_GEOM);
  3501. S32 num_mapped_veretx_buffer = LLVertexBuffer::sMappedCount ;
  3503. group->mBuilt = 1.f;
  3505. for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
  3506. {
  3507. LLDrawable* drawablep = *drawable_iter;
  3509. if (drawablep->isDead() || drawablep->isState(LLDrawable::FORCE_INVISIBLE) )
  3510. {
  3511. continue;
  3512. }
  3514. if (drawablep->isState(LLDrawable::REBUILD_ALL))
  3515. {
  3516. LLVOVolume* vobj = drawablep->getVOVolume();
  3517. vobj->preRebuild();
  3518. LLVolume* volume = vobj->getVolume();
  3519. for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
  3520. {
  3521. LLFace* face = drawablep->getFace(i);
  3522. if (face && face->mVertexBuffer.notNull())
  3523. {
  3524. face->getGeometryVolume(*volume, face->getTEOffset(), 
  3525. vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), face->getGeomIndex());
  3526. }
  3527. }
  3529. drawablep->clearState(LLDrawable::REBUILD_ALL);
  3530. }
  3531. }
  3533. //unmap all the buffers
  3534. for (LLSpatialGroup::buffer_map_t::iterator i = group->mBufferMap.begin(); i != group->mBufferMap.end(); ++i)
  3535. {
  3536. LLSpatialGroup::buffer_texture_map_t& map = i->second;
  3537. for (LLSpatialGroup::buffer_texture_map_t::iterator j = map.begin(); j != map.end(); ++j)
  3538. {
  3539. LLSpatialGroup::buffer_list_t& list = j->second;
  3540. for (LLSpatialGroup::buffer_list_t::iterator k = list.begin(); k != list.end(); ++k)
  3541. {
  3542. LLVertexBuffer* buffer = *k;
  3543. if (buffer->isLocked())
  3544. {
  3545. buffer->setBuffer(0);
  3546. }
  3547. }
  3548. }
  3549. }
  3551. // don't forget alpha
  3552. if(group != NULL && 
  3553.    !group->mVertexBuffer.isNull() && 
  3554.    group->mVertexBuffer->isLocked())
  3555. {
  3556. group->mVertexBuffer->setBuffer(0);
  3557. }
  3559. //if not all buffers are unmapped
  3560. if(num_mapped_veretx_buffer != LLVertexBuffer::sMappedCount) 
  3561. {
  3562. llwarns << "Not all mapped vertex buffers are unmapped!" << llendl ; 
  3563. for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
  3564. {
  3565. LLDrawable* drawablep = *drawable_iter;
  3566. for (S32 i = 0; i < drawablep->getNumFaces(); ++i)
  3567. {
  3568. LLFace* face = drawablep->getFace(i);
  3569. if (face && face->mVertexBuffer.notNull() && face->mVertexBuffer->isLocked())
  3570. {
  3571. face->mVertexBuffer->setBuffer(0) ;
  3572. }
  3573. }
  3574. } 
  3575. }
  3577. group->clearState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO);
  3578. }
  3580. if (group && group->isState(LLSpatialGroup::NEW_DRAWINFO))
  3581. {
  3582. llerrs << "WTF?" << llendl;
  3583. }
  3584. }
  3586. void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::vector<LLFace*>& faces, BOOL distance_sort)
  3587. {
  3588. llpushcallstacks ;
  3589. //calculate maximum number of vertices to store in a single buffer
  3590. U32 max_vertices = (gSavedSettings.getS32("RenderMaxVBOSize")*1024)/LLVertexBuffer::calcStride(group->mSpatialPartition->mVertexDataMask);
  3591. max_vertices = llmin(max_vertices, (U32) 65535);
  3593. if (!distance_sort)
  3594. {
  3595. //sort faces by things that break batches
  3596. std::sort(faces.begin(), faces.end(), LLFace::CompareBatchBreaker());
  3597. }
  3598. else
  3599. {
  3600. //sort faces by distance
  3601. std::sort(faces.begin(), faces.end(), LLFace::CompareDistanceGreater());
  3602. }
  3604. std::vector<LLFace*>::iterator face_iter = faces.begin();
  3606. LLSpatialGroup::buffer_map_t buffer_map;
  3608. LLViewerTexture* last_tex = NULL;
  3609. S32 buffer_index = 0;
  3611. if (distance_sort)
  3612. {
  3613. buffer_index = -1;
  3614. }
  3616. while (face_iter != faces.end())
  3617. {
  3618. //pull off next face
  3619. LLFace* facep = *face_iter;
  3620. LLViewerTexture* tex = facep->getTexture();
  3622. if (distance_sort)
  3623. {
  3624. tex = NULL;
  3625. }
  3627. if (last_tex == tex)
  3628. {
  3629. buffer_index++;
  3630. }
  3631. else
  3632. {
  3633. last_tex = tex;
  3634. buffer_index = 0;
  3635. }
  3637. U32 index_count = facep->getIndicesCount();
  3638. U32 geom_count = facep->getGeomCount();
  3640. //sum up vertices needed for this texture
  3641. std::vector<LLFace*>::iterator i = face_iter;
  3642. ++i;
  3644. while (i != faces.end() && 
  3645. (LLPipeline::sTextureBindTest || (distance_sort || (*i)->getTexture() == tex)))
  3646. {
  3647. facep = *i;
  3649. if (geom_count + facep->getGeomCount() > max_vertices)
  3650. { //cut vertex buffers on geom count too big
  3651. break;
  3652. }
  3654. ++i;
  3655. index_count += facep->getIndicesCount();
  3656. geom_count += facep->getGeomCount();
  3657. }
  3659. //create/delete/resize vertex buffer if needed
  3660. LLVertexBuffer* buffer = NULL;
  3661. LLSpatialGroup::buffer_texture_map_t::iterator found_iter = group->mBufferMap[mask].find(tex);
  3663. if (found_iter != group->mBufferMap[mask].end())
  3664. {
  3665. if ((U32) buffer_index < found_iter->second.size())
  3666. {
  3667. buffer = found_iter->second[buffer_index];
  3668. }
  3669. }
  3671. if (!buffer)
  3672. { //create new buffer if needed
  3673. buffer = createVertexBuffer(mask, 
  3674. group->mBufferUsage);
  3675. buffer->allocateBuffer(geom_count, index_count, TRUE);
  3676. }
  3677. else 
  3678. {
  3679. if (LLVertexBuffer::sEnableVBOs && buffer->getUsage() != group->mBufferUsage)
  3680. {
  3681. buffer = createVertexBuffer(group->mSpatialPartition->mVertexDataMask, 
  3682. group->mBufferUsage);
  3683. buffer->allocateBuffer(geom_count, index_count, TRUE);
  3684. }
  3685. else
  3686. {
  3687. buffer->resizeBuffer(geom_count, index_count);
  3688. }
  3689. }
  3691. buffer_map[mask][tex].push_back(buffer);
  3693. //add face geometry
  3695. U32 indices_index = 0;
  3696. U16 index_offset = 0;
  3698. while (face_iter < i)
  3699. {
  3700. facep = *face_iter;
  3701. facep->mIndicesIndex = indices_index;
  3702. facep->mGeomIndex = index_offset;
  3703. facep->mVertexBuffer = buffer;
  3704. {
  3705. facep->updateRebuildFlags();
  3706. if (!LLPipeline::sDelayVBUpdate)
  3707. {
  3708. LLDrawable* drawablep = facep->getDrawable();
  3709. LLVOVolume* vobj = drawablep->getVOVolume();
  3710. LLVolume* volume = vobj->getVolume();
  3712. U32 te_idx = facep->getTEOffset();
  3714. if (facep->getGeometryVolume(*volume, te_idx, 
  3715. vobj->getRelativeXform(), vobj->getRelativeXformInvTrans(), index_offset))
  3716. {
  3717. buffer->markDirty(facep->getGeomIndex(), facep->getGeomCount(), 
  3718. facep->getIndicesStart(), facep->getIndicesCount());
  3719. }
  3720. }
  3721. }
  3723. index_offset += facep->getGeomCount();
  3724. indices_index += facep->mIndicesCount;
  3726. BOOL force_simple = facep->mPixelArea < FORCE_SIMPLE_RENDER_AREA;
  3727. BOOL fullbright = facep->isState(LLFace::FULLBRIGHT);
  3728. if ((mask & LLVertexBuffer::MAP_NORMAL) == 0)
  3729. { //paranoia check to make sure GL doesn't try to read non-existant normals
  3730. fullbright = TRUE;
  3731. }
  3733. const LLTextureEntry* te = facep->getTextureEntry();
  3735. BOOL is_alpha = facep->getPoolType() == LLDrawPool::POOL_ALPHA ? TRUE : FALSE;
  3737. if (is_alpha)
  3738. {
  3739. // can we safely treat this as an alpha mask?
  3740. if (LLPipeline::sFastAlpha &&
  3741.     (te->getColor().mV[VW] == 1.0f) &&
  3742.     (!te->getFullbright()) && // hack: alpha masking renders fullbright faces invisible, need to figure out why - for now, avoid
  3743.     facep->getTexture()->getIsAlphaMask())
  3744. {
  3745. if (te->getFullbright())
  3746. {
  3747. registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK);
  3748. }
  3749. else
  3750. {
  3751. registerFace(group, facep, LLRenderPass::PASS_ALPHA_MASK);
  3752. }
  3753. }
  3754. else
  3755. {
  3756. registerFace(group, facep, LLRenderPass::PASS_ALPHA);
  3757. }
  3759. if (LLPipeline::sRenderDeferred)
  3760. {
  3761. registerFace(group, facep, LLRenderPass::PASS_ALPHA_SHADOW);
  3762. }
  3763. }
  3764. else if (gPipeline.canUseVertexShaders()
  3765. && group->mSpatialPartition->mPartitionType != LLViewerRegion::PARTITION_HUD 
  3766. && LLPipeline::sRenderBump 
  3767. && te->getShiny())
  3768. {
  3769. if (tex->getPrimaryFormat() == GL_ALPHA)
  3770. {
  3771. registerFace(group, facep, LLRenderPass::PASS_INVISI_SHINY);
  3772. registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
  3773. }
  3774. else if (LLPipeline::sRenderDeferred)
  3775. {
  3776. if (te->getBumpmap())
  3777. {
  3778. registerFace(group, facep, LLRenderPass::PASS_BUMP);
  3779. }
  3780. else if (te->getFullbright())
  3781. {
  3782. registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
  3783. }
  3784. else
  3785. {
  3786. llassert(mask & LLVertexBuffer::MAP_NORMAL);
  3787. registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
  3788. }
  3789. }
  3790. else if (fullbright)
  3791. {
  3792. registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT_SHINY);
  3793. }
  3794. else
  3795. {
  3796. registerFace(group, facep, LLRenderPass::PASS_SHINY);
  3797. }
  3798. }
  3799. else
  3800. {
  3801. if (!is_alpha && tex->getPrimaryFormat() == GL_ALPHA)
  3802. {
  3803. registerFace(group, facep, LLRenderPass::PASS_INVISIBLE);
  3804. }
  3805. else if (fullbright)
  3806. {
  3807. registerFace(group, facep, LLRenderPass::PASS_FULLBRIGHT);
  3808. }
  3809. else
  3810. {
  3811. if (LLPipeline::sRenderDeferred && te->getBumpmap())
  3812. {
  3813. registerFace(group, facep, LLRenderPass::PASS_BUMP);
  3814. }
  3815. else
  3816. {
  3817. llassert(mask & LLVertexBuffer::MAP_NORMAL);
  3818. registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
  3819. }
  3820. }
  3822. if (!is_alpha && te->getShiny() && LLPipeline::sRenderBump)
  3823. {
  3824. registerFace(group, facep, LLRenderPass::PASS_SHINY);
  3825. }
  3826. }
  3828. if (!is_alpha && !LLPipeline::sRenderDeferred)
  3829. {
  3830. llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);
  3831. facep->setPoolType((fullbright) ? LLDrawPool::POOL_FULLBRIGHT : LLDrawPool::POOL_SIMPLE);
  3833. if (!force_simple && te->getBumpmap() && LLPipeline::sRenderBump)
  3834. {
  3835. registerFace(group, facep, LLRenderPass::PASS_BUMP);
  3836. }
  3837. }
  3839. if (LLPipeline::sRenderGlow && te->getGlow() > 0.f)
  3840. {
  3841. registerFace(group, facep, LLRenderPass::PASS_GLOW);
  3842. }
  3844. ++face_iter;
  3845. }
  3847. buffer->setBuffer(0);
  3848. }
  3850. group->mBufferMap[mask].clear();
  3851. for (LLSpatialGroup::buffer_texture_map_t::iterator i = buffer_map[mask].begin(); i != buffer_map[mask].end(); ++i)
  3852. {
  3853. group->mBufferMap[mask][i->first] = i->second;
  3854. }
  3855. }
  3857. void LLGeometryManager::addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32 &index_count)
  3858. {
  3859. //initialize to default usage for this partition
  3860. U32 usage = group->mSpatialPartition->mBufferUsage;
  3862. //clear off any old faces
  3863. mFaceList.clear();
  3865. //for each drawable
  3866. for (LLSpatialGroup::element_iter drawable_iter = group->getData().begin(); drawable_iter != group->getData().end(); ++drawable_iter)
  3867. {
  3868. LLDrawable* drawablep = *drawable_iter;
  3870. if (drawablep->isDead())
  3871. {
  3872. continue;
  3873. }
  3875. if (drawablep->isAnimating())
  3876. { //fall back to stream draw for animating verts
  3877. usage = GL_STREAM_DRAW_ARB;
  3878. }
  3880. //for each face
  3881. for (S32 i = 0; i < drawablep->getNumFaces(); i++)
  3882. {
  3883. //sum up face verts and indices
  3884. drawablep->updateFaceSize(i);
  3885. LLFace* facep = drawablep->getFace(i);
  3886. if (facep->hasGeometry() && facep->mPixelArea > FORCE_CULL_AREA)
  3887. {
  3888. vertex_count += facep->getGeomCount();
  3889. index_count += facep->getIndicesCount();
  3891. //remember face (for sorting)
  3892. mFaceList.push_back(facep);
  3893. }
  3894. else
  3895. {
  3896. facep->mVertexBuffer = NULL;
  3897. facep->mLastVertexBuffer = NULL;
  3898. }
  3899. }
  3900. }
  3902. group->mBufferUsage = usage;
  3903. }
  3905. LLHUDPartition::LLHUDPartition()
  3906. {
  3907. mPartitionType = LLViewerRegion::PARTITION_HUD;
  3908. mDrawableType = LLPipeline::RENDER_TYPE_HUD;
  3909. mSlopRatio = 0.f;
  3910. mLODPeriod = 1;
  3911. }
  3913. void LLHUDPartition::shift(const LLVector3 &offset)
  3914. {
  3915. //HUD objects don't shift with region crossing.  That would be silly.
  3916. }