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

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

游戏引擎

开发平台：

C++ Builder

llviewerobject.cpp：源码内容
  1. LLFloaterReg::hideInstance("properties", item_id);
  3. LLMessageSystem* msg = gMessageSystem;
  4. msg->newMessageFast(_PREHASH_RemoveTaskInventory);
  5. msg->nextBlockFast(_PREHASH_AgentData);
  6. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  7. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  8. msg->nextBlockFast(_PREHASH_InventoryData);
  9. msg->addU32Fast(_PREHASH_LocalID, mLocalID);
  10. msg->addUUIDFast(_PREHASH_ItemID, item_id);
  11. msg->sendReliable(mRegionp->getHost());
  12. deleteInventoryItem(item_id);
  13. ++mInventorySerialNum;
  14. }
  16. void LLViewerObject::updateInventory(
  17. LLViewerInventoryItem* item,
  18. U8 key,
  19. bool is_new)
  20. {
  21. LLMemType mt(LLMemType::MTYPE_OBJECT);
  23. // This slices the object into what we're concerned about on the
  24. // viewer. The simulator will take the permissions and transfer
  25. // ownership.
  26. LLPointer<LLViewerInventoryItem> task_item =
  27. new LLViewerInventoryItem(item->getUUID(), mID, item->getPermissions(),
  28.   item->getAssetUUID(), item->getType(),
  29.   item->getInventoryType(),
  30.   item->getName(), item->getDescription(),
  31.   item->getSaleInfo(),
  32.   item->getFlags(),
  33.   item->getCreationDate());
  34. task_item->setTransactionID(item->getTransactionID());
  35. LLMessageSystem* msg = gMessageSystem;
  36. msg->newMessageFast(_PREHASH_UpdateTaskInventory);
  37. msg->nextBlockFast(_PREHASH_AgentData);
  38. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  39. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  40. msg->nextBlockFast(_PREHASH_UpdateData);
  41. msg->addU32Fast(_PREHASH_LocalID, mLocalID);
  42. msg->addU8Fast(_PREHASH_Key, key);
  43. msg->nextBlockFast(_PREHASH_InventoryData);
  44. task_item->packMessage(msg);
  45. msg->sendReliable(mRegionp->getHost());
  47. // do the internal logic
  48. doUpdateInventory(task_item, key, is_new);
  49. }
  51. void LLViewerObject::updateInventoryLocal(LLInventoryItem* item, U8 key)
  52. {
  53. LLPointer<LLViewerInventoryItem> task_item =
  54. new LLViewerInventoryItem(item->getUUID(), mID, item->getPermissions(),
  55.   item->getAssetUUID(), item->getType(),
  56.   item->getInventoryType(),
  57.   item->getName(), item->getDescription(),
  58.   item->getSaleInfo(), item->getFlags(),
  59.   item->getCreationDate());
  61. // do the internal logic
  62. const bool is_new = false;
  63. doUpdateInventory(task_item, key, is_new);
  64. }
  66. LLInventoryObject* LLViewerObject::getInventoryObject(const LLUUID& item_id)
  67. {
  68. LLInventoryObject* rv = NULL;
  69. if(mInventory)
  70. {
  71. InventoryObjectList::iterator it = mInventory->begin();
  72. InventoryObjectList::iterator end = mInventory->end();
  73. for ( ; it != end; ++it)
  74. {
  75. if((*it)->getUUID() == item_id)
  76. {
  77. rv = *it;
  78. break;
  79. }
  80. }
  81. }
  82. return rv;
  83. }
  85. void LLViewerObject::getInventoryContents(InventoryObjectList& objects)
  86. {
  87. if(mInventory)
  88. {
  89. InventoryObjectList::iterator it = mInventory->begin();
  90. InventoryObjectList::iterator end = mInventory->end();
  91. for( ; it != end; ++it)
  92. {
  93. if ((*it)->getType() != LLAssetType::AT_CATEGORY)
  94. {
  95. objects.push_back(*it);
  96. }
  97. }
  98. }
  99. }
  101. LLInventoryObject* LLViewerObject::getInventoryRoot()
  102. {
  103. if (!mInventory || !mInventory->size())
  104. {
  105. return NULL;
  106. }
  107. return mInventory->back();
  108. }
  110. LLViewerInventoryItem* LLViewerObject::getInventoryItemByAsset(const LLUUID& asset_id)
  111. {
  112. if (mInventoryDirty)
  113. llwarns << "Peforming inventory lookup for object " << mID << " that has dirty inventory!" << llendl;
  115. LLViewerInventoryItem* rv = NULL;
  116. if(mInventory)
  117. {
  118. LLViewerInventoryItem* item = NULL;
  120. InventoryObjectList::iterator it = mInventory->begin();
  121. InventoryObjectList::iterator end = mInventory->end();
  122. for( ; it != end; ++it)
  123. {
  124. LLInventoryObject* obj = *it;
  125. if(obj->getType() != LLAssetType::AT_CATEGORY)
  126. {
  127. // *FIX: gank-ass down cast!
  128. item = (LLViewerInventoryItem*)obj;
  129. if(item->getAssetUUID() == asset_id)
  130. {
  131. rv = item;
  132. break;
  133. }
  134. }
  135. }
  136. }
  137. return rv;
  138. }
  140. void LLViewerObject::updateViewerInventoryAsset(
  141. const LLViewerInventoryItem* item,
  142. const LLUUID& new_asset)
  143. {
  144. LLPointer<LLViewerInventoryItem> task_item =
  145. new LLViewerInventoryItem(item);
  146. task_item->setAssetUUID(new_asset);
  148. // do the internal logic
  149. doUpdateInventory(task_item, TASK_INVENTORY_ITEM_KEY, false);
  150. }
  152. void LLViewerObject::setPixelAreaAndAngle(LLAgent &agent)
  153. {
  154. if (getVolume())
  155. { //volumes calculate pixel area and angle per face
  156. return;
  157. }
  159. LLVector3 viewer_pos_agent = agent.getCameraPositionAgent();
  160. LLVector3 pos_agent = getRenderPosition();
  162. F32 dx = viewer_pos_agent.mV[VX] - pos_agent.mV[VX];
  163. F32 dy = viewer_pos_agent.mV[VY] - pos_agent.mV[VY];
  164. F32 dz = viewer_pos_agent.mV[VZ] - pos_agent.mV[VZ];
  166. F32 max_scale = getMaxScale();
  167. F32 mid_scale = getMidScale();
  168. F32 min_scale = getMinScale();
  170. // IW: estimate - when close to large objects, computing range based on distance from center is no good
  171. // to try to get a min distance from face, subtract min_scale/2 from the range.
  172. // This means we'll load too much detail sometimes, but that's better than not enough
  173. // I don't think there's a better way to do this without calculating distance per-poly
  174. F32 range = sqrt(dx*dx + dy*dy + dz*dz) - min_scale/2;
  176. LLViewerCamera* camera = LLViewerCamera::getInstance();
  177. if (range < 0.001f || isHUDAttachment()) // range == zero
  178. {
  179. mAppAngle = 180.f;
  180. mPixelArea = (F32)camera->getScreenPixelArea();
  181. }
  182. else
  183. {
  184. mAppAngle = (F32) atan2( max_scale, range) * RAD_TO_DEG;
  186. F32 pixels_per_meter = camera->getPixelMeterRatio() / range;
  188. mPixelArea = (pixels_per_meter * max_scale) * (pixels_per_meter * mid_scale);
  189. if (mPixelArea > camera->getScreenPixelArea())
  190. {
  191. mAppAngle = 180.f;
  192. mPixelArea = (F32)camera->getScreenPixelArea();
  193. }
  194. }
  195. }
  197. BOOL LLViewerObject::updateLOD()
  198. {
  199. return FALSE;
  200. }
  202. BOOL LLViewerObject::updateGeometry(LLDrawable *drawable)
  203. {
  204. return TRUE;
  205. }
  207. void LLViewerObject::updateGL()
  208. {
  210. }
  212. void LLViewerObject::updateFaceSize(S32 idx)
  213. {
  215. }
  217. LLDrawable* LLViewerObject::createDrawable(LLPipeline *pipeline)
  218. {
  219. return NULL;
  220. }
  222. void LLViewerObject::setScale(const LLVector3 &scale, BOOL damped)
  223. {
  224. LLPrimitive::setScale(scale);
  225. if (mDrawable.notNull())
  226. {
  227. //encompass completely sheared objects by taking 
  228. //the most extreme point possible (<1,1,0.5>)
  229. mDrawable->setRadius(LLVector3(1,1,0.5f).scaleVec(scale).magVec());
  230. updateDrawable(damped);
  231. }
  233. if( (LL_PCODE_VOLUME == getPCode()) && !isDead() )
  234. {
  235. if (permYouOwner() || (scale.magVecSquared() > (7.5f * 7.5f)) )
  236. {
  237. if (!mOnMap)
  238. {
  239. gObjectList.addToMap(this);
  240. mOnMap = TRUE;
  241. }
  242. }
  243. else
  244. {
  245. if (mOnMap)
  246. {
  247. gObjectList.removeFromMap(this);
  248. mOnMap = FALSE;
  249. }
  250. }
  251. }
  252. }
  254. void LLViewerObject::updateSpatialExtents(LLVector3& newMin, LLVector3 &newMax)
  255. {
  256. LLVector3 center = getRenderPosition();
  257. LLVector3 size = getScale();
  258. newMin.setVec(center-size);
  259. newMax.setVec(center+size);
  260. mDrawable->setPositionGroup((newMin + newMax) * 0.5f);
  261. }
  263. F32 LLViewerObject::getBinRadius()
  264. {
  265. if (mDrawable.notNull())
  266. {
  267. const LLVector3* ext = mDrawable->getSpatialExtents();
  268. return (ext[1]-ext[0]).magVec();
  269. }
  271. return getScale().magVec();
  272. }
  274. F32 LLViewerObject::getMaxScale() const
  275. {
  276. return llmax(getScale().mV[VX],getScale().mV[VY], getScale().mV[VZ]);
  277. }
  279. F32 LLViewerObject::getMinScale() const
  280. {
  281. return llmin(getScale().mV[0],getScale().mV[1],getScale().mV[2]);
  282. }
  284. F32 LLViewerObject::getMidScale() const
  285. {
  286. if (getScale().mV[VX] < getScale().mV[VY])
  287. {
  288. if (getScale().mV[VY] < getScale().mV[VZ])
  289. {
  290. return getScale().mV[VY];
  291. }
  292. else if (getScale().mV[VX] < getScale().mV[VZ])
  293. {
  294. return getScale().mV[VZ];
  295. }
  296. else
  297. {
  298. return getScale().mV[VX];
  299. }
  300. }
  301. else if (getScale().mV[VX] < getScale().mV[VZ])
  302. {
  303. return getScale().mV[VX];
  304. }
  305. else if (getScale().mV[VY] < getScale().mV[VZ])
  306. {
  307. return getScale().mV[VZ];
  308. }
  309. else
  310. {
  311. return getScale().mV[VY];
  312. }
  313. }
  316. void LLViewerObject::updateTextures()
  317. {
  318. }
  320. void LLViewerObject::boostTexturePriority(BOOL boost_children /* = TRUE */)
  321. {
  322. if (isDead())
  323. {
  324. return;
  325. }
  327. S32 i;
  328. S32 tex_count = getNumTEs();
  329. for (i = 0; i < tex_count; i++)
  330. {
  331.   getTEImage(i)->setBoostLevel(LLViewerTexture::BOOST_SELECTED);
  332. }
  334. if (isSculpted())
  335. {
  336. LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  337. LLUUID sculpt_id = sculpt_params->getSculptTexture();
  338. LLViewerTextureManager::getFetchedTexture(sculpt_id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)->setBoostLevel(LLViewerTexture::BOOST_SELECTED);
  339. }
  341. if (boost_children)
  342. {
  343. for (child_list_t::iterator iter = mChildList.begin();
  344.  iter != mChildList.end(); iter++)
  345. {
  346. LLViewerObject* child = *iter;
  347. child->boostTexturePriority();
  348. }
  349. }
  350. }
  353. void LLViewerObject::setLineWidthForWindowSize(S32 window_width)
  354. {
  355. if (window_width < 700)
  356. {
  357. LLUI::setLineWidth(2.0f);
  358. }
  359. else if (window_width < 1100)
  360. {
  361. LLUI::setLineWidth(3.0f);
  362. }
  363. else if (window_width < 2000)
  364. {
  365. LLUI::setLineWidth(4.0f);
  366. }
  367. else
  368. {
  369. // _damn_, what a nice monitor!
  370. LLUI::setLineWidth(5.0f);
  371. }
  372. }
  374. void LLViewerObject::increaseArrowLength()
  375. {
  376. /* ???
  377. if (mAxisArrowLength == 50)
  378. {
  379. mAxisArrowLength = 100;
  380. }
  381. else
  382. {
  383. mAxisArrowLength = 150;
  384. }
  385. */
  386. }
  389. void LLViewerObject::decreaseArrowLength()
  390. {
  391. /* ???
  392. if (mAxisArrowLength == 150)
  393. {
  394. mAxisArrowLength = 100;
  395. }
  396. else
  397. {
  398. mAxisArrowLength = 50;
  399. }
  400. */
  401. }
  403. // Culled from newsim LLTask::addNVPair
  404. void LLViewerObject::addNVPair(const std::string& data)
  405. {
  406. // cout << "LLViewerObject::addNVPair() with ---" << data << "---" << endl;
  407. LLNameValue *nv = new LLNameValue(data.c_str());
  409. // char splat[MAX_STRING];
  410. // temp->printNameValue(splat);
  411. // llinfos << "addNVPair " << splat << llendl;
  413. name_value_map_t::iterator iter = mNameValuePairs.find(nv->mName);
  414. if (iter != mNameValuePairs.end())
  415. {
  416. LLNameValue* foundnv = iter->second;
  417. if (foundnv->mClass != NVC_READ_ONLY)
  418. {
  419. delete foundnv;
  420. mNameValuePairs.erase(iter);
  421. }
  422. else
  423. {
  424. delete nv;
  425. // llinfos << "Trying to write to Read Only NVPair " << temp->mName << " in addNVPair()" << llendl;
  426. return;
  427. }
  428. }
  429. mNameValuePairs[nv->mName] = nv;
  430. }
  432. BOOL LLViewerObject::removeNVPair(const std::string& name)
  433. {
  434. char* canonical_name = gNVNameTable.addString(name);
  436. lldebugs << "LLViewerObject::removeNVPair(): " << name << llendl;
  438. name_value_map_t::iterator iter = mNameValuePairs.find(canonical_name);
  439. if (iter != mNameValuePairs.end())
  440. {
  441. if( mRegionp )
  442. {
  443. LLNameValue* nv = iter->second;
  444. /*
  445. std::string buffer = nv->printNameValue();
  446. gMessageSystem->newMessageFast(_PREHASH_RemoveNameValuePair);
  447. gMessageSystem->nextBlockFast(_PREHASH_TaskData);
  448. gMessageSystem->addUUIDFast(_PREHASH_ID, mID);
  450. gMessageSystem->nextBlockFast(_PREHASH_NameValueData);
  451. gMessageSystem->addStringFast(_PREHASH_NVPair, buffer);
  453. gMessageSystem->sendReliable( mRegionp->getHost() );
  454. */
  455. // Remove the NV pair from the local list.
  456. delete nv;
  457. mNameValuePairs.erase(iter);
  458. return TRUE;
  459. }
  460. else
  461. {
  462. lldebugs << "removeNVPair - No region for object" << llendl;
  463. }
  464. }
  465. return FALSE;
  466. }
  469. LLNameValue *LLViewerObject::getNVPair(const std::string& name) const
  470. {
  471. char *canonical_name;
  473. canonical_name = gNVNameTable.addString(name);
  475. // If you access a map with a name that isn't in it, it will add the name and a null pointer.
  476. // So first check if the data is in the map.
  477. name_value_map_t::const_iterator iter = mNameValuePairs.find(canonical_name);
  478. if (iter != mNameValuePairs.end())
  479. {
  480. return iter->second;
  481. }
  482. else
  483. {
  484. return NULL;
  485. }
  486. }
  488. void LLViewerObject::updatePositionCaches() const
  489. {
  490. if(mRegionp)
  491. {
  492. if (!isRoot())
  493. {
  494. mPositionRegion = ((LLViewerObject *)getParent())->getPositionRegion() + getPosition() * getParent()->getRotation();
  495. mPositionAgent = mRegionp->getPosAgentFromRegion(mPositionRegion);
  496. }
  497. else
  498. {
  499. mPositionRegion = getPosition();
  500. mPositionAgent = mRegionp->getPosAgentFromRegion(mPositionRegion);
  501. }
  502. }
  503. }
  505. const LLVector3d LLViewerObject::getPositionGlobal() const
  506. {
  507. if(mRegionp)
  508. {
  509. LLVector3d position_global = mRegionp->getPosGlobalFromRegion(getPositionRegion());
  511. if (isAttachment())
  512. {
  513. position_global = gAgent.getPosGlobalFromAgent(getRenderPosition());
  514. }
  515. return position_global;
  516. }
  517. else
  518. {
  519. LLVector3d position_global(getPosition());
  520. return position_global;
  521. }
  522. }
  524. const LLVector3 &LLViewerObject::getPositionAgent() const
  525. {
  526. if (mRegionp)
  527. {
  528. if (mDrawable.notNull() && (!mDrawable->isRoot() && getParent()))
  529. {
  530. // Don't return cached position if you have a parent, recalc (until all dirtying is done correctly.
  531. LLVector3 position_region;
  532. position_region = ((LLViewerObject *)getParent())->getPositionRegion() + getPosition() * getParent()->getRotation();
  533. mPositionAgent = mRegionp->getPosAgentFromRegion(position_region);
  534. }
  535. else
  536. {
  537. mPositionAgent = mRegionp->getPosAgentFromRegion(getPosition());
  538. }
  539. }
  540. return mPositionAgent;
  541. }
  543. const LLVector3 &LLViewerObject::getPositionRegion() const
  544. {
  545. if (!isRoot())
  546. {
  547. LLViewerObject *parent = (LLViewerObject *)getParent();
  548. mPositionRegion = parent->getPositionRegion() + (getPosition() * parent->getRotation());
  549. }
  550. else
  551. {
  552. mPositionRegion = getPosition();
  553. }
  555. return mPositionRegion;
  556. }
  558. const LLVector3 LLViewerObject::getPositionEdit() const
  559. {
  560. if (isRootEdit())
  561. {
  562. return getPosition();
  563. }
  564. else
  565. {
  566. LLViewerObject *parent = (LLViewerObject *)getParent();
  567. LLVector3 position_edit = parent->getPositionEdit() + getPosition() * parent->getRotationEdit();
  568. return position_edit;
  569. }
  570. }
  572. const LLVector3 LLViewerObject::getRenderPosition() const
  573. {
  574. if (mDrawable.isNull() || mDrawable->getGeneration() < 0)
  575. {
  576. return getPositionAgent();
  577. }
  578. else
  579. {
  580. return mDrawable->getPositionAgent();
  581. }
  582. }
  584. const LLVector3 LLViewerObject::getPivotPositionAgent() const
  585. {
  586. return getRenderPosition();
  587. }
  589. const LLQuaternion LLViewerObject::getRenderRotation() const
  590. {
  591. LLQuaternion ret;
  592. if (mDrawable.isNull() || mDrawable->isStatic())
  593. {
  594. ret = getRotationEdit();
  595. }
  596. else
  597. {
  598. if (!mDrawable->isRoot())
  599. {
  600. ret = getRotation() * LLQuaternion(mDrawable->getParent()->getWorldMatrix());
  601. }
  602. else
  603. {
  604. ret = LLQuaternion(mDrawable->getWorldMatrix());
  605. }
  606. }
  608. return ret;
  609. }
  611. const LLMatrix4 LLViewerObject::getRenderMatrix() const
  612. {
  613. return mDrawable->getWorldMatrix();
  614. }
  616. const LLQuaternion LLViewerObject::getRotationRegion() const
  617. {
  618. LLQuaternion global_rotation = getRotation();
  619. if (!((LLXform *)this)->isRoot())
  620. {
  621. global_rotation = global_rotation * getParent()->getRotation();
  622. }
  623. return global_rotation;
  624. }
  626. const LLQuaternion LLViewerObject::getRotationEdit() const
  627. {
  628. LLQuaternion global_rotation = getRotation();
  629. if (!((LLXform *)this)->isRootEdit())
  630. {
  631. global_rotation = global_rotation * getParent()->getRotation();
  632. }
  633. return global_rotation;
  634. }
  636. void LLViewerObject::setPositionAbsoluteGlobal( const LLVector3d &pos_global, BOOL damped )
  637. {
  638. if (isAttachment())
  639. {
  640. LLVector3 new_pos = mRegionp->getPosRegionFromGlobal(pos_global);
  641. if (isRootEdit())
  642. {
  643. new_pos -= mDrawable->mXform.getParent()->getWorldPosition();
  644. LLQuaternion world_rotation = mDrawable->mXform.getParent()->getWorldRotation();
  645. new_pos = new_pos * ~world_rotation;
  646. }
  647. else
  648. {
  649. LLViewerObject* parentp = (LLViewerObject*)getParent();
  650. new_pos -= parentp->getPositionAgent();
  651. new_pos = new_pos * ~parentp->getRotationRegion();
  652. }
  653. LLViewerObject::setPosition(new_pos);
  655. if (mParent && ((LLViewerObject*)mParent)->isAvatar())
  656. {
  657. // we have changed the position of an attachment, so we need to clamp it
  658. LLVOAvatar *avatar = (LLVOAvatar*)mParent;
  660. avatar->clampAttachmentPositions();
  661. }
  662. }
  663. else
  664. {
  665. if( isRoot() )
  666. {
  667. setPositionRegion(mRegionp->getPosRegionFromGlobal(pos_global));
  668. }
  669. else
  670. {
  671. // the relative position with the parent is not constant
  672. LLViewerObject* parent = (LLViewerObject *)getParent();
  673. //RN: this assumes we are only calling this function from the edit tools
  674. gPipeline.updateMoveNormalAsync(parent->mDrawable);
  676. LLVector3 pos_local = mRegionp->getPosRegionFromGlobal(pos_global) - parent->getPositionRegion();
  677. pos_local = pos_local * ~parent->getRotationRegion();
  678. LLViewerObject::setPosition( pos_local );
  679. }
  680. }
  681. //RN: assumes we always want to snap the object when calling this function
  682. gPipeline.updateMoveNormalAsync(mDrawable);
  683. }
  685. void LLViewerObject::setPosition(const LLVector3 &pos, BOOL damped)
  686. {
  687. if (getPosition() != pos)
  688. {
  689. setChanged(TRANSLATED | SILHOUETTE);
  690. }
  692. LLXform::setPosition(pos);
  693. updateDrawable(damped);
  694. if (isRoot())
  695. {
  696. // position caches need to be up to date on root objects
  697. updatePositionCaches();
  698. }
  699. }
  701. void LLViewerObject::setPositionGlobal(const LLVector3d &pos_global, BOOL damped)
  702. {
  703. if (isAttachment())
  704. {
  705. if (isRootEdit())
  706. {
  707. LLVector3 newPos = mRegionp->getPosRegionFromGlobal(pos_global);
  708. newPos = newPos - mDrawable->mXform.getParent()->getWorldPosition();
  710. LLQuaternion invWorldRotation = mDrawable->mXform.getParent()->getWorldRotation();
  711. invWorldRotation.transQuat();
  713. newPos = newPos * invWorldRotation;
  714. LLViewerObject::setPosition(newPos);
  715. }
  716. else
  717. {
  718. // assumes parent is root editable (root of attachment)
  719. LLVector3 newPos = mRegionp->getPosRegionFromGlobal(pos_global);
  720. newPos = newPos - mDrawable->mXform.getParent()->getWorldPosition();
  721. LLVector3 delta_pos = newPos - getPosition();
  723. LLQuaternion invRotation = mDrawable->getRotation();
  724. invRotation.transQuat();
  726. delta_pos = delta_pos * invRotation;
  728. // *FIX: is this right?  Shouldn't we be calling the
  729. // LLViewerObject version of setPosition?
  730. LLVector3 old_pos = mDrawable->mXform.getParent()->getPosition();
  731. mDrawable->mXform.getParent()->setPosition(old_pos + delta_pos);
  732. setChanged(TRANSLATED | SILHOUETTE);
  733. }
  734. if (mParent && ((LLViewerObject*)mParent)->isAvatar())
  735. {
  736. // we have changed the position of an attachment, so we need to clamp it
  737. LLVOAvatar *avatar = (LLVOAvatar*)mParent;
  739. avatar->clampAttachmentPositions();
  740. }
  741. }
  742. else
  743. {
  744. if (isRoot())
  745. {
  746. setPositionRegion(mRegionp->getPosRegionFromGlobal(pos_global));
  747. }
  748. else
  749. {
  750. // the relative position with the parent is constant, but the parent's position needs to be changed
  751. LLVector3d position_offset;
  752. position_offset.setVec(getPosition()*getParent()->getRotation());
  753. LLVector3d new_pos_global = pos_global - position_offset;
  754. ((LLViewerObject *)getParent())->setPositionGlobal(new_pos_global);
  755. }
  756. }
  757. updateDrawable(damped);
  758. }
  761. void LLViewerObject::setPositionParent(const LLVector3 &pos_parent, BOOL damped)
  762. {
  763. // Set position relative to parent, if no parent, relative to region
  764. if (!isRoot())
  765. {
  766. LLViewerObject::setPosition(pos_parent);
  767. updateDrawable(damped);
  768. }
  769. else
  770. {
  771. setPositionRegion(pos_parent, damped);
  772. }
  773. }
  775. void LLViewerObject::setPositionRegion(const LLVector3 &pos_region, BOOL damped)
  776. {
  777. if (!isRootEdit())
  778. {
  779. LLViewerObject* parent = (LLViewerObject*) getParent();
  780. LLViewerObject::setPosition((pos_region-parent->getPositionRegion())*~parent->getRotationRegion());
  781. }
  782. else
  783. {
  784. LLViewerObject::setPosition(pos_region);
  785. mPositionRegion = pos_region;
  786. mPositionAgent = mRegionp->getPosAgentFromRegion(mPositionRegion);
  787. }
  788. }
  790. void LLViewerObject::setPositionAgent(const LLVector3 &pos_agent, BOOL damped)
  791. {
  792. LLVector3 pos_region = getRegion()->getPosRegionFromAgent(pos_agent);
  793. setPositionRegion(pos_region, damped);
  794. }
  796. // identical to setPositionRegion() except it checks for child-joints 
  797. // and doesn't also move the joint-parent
  798. // TODO -- implement similar intelligence for joint-parents toward
  799. // their joint-children
  800. void LLViewerObject::setPositionEdit(const LLVector3 &pos_edit, BOOL damped)
  801. {
  802. if (!isRootEdit())
  803. {
  804. // the relative position with the parent is constant, but the parent's position needs to be changed
  805. LLVector3 position_offset = getPosition() * getParent()->getRotation();
  807. ((LLViewerObject *)getParent())->setPositionEdit(pos_edit - position_offset);
  808. }
  809. else if (isJointChild())
  810. {
  811. // compute new parent-relative position
  812. LLViewerObject *parent = (LLViewerObject *) getParent();
  813. LLQuaternion inv_parent_rot = parent->getRotation();
  814. inv_parent_rot.transQuat();
  815. LLVector3 pos_parent = (pos_edit - parent->getPositionRegion()) * inv_parent_rot;
  816. LLViewerObject::setPosition(pos_parent);
  817. }
  818. else
  819. {
  820. LLViewerObject::setPosition(pos_edit);
  821. mPositionRegion = pos_edit;
  822. mPositionAgent = mRegionp->getPosAgentFromRegion(mPositionRegion);
  823. }
  824. updateDrawable(damped);
  825. }
  828. LLViewerObject* LLViewerObject::getRootEdit() const
  829. {
  830. const LLViewerObject* root = this;
  831. while (root->mParent 
  832.    && !(root->mJointInfo
  833.    || ((LLViewerObject*)root->mParent)->isAvatar()) )
  834. {
  835. root = (LLViewerObject*)root->mParent;
  836. }
  837. return (LLViewerObject*)root;
  838. }
  841. BOOL LLViewerObject::lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
  842.   S32 face,
  843.   BOOL pick_transparent,
  844.   S32* face_hit,
  845.   LLVector3* intersection,
  846.   LLVector2* tex_coord,
  847.   LLVector3* normal,
  848.   LLVector3* bi_normal)
  849. {
  850. return false;
  851. }
  853. BOOL LLViewerObject::lineSegmentBoundingBox(const LLVector3& start, const LLVector3& end)
  854. {
  855. if (mDrawable.isNull() || mDrawable->isDead())
  856. {
  857. return FALSE;
  858. }
  860. const LLVector3* ext = mDrawable->getSpatialExtents();
  862. LLVector3 center = (ext[1]+ext[0])*0.5f;
  863. LLVector3 size = (ext[1]-ext[0])*0.5f;
  865. return LLLineSegmentBoxIntersect(start, end, center, size);
  866. }
  868. U8 LLViewerObject::getMediaType() const
  869. {
  870. if (mMedia)
  871. {
  872. return mMedia->mMediaType;
  873. }
  874. else
  875. {
  876. return LLViewerObject::MEDIA_NONE;
  877. }
  878. }
  880. void LLViewerObject::setMediaType(U8 media_type)
  881. {
  882. if (!mMedia)
  883. {
  884. // TODO what if we don't have a media pointer?
  885. }
  886. else if (mMedia->mMediaType != media_type)
  887. {
  888. mMedia->mMediaType = media_type;
  890. // TODO: update materials with new image
  891. }
  892. }
  894. std::string LLViewerObject::getMediaURL() const
  895. {
  896. if (mMedia)
  897. {
  898. return mMedia->mMediaURL;
  899. }
  900. else
  901. {
  902. return std::string();
  903. }
  904. }
  906. void LLViewerObject::setMediaURL(const std::string& media_url)
  907. {
  908. LLMemType mt(LLMemType::MTYPE_OBJECT);
  910. if (!mMedia)
  911. {
  912. mMedia = new LLViewerObjectMedia;
  913. mMedia->mMediaURL = media_url;
  914. mMedia->mPassedWhitelist = FALSE;
  916. // TODO: update materials with new image
  917. }
  918. else if (mMedia->mMediaURL != media_url)
  919. {
  920. mMedia->mMediaURL = media_url;
  921. mMedia->mPassedWhitelist = FALSE;
  923. // TODO: update materials with new image
  924. }
  925. }
  927. BOOL LLViewerObject::getMediaPassedWhitelist() const
  928. {
  929. if (mMedia)
  930. {
  931. return mMedia->mPassedWhitelist;
  932. }
  933. else
  934. {
  935. return FALSE;
  936. }
  937. }
  939. void LLViewerObject::setMediaPassedWhitelist(BOOL passed)
  940. {
  941. if (mMedia)
  942. {
  943. mMedia->mPassedWhitelist = passed;
  944. }
  945. }
  947. BOOL LLViewerObject::setMaterial(const U8 material)
  948. {
  949. BOOL res = LLPrimitive::setMaterial(material);
  950. if (res)
  951. {
  952. setChanged(TEXTURE);
  953. }
  954. return res;
  955. }
  957. void LLViewerObject::setNumTEs(const U8 num_tes)
  958. {
  959. LLMemType mt(LLMemType::MTYPE_OBJECT);
  961. U32 i;
  962. if (num_tes != getNumTEs())
  963. {
  964. if (num_tes)
  965. {
  966. LLPointer<LLViewerTexture> *new_images;
  967. new_images = new LLPointer<LLViewerTexture>[num_tes];
  968. for (i = 0; i < num_tes; i++)
  969. {
  970. if (i < getNumTEs())
  971. {
  972. new_images[i] = mTEImages[i];
  973. }
  974. else if (getNumTEs())
  975. {
  976. new_images[i] = mTEImages[getNumTEs()-1];
  977. }
  978. else
  979. {
  980. new_images[i] = NULL;
  981. }
  982. }
  984. deleteTEImages();
  986. mTEImages = new_images;
  987. }
  988. else
  989. {
  990. deleteTEImages();
  991. }
  992. LLPrimitive::setNumTEs(num_tes);
  993. setChanged(TEXTURE);
  995. if (mDrawable.notNull())
  996. {
  997. gPipeline.markTextured(mDrawable);
  998. }
  999. }
  1000. }
  1002. void LLViewerObject::sendMaterialUpdate() const
  1003. {
  1004. LLViewerRegion* regionp = getRegion();
  1005. if(!regionp) return;
  1006. gMessageSystem->newMessageFast(_PREHASH_ObjectMaterial);
  1007. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1008. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1009. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1010. gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  1011. gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, mLocalID );
  1012. gMessageSystem->addU8Fast(_PREHASH_Material, getMaterial() );
  1013. gMessageSystem->sendReliable( regionp->getHost() );
  1015. }
  1017. // formerly send_object_rotation
  1018. void LLViewerObject::sendRotationUpdate() const
  1019. {
  1020. LLViewerRegion* regionp = getRegion();
  1021. if(!regionp) return;
  1022. gMessageSystem->newMessageFast(_PREHASH_ObjectRotation);
  1023. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1024. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1025. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1026. gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  1027. gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, mLocalID);
  1028. gMessageSystem->addQuatFast(_PREHASH_Rotation, getRotationEdit());
  1029. //llinfos << "Sent rotation " << getRotationEdit() << llendl;
  1030. gMessageSystem->sendReliable( regionp->getHost() );
  1031. }
  1033. /* Obsolete, we use MultipleObjectUpdate instead
  1034. //// formerly send_object_position_global
  1035. //void LLViewerObject::sendPositionUpdate() const
  1036. //{
  1037. // gMessageSystem->newMessageFast(_PREHASH_ObjectPosition);
  1038. // gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1039. // gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1040. // gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1041. // gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  1042. // gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, mLocalID );
  1043. // gMessageSystem->addVector3Fast(_PREHASH_Position, getPositionRegion());
  1044. // LLViewerRegion* regionp = getRegion();
  1045. // gMessageSystem->sendReliable(regionp->getHost());
  1046. //}
  1047. */
  1049. //formerly send_object_shape(LLViewerObject *object)
  1050. void LLViewerObject::sendShapeUpdate()
  1051. {
  1052. gMessageSystem->newMessageFast(_PREHASH_ObjectShape);
  1053. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1054. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1055. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1056. gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  1057. gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, mLocalID );
  1059. LLVolumeMessage::packVolumeParams(&getVolume()->getParams(), gMessageSystem);
  1061. LLViewerRegion *regionp = getRegion();
  1062. gMessageSystem->sendReliable( regionp->getHost() );
  1063. }
  1066. void LLViewerObject::sendTEUpdate() const
  1067. {
  1068. LLMessageSystem* msg = gMessageSystem;
  1069. msg->newMessageFast(_PREHASH_ObjectImage);
  1071. msg->nextBlockFast(_PREHASH_AgentData);
  1072. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  1073. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1075. msg->nextBlockFast(_PREHASH_ObjectData);
  1076. msg->addU32Fast(_PREHASH_ObjectLocalID, mLocalID );
  1077. if (mMedia)
  1078. {
  1079. msg->addString("MediaURL", mMedia->mMediaURL);
  1080. }
  1081. else
  1082. {
  1083. msg->addString("MediaURL", NULL);
  1084. }
  1086. // TODO send media type
  1088. packTEMessage(msg);
  1090. LLViewerRegion *regionp = getRegion();
  1091. msg->sendReliable( regionp->getHost() );
  1092. }
  1094. void LLViewerObject::setTE(const U8 te, const LLTextureEntry &texture_entry)
  1095. {
  1096. LLPrimitive::setTE(te, texture_entry);
  1097. //  This doesn't work, don't get any textures.
  1098. // if (mDrawable.notNull() && mDrawable->isVisible())
  1099. // {
  1100. const LLUUID& image_id = getTE(te)->getID();
  1101. mTEImages[te] = LLViewerTextureManager::getFetchedTexture(image_id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  1102. // }
  1103. }
  1105. void LLViewerObject::setTEImage(const U8 te, LLViewerTexture *imagep)
  1106. {
  1107. if (mTEImages[te] != imagep)
  1108. {
  1109. mTEImages[te] = imagep;
  1110. LLPrimitive::setTETexture(te, imagep->getID());
  1111. setChanged(TEXTURE);
  1112. if (mDrawable.notNull())
  1113. {
  1114. gPipeline.markTextured(mDrawable);
  1115. }
  1116. }
  1117. }
  1120. S32 LLViewerObject::setTETextureCore(const U8 te, const LLUUID& uuid, LLHost host)
  1121. {
  1122. S32 retval = 0;
  1123. if (uuid != getTE(te)->getID() ||
  1124. uuid == LLUUID::null)
  1125. {
  1126. retval = LLPrimitive::setTETexture(te, uuid);
  1127. mTEImages[te] = LLViewerTextureManager::getFetchedTexture(uuid, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, host);
  1128. setChanged(TEXTURE);
  1129. if (mDrawable.notNull())
  1130. {
  1131. gPipeline.markTextured(mDrawable);
  1132. }
  1133. }
  1134. return retval;
  1135. }
  1138. void LLViewerObject::changeTEImage(S32 index, LLViewerTexture* new_image) 
  1139. {
  1140. if(index < 0 || index >= getNumTEs())
  1141. {
  1142. return ;
  1143. }
  1144. mTEImages[index] = new_image ;
  1145. }
  1147. S32 LLViewerObject::setTETexture(const U8 te, const LLUUID& uuid)
  1148. {
  1149. // Invalid host == get from the agent's sim
  1150. return setTETextureCore(te, uuid, LLHost::invalid);
  1151. }
  1154. S32 LLViewerObject::setTEColor(const U8 te, const LLColor3& color)
  1155. {
  1156. return setTEColor(te, LLColor4(color));
  1157. }
  1159. S32 LLViewerObject::setTEColor(const U8 te, const LLColor4& color)
  1160. {
  1161. S32 retval = 0;
  1162. const LLTextureEntry *tep = getTE(te);
  1163. if (!tep)
  1164. {
  1165. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1166. }
  1167. else if (color != tep->getColor())
  1168. {
  1169. retval = LLPrimitive::setTEColor(te, color);
  1170. if (mDrawable.notNull() && retval)
  1171. {
  1172. // These should only happen on updates which are not the initial update.
  1173. dirtyMesh();
  1174. }
  1175. }
  1176. return retval;
  1177. }
  1179. S32 LLViewerObject::setTEBumpmap(const U8 te, const U8 bump)
  1180. {
  1181. S32 retval = 0;
  1182. const LLTextureEntry *tep = getTE(te);
  1183. if (!tep)
  1184. {
  1185. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1186. }
  1187. else if (bump != tep->getBumpmap())
  1188. {
  1189. retval = LLPrimitive::setTEBumpmap(te, bump);
  1190. setChanged(TEXTURE);
  1191. if (mDrawable.notNull() && retval)
  1192. {
  1193. gPipeline.markTextured(mDrawable);
  1194. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, TRUE);
  1195. }
  1196. }
  1197. return retval;
  1198. }
  1200. S32 LLViewerObject::setTETexGen(const U8 te, const U8 texgen)
  1201. {
  1202. S32 retval = 0;
  1203. const LLTextureEntry *tep = getTE(te);
  1204. if (!tep)
  1205. {
  1206. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1207. }
  1208. else if (texgen != tep->getTexGen())
  1209. {
  1210. retval = LLPrimitive::setTETexGen(te, texgen);
  1211. setChanged(TEXTURE);
  1212. }
  1213. return retval;
  1214. }
  1216. S32 LLViewerObject::setTEMediaTexGen(const U8 te, const U8 media)
  1217. {
  1218. S32 retval = 0;
  1219. const LLTextureEntry *tep = getTE(te);
  1220. if (!tep)
  1221. {
  1222. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1223. }
  1224. else if (media != tep->getMediaTexGen())
  1225. {
  1226. retval = LLPrimitive::setTEMediaTexGen(te, media);
  1227. setChanged(TEXTURE);
  1228. }
  1229. return retval;
  1230. }
  1232. S32 LLViewerObject::setTEShiny(const U8 te, const U8 shiny)
  1233. {
  1234. S32 retval = 0;
  1235. const LLTextureEntry *tep = getTE(te);
  1236. if (!tep)
  1237. {
  1238. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1239. }
  1240. else if (shiny != tep->getShiny())
  1241. {
  1242. retval = LLPrimitive::setTEShiny(te, shiny);
  1243. setChanged(TEXTURE);
  1244. }
  1245. return retval;
  1246. }
  1248. S32 LLViewerObject::setTEFullbright(const U8 te, const U8 fullbright)
  1249. {
  1250. S32 retval = 0;
  1251. const LLTextureEntry *tep = getTE(te);
  1252. if (!tep)
  1253. {
  1254. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1255. }
  1256. else if (fullbright != tep->getFullbright())
  1257. {
  1258. retval = LLPrimitive::setTEFullbright(te, fullbright);
  1259. setChanged(TEXTURE);
  1260. if (mDrawable.notNull() && retval)
  1261. {
  1262. gPipeline.markTextured(mDrawable);
  1263. }
  1264. }
  1265. return retval;
  1266. }
  1269. S32 LLViewerObject::setTEMediaFlags(const U8 te, const U8 media_flags)
  1270. {
  1271. // this might need work for media type
  1272. S32 retval = 0;
  1273. const LLTextureEntry *tep = getTE(te);
  1274. if (!tep)
  1275. {
  1276. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1277. }
  1278. else if (media_flags != tep->getMediaFlags())
  1279. {
  1280. retval = LLPrimitive::setTEMediaFlags(te, media_flags);
  1281. setChanged(TEXTURE);
  1282. if (mDrawable.notNull() && retval)
  1283. {
  1284. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, TRUE);
  1285. gPipeline.markTextured(mDrawable);
  1286. // JC - probably only need this if changes texture coords
  1287. //gPipeline.markRebuild(mDrawable);
  1288. }
  1289. }
  1290. return retval;
  1291. }
  1293. S32 LLViewerObject::setTEGlow(const U8 te, const F32 glow)
  1294. {
  1295. S32 retval = 0;
  1296. const LLTextureEntry *tep = getTE(te);
  1297. if (!tep)
  1298. {
  1299. llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
  1300. }
  1301. else if (glow != tep->getGlow())
  1302. {
  1303. retval = LLPrimitive::setTEGlow(te, glow);
  1304. setChanged(TEXTURE);
  1305. if (mDrawable.notNull() && retval)
  1306. {
  1307. gPipeline.markTextured(mDrawable);
  1308. }
  1309. }
  1310. return retval;
  1311. }
  1314. S32 LLViewerObject::setTEScale(const U8 te, const F32 s, const F32 t)
  1315. {
  1316. S32 retval = 0;
  1317. retval = LLPrimitive::setTEScale(te, s, t);
  1318. setChanged(TEXTURE);
  1319. if (mDrawable.notNull() && retval)
  1320. {
  1321. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1322. }
  1323. return retval;
  1324. }
  1326. S32 LLViewerObject::setTEScaleS(const U8 te, const F32 s)
  1327. {
  1328. S32 retval = LLPrimitive::setTEScaleS(te, s);
  1329. if (mDrawable.notNull() && retval)
  1330. {
  1331. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1332. }
  1334. return retval;
  1335. }
  1337. S32 LLViewerObject::setTEScaleT(const U8 te, const F32 t)
  1338. {
  1339. S32 retval = LLPrimitive::setTEScaleT(te, t);
  1340. if (mDrawable.notNull() && retval)
  1341. {
  1342. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1343. }
  1345. return retval;
  1346. }
  1348. S32 LLViewerObject::setTEOffset(const U8 te, const F32 s, const F32 t)
  1349. {
  1350. S32 retval = LLPrimitive::setTEOffset(te, s, t);
  1351. if (mDrawable.notNull() && retval)
  1352. {
  1353. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1354. }
  1355. return retval;
  1356. }
  1358. S32 LLViewerObject::setTEOffsetS(const U8 te, const F32 s)
  1359. {
  1360. S32 retval = LLPrimitive::setTEOffsetS(te, s);
  1361. if (mDrawable.notNull() && retval)
  1362. {
  1363. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1364. }
  1366. return retval;
  1367. }
  1369. S32 LLViewerObject::setTEOffsetT(const U8 te, const F32 t)
  1370. {
  1371. S32 retval = LLPrimitive::setTEOffsetT(te, t);
  1372. if (mDrawable.notNull() && retval)
  1373. {
  1374. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1375. }
  1377. return retval;
  1378. }
  1380. S32 LLViewerObject::setTERotation(const U8 te, const F32 r)
  1381. {
  1382. S32 retval = LLPrimitive::setTERotation(te, r);
  1383. if (mDrawable.notNull() && retval)
  1384. {
  1385. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD);
  1386. }
  1387. return retval;
  1388. }
  1391. LLViewerTexture *LLViewerObject::getTEImage(const U8 face) const
  1392. {
  1393. // llassert(mTEImages);
  1395. if (face < getNumTEs())
  1396. {
  1397. LLViewerTexture* image = mTEImages[face];
  1398. if (image)
  1399. {
  1400. return image;
  1401. }
  1402. else
  1403. {
  1404. return (LLViewerTexture*)(LLViewerFetchedTexture::sDefaultImagep);
  1405. }
  1406. }
  1408. llerrs << llformat("Requested Image from invalid face: %d/%d",face,getNumTEs()) << llendl;
  1410. return NULL;
  1411. }
  1414. void LLViewerObject::fitFaceTexture(const U8 face)
  1415. {
  1416. llinfos << "fitFaceTexture not implemented" << llendl;
  1417. }
  1420. LLBBox LLViewerObject::getBoundingBoxAgent() const
  1421. {
  1422. LLVector3 position_agent;
  1423. LLQuaternion rot;
  1424. LLViewerObject* avatar_parent = NULL;
  1425. LLViewerObject* root_edit = (LLViewerObject*)getRootEdit();
  1426. if (root_edit)
  1427. {
  1428. avatar_parent = (LLViewerObject*)root_edit->getParent();
  1429. }
  1431. if (avatar_parent && avatar_parent->isAvatar() && root_edit && root_edit->mDrawable.notNull())
  1432. {
  1433. LLXform* parent_xform = root_edit->mDrawable->getXform()->getParent();
  1434. position_agent = (getPositionEdit() * parent_xform->getWorldRotation()) + parent_xform->getWorldPosition();
  1435. rot = getRotationEdit() * parent_xform->getWorldRotation();
  1436. }
  1437. else
  1438. {
  1439. position_agent = getPositionAgent();
  1440. rot = getRotationRegion();
  1441. }
  1443. return LLBBox( position_agent, rot, getScale() * -0.5f, getScale() * 0.5f );
  1444. }
  1446. U32 LLViewerObject::getNumVertices() const
  1447. {
  1448. U32 num_vertices = 0;
  1449. if (mDrawable.notNull())
  1450. {
  1451. S32 i, num_faces;
  1452. num_faces = mDrawable->getNumFaces();
  1453. for (i = 0; i < num_faces; i++)
  1454. {
  1455. num_vertices += mDrawable->getFace(i)->getGeomCount();
  1456. }
  1457. }
  1458. return num_vertices;
  1459. }
  1461. U32 LLViewerObject::getNumIndices() const
  1462. {
  1463. U32 num_indices = 0;
  1464. if (mDrawable.notNull())
  1465. {
  1466. S32 i, num_faces;
  1467. num_faces = mDrawable->getNumFaces();
  1468. for (i = 0; i < num_faces; i++)
  1469. {
  1470. num_indices += mDrawable->getFace(i)->getIndicesCount();
  1471. }
  1472. }
  1473. return num_indices;
  1474. }
  1476. // Find the number of instances of this object's inventory that are of the given type
  1477. S32 LLViewerObject::countInventoryContents(LLAssetType::EType type)
  1478. {
  1479. S32 count = 0;
  1480. if( mInventory )
  1481. {
  1482. InventoryObjectList::const_iterator it = mInventory->begin();
  1483. InventoryObjectList::const_iterator end = mInventory->end();
  1484. for(  ; it != end ; ++it )
  1485. {
  1486. if( (*it)->getType() == type )
  1487. {
  1488. ++count;
  1489. }
  1490. }
  1491. }
  1492. return count;
  1493. }
  1496. void LLViewerObject::setCanSelect(BOOL canSelect)
  1497. {
  1498. mbCanSelect = canSelect;
  1499. for (child_list_t::iterator iter = mChildList.begin();
  1500.  iter != mChildList.end(); iter++)
  1501. {
  1502. LLViewerObject* child = *iter;
  1503. child->mbCanSelect = canSelect;
  1504. }
  1505. }
  1507. void LLViewerObject::setDebugText(const std::string &utf8text)
  1508. {
  1509. if (utf8text.empty() && !mText)
  1510. {
  1511. return;
  1512. }
  1514. if (!mText)
  1515. {
  1516. mText = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);
  1517. mText->setFont(LLFontGL::getFontSansSerif());
  1518. mText->setVertAlignment(LLHUDText::ALIGN_VERT_TOP);
  1519. mText->setMaxLines(-1);
  1520. mText->setSourceObject(this);
  1521. mText->setOnHUDAttachment(isHUDAttachment());
  1522. }
  1523. mText->setColor(LLColor4::white);
  1524. mText->setStringUTF8(utf8text);
  1525. mText->setZCompare(FALSE);
  1526. mText->setDoFade(FALSE);
  1527. updateText();
  1528. }
  1530. void LLViewerObject::setIcon(LLViewerTexture* icon_image)
  1531. {
  1532. if (!mIcon)
  1533. {
  1534. mIcon = (LLHUDIcon *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_ICON);
  1535. mIcon->setSourceObject(this);
  1536. mIcon->setImage(icon_image);
  1537. // *TODO: make this user configurable
  1538. mIcon->setScale(0.03f);
  1539. }
  1540. else
  1541. {
  1542. mIcon->restartLifeTimer();
  1543. }
  1544. }
  1546. void LLViewerObject::clearIcon()
  1547. {
  1548. if (mIcon)
  1549. {
  1550. mIcon = NULL;
  1551. }
  1552. }
  1554. LLViewerObject* LLViewerObject::getSubParent() 
  1555. { 
  1556. if (isJointChild())
  1557. {
  1558. return this;
  1559. }
  1560. return (LLViewerObject*) getParent();
  1561. }
  1563. const LLViewerObject* LLViewerObject::getSubParent() const
  1564. {
  1565. if (isJointChild())
  1566. {
  1567. return this;
  1568. }
  1569. return (const LLViewerObject*) getParent();
  1570. }
  1572. BOOL LLViewerObject::isOnMap()
  1573. {
  1574. return mOnMap;
  1575. }
  1578. void LLViewerObject::updateText()
  1579. {
  1580. if (!isDead())
  1581. {
  1582. if (mText.notNull())
  1583. {
  1584. LLVector3 up_offset(0,0,0);
  1585. up_offset.mV[2] = getScale().mV[VZ]*0.6f;
  1587. if (mDrawable.notNull())
  1588. {
  1589. mText->setPositionAgent(getRenderPosition() + up_offset);
  1590. }
  1591. else
  1592. {
  1593. mText->setPositionAgent(getPositionAgent() + up_offset);
  1594. }
  1595. }
  1596. }
  1597. }
  1599. LLVOAvatar* LLViewerObject::asAvatar()
  1600. {
  1601. return NULL;
  1602. }
  1604. BOOL LLViewerObject::isParticleSource() const
  1605. {
  1606. return !mPartSourcep.isNull() && !mPartSourcep->isDead();
  1607. }
  1609. void LLViewerObject::setParticleSource(const LLPartSysData& particle_parameters, const LLUUID& owner_id)
  1610. {
  1611. if (mPartSourcep)
  1612. {
  1613. deleteParticleSource();
  1614. }
  1616. LLPointer<LLViewerPartSourceScript> pss = LLViewerPartSourceScript::createPSS(this, particle_parameters);
  1617. mPartSourcep = pss;
  1619. if (mPartSourcep)
  1620. {
  1621. mPartSourcep->setOwnerUUID(owner_id);
  1623. if (mPartSourcep->getImage()->getID() != mPartSourcep->mPartSysData.mPartImageID)
  1624. {
  1625. LLViewerTexture* image;
  1626. if (mPartSourcep->mPartSysData.mPartImageID == LLUUID::null)
  1627. {
  1628. image = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.tga");
  1629. }
  1630. else
  1631. {
  1632. image = LLViewerTextureManager::getFetchedTexture(mPartSourcep->mPartSysData.mPartImageID);
  1633. }
  1634. mPartSourcep->setImage(image);
  1635. }
  1636. }
  1637. LLViewerPartSim::getInstance()->addPartSource(pss);
  1638. }
  1640. void LLViewerObject::unpackParticleSource(const S32 block_num, const LLUUID& owner_id)
  1641. {
  1642. if (!mPartSourcep.isNull() && mPartSourcep->isDead())
  1643. {
  1644. mPartSourcep = NULL;
  1645. }
  1646. if (mPartSourcep)
  1647. {
  1648. // If we've got one already, just update the existing source (or remove it)
  1649. if (!LLViewerPartSourceScript::unpackPSS(this, mPartSourcep, block_num))
  1650. {
  1651. mPartSourcep->setDead();
  1652. mPartSourcep = NULL;
  1653. }
  1654. }
  1655. else
  1656. {
  1657. LLPointer<LLViewerPartSourceScript> pss = LLViewerPartSourceScript::unpackPSS(this, NULL, block_num);
  1658. //If the owner is muted, don't create the system
  1659. if(LLMuteList::getInstance()->isMuted(owner_id, LLMute::flagParticles)) return;
  1661. // We need to be able to deal with a particle source that hasn't changed, but still got an update!
  1662. if (pss)
  1663. {
  1664. //  llinfos << "Making particle system with owner " << owner_id << llendl;
  1665. pss->setOwnerUUID(owner_id);
  1666. mPartSourcep = pss;
  1667. LLViewerPartSim::getInstance()->addPartSource(pss);
  1668. }
  1669. }
  1670. if (mPartSourcep)
  1671. {
  1672. if (mPartSourcep->getImage()->getID() != mPartSourcep->mPartSysData.mPartImageID)
  1673. {
  1674. LLViewerTexture* image;
  1675. if (mPartSourcep->mPartSysData.mPartImageID == LLUUID::null)
  1676. {
  1677. image = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  1678. }
  1679. else
  1680. {
  1681. image = LLViewerTextureManager::getFetchedTexture(mPartSourcep->mPartSysData.mPartImageID);
  1682. }
  1683. mPartSourcep->setImage(image);
  1684. }
  1685. }
  1686. }
  1688. void LLViewerObject::unpackParticleSource(LLDataPacker &dp, const LLUUID& owner_id)
  1689. {
  1690. if (!mPartSourcep.isNull() && mPartSourcep->isDead())
  1691. {
  1692. mPartSourcep = NULL;
  1693. }
  1694. if (mPartSourcep)
  1695. {
  1696. // If we've got one already, just update the existing source (or remove it)
  1697. if (!LLViewerPartSourceScript::unpackPSS(this, mPartSourcep, dp))
  1698. {
  1699. mPartSourcep->setDead();
  1700. mPartSourcep = NULL;
  1701. }
  1702. }
  1703. else
  1704. {
  1705. LLPointer<LLViewerPartSourceScript> pss = LLViewerPartSourceScript::unpackPSS(this, NULL, dp);
  1706. //If the owner is muted, don't create the system
  1707. if(LLMuteList::getInstance()->isMuted(owner_id, LLMute::flagParticles)) return;
  1708. // We need to be able to deal with a particle source that hasn't changed, but still got an update!
  1709. if (pss)
  1710. {
  1711. //  llinfos << "Making particle system with owner " << owner_id << llendl;
  1712. pss->setOwnerUUID(owner_id);
  1713. mPartSourcep = pss;
  1714. LLViewerPartSim::getInstance()->addPartSource(pss);
  1715. }
  1716. }
  1717. if (mPartSourcep)
  1718. {
  1719. if (mPartSourcep->getImage()->getID() != mPartSourcep->mPartSysData.mPartImageID)
  1720. {
  1721. LLViewerTexture* image;
  1722. if (mPartSourcep->mPartSysData.mPartImageID == LLUUID::null)
  1723. {
  1724. image = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  1725. }
  1726. else
  1727. {
  1728. image = LLViewerTextureManager::getFetchedTexture(mPartSourcep->mPartSysData.mPartImageID);
  1729. }
  1730. mPartSourcep->setImage(image);
  1731. }
  1732. }
  1733. }
  1735. void LLViewerObject::deleteParticleSource()
  1736. {
  1737. if (mPartSourcep.notNull())
  1738. {
  1739. mPartSourcep->setDead();
  1740. mPartSourcep = NULL;
  1741. }
  1742. }
  1744. // virtual
  1745. void LLViewerObject::updateDrawable(BOOL force_damped)
  1746. {
  1747. if (mDrawable.notNull() && 
  1748. !mDrawable->isState(LLDrawable::ON_MOVE_LIST) &&
  1749. isChanged(MOVED))
  1750. {
  1751. BOOL damped_motion = 
  1752. !isChanged(SHIFTED) && // not shifted between regions this frame and...
  1753. ( force_damped || // ...forced into damped motion by application logic or...
  1754. ( !isSelected() && // ...not selected and...
  1755. ( mDrawable->isRoot() || // ... is root or ...
  1756. (getParent() && !((LLViewerObject*)getParent())->isSelected())// ... parent is not selected and ...
  1757. ) &&
  1758. getPCode() == LL_PCODE_VOLUME && // ...is a volume object and...
  1759. getVelocity().isExactlyZero() && // ...is not moving physically and...
  1760. mDrawable->getGeneration() != -1                    // ...was not created this frame.
  1761. )
  1762. );
  1763. gPipeline.markMoved(mDrawable, damped_motion);
  1764. }
  1765. clearChanged(SHIFTED);
  1766. }
  1768. // virtual, overridden by LLVOVolume
  1769. F32 LLViewerObject::getVObjRadius() const
  1770. {
  1771. return mDrawable.notNull() ? mDrawable->getRadius() : 0.f;
  1772. }
  1774. void LLViewerObject::setAttachedSound(const LLUUID &audio_uuid, const LLUUID& owner_id, const F32 gain, const U8 flags)
  1775. {
  1776. if (!gAudiop)
  1777. {
  1778. return;
  1779. }
  1781. if (audio_uuid.isNull())
  1782. {
  1783. if (!mAudioSourcep)
  1784. {
  1785. return;
  1786. }
  1787. if (mAudioSourcep->isLoop() && !mAudioSourcep->hasPendingPreloads())
  1788. {
  1789. // We don't clear the sound if it's a loop, it'll go away on its own.
  1790. // At least, this appears to be how the scripts work.
  1791. // The attached sound ID is set to NULL to avoid it playing back when the
  1792. // object rezzes in on non-looping sounds.
  1793. //llinfos << "Clearing attached sound " << mAudioSourcep->getCurrentData()->getID() << llendl;
  1794. gAudiop->cleanupAudioSource(mAudioSourcep);
  1795. mAudioSourcep = NULL;
  1796. }
  1797. else if (flags & LL_SOUND_FLAG_STOP)
  1798.         {
  1799. // Just shut off the sound
  1800. mAudioSourcep->play(LLUUID::null);
  1801. }
  1802. return;
  1803. }
  1804. if (flags & LL_SOUND_FLAG_LOOP
  1805. && mAudioSourcep && mAudioSourcep->isLoop() && mAudioSourcep->getCurrentData()
  1806. && mAudioSourcep->getCurrentData()->getID() == audio_uuid)
  1807. {
  1808. //llinfos << "Already playing this sound on a loop, ignoring" << llendl;
  1809. return;
  1810. }
  1812. // don't clean up before previous sound is done. Solves: SL-33486
  1813. if ( mAudioSourcep && mAudioSourcep->isDone() ) 
  1814. {
  1815. gAudiop->cleanupAudioSource(mAudioSourcep);
  1816. mAudioSourcep = NULL;
  1817. }
  1819. getAudioSource(owner_id);
  1821. if (mAudioSourcep)
  1822. {
  1823. BOOL queue = flags & LL_SOUND_FLAG_QUEUE;
  1824. mAudioGain = gain;
  1825. mAudioSourcep->setGain(gain);
  1826. mAudioSourcep->setLoop(flags & LL_SOUND_FLAG_LOOP);
  1827. mAudioSourcep->setSyncMaster(flags & LL_SOUND_FLAG_SYNC_MASTER);
  1828. mAudioSourcep->setSyncSlave(flags & LL_SOUND_FLAG_SYNC_SLAVE);
  1829. mAudioSourcep->setQueueSounds(queue);
  1830. if(!queue) // stop any current sound first to avoid "farts of doom" (SL-1541) -MG
  1831. {
  1832. mAudioSourcep->play(LLUUID::null);
  1833. }
  1835. // Play this sound if region maturity permits
  1836. if( gAgent.canAccessMaturityAtGlobal(this->getPositionGlobal()) )
  1837. {
  1838. //llinfos << "Playing attached sound " << audio_uuid << llendl;
  1839. mAudioSourcep->play(audio_uuid);
  1840. }
  1841. }
  1842. }
  1844. LLAudioSource *LLViewerObject::getAudioSource(const LLUUID& owner_id)
  1845. {
  1846. if (!mAudioSourcep)
  1847. {
  1848. // Arbitrary low gain for a sound that's not playing.
  1849. // This is used for sound preloads, for example.
  1850. LLAudioSourceVO *asvop = new LLAudioSourceVO(mID, owner_id, 0.01f, this);
  1852. mAudioSourcep = asvop;
  1853. if(gAudiop) gAudiop->addAudioSource(asvop);
  1854. }
  1856. return mAudioSourcep;
  1857. }
  1859. void LLViewerObject::adjustAudioGain(const F32 gain)
  1860. {
  1861. if (!gAudiop)
  1862. {
  1863. return;
  1864. }
  1865. if (mAudioSourcep)
  1866. {
  1867. mAudioGain = gain;
  1868. mAudioSourcep->setGain(mAudioGain);
  1869. }
  1870. }
  1872. //----------------------------------------------------------------------------
  1874. bool LLViewerObject::unpackParameterEntry(U16 param_type, LLDataPacker *dp)
  1875. {
  1876. ExtraParameter* param = getExtraParameterEntryCreate(param_type);
  1877. if (param)
  1878. {
  1879. param->data->unpack(*dp);
  1880. param->in_use = TRUE;
  1881. parameterChanged(param_type, param->data, TRUE, false);
  1882. return true;
  1883. }
  1884. else
  1885. {
  1886. return false;
  1887. }
  1888. }
  1890. LLViewerObject::ExtraParameter* LLViewerObject::createNewParameterEntry(U16 param_type)
  1891. {
  1892. LLNetworkData* new_block = NULL;
  1893. switch (param_type)
  1894. {
  1895.   case LLNetworkData::PARAMS_FLEXIBLE:
  1896.   {
  1897.   new_block = new LLFlexibleObjectData();
  1898.   break;
  1899.   }
  1900.   case LLNetworkData::PARAMS_LIGHT:
  1901.   {
  1902.   new_block = new LLLightParams();
  1903.   break;
  1904.   }
  1905.   case LLNetworkData::PARAMS_SCULPT:
  1906.   {
  1907.   new_block = new LLSculptParams();
  1908.   break;
  1909.   }
  1910.   case LLNetworkData::PARAMS_LIGHT_IMAGE:
  1911.   {
  1912.   new_block = new LLLightImageParams();
  1913.   break;
  1914.   }
  1915.   default:
  1916.   {
  1917.   llinfos << "Unknown param type." << llendl;
  1918.   break;
  1919.   }
  1920. };
  1922. if (new_block)
  1923. {
  1924. ExtraParameter* new_entry = new ExtraParameter;
  1925. new_entry->data = new_block;
  1926. new_entry->in_use = false; // not in use yet
  1927. mExtraParameterList[param_type] = new_entry;
  1928. return new_entry;
  1929. }
  1930. return NULL;
  1931. }
  1933. LLViewerObject::ExtraParameter* LLViewerObject::getExtraParameterEntry(U16 param_type) const
  1934. {
  1935. std::map<U16, ExtraParameter*>::const_iterator itor = mExtraParameterList.find(param_type);
  1936. if (itor != mExtraParameterList.end())
  1937. {
  1938. return itor->second;
  1939. }
  1940. return NULL;
  1941. }
  1943. LLViewerObject::ExtraParameter* LLViewerObject::getExtraParameterEntryCreate(U16 param_type)
  1944. {
  1945. ExtraParameter* param = getExtraParameterEntry(param_type);
  1946. if (!param)
  1947. {
  1948. param = createNewParameterEntry(param_type);
  1949. }
  1950. return param;
  1951. }
  1953. LLNetworkData* LLViewerObject::getParameterEntry(U16 param_type) const
  1954. {
  1955. ExtraParameter* param = getExtraParameterEntry(param_type);
  1956. if (param)
  1957. {
  1958. return param->data;
  1959. }
  1960. else
  1961. {
  1962. return NULL;
  1963. }
  1964. }
  1966. BOOL LLViewerObject::getParameterEntryInUse(U16 param_type) const
  1967. {
  1968. ExtraParameter* param = getExtraParameterEntry(param_type);
  1969. if (param)
  1970. {
  1971. return param->in_use;
  1972. }
  1973. else
  1974. {
  1975. return FALSE;
  1976. }
  1977. }
  1979. bool LLViewerObject::setParameterEntry(U16 param_type, const LLNetworkData& new_value, bool local_origin)
  1980. {
  1981. ExtraParameter* param = getExtraParameterEntryCreate(param_type);
  1982. if (param)
  1983. {
  1984. if (param->in_use && new_value == *(param->data))
  1985. {
  1986. return false;
  1987. }
  1988. param->in_use = true;
  1989. param->data->copy(new_value);
  1990. parameterChanged(param_type, param->data, TRUE, local_origin);
  1991. return true;
  1992. }
  1993. else
  1994. {
  1995. return false;
  1996. }
  1997. }
  1999. // Assumed to be called locally
  2000. // If in_use is TRUE, will crate a new extra parameter if none exists.
  2001. // Should always return true.
  2002. bool LLViewerObject::setParameterEntryInUse(U16 param_type, BOOL in_use, bool local_origin)
  2003. {
  2004. ExtraParameter* param = getExtraParameterEntryCreate(param_type);
  2005. if (param && param->in_use != in_use)
  2006. {
  2007. param->in_use = in_use;
  2008. parameterChanged(param_type, param->data, in_use, local_origin);
  2009. return true;
  2010. }
  2011. return false;
  2012. }
  2014. void LLViewerObject::parameterChanged(U16 param_type, bool local_origin)
  2015. {
  2016. ExtraParameter* param = getExtraParameterEntry(param_type);
  2017. if (param)
  2018. {
  2019. parameterChanged(param_type, param->data, param->in_use, local_origin);
  2020. }
  2021. }
  2023. void LLViewerObject::parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin)
  2024. {
  2025. if (local_origin)
  2026. {
  2027. LLViewerRegion* regionp = getRegion();
  2028. if(!regionp) return;
  2030. // Change happened on the viewer. Send the change up
  2031. U8 tmp[MAX_OBJECT_PARAMS_SIZE];
  2032. LLDataPackerBinaryBuffer dpb(tmp, MAX_OBJECT_PARAMS_SIZE);
  2033. if (data->pack(dpb))
  2034. {
  2035. U32 datasize = (U32)dpb.getCurrentSize();
  2037. LLMessageSystem* msg = gMessageSystem;
  2038. msg->newMessageFast(_PREHASH_ObjectExtraParams);
  2039. msg->nextBlockFast(_PREHASH_AgentData);
  2040. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  2041. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  2042. msg->nextBlockFast(_PREHASH_ObjectData);
  2043. msg->addU32Fast(_PREHASH_ObjectLocalID, mLocalID );
  2045. msg->addU16Fast(_PREHASH_ParamType, param_type);
  2046. msg->addBOOLFast(_PREHASH_ParamInUse, in_use);
  2048. msg->addU32Fast(_PREHASH_ParamSize, datasize);
  2049. msg->addBinaryDataFast(_PREHASH_ParamData, tmp, datasize);
  2051. msg->sendReliable( regionp->getHost() );
  2052. }
  2053. else
  2054. {
  2055. llwarns << "Failed to send object extra parameters: " << param_type << llendl;
  2056. }
  2057. }
  2058. }
  2060. void LLViewerObject::setDrawableState(U32 state, BOOL recursive)
  2061. {
  2062. if (mDrawable)
  2063. {
  2064. mDrawable->setState(state);
  2065. }
  2066. if (recursive)
  2067. {
  2068. for (child_list_t::iterator iter = mChildList.begin();
  2069.  iter != mChildList.end(); iter++)
  2070. {
  2071. LLViewerObject* child = *iter;
  2072. child->setDrawableState(state, recursive);
  2073. }
  2074. }
  2075. }
  2077. void LLViewerObject::clearDrawableState(U32 state, BOOL recursive)
  2078. {
  2079. if (mDrawable)
  2080. {
  2081. mDrawable->clearState(state);
  2082. }
  2083. if (recursive)
  2084. {
  2085. for (child_list_t::iterator iter = mChildList.begin();
  2086.  iter != mChildList.end(); iter++)
  2087. {
  2088. LLViewerObject* child = *iter;
  2089. child->clearDrawableState(state, recursive);
  2090. }
  2091. }
  2092. }
  2094. //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  2095. // RN: these functions assume a 2-level hierarchy 
  2096. //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  2098. // Owned by anyone?
  2099. BOOL LLViewerObject::permAnyOwner() const
  2100. { 
  2101. if (isRootEdit())
  2102. {
  2103. return ((mFlags & FLAGS_OBJECT_ANY_OWNER) != 0); 
  2104. }
  2105. else
  2106. {
  2107. return ((LLViewerObject*)getParent())->permAnyOwner();
  2108. }
  2109. }
  2110. // Owned by this viewer?
  2111. BOOL LLViewerObject::permYouOwner() const
  2112. { 
  2113. if (isRootEdit())
  2114. {
  2115. #ifdef HACKED_GODLIKE_VIEWER
  2116. return TRUE;
  2117. #else
  2118. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2119. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2120.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2121. {
  2122. return TRUE;
  2123. }
  2124. # endif
  2125. return ((mFlags & FLAGS_OBJECT_YOU_OWNER) != 0); 
  2126. #endif
  2127. }
  2128. else
  2129. {
  2130. return ((LLViewerObject*)getParent())->permYouOwner();
  2131. }
  2132. }
  2134. // Owned by a group?
  2135. BOOL LLViewerObject::permGroupOwner() const
  2136. { 
  2137. if (isRootEdit())
  2138. {
  2139. return ((mFlags & FLAGS_OBJECT_GROUP_OWNED) != 0); 
  2140. }
  2141. else
  2142. {
  2143. return ((LLViewerObject*)getParent())->permGroupOwner();
  2144. }
  2145. }
  2147. // Can the owner edit
  2148. BOOL LLViewerObject::permOwnerModify() const
  2149. { 
  2150. if (isRootEdit())
  2151. {
  2152. #ifdef HACKED_GODLIKE_VIEWER
  2153. return TRUE;
  2154. #else
  2155. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2156. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2157.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2158. {
  2159. return TRUE;
  2160. }
  2161. # endif
  2162. return ((mFlags & FLAGS_OBJECT_OWNER_MODIFY) != 0); 
  2163. #endif
  2164. }
  2165. else
  2166. {
  2167. return ((LLViewerObject*)getParent())->permOwnerModify();
  2168. }
  2169. }
  2171. // Can edit
  2172. BOOL LLViewerObject::permModify() const
  2173. { 
  2174. if (isRootEdit())
  2175. {
  2176. #ifdef HACKED_GODLIKE_VIEWER
  2177. return TRUE;
  2178. #else
  2179. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2180. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2181.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2182. {
  2183. return TRUE;
  2184. }
  2185. # endif
  2186. return ((mFlags & FLAGS_OBJECT_MODIFY) != 0); 
  2187. #endif
  2188. }
  2189. else
  2190. {
  2191. return ((LLViewerObject*)getParent())->permModify();
  2192. }
  2193. }
  2195. // Can copy
  2196. BOOL LLViewerObject::permCopy() const
  2197. { 
  2198. if (isRootEdit())
  2199. {
  2200. #ifdef HACKED_GODLIKE_VIEWER
  2201. return TRUE;
  2202. #else
  2203. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2204. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2205.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2206. {
  2207. return TRUE;
  2208. }
  2209. # endif
  2210. return ((mFlags & FLAGS_OBJECT_COPY) != 0); 
  2211. #endif
  2212. }
  2213. else
  2214. {
  2215. return ((LLViewerObject*)getParent())->permCopy();
  2216. }
  2217. }
  2219. // Can move
  2220. BOOL LLViewerObject::permMove() const
  2221. {
  2222. if (isRootEdit())
  2223. {
  2224. #ifdef HACKED_GODLIKE_VIEWER
  2225. return TRUE;
  2226. #else
  2227. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2228. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2229.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2230. {
  2231. return TRUE;
  2232. }
  2233. # endif
  2234. return ((mFlags & FLAGS_OBJECT_MOVE) != 0); 
  2235. #endif
  2236. }
  2237. else
  2238. {
  2239. return ((LLViewerObject*)getParent())->permMove();
  2240. }
  2241. }
  2243. // Can be transferred
  2244. BOOL LLViewerObject::permTransfer() const
  2245. { 
  2246. if (isRootEdit())
  2247. {
  2248. #ifdef HACKED_GODLIKE_VIEWER
  2249. return TRUE;
  2250. #else
  2251. # ifdef TOGGLE_HACKED_GODLIKE_VIEWER
  2252. if (!LLViewerLogin::getInstance()->isInProductionGrid()
  2253.             && (gAgent.getGodLevel() >= GOD_MAINTENANCE))
  2254. {
  2255. return TRUE;
  2256. }
  2257. # endif
  2258. return ((mFlags & FLAGS_OBJECT_TRANSFER) != 0); 
  2259. #endif
  2260. }
  2261. else
  2262. {
  2263. return ((LLViewerObject*)getParent())->permTransfer();
  2264. }
  2265. }
  2267. // Can only open objects that you own, or that someone has
  2268. // given you modify rights to.  JC
  2269. BOOL LLViewerObject::allowOpen() const
  2270. {
  2271. return !flagInventoryEmpty() && (permYouOwner() || permModify());
  2272. }
  2274. LLViewerObject::LLInventoryCallbackInfo::~LLInventoryCallbackInfo()
  2275. {
  2276. if (mListener)
  2277. {
  2278. mListener->clearVOInventoryListener();
  2279. }
  2280. }
  2282. void LLViewerObject::updateVolume(const LLVolumeParams& volume_params)
  2283. {
  2284. if (setVolume(volume_params, 1)) // *FIX: magic number, ack!
  2285. {
  2286. // Transmit the update to the simulator
  2287. sendShapeUpdate();
  2288. markForUpdate(TRUE);
  2289. }
  2290. }
  2292. void LLViewerObject::markForUpdate(BOOL priority)
  2293. {
  2294. if (mDrawable.notNull())
  2295. {
  2296. gPipeline.markTextured(mDrawable);
  2297. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, priority);
  2298. }
  2299. }
  2301. bool LLViewerObject::getIncludeInSearch() const
  2302. {
  2303. return ((mFlags & FLAGS_INCLUDE_IN_SEARCH) != 0);
  2304. }
  2306. void LLViewerObject::setIncludeInSearch(bool include_in_search)
  2307. {
  2308. if (include_in_search)
  2309. {
  2310. mFlags |= FLAGS_INCLUDE_IN_SEARCH;
  2311. }
  2312. else
  2313. {
  2314. mFlags &= ~FLAGS_INCLUDE_IN_SEARCH;
  2315. }
  2316. }
  2318. void LLViewerObject::setRegion(LLViewerRegion *regionp)
  2319. {
  2320. llassert(regionp);
  2321. mLatestRecvPacketID = 0;
  2322. mRegionp = regionp;
  2324. for (child_list_t::iterator i = mChildList.begin(); i != mChildList.end(); ++i)
  2325. {
  2326. LLViewerObject* child = *i;
  2327. child->setRegion(regionp);
  2328. }
  2330. setChanged(MOVED | SILHOUETTE);
  2331. updateDrawable(FALSE);
  2332. }
  2334. bool LLViewerObject::specialHoverCursor() const
  2335. {
  2336. return (mFlags & FLAGS_USE_PHYSICS)
  2337. || (mFlags & FLAGS_HANDLE_TOUCH)
  2338. || (mClickAction != 0);
  2339. }
  2341. void LLViewerObject::updateFlags()
  2342. {
  2343. LLViewerRegion* regionp = getRegion();
  2344. if(!regionp) return;
  2345. gMessageSystem->newMessage("ObjectFlagUpdate");
  2346. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  2347. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  2348. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  2349. gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, getLocalID() );
  2350. gMessageSystem->addBOOLFast(_PREHASH_UsePhysics, usePhysics() );
  2351. gMessageSystem->addBOOL("IsTemporary", flagTemporaryOnRez() );
  2352. gMessageSystem->addBOOL("IsPhantom", flagPhantom() );
  2353. gMessageSystem->addBOOL("CastsShadows", flagCastShadows() );
  2354. gMessageSystem->sendReliable( regionp->getHost() );
  2355. }
  2357. BOOL LLViewerObject::setFlags(U32 flags, BOOL state)
  2358. {
  2359. BOOL setit = FALSE;
  2360. if (state)
  2361. {
  2362. if ((mFlags & flags) != flags)
  2363. {
  2364. mFlags |= flags;
  2365. setit = TRUE;
  2366. }
  2367. }
  2368. else
  2369. {
  2370. if ((mFlags & flags) != 0)
  2371. {
  2372. mFlags &= ~flags;
  2373. setit = TRUE;
  2374. }
  2375. }
  2377. // BUG: Sometimes viewer physics and simulator physics get
  2378. // out of sync.  To fix this, always send update to simulator.
  2379. //  if (setit)
  2380. {
  2381. updateFlags();
  2382. }
  2383. return setit;
  2384. }
  2386. void LLViewerObject::applyAngularVelocity(F32 dt)
  2387. {
  2388. //do target omega here
  2389. mRotTime += dt;
  2390. LLVector3 ang_vel = getAngularVelocity();
  2391. F32 omega = ang_vel.magVecSquared();
  2392. F32 angle = 0.0f;
  2393. LLQuaternion dQ;
  2394. if (omega > 0.00001f)
  2395. {
  2396. omega = sqrt(omega);
  2397. angle = omega * dt;
  2399. ang_vel *= 1.f/omega;
  2401. dQ.setQuat(angle, ang_vel);
  2403. setRotation(getRotation()*dQ);
  2404. setChanged(MOVED | SILHOUETTE);
  2405. }
  2406. }
  2408. void LLViewerObject::resetRot()
  2409. {
  2410. mRotTime = 0.0f;
  2411. }
  2413. U32 LLViewerObject::getPartitionType() const
  2414. { 
  2415. return LLViewerRegion::PARTITION_NONE; 
  2416. }
  2418. void LLViewerObject::dirtySpatialGroup(BOOL priority) const
  2419. {
  2420. if (mDrawable)
  2421. {
  2422. LLSpatialGroup* group = mDrawable->getSpatialGroup();
  2423. if (group)
  2424. {
  2425. group->dirtyGeom();
  2426. gPipeline.markRebuild(group, priority);
  2427. }
  2428. }
  2429. }
  2431. void LLViewerObject::dirtyMesh()
  2432. {
  2433. if (mDrawable)
  2434. {
  2435. LLSpatialGroup* group = mDrawable->getSpatialGroup();
  2436. if (group)
  2437. {
  2438. group->dirtyMesh();
  2439. }
  2440. }
  2441. }
  2443. F32 LLAlphaObject::getPartSize(S32 idx)
  2444. {
  2445. return 0.f;
  2446. }
  2448. // virtual
  2449. void LLStaticViewerObject::updateDrawable(BOOL force_damped)
  2450. {
  2451. // Force an immediate rebuild on any update
  2452. if (mDrawable.notNull())
  2453. {
  2454. mDrawable->updateXform(TRUE);
  2455. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  2456. }
  2457. clearChanged(SHIFTED);
  2458. }
  2460. void LLViewerObject::saveUnselectedChildrenPosition(std::vector<LLVector3>& positions)
  2461. {
  2462. if(mChildList.empty() || !positions.empty())
  2463. {
  2464. return ;
  2465. }
  2467. for (LLViewerObject::child_list_t::const_iterator iter = mChildList.begin();
  2468. iter != mChildList.end(); iter++)
  2469. {
  2470. LLViewerObject* childp = *iter;
  2471. if (!childp->isSelected() && childp->mDrawable.notNull())
  2472. {
  2473. positions.push_back(childp->getPositionEdit());
  2474. }
  2475. }
  2477. return ;
  2478. }
  2480. void LLViewerObject::saveUnselectedChildrenRotation(std::vector<LLQuaternion>& rotations)
  2481. {
  2482. if(mChildList.empty())
  2483. {
  2484. return ;
  2485. }
  2487. for (LLViewerObject::child_list_t::const_iterator iter = mChildList.begin();
  2488. iter != mChildList.end(); iter++)
  2489. {
  2490. LLViewerObject* childp = *iter;
  2491. if (!childp->isSelected() && childp->mDrawable.notNull())
  2492. {
  2493. rotations.push_back(childp->getRotationEdit());
  2494. }
  2495. }
  2497. return ;
  2498. }
  2500. //counter-rotation
  2501. void LLViewerObject::resetChildrenRotationAndPosition(const std::vector<LLQuaternion>& rotations, 
  2502. const std::vector<LLVector3>& positions)
  2503. {
  2504. if(mChildList.empty())
  2505. {
  2506. return ;
  2507. }
  2509. S32 index = 0 ;
  2510. LLQuaternion inv_rotation = ~getRotationEdit() ;
  2511. LLVector3 offset = getPositionEdit() ;
  2512. for (LLViewerObject::child_list_t::const_iterator iter = mChildList.begin();
  2513. iter != mChildList.end(); iter++)
  2514. {
  2515. LLViewerObject* childp = *iter;
  2516. if (!childp->isSelected() && childp->mDrawable.notNull())
  2517. {
  2518. if (childp->getPCode() != LL_PCODE_LEGACY_AVATAR)
  2519. {
  2520. childp->setRotation(rotations[index] * inv_rotation);
  2521. childp->setPosition((positions[index] - offset) * inv_rotation);
  2522. LLManip::rebuild(childp);
  2523. }
  2524. else //avatar
  2525. {
  2526. LLVector3 reset_pos = (positions[index] - offset) * inv_rotation ;
  2527. LLQuaternion reset_rot = rotations[index] * inv_rotation ;
  2529. ((LLVOAvatar*)childp)->mDrawable->mXform.setPosition(reset_pos);
  2530. ((LLVOAvatar*)childp)->mDrawable->mXform.setRotation(reset_rot) ;
  2532. ((LLVOAvatar*)childp)->mDrawable->getVObj()->setPosition(reset_pos, TRUE);
  2533. ((LLVOAvatar*)childp)->mDrawable->getVObj()->setRotation(reset_rot, TRUE) ;
  2535. LLManip::rebuild(childp);
  2536. }
  2537. index++;
  2538. }
  2539. }
  2541. return ;
  2542. }
  2544. //counter-translation
  2545. void LLViewerObject::resetChildrenPosition(const LLVector3& offset, BOOL simplified)
  2546. {
  2547. if(mChildList.empty())
  2548. {
  2549. return ;
  2550. }
  2552. LLVector3 child_offset;
  2553. if(simplified) //translation only, rotation matrix does not change
  2554. {
  2555. child_offset = offset * ~getRotation();
  2556. }
  2557. else //rotation matrix might change too.
  2558. {
  2559. if (isAttachment() && mDrawable.notNull())
  2560. {
  2561. LLXform* attachment_point_xform = mDrawable->getXform()->getParent();
  2562. LLQuaternion parent_rotation = getRotation() * attachment_point_xform->getWorldRotation();
  2563. child_offset = offset * ~parent_rotation;
  2564. }
  2565. else
  2566. {
  2567. child_offset = offset * ~getRenderRotation();
  2568. }
  2569. }
  2571. for (LLViewerObject::child_list_t::const_iterator iter = mChildList.begin();
  2572. iter != mChildList.end(); iter++)
  2573. {
  2574. LLViewerObject* childp = *iter;
  2575. if (!childp->isSelected() && childp->mDrawable.notNull())
  2576. {
  2577. if (childp->getPCode() != LL_PCODE_LEGACY_AVATAR)
  2578. {
  2579. childp->setPosition(childp->getPosition() + child_offset);
  2580. LLManip::rebuild(childp);
  2581. }
  2582. else //avatar
  2583. {
  2584. LLVector3 reset_pos = ((LLVOAvatar*)childp)->mDrawable->mXform.getPosition() + child_offset ;
  2586. ((LLVOAvatar*)childp)->mDrawable->mXform.setPosition(reset_pos);
  2587. ((LLVOAvatar*)childp)->mDrawable->getVObj()->setPosition(reset_pos);
  2589. LLManip::rebuild(childp);
  2590. }
  2591. }
  2592. }
  2594. return ;
  2595. }