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

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

游戏引擎

开发平台：

C++ Builder

llvoavatarself.cpp：源码内容
  1. /** 
  2.  * @file llvoavatar.cpp
  3.  * @brief Implementation of LLVOAvatar class which is a derivation fo LLViewerObject
  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. #if LL_MSVC
  34. // disable warning about boost::lexical_cast returning uninitialized data
  35. // when it fails to parse the string
  36. #pragma warning (disable:4701)
  37. #endif
  39. #include "llviewerprecompiledheaders.h"
  41. #include "llvoavatarself.h"
  42. #include "llvoavatar.h"
  44. #include "pipeline.h"
  46. #include "llagent.h" //  Get state values from here
  47. #include "llagentwearables.h"
  48. #include "llhudeffecttrail.h"
  49. #include "llhudmanager.h"
  50. #include "llselectmgr.h"
  51. #include "lltoolgrab.h" // for needsRenderBeam
  52. #include "lltoolmgr.h" // for needsRenderBeam
  53. #include "lltoolmorph.h"
  54. #include "lltrans.h"
  55. #include "llviewercamera.h"
  56. #include "llviewermenu.h"
  57. #include "llviewerobjectlist.h"
  58. #include "llviewerstats.h"
  59. #include "llviewerregion.h"
  60. #include "llappearancemgr.h"
  62. #if LL_MSVC
  63. // disable boost::lexical_cast warning
  64. #pragma warning (disable:4702)
  65. #endif
  67. #include <boost/lexical_cast.hpp>
  69. using namespace LLVOAvatarDefines;
  71. /*********************************************************************************
  72.  **                                                                             **
  73.  ** Begin private LLVOAvatarSelf Support classes
  74.  **
  75.  **/
  77. struct LocalTextureData
  78. {
  79. LocalTextureData() : 
  80. mIsBakedReady(FALSE), 
  81. mDiscard(MAX_DISCARD_LEVEL+1), 
  82. mImage(NULL), 
  83. mWearableID(IMG_DEFAULT_AVATAR),
  84. mTexEntry(NULL)
  85. {}
  86. LLPointer<LLViewerFetchedTexture> mImage;
  87. BOOL mIsBakedReady;
  88. S32 mDiscard;
  89. LLUUID mWearableID; // UUID of the wearable that this texture belongs to, not of the image itself
  90. LLTextureEntry *mTexEntry;
  91. };
  93. //-----------------------------------------------------------------------------
  94. // Callback data
  95. //-----------------------------------------------------------------------------
  96. struct LLAvatarTexData
  97. {
  98. LLAvatarTexData(const LLUUID& id, ETextureIndex index) : 
  99. mAvatarID(id), 
  100. mIndex(index) 
  101. {}
  102. LLUUID mAvatarID;
  103. ETextureIndex mIndex;
  104. };
  106. /**
  107.  **
  108.  ** End LLVOAvatarSelf Support classes
  109.  **                                                                             **
  110.  *********************************************************************************/
  113. //-----------------------------------------------------------------------------
  114. // Static Data
  115. //-----------------------------------------------------------------------------
  116. S32 LLVOAvatarSelf::sScratchTexBytes = 0;
  117. LLMap< LLGLenum, LLGLuint*> LLVOAvatarSelf::sScratchTexNames;
  118. LLMap< LLGLenum, F32*> LLVOAvatarSelf::sScratchTexLastBindTime;
  121. /*********************************************************************************
  122.  **                                                                             **
  123.  ** Begin LLVOAvatarSelf Constructor routines
  124.  **
  125.  **/
  127. LLVOAvatarSelf::LLVOAvatarSelf(const LLUUID& id,
  128.    const LLPCode pcode,
  129.    LLViewerRegion* regionp) :
  130. LLVOAvatar(id, pcode, regionp),
  131. mScreenp(NULL),
  132. mLastRegionHandle(0),
  133. mRegionCrossingCount(0)
  134. {
  135. gAgent.setAvatarObject(this);
  136. gAgentWearables.setAvatarObject(this);
  138. lldebugs << "Marking avatar as self " << id << llendl;
  139. }
  141. void LLVOAvatarSelf::initInstance()
  142. {
  143. BOOL status = TRUE;
  144. // creates hud joint(mScreen) among other things
  145. status &= loadAvatarSelf();
  147. // adds attachment points to mScreen among other things
  148. LLVOAvatar::initInstance();
  150. status &= buildMenus();
  151. if (!status)
  152. {
  153. llerrs << "Unable to load user's avatar" << llendl;
  154. return;
  155. }
  156. }
  158. // virtual
  159. void LLVOAvatarSelf::markDead()
  160. {
  161. mBeam = NULL;
  162. LLVOAvatar::markDead();
  163. }
  165. /*virtual*/ BOOL LLVOAvatarSelf::loadAvatar()
  166. {
  167. BOOL success = LLVOAvatar::loadAvatar();
  169. // set all parameters sotred directly in the avatar to have
  170. // the isSelfParam to be TRUE - this is used to prevent
  171. // them from being animated or trigger accidental rebakes
  172. // when we copy params from the wearable to the base avatar.
  173. for (LLViewerVisualParam* param = (LLViewerVisualParam*) getFirstVisualParam(); 
  174.  param;
  175.  param = (LLViewerVisualParam*) getNextVisualParam())
  176. {
  177. if (param->getWearableType() != WT_INVALID)
  178. {
  179. param->setIsDummy(TRUE);
  180. }
  181. }
  183. return success;
  184. }
  187. BOOL LLVOAvatarSelf::loadAvatarSelf()
  188. {
  189. BOOL success = TRUE;
  190. // avatar_skeleton.xml
  191. if (!buildSkeletonSelf(sAvatarSkeletonInfo))
  192. {
  193. llwarns << "avatar file: buildSkeleton() failed" << llendl;
  194. return FALSE;
  195. }
  196. // TODO: make loadLayersets() called only by self.
  197. //success &= loadLayersets();
  199. return success;
  200. }
  202. BOOL LLVOAvatarSelf::buildSkeletonSelf(const LLVOAvatarSkeletonInfo *info)
  203. {
  204. LLMemType mt(LLMemType::MTYPE_AVATAR);
  206. // add special-purpose "screen" joint
  207. mScreenp = new LLViewerJoint("mScreen", NULL);
  208. // for now, put screen at origin, as it is only used during special
  209. // HUD rendering mode
  210. F32 aspect = LLViewerCamera::getInstance()->getAspect();
  211. LLVector3 scale(1.f, aspect, 1.f);
  212. mScreenp->setScale(scale);
  213. mScreenp->setWorldPosition(LLVector3::zero);
  214. return TRUE;
  215. }
  217. BOOL LLVOAvatarSelf::buildMenus()
  218. {
  219. //-------------------------------------------------------------------------
  220. // build the attach and detach menus
  221. //-------------------------------------------------------------------------
  222. gAttachBodyPartPieMenus[0] = NULL;
  224. LLContextMenu::Params params;
  225. params.label(LLTrans::getString("BodyPartsRightArm") + " >");
  226. params.name(params.label);
  227. params.visible(false);
  228. gAttachBodyPartPieMenus[1] = LLUICtrlFactory::create<LLContextMenu> (params);
  230. params.label(LLTrans::getString("BodyPartsHead") + " >");
  231. params.name(params.label);
  232. gAttachBodyPartPieMenus[2] = LLUICtrlFactory::create<LLContextMenu> (params);
  234. params.label(LLTrans::getString("BodyPartsLeftArm") + " >");
  235. params.name(params.label);
  236. gAttachBodyPartPieMenus[3] = LLUICtrlFactory::create<LLContextMenu> (params);
  238. gAttachBodyPartPieMenus[4] = NULL;
  240. params.label(LLTrans::getString("BodyPartsLeftLeg") + " >");
  241. params.name(params.label);
  242. gAttachBodyPartPieMenus[5] = LLUICtrlFactory::create<LLContextMenu> (params);
  244. params.label(LLTrans::getString("BodyPartsTorso") + " >");
  245. params.name(params.label);
  246. gAttachBodyPartPieMenus[6] = LLUICtrlFactory::create<LLContextMenu> (params);
  248. params.label(LLTrans::getString("BodyPartsRightLeg") + " >");
  249. params.name(params.label);
  250. gAttachBodyPartPieMenus[7] = LLUICtrlFactory::create<LLContextMenu> (params);
  252. gDetachBodyPartPieMenus[0] = NULL;
  254. params.label(LLTrans::getString("BodyPartsRightArm") + " >");
  255. params.name(params.label);
  256. gDetachBodyPartPieMenus[1] = LLUICtrlFactory::create<LLContextMenu> (params);
  258. params.label(LLTrans::getString("BodyPartsHead") + " >");
  259. params.name(params.label);
  260. gDetachBodyPartPieMenus[2] = LLUICtrlFactory::create<LLContextMenu> (params);
  262. params.label(LLTrans::getString("BodyPartsLeftArm") + " >");
  263. params.name(params.label);
  264. gDetachBodyPartPieMenus[3] = LLUICtrlFactory::create<LLContextMenu> (params);
  266. gDetachBodyPartPieMenus[4] = NULL;
  268. params.label(LLTrans::getString("BodyPartsLeftLeg") + " >");
  269. params.name(params.label);
  270. gDetachBodyPartPieMenus[5] = LLUICtrlFactory::create<LLContextMenu> (params);
  272. params.label(LLTrans::getString("BodyPartsTorso") + " >");
  273. params.name(params.label);
  274. gDetachBodyPartPieMenus[6] = LLUICtrlFactory::create<LLContextMenu> (params);
  276. params.label(LLTrans::getString("BodyPartsRightLeg") + " >");
  277. params.name(params.label);
  278. gDetachBodyPartPieMenus[7] = LLUICtrlFactory::create<LLContextMenu> (params);
  280. for (S32 i = 0; i < 8; i++)
  281. {
  282. if (gAttachBodyPartPieMenus[i])
  283. {
  284. gAttachPieMenu->appendContextSubMenu( gAttachBodyPartPieMenus[i] );
  285. }
  286. else
  287. {
  288. BOOL attachment_found = FALSE;
  289. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  290.  iter != mAttachmentPoints.end();
  291.  ++iter)
  292. {
  293. LLViewerJointAttachment* attachment = iter->second;
  294. if (attachment->getGroup() == i)
  295. {
  296. LLMenuItemCallGL::Params item_params;
  298. std::string sub_piemenu_name = attachment->getName();
  299. if (LLTrans::getString(sub_piemenu_name) != "")
  300. {
  301. item_params.label = LLTrans::getString(sub_piemenu_name);
  302. }
  303. else
  304. {
  305. item_params.label = sub_piemenu_name;
  306. }
  307. item_params.name =(item_params.label );
  308. item_params.on_click.function_name = "Object.AttachToAvatar";
  309. item_params.on_click.parameter = iter->first;
  310. item_params.on_enable.function_name = "Object.EnableWear";
  311. item_params.on_enable.parameter = iter->first;
  312. LLMenuItemCallGL* item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  314. gAttachPieMenu->addChild(item);
  316. attachment_found = TRUE;
  317. break;
  319. }
  320. }
  321. }
  323. if (gDetachBodyPartPieMenus[i])
  324. {
  325. gDetachPieMenu->appendContextSubMenu( gDetachBodyPartPieMenus[i] );
  326. }
  327. else
  328. {
  329. BOOL attachment_found = FALSE;
  330. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  331.  iter != mAttachmentPoints.end();
  332.  ++iter)
  333. {
  334. LLViewerJointAttachment* attachment = iter->second;
  335. if (attachment->getGroup() == i)
  336. {
  337. LLMenuItemCallGL::Params item_params;
  338. std::string sub_piemenu_name = attachment->getName();
  339. if (LLTrans::getString(sub_piemenu_name) != "")
  340. {
  341. item_params.label = LLTrans::getString(sub_piemenu_name);
  342. }
  343. else
  344. {
  345. item_params.label = sub_piemenu_name;
  346. }
  347. item_params.name =(item_params.label );
  348. item_params.on_click.function_name = "Attachment.Detach";
  349. item_params.on_click.parameter = iter->first;
  350. item_params.on_enable.function_name = "Attachment.EnableDetach";
  351. item_params.on_enable.parameter = iter->first;
  352. LLMenuItemCallGL* item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  354. gDetachPieMenu->addChild(item);
  356. attachment_found = TRUE;
  357. break;
  358. }
  359. }
  360. }
  361. }
  363. // add screen attachments
  364. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  365.  iter != mAttachmentPoints.end();
  366.  ++iter)
  367. {
  368. LLViewerJointAttachment* attachment = iter->second;
  369. if (attachment->getGroup() == 8)
  370. {
  371. LLMenuItemCallGL::Params item_params;
  372. std::string sub_piemenu_name = attachment->getName();
  373. if (LLTrans::getString(sub_piemenu_name) != "")
  374. {
  375. item_params.label = LLTrans::getString(sub_piemenu_name);
  376. }
  377. else
  378. {
  379. item_params.label = sub_piemenu_name;
  380. }
  381. item_params.name =(item_params.label );
  382. item_params.on_click.function_name = "Object.AttachToAvatar";
  383. item_params.on_click.parameter = iter->first;
  384. item_params.on_enable.function_name = "Object.EnableWear";
  385. item_params.on_enable.parameter = iter->first;
  386. LLMenuItemCallGL* item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  387. gAttachScreenPieMenu->addChild(item);
  389. item_params.on_click.function_name = "Attachment.DetachFromPoint";
  390. item_params.on_click.parameter = iter->first;
  391. item_params.on_enable.function_name = "Attachment.PointFilled";
  392. item_params.on_enable.parameter = iter->first;
  393. item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  394. gDetachScreenPieMenu->addChild(item);
  395. }
  396. }
  398. for (S32 pass = 0; pass < 2; pass++)
  399. {
  400. // *TODO: Skinning - gAttachSubMenu is an awful, awful hack
  401. if (!gAttachSubMenu)
  402. {
  403. break;
  404. }
  405. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  406.  iter != mAttachmentPoints.end();
  407.  ++iter)
  408. {
  409. LLViewerJointAttachment* attachment = iter->second;
  410. if (attachment->getIsHUDAttachment() != (pass == 1))
  411. {
  412. continue;
  413. }
  414. LLMenuItemCallGL::Params item_params;
  415. std::string sub_piemenu_name = attachment->getName();
  416. if (LLTrans::getString(sub_piemenu_name) != "")
  417. {
  418. item_params.label = LLTrans::getString(sub_piemenu_name);
  419. }
  420. else
  421. {
  422. item_params.label = sub_piemenu_name;
  423. }
  424. item_params.name =(item_params.label );
  425. item_params.on_click.function_name = "Object.AttachToAvatar";
  426. item_params.on_click.parameter = iter->first;
  427. item_params.on_enable.function_name = "Object.EnableWear";
  428. item_params.on_enable.parameter = iter->first;
  429. //* TODO: Skinning:
  430. //LLSD params;
  431. //params["index"] = iter->first;
  432. //params["label"] = attachment->getName();
  433. //item->addEventHandler("on_enable", LLMenuItemCallGL::MenuCallback().function_name("Attachment.Label").parameter(params));
  435. LLMenuItemCallGL* item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  436. gAttachSubMenu->addChild(item);
  438. item_params.on_click.function_name = "Attachment.DetachFromPoint";
  439. item_params.on_click.parameter = iter->first;
  440. item_params.on_enable.function_name = "Attachment.PointFilled";
  441. item_params.on_enable.parameter = iter->first;
  442. //* TODO: Skinning: item->addEventHandler("on_enable", LLMenuItemCallGL::MenuCallback().function_name("Attachment.Label").parameter(params));
  444. item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  445. gDetachSubMenu->addChild(item);
  446. }
  447. if (pass == 0)
  448. {
  449. // put separator between non-hud and hud attachments
  450. gAttachSubMenu->addSeparator();
  451. gDetachSubMenu->addSeparator();
  452. }
  453. }
  455. for (S32 group = 0; group < 8; group++)
  456. {
  457. // skip over groups that don't have sub menus
  458. if (!gAttachBodyPartPieMenus[group] || !gDetachBodyPartPieMenus[group])
  459. {
  460. continue;
  461. }
  463. std::multimap<S32, S32> attachment_pie_menu_map;
  465. // gather up all attachment points assigned to this group, and throw into map sorted by pie slice number
  466. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  467.  iter != mAttachmentPoints.end();
  468.  ++iter)
  469. {
  470. LLViewerJointAttachment* attachment = iter->second;
  471. if(attachment->getGroup() == group)
  472. {
  473. // use multimap to provide a partial order off of the pie slice key
  474. S32 pie_index = attachment->getPieSlice();
  475. attachment_pie_menu_map.insert(std::make_pair(pie_index, iter->first));
  476. }
  477. }
  479. // add in requested order to pie menu, inserting separators as necessary
  480. for (std::multimap<S32, S32>::iterator attach_it = attachment_pie_menu_map.begin();
  481.  attach_it != attachment_pie_menu_map.end(); ++attach_it)
  482. {
  483. S32 attach_index = attach_it->second;
  485. LLViewerJointAttachment* attachment = get_if_there(mAttachmentPoints, attach_index, (LLViewerJointAttachment*)NULL);
  486. if (attachment)
  487. {
  488. LLMenuItemCallGL::Params item_params;
  489. item_params.name = attachment->getName();
  490. item_params.label = attachment->getName();
  491. item_params.on_click.function_name = "Object.AttachToAvatar";
  492. item_params.on_click.parameter = attach_index;
  493. item_params.on_enable.function_name = "Object.EnableWear";
  494. item_params.on_enable.parameter = attach_index;
  496. LLMenuItemCallGL* item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  497. gAttachBodyPartPieMenus[group]->addChild(item);
  499. item_params.on_click.function_name = "Attachment.DetachFromPoint";
  500. item_params.on_click.parameter = attach_index;
  501. item_params.on_enable.function_name = "Attachment.PointFilled";
  502. item_params.on_enable.parameter = attach_index;
  503. item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
  504. gDetachBodyPartPieMenus[group]->addChild(item);
  505. }
  506. }
  507. }
  508. return TRUE;
  509. }
  511. LLVOAvatarSelf::~LLVOAvatarSelf()
  512. {
  513. // gAgents pointer might have been set to a different Avatar Self, don't get rid of it if so.
  514. if (gAgent.getAvatarObject() == this)
  515. {
  516. gAgent.setAvatarObject(NULL);
  517. gAgentWearables.setAvatarObject(NULL);
  518. }
  519. delete mScreenp;
  520. mScreenp = NULL;
  521. }
  523. /**
  524.  **
  525.  ** End LLVOAvatarSelf Constructor routines
  526.  **                                                                             **
  527.  *********************************************************************************/
  529. //virtual
  530. BOOL LLVOAvatarSelf::loadLayersets()
  531. {
  532. BOOL success = TRUE;
  533. for (LLVOAvatarXmlInfo::layer_info_list_t::const_iterator iter = sAvatarXmlInfo->mLayerInfoList.begin();
  534.  iter != sAvatarXmlInfo->mLayerInfoList.end(); 
  535.  ++iter)
  536. {
  537. // Construct a layerset for each one specified in avatar_lad.xml and initialize it as such.
  538. const LLTexLayerSetInfo *info = *iter;
  539. LLTexLayerSet* layer_set = new LLTexLayerSet( this );
  541. if (!layer_set->setInfo(info))
  542. {
  543. stop_glerror();
  544. delete layer_set;
  545. llwarns << "avatar file: layer_set->parseData() failed" << llendl;
  546. return FALSE;
  547. }
  549. // scan baked textures and associate the layerset with the appropriate one
  550. EBakedTextureIndex baked_index = BAKED_NUM_INDICES;
  551. for (LLVOAvatarDictionary::BakedTextures::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
  552.  baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
  553.  ++baked_iter)
  554. {
  555. const LLVOAvatarDictionary::BakedEntry *baked_dict = baked_iter->second;
  556. if (layer_set->isBodyRegion(baked_dict->mName))
  557. {
  558. baked_index = baked_iter->first;
  559. // ensure both structures are aware of each other
  560. mBakedTextureDatas[baked_index].mTexLayerSet = layer_set;
  561. layer_set->setBakedTexIndex(baked_index);
  562. break;
  563. }
  564. }
  565. // if no baked texture was found, warn and cleanup
  566. if (baked_index == BAKED_NUM_INDICES)
  567. {
  568. llwarns << "<layer_set> has invalid body_region attribute" << llendl;
  569. delete layer_set;
  570. return FALSE;
  571. }
  573. // scan morph masks and let any affected layers know they have an associated morph
  574. for (LLVOAvatar::morph_list_t::const_iterator morph_iter = mBakedTextureDatas[baked_index].mMaskedMorphs.begin();
  575. morph_iter != mBakedTextureDatas[baked_index].mMaskedMorphs.end();
  576.  ++morph_iter)
  577. {
  578. LLMaskedMorph *morph = *morph_iter;
  579. LLTexLayerInterface* layer = layer_set->findLayerByName(morph->mLayer);
  580. if (layer)
  581. {
  582. layer->setHasMorph(TRUE);
  583. }
  584. else
  585. {
  586. llwarns << "Could not find layer named " << morph->mLayer << " to set morph flag" << llendl;
  587. success = FALSE;
  588. }
  589. }
  590. }
  591. return success;
  592. }
  593. // virtual
  594. BOOL LLVOAvatarSelf::updateCharacter(LLAgent &agent)
  595. {
  596. LLMemType mt(LLMemType::MTYPE_AVATAR);
  598. // update screen joint size
  599. if (mScreenp)
  600. {
  601. F32 aspect = LLViewerCamera::getInstance()->getAspect();
  602. LLVector3 scale(1.f, aspect, 1.f);
  603. mScreenp->setScale(scale);
  604. mScreenp->updateWorldMatrixChildren();
  605. resetHUDAttachments();
  606. }
  607. return LLVOAvatar::updateCharacter(agent);
  608. }
  610. // virtual
  611. LLJoint *LLVOAvatarSelf::getJoint(const std::string &name)
  612. {
  613. if (mScreenp)
  614. {
  615. LLJoint* jointp = mScreenp->findJoint(name);
  616. if (jointp) return jointp;
  617. }
  618. return LLVOAvatar::getJoint(name);
  619. }
  621. /*virtual*/ BOOL LLVOAvatarSelf::setVisualParamWeight(LLVisualParam *which_param, F32 weight, BOOL upload_bake )
  622. {
  623. if (!which_param)
  624. {
  625. return FALSE;
  626. }
  627. LLViewerVisualParam *param = (LLViewerVisualParam*) LLCharacter::getVisualParam(which_param->getID());
  628. return setParamWeight(param,weight,upload_bake);
  629. }
  631. /*virtual*/ BOOL LLVOAvatarSelf::setVisualParamWeight(const char* param_name, F32 weight, BOOL upload_bake )
  632. {
  633. if (!param_name)
  634. {
  635. return FALSE;
  636. }
  637. LLViewerVisualParam *param = (LLViewerVisualParam*) LLCharacter::getVisualParam(param_name);
  638. return setParamWeight(param,weight,upload_bake);
  639. }
  641. /*virtual*/ BOOL LLVOAvatarSelf::setVisualParamWeight(S32 index, F32 weight, BOOL upload_bake )
  642. {
  643. LLViewerVisualParam *param = (LLViewerVisualParam*) LLCharacter::getVisualParam(index);
  644. return setParamWeight(param,weight,upload_bake);
  645. }
  647. BOOL LLVOAvatarSelf::setParamWeight(LLViewerVisualParam *param, F32 weight, BOOL upload_bake )
  648. {
  649. if (!param)
  650. {
  651. return FALSE;
  652. }
  654. if (param->getCrossWearable())
  655. {
  656. EWearableType type = (EWearableType)param->getWearableType();
  657. U32 size = gAgentWearables.getWearableCount(type);
  658. for (U32 count = 0; count < size; ++count)
  659. {
  660. LLWearable *wearable = gAgentWearables.getWearable(type,count);
  661. if (wearable)
  662. {
  663. wearable->setVisualParamWeight(param->getID(), weight, upload_bake);
  664. }
  665. }
  666. }
  668. return LLCharacter::setVisualParamWeight(param,weight,upload_bake);
  669. }
  671. /*virtual*/ 
  672. void LLVOAvatarSelf::updateVisualParams()
  673. {
  674. for (U32 type = 0; type < WT_COUNT; type++)
  675. {
  676. LLWearable *wearable = gAgentWearables.getTopWearable((EWearableType)type);
  677. if (wearable)
  678. {
  679. wearable->writeToAvatar();
  680. }
  681. }
  683. LLVOAvatar::updateVisualParams();
  684. }
  686. /*virtual*/
  687. void LLVOAvatarSelf::idleUpdateAppearanceAnimation()
  688. {
  689. // Animate all top-level wearable visual parameters
  690. gAgentWearables.animateAllWearableParams(calcMorphAmount(), FALSE);
  692. // apply wearable visual params to avatar
  693. updateVisualParams();
  695. //allow avatar to process updates
  696. LLVOAvatar::idleUpdateAppearanceAnimation();
  698. }
  700. // virtual
  701. void LLVOAvatarSelf::requestStopMotion(LLMotion* motion)
  702. {
  703. // Only agent avatars should handle the stop motion notifications.
  705. // Notify agent that motion has stopped
  706. gAgent.requestStopMotion(motion);
  707. }
  709. // virtual
  710. void LLVOAvatarSelf::stopMotionFromSource(const LLUUID& source_id)
  711. {
  712. for (AnimSourceIterator motion_it = mAnimationSources.find(source_id); motion_it != mAnimationSources.end(); )
  713. {
  714. gAgent.sendAnimationRequest(motion_it->second, ANIM_REQUEST_STOP);
  715. mAnimationSources.erase(motion_it++);
  716. }
  718. LLViewerObject* object = gObjectList.findObject(source_id);
  719. if (object)
  720. {
  721. object->mFlags &= ~FLAGS_ANIM_SOURCE;
  722. }
  723. }
  725. void LLVOAvatarSelf::setLocalTextureTE(U8 te, LLViewerTexture* image, U32 index)
  726. {
  727. if (te >= TEX_NUM_INDICES)
  728. {
  729. llassert(0);
  730. return;
  731. }
  733. if (getTEImage(te)->getID() == image->getID())
  734. {
  735. return;
  736. }
  738. if (isIndexBakedTexture((ETextureIndex)te))
  739. {
  740. llassert(0);
  741. return;
  742. }
  744. setTEImage(te, image);
  745. }
  747. //virtual
  748. void LLVOAvatarSelf::removeMissingBakedTextures()
  749. {
  750. BOOL removed = FALSE;
  751. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  752. {
  753. const S32 te = mBakedTextureDatas[i].mTextureIndex;
  754. LLViewerTexture* tex = getTEImage(te) ;
  755. if (!tex || tex->isMissingAsset())
  756. {
  757. setTEImage(te, LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT_AVATAR));
  758. removed = TRUE;
  759. }
  760. }
  762. if (removed)
  763. {
  764. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  765. {
  766. invalidateComposite(mBakedTextureDatas[i].mTexLayerSet, FALSE);
  767. }
  768. updateMeshTextures();
  769. requestLayerSetUploads();
  770. }
  771. }
  773. //virtual
  774. void LLVOAvatarSelf::updateRegion(LLViewerRegion *regionp)
  775. {
  776. if (regionp->getHandle() != mLastRegionHandle)
  777. {
  778. if (mLastRegionHandle != 0)
  779. {
  780. ++mRegionCrossingCount;
  781. F64 delta = (F64)mRegionCrossingTimer.getElapsedTimeF32();
  782. F64 avg = (mRegionCrossingCount == 1) ? 0 : LLViewerStats::getInstance()->getStat(LLViewerStats::ST_CROSSING_AVG);
  783. F64 delta_avg = (delta + avg*(mRegionCrossingCount-1)) / mRegionCrossingCount;
  784. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_CROSSING_AVG, delta_avg);
  786. F64 max = (mRegionCrossingCount == 1) ? 0 : LLViewerStats::getInstance()->getStat(LLViewerStats::ST_CROSSING_MAX);
  787. max = llmax(delta, max);
  788. LLViewerStats::getInstance()->setStat(LLViewerStats::ST_CROSSING_MAX, max);
  789. }
  790. mLastRegionHandle = regionp->getHandle();
  791. }
  792. mRegionCrossingTimer.reset();
  793. }
  795. //--------------------------------------------------------------------
  796. // draw tractor beam when editing objects
  797. //--------------------------------------------------------------------
  798. //virtual
  799. void LLVOAvatarSelf::idleUpdateTractorBeam()
  800. {
  801. // This is only done for yourself (maybe it should be in the agent?)
  802. if (!needsRenderBeam() || !mIsBuilt)
  803. {
  804. mBeam = NULL;
  805. }
  806. else if (!mBeam || mBeam->isDead())
  807. {
  808. // VEFFECT: Tractor Beam
  809. mBeam = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BEAM);
  810. mBeam->setColor(LLColor4U(gAgent.getEffectColor()));
  811. mBeam->setSourceObject(this);
  812. mBeamTimer.reset();
  813. }
  815. if (!mBeam.isNull())
  816. {
  817. LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
  819. if (gAgent.mPointAt.notNull())
  820. {
  821. // get point from pointat effect
  822. mBeam->setPositionGlobal(gAgent.mPointAt->getPointAtPosGlobal());
  823. mBeam->triggerLocal();
  824. }
  825. else if (selection->getFirstRootObject() && 
  826. selection->getSelectType() != SELECT_TYPE_HUD)
  827. {
  828. LLViewerObject* objectp = selection->getFirstRootObject();
  829. mBeam->setTargetObject(objectp);
  830. }
  831. else
  832. {
  833. mBeam->setTargetObject(NULL);
  834. LLTool *tool = LLToolMgr::getInstance()->getCurrentTool();
  835. if (tool->isEditing())
  836. {
  837. if (tool->getEditingObject())
  838. {
  839. mBeam->setTargetObject(tool->getEditingObject());
  840. }
  841. else
  842. {
  843. mBeam->setPositionGlobal(tool->getEditingPointGlobal());
  844. }
  845. }
  846. else
  847. {
  848. const LLPickInfo& pick = gViewerWindow->getLastPick();
  849. mBeam->setPositionGlobal(pick.mPosGlobal);
  850. }
  852. }
  853. if (mBeamTimer.getElapsedTimeF32() > 0.25f)
  854. {
  855. mBeam->setColor(LLColor4U(gAgent.getEffectColor()));
  856. mBeam->setNeedsSendToSim(TRUE);
  857. mBeamTimer.reset();
  858. }
  859. }
  860. }
  862. //-----------------------------------------------------------------------------
  863. // restoreMeshData()
  864. //-----------------------------------------------------------------------------
  865. // virtual
  866. void LLVOAvatarSelf::restoreMeshData()
  867. {
  868. LLMemType mt(LLMemType::MTYPE_AVATAR);
  870. //llinfos << "Restoring" << llendl;
  871. mMeshValid = TRUE;
  872. updateJointLODs();
  873. updateAttachmentVisibility(gAgent.getCameraMode());
  875. // force mesh update as LOD might not have changed to trigger this
  876. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, TRUE);
  877. }
  881. //-----------------------------------------------------------------------------
  882. // updateAttachmentVisibility()
  883. //-----------------------------------------------------------------------------
  884. void LLVOAvatarSelf::updateAttachmentVisibility(U32 camera_mode)
  885. {
  886. for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); 
  887.  iter != mAttachmentPoints.end();
  888.  ++iter)
  889. {
  890. LLViewerJointAttachment* attachment = iter->second;
  891. if (attachment->getIsHUDAttachment())
  892. {
  893. attachment->setAttachmentVisibility(TRUE);
  894. }
  895. else
  896. {
  897. switch (camera_mode)
  898. {
  899. case CAMERA_MODE_MOUSELOOK:
  900. if (LLVOAvatar::sVisibleInFirstPerson && attachment->getVisibleInFirstPerson())
  901. {
  902. attachment->setAttachmentVisibility(TRUE);
  903. }
  904. else
  905. {
  906. attachment->setAttachmentVisibility(FALSE);
  907. }
  908. break;
  909. default:
  910. attachment->setAttachmentVisibility(TRUE);
  911. break;
  912. }
  913. }
  914. }
  915. }
  917. /*virtual*/ BOOL LLVOAvatarSelf::isWearingWearableType(EWearableType type ) const
  918. {
  919. return gAgentWearables.getWearableCount(type) > 0;
  920. }
  922. //-----------------------------------------------------------------------------
  923. // updatedWearable( EWearableType type )
  924. // forces an update to any baked textures relevant to type.
  925. // will force an upload of the resulting bake if the second parameter is TRUE
  926. //-----------------------------------------------------------------------------
  927. void LLVOAvatarSelf::wearableUpdated( EWearableType type, BOOL upload_result )
  928. {
  929. for (LLVOAvatarDictionary::BakedTextures::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
  930.  baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
  931.  ++baked_iter)
  932. {
  933. const LLVOAvatarDictionary::BakedEntry *baked_dict = baked_iter->second;
  934. const LLVOAvatarDefines::EBakedTextureIndex index = baked_iter->first;
  936. // if we're editing our appearance, ensure that we're not using baked textures
  937. // The baked texture for alpha masks is set explicitly when you hit "save"
  938. if (gAgent.cameraCustomizeAvatar())
  939. {
  940. setNewBakedTexture(index,IMG_DEFAULT_AVATAR);
  941. }
  942. if (baked_dict)
  943. {
  944. for (LLVOAvatarDefines::wearables_vec_t::const_iterator type_iter = baked_dict->mWearables.begin();
  945. type_iter != baked_dict->mWearables.end();
  946.  ++type_iter)
  947. {
  948. const EWearableType comp_type = *type_iter;
  949. if (comp_type == type)
  950. {
  951. if (mBakedTextureDatas[index].mTexLayerSet)
  952. {
  953. invalidateComposite(mBakedTextureDatas[index].mTexLayerSet, upload_result);
  954. }
  955. break;
  956. }
  957. }
  958. }
  959. }
  960. }
  962. //-----------------------------------------------------------------------------
  963. // isWearingAttachment()
  964. //-----------------------------------------------------------------------------
  965. BOOL LLVOAvatarSelf::isWearingAttachment(const LLUUID& inv_item_id) const
  966. {
  967. const LLUUID& base_inv_item_id = gInventory.getLinkedItemID(inv_item_id);
  968. for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); 
  969.  iter != mAttachmentPoints.end();
  970.  ++iter)
  971. {
  972. const LLViewerJointAttachment* attachment = iter->second;
  973. if (attachment->getAttachedObject(base_inv_item_id))
  974. {
  975. return TRUE;
  976. }
  977. }
  978. return FALSE;
  979. }
  981. //-----------------------------------------------------------------------------
  982. // getWornAttachment()
  983. //-----------------------------------------------------------------------------
  984. LLViewerObject* LLVOAvatarSelf::getWornAttachment(const LLUUID& inv_item_id)
  985. {
  986. const LLUUID& base_inv_item_id = gInventory.getLinkedItemID(inv_item_id);
  987. for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); 
  988.  iter != mAttachmentPoints.end();
  989.  ++iter)
  990. {
  991. LLViewerJointAttachment* attachment = iter->second;
  992.   if (LLViewerObject *attached_object = attachment->getAttachedObject(base_inv_item_id))
  993. {
  994. return attached_object;
  995. }
  996. }
  997. return NULL;
  998. }
  1000. const std::string LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id) const
  1001. {
  1002. const LLUUID& base_inv_item_id = gInventory.getLinkedItemID(inv_item_id);
  1003. for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); 
  1004.  iter != mAttachmentPoints.end(); 
  1005.  ++iter)
  1006. {
  1007. const LLViewerJointAttachment* attachment = iter->second;
  1008. if (attachment->getAttachedObject(base_inv_item_id))
  1009. {
  1010. return attachment->getName();
  1011. }
  1012. }
  1014. return LLStringUtil::null;
  1015. }
  1017. //virtual
  1018. const LLViewerJointAttachment *LLVOAvatarSelf::attachObject(LLViewerObject *viewer_object)
  1019. {
  1020. const LLViewerJointAttachment *attachment = LLVOAvatar::attachObject(viewer_object);
  1021. if (!attachment)
  1022. {
  1023. return 0;
  1024. }
  1026. updateAttachmentVisibility(gAgent.getCameraMode());
  1028. // Then make sure the inventory is in sync with the avatar.
  1030. // Should just be the last object added
  1031. if (attachment->isObjectAttached(viewer_object))
  1032. {
  1033. const LLUUID& attachment_id = viewer_object->getItemID();
  1034. LLAppearanceManager::instance().registerAttachment(attachment_id);
  1035. }
  1037. return attachment;
  1038. }
  1040. //virtual
  1041. BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object)
  1042. {
  1043. const LLUUID attachment_id = viewer_object->getItemID();
  1044. if (LLVOAvatar::detachObject(viewer_object))
  1045. {
  1046. // the simulator should automatically handle permission revocation
  1048. stopMotionFromSource(attachment_id);
  1049. LLFollowCamMgr::setCameraActive(viewer_object->getID(), FALSE);
  1051. LLViewerObject::const_child_list_t& child_list = viewer_object->getChildren();
  1052. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1053.  iter != child_list.end(); 
  1054.  ++iter)
  1055. {
  1056. LLViewerObject* child_objectp = *iter;
  1057. // the simulator should automatically handle
  1058. // permissions revocation
  1060. stopMotionFromSource(child_objectp->getID());
  1061. LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE);
  1062. }
  1064. // Make sure the inventory is in sync with the avatar.
  1066. // Update COF contents, don't trigger appearance update.
  1067. if (gAgent.getAvatarObject() == NULL)
  1068. {
  1069. llinfos << "removeItemLinks skipped, avatar is under destruction" << llendl;
  1070. }
  1071. else
  1072. {
  1073. LLAppearanceManager::instance().unregisterAttachment(attachment_id);
  1074. }
  1076. return TRUE;
  1077. }
  1078. return FALSE;
  1079. }
  1081. U32 LLVOAvatarSelf::getNumWearables(LLVOAvatarDefines::ETextureIndex i) const
  1082. {
  1083. EWearableType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
  1084. return gAgentWearables.getWearableCount(type);
  1085. }
  1087. // virtual
  1088. void LLVOAvatarSelf::localTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata)
  1089. {
  1090. //llinfos << "onLocalTextureLoaded: " << src_vi->getID() << llendl;
  1092. const LLUUID& src_id = src_vi->getID();
  1093. LLAvatarTexData *data = (LLAvatarTexData *)userdata;
  1094. ETextureIndex index = data->mIndex;
  1095. if (!isIndexLocalTexture(index)) return;
  1096. LLLocalTextureObject *local_tex_obj = getLocalTextureObject(index, 0);
  1098. // fix for EXT-268. Preventing using of NULL pointer
  1099. if(NULL == local_tex_obj)
  1100. {
  1101. LL_WARNS("TAG") << "There is no Local Texture Object with index: " << index 
  1102. << ", final: " << final
  1103. << LL_ENDL;
  1104. return;
  1105. }
  1106. if (success)
  1107. {
  1108. if (!local_tex_obj->getBakedReady() &&
  1109. local_tex_obj->getImage() != NULL &&
  1110. (local_tex_obj->getID() == src_id) &&
  1111. discard_level < local_tex_obj->getDiscard())
  1112. {
  1113. local_tex_obj->setDiscard(discard_level);
  1114. if (!gAgent.cameraCustomizeAvatar())
  1115. {
  1116. requestLayerSetUpdate(index);
  1117. }
  1118. else if (gAgent.cameraCustomizeAvatar())
  1119. {
  1120. LLVisualParamHint::requestHintUpdates();
  1121. }
  1122. updateMeshTextures();
  1123. }
  1124. }
  1125. else if (final)
  1126. {
  1127. // Failed: asset is missing
  1128. if (!local_tex_obj->getBakedReady() &&
  1129. local_tex_obj->getImage() != NULL &&
  1130. local_tex_obj->getImage()->getID() == src_id)
  1131. {
  1132. local_tex_obj->setDiscard(0);
  1133. requestLayerSetUpdate(index);
  1134. updateMeshTextures();
  1135. }
  1136. }
  1137. }
  1139. // virtual
  1140. BOOL LLVOAvatarSelf::getLocalTextureGL(ETextureIndex type, LLViewerTexture** tex_pp, U32 index) const
  1141. {
  1142. *tex_pp = NULL;
  1144. if (!isIndexLocalTexture(type)) return FALSE;
  1145. if (getLocalTextureID(type, index) == IMG_DEFAULT_AVATAR) return TRUE;
  1147. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type, index);
  1148. if (!local_tex_obj)
  1149. {
  1150. return FALSE;
  1151. }
  1152. *tex_pp = local_tex_obj->getImage();
  1153. return TRUE;
  1154. }
  1156. LLViewerFetchedTexture* LLVOAvatarSelf::getLocalTextureGL(LLVOAvatarDefines::ETextureIndex type, U32 index) const
  1157. {
  1158. if (!isIndexLocalTexture(type))
  1159. {
  1160. return NULL;
  1161. }
  1163. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type, index);
  1164. if (!local_tex_obj)
  1165. {
  1166. return NULL;
  1167. }
  1168. if (local_tex_obj->getID() == IMG_DEFAULT_AVATAR)
  1169. {
  1170. return LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT_AVATAR);
  1171. }
  1172. return local_tex_obj->getImage();
  1173. }
  1175. const LLUUID& LLVOAvatarSelf::getLocalTextureID(ETextureIndex type, U32 index) const
  1176. {
  1177. if (!isIndexLocalTexture(type)) return IMG_DEFAULT_AVATAR;
  1179. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type, index);
  1180. if (local_tex_obj && local_tex_obj->getImage() != NULL)
  1181. {
  1182. return local_tex_obj->getImage()->getID();
  1183. }
  1184. return IMG_DEFAULT_AVATAR;
  1185. } 
  1188. //-----------------------------------------------------------------------------
  1189. // isLocalTextureDataAvailable()
  1190. // Returns true if at least the lowest quality discard level exists for every texture
  1191. // in the layerset.
  1192. //-----------------------------------------------------------------------------
  1193. BOOL LLVOAvatarSelf::isLocalTextureDataAvailable(const LLTexLayerSet* layerset) const
  1194. {
  1195. /* if (layerset == mBakedTextureDatas[BAKED_HEAD].mTexLayerSet)
  1196.    return getLocalDiscardLevel(TEX_HEAD_BODYPAINT) >= 0; */
  1197. for (LLVOAvatarDictionary::BakedTextures::const_iterator baked_iter = LLVOAvatarDictionary::getInstance()->getBakedTextures().begin();
  1198.  baked_iter != LLVOAvatarDictionary::getInstance()->getBakedTextures().end();
  1199.  ++baked_iter)
  1200. {
  1201. const EBakedTextureIndex baked_index = baked_iter->first;
  1202. if (layerset == mBakedTextureDatas[baked_index].mTexLayerSet)
  1203. {
  1204. BOOL ret = true;
  1205. const LLVOAvatarDictionary::BakedEntry *baked_dict = baked_iter->second;
  1206. for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
  1207.  local_tex_iter != baked_dict->mLocalTextures.end();
  1208.  ++local_tex_iter)
  1209. {
  1210. const ETextureIndex tex_index = *local_tex_iter;
  1211. const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
  1212. const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
  1213. for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
  1214. {
  1215. ret &= (getLocalDiscardLevel(tex_index, wearable_index) >= 0);
  1216. }
  1217. }
  1218. return ret;
  1219. }
  1220. }
  1221. llassert(0);
  1222. return FALSE;
  1223. }
  1225. //-----------------------------------------------------------------------------
  1226. // virtual
  1227. // isLocalTextureDataFinal()
  1228. // Returns true if the highest quality discard level exists for every texture
  1229. // in the layerset.
  1230. //-----------------------------------------------------------------------------
  1231. BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLTexLayerSet* layerset) const
  1232. {
  1233. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1234. {
  1235. if (layerset == mBakedTextureDatas[i].mTexLayerSet)
  1236. {
  1237. const LLVOAvatarDictionary::BakedEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)i);
  1238. for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin();
  1239.  local_tex_iter != baked_dict->mLocalTextures.end();
  1240.  ++local_tex_iter)
  1241. {
  1242. const ETextureIndex tex_index = *local_tex_iter;
  1243. const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(tex_index);
  1244. const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
  1245. for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
  1246. {
  1247. if (getLocalDiscardLevel(*local_tex_iter, wearable_index) != 0)
  1248. {
  1249. return FALSE;
  1250. }
  1251. }
  1252. }
  1253. return TRUE;
  1254. }
  1255. }
  1256. llassert(0);
  1257. return FALSE;
  1258. }
  1260. BOOL LLVOAvatarSelf::isTextureDefined(LLVOAvatarDefines::ETextureIndex type, U32 index) const
  1261. {
  1262. LLUUID id;
  1263. BOOL isDefined = TRUE;
  1264. if (isIndexLocalTexture(type))
  1265. {
  1266. const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType(type);
  1267. const U32 wearable_count = gAgentWearables.getWearableCount(wearable_type);
  1268. if (index >= wearable_count)
  1269. {
  1270. // invalid index passed in. check all textures of a given type
  1271. for (U32 wearable_index = 0; wearable_index < wearable_count; wearable_index++)
  1272. {
  1273. id = getLocalTextureID(type, wearable_index);
  1274. isDefined &= (id != IMG_DEFAULT_AVATAR && id != IMG_DEFAULT);
  1275. }
  1276. }
  1277. else
  1278. {
  1279. id = getLocalTextureID(type, index);
  1280. isDefined &= (id != IMG_DEFAULT_AVATAR && id != IMG_DEFAULT);
  1281. }
  1282. }
  1283. else
  1284. {
  1285. id = getTEImage(type)->getID();
  1286. isDefined &= (id != IMG_DEFAULT_AVATAR && id != IMG_DEFAULT);
  1287. }
  1289. return isDefined;
  1290. }
  1292. //-----------------------------------------------------------------------------
  1293. // virtual
  1294. // requestLayerSetUploads()
  1295. //-----------------------------------------------------------------------------
  1296. void LLVOAvatarSelf::requestLayerSetUploads()
  1297. {
  1298. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1299. {
  1300. ETextureIndex tex_index = mBakedTextureDatas[i].mTextureIndex;
  1301. BOOL layer_baked = isTextureDefined(tex_index, gAgentWearables.getWearableCount(tex_index));
  1302. if (!layer_baked && mBakedTextureDatas[i].mTexLayerSet)
  1303. {
  1304. mBakedTextureDatas[i].mTexLayerSet->requestUpload();
  1305. }
  1306. }
  1307. }
  1309. bool LLVOAvatarSelf::areTexturesCurrent() const
  1310. {
  1311. return !hasPendingBakedUploads() && gAgentWearables.areWearablesLoaded();
  1312. }
  1314. // virtual
  1315. bool LLVOAvatarSelf::hasPendingBakedUploads() const
  1316. {
  1317. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1318. {
  1319. BOOL upload_pending = (mBakedTextureDatas[i].mTexLayerSet && mBakedTextureDatas[i].mTexLayerSet->getComposite()->uploadPending());
  1320. if (upload_pending)
  1321. {
  1322. return true;
  1323. }
  1324. }
  1325. return false;
  1326. }
  1328. void LLVOAvatarSelf::invalidateComposite( LLTexLayerSet* layerset, BOOL upload_result )
  1329. {
  1330. if( !layerset || !layerset->getUpdatesEnabled() )
  1331. {
  1332. return;
  1333. }
  1334. // llinfos << "LLVOAvatar::invalidComposite() " << layerset->getBodyRegion() << llendl;
  1336. layerset->requestUpdate();
  1337. layerset->invalidateMorphMasks();
  1339. if( upload_result )
  1340. {
  1341. llassert(isSelf());
  1343. ETextureIndex baked_te = getBakedTE( layerset );
  1344. setTEImage( baked_te, LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT_AVATAR) );
  1345. layerset->requestUpload();
  1346. updateMeshTextures();
  1347. }
  1348. }
  1350. void LLVOAvatarSelf::invalidateAll()
  1351. {
  1352. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1353. {
  1354. invalidateComposite(mBakedTextureDatas[i].mTexLayerSet, TRUE);
  1355. }
  1356. }
  1358. //-----------------------------------------------------------------------------
  1359. // setCompositeUpdatesEnabled()
  1360. //-----------------------------------------------------------------------------
  1361. void LLVOAvatarSelf::setCompositeUpdatesEnabled( BOOL b )
  1362. {
  1363. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1364. {
  1365. if (mBakedTextureDatas[i].mTexLayerSet )
  1366. {
  1367. mBakedTextureDatas[i].mTexLayerSet->setUpdatesEnabled( b );
  1368. }
  1369. }
  1370. }
  1372. void LLVOAvatarSelf::setupComposites()
  1373. {
  1374. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1375. {
  1376. ETextureIndex tex_index = mBakedTextureDatas[i].mTextureIndex;
  1377. BOOL layer_baked = isTextureDefined(tex_index, gAgentWearables.getWearableCount(tex_index));
  1378. if (mBakedTextureDatas[i].mTexLayerSet)
  1379. {
  1380. mBakedTextureDatas[i].mTexLayerSet->setUpdatesEnabled(!layer_baked);
  1381. }
  1382. }
  1383. }
  1385. void LLVOAvatarSelf::updateComposites()
  1386. {
  1387. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1388. {
  1389. if (mBakedTextureDatas[i].mTexLayerSet 
  1390. && ((i != BAKED_SKIRT) || isWearingWearableType(WT_SKIRT)))
  1391. {
  1392. mBakedTextureDatas[i].mTexLayerSet->updateComposite();
  1393. }
  1394. }
  1395. }
  1397. // virtual
  1398. S32 LLVOAvatarSelf::getLocalDiscardLevel(ETextureIndex type, U32 wearable_index) const
  1399. {
  1400. if (!isIndexLocalTexture(type)) return FALSE;
  1402. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type, wearable_index);
  1403. if (local_tex_obj)
  1404. {
  1405. if (type >= 0
  1406. && local_tex_obj->getID() != IMG_DEFAULT_AVATAR
  1407. && !local_tex_obj->getImage()->isMissingAsset())
  1408. {
  1409. return local_tex_obj->getImage()->getDiscardLevel();
  1410. }
  1411. else
  1412. {
  1413. // We don't care about this (no image associated with the layer) treat as fully loaded.
  1414. return 0;
  1415. }
  1416. }
  1417. return 0;
  1418. }
  1420. // virtual
  1421. // Counts the memory footprint of local textures.
  1422. void LLVOAvatarSelf::getLocalTextureByteCount(S32* gl_bytes) const
  1423. {
  1424. *gl_bytes = 0;
  1425. for (S32 type = 0; type < TEX_NUM_INDICES; type++)
  1426. {
  1427. if (!isIndexLocalTexture((ETextureIndex)type)) continue;
  1428. U32 max_tex = getNumWearables((ETextureIndex) type);
  1429. for (U32 num = 0; num < max_tex; num++)
  1430. {
  1431. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject((ETextureIndex) type, num);
  1432. if (local_tex_obj)
  1433. {
  1434. const LLViewerFetchedTexture* image_gl = local_tex_obj->getImage();
  1435. if (image_gl)
  1436. {
  1437. S32 bytes = (S32)image_gl->getWidth() * image_gl->getHeight() * image_gl->getComponents();
  1439. if (image_gl->hasGLTexture())
  1440. {
  1441. *gl_bytes += bytes;
  1442. }
  1443. }
  1444. }
  1445. }
  1446. }
  1447. }
  1449. // virtual 
  1450. void LLVOAvatarSelf::setLocalTexture(ETextureIndex type, LLViewerTexture* src_tex, BOOL baked_version_ready, U32 index)
  1451. {
  1452. if (!isIndexLocalTexture(type)) return;
  1454. LLViewerFetchedTexture* tex = LLViewerTextureManager::staticCastToFetchedTexture(src_tex, TRUE) ;
  1455. if(!tex)
  1456. {
  1457. return ;
  1458. }
  1460. S32 desired_discard = isSelf() ? 0 : 2;
  1461. LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type,index);
  1462. if (!local_tex_obj)
  1463. {
  1464. if (type >= TEX_NUM_INDICES)
  1465. {
  1466. llerrs << "Tried to set local texture with invalid type: (" << (U32) type << ", " << index << ")" << llendl;
  1467. return;
  1468. }
  1469. EWearableType wearable_type = LLVOAvatarDictionary::getInstance()->getTEWearableType(type);
  1470. if (!gAgentWearables.getWearable(wearable_type,index))
  1471. {
  1472. // no wearable is loaded, cannot set the texture.
  1473. return;
  1474. }
  1475. gAgentWearables.addLocalTextureObject(wearable_type,type,index);
  1476. local_tex_obj = getLocalTextureObject(type,index);
  1477. if (!local_tex_obj)
  1478. {
  1479. llerrs << "Unable to create LocalTextureObject for wearable type & index: (" << (U32) wearable_type << ", " << index << ")" << llendl;
  1480. return;
  1481. }
  1483. LLTexLayerSet *layer_set = getLayerSet(type);
  1484. if (layer_set)
  1485. {
  1486. layer_set->cloneTemplates(local_tex_obj, type, gAgentWearables.getWearable(wearable_type,index));
  1487. }
  1489. }
  1490. if (!baked_version_ready)
  1491. {
  1492. if (tex != local_tex_obj->getImage() || local_tex_obj->getBakedReady())
  1493. {
  1494. local_tex_obj->setDiscard(MAX_DISCARD_LEVEL+1);
  1495. }
  1496. if (tex->getID() != IMG_DEFAULT_AVATAR)
  1497. {
  1498. if (local_tex_obj->getDiscard() > desired_discard)
  1499. {
  1500. S32 tex_discard = tex->getDiscardLevel();
  1501. if (tex_discard >= 0 && tex_discard <= desired_discard)
  1502. {
  1503. local_tex_obj->setDiscard(tex_discard);
  1504. if (isSelf() && !gAgent.cameraCustomizeAvatar())
  1505. {
  1506. requestLayerSetUpdate(type);
  1507. }
  1508. else if (isSelf() && gAgent.cameraCustomizeAvatar())
  1509. {
  1510. LLVisualParamHint::requestHintUpdates();
  1511. }
  1512. }
  1513. else
  1514. {
  1515. tex->setLoadedCallback(onLocalTextureLoaded, desired_discard, TRUE, FALSE, new LLAvatarTexData(getID(), type));
  1516. }
  1517. }
  1518. tex->setMinDiscardLevel(desired_discard);
  1519. }
  1520. }
  1521. local_tex_obj->setImage(tex);
  1522. local_tex_obj->setID(tex->getID());
  1523. setBakedReady(type,baked_version_ready,index);
  1524. }
  1525. //virtual
  1526. void LLVOAvatarSelf::setBakedReady(LLVOAvatarDefines::ETextureIndex type, BOOL baked_version_exists, U32 index)
  1527. {
  1528. if (!isIndexLocalTexture(type)) return;
  1529. LLLocalTextureObject *local_tex_obj = getLocalTextureObject(type,index);
  1530. if (local_tex_obj)
  1531. {
  1532. local_tex_obj->setBakedReady( baked_version_exists );
  1533. }
  1534. }
  1537. // virtual
  1538. void LLVOAvatarSelf::dumpLocalTextures() const
  1539. {
  1540. llinfos << "Local Textures:" << llendl;
  1542. /* ETextureIndex baked_equiv[] = {
  1543.    TEX_UPPER_BAKED,
  1544.    if (isTextureDefined(baked_equiv[i])) */
  1545. for (LLVOAvatarDictionary::Textures::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
  1546.  iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
  1547.  ++iter)
  1548. {
  1549. const LLVOAvatarDictionary::TextureEntry *texture_dict = iter->second;
  1550. if (!texture_dict->mIsLocalTexture || !texture_dict->mIsUsedByBakedTexture)
  1551. continue;
  1553. const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
  1554. const ETextureIndex baked_equiv = LLVOAvatarDictionary::getInstance()->getBakedTexture(baked_index)->mTextureIndex;
  1556. const std::string &name = texture_dict->mName;
  1557. const LLLocalTextureObject *local_tex_obj = getLocalTextureObject(iter->first, 0);
  1558. // index is baked texture - index is not relevant. putting in 0 as placeholder
  1559. if (isTextureDefined(baked_equiv, 0))
  1560. {
  1561. #if LL_RELEASE_FOR_DOWNLOAD
  1562. // End users don't get to trivially see avatar texture IDs, makes textures
  1563. // easier to steal. JC
  1564. llinfos << "LocTex " << name << ": Baked " << llendl;
  1565. #else
  1566. llinfos << "LocTex " << name << ": Baked " << getTEImage(baked_equiv)->getID() << llendl;
  1567. #endif
  1568. }
  1569. else if (local_tex_obj && local_tex_obj->getImage() != NULL)
  1570. {
  1571. if (local_tex_obj->getImage()->getID() == IMG_DEFAULT_AVATAR)
  1572. {
  1573. llinfos << "LocTex " << name << ": None" << llendl;
  1574. }
  1575. else
  1576. {
  1577. const LLViewerFetchedTexture* image = local_tex_obj->getImage();
  1579. llinfos << "LocTex " << name << ": "
  1580. << "Discard " << image->getDiscardLevel() << ", "
  1581. << "(" << image->getWidth() << ", " << image->getHeight() << ") " 
  1582. #if !LL_RELEASE_FOR_DOWNLOAD
  1583. // End users don't get to trivially see avatar texture IDs,
  1584. // makes textures easier to steal
  1585. << image->getID() << " "
  1586. #endif
  1587. << "Priority: " << image->getDecodePriority()
  1588. << llendl;
  1589. }
  1590. }
  1591. else
  1592. {
  1593. llinfos << "LocTex " << name << ": No LLViewerTexture" << llendl;
  1594. }
  1595. }
  1596. }
  1598. //-----------------------------------------------------------------------------
  1599. // static 
  1600. // onLocalTextureLoaded()
  1601. //-----------------------------------------------------------------------------
  1603. void LLVOAvatarSelf::onLocalTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata)
  1604. {
  1605. LLAvatarTexData *data = (LLAvatarTexData *)userdata;
  1606. LLVOAvatarSelf *self = (LLVOAvatarSelf *)gObjectList.findObject(data->mAvatarID);
  1607. if (self)
  1608. {
  1609. // We should only be handling local textures for ourself
  1610. self->localTextureLoaded(success, src_vi, src_raw, aux_src, discard_level, final, userdata);
  1611. }
  1612. // ensure data is cleaned up
  1613. if (final || !success)
  1614. {
  1615. delete data;
  1616. }
  1617. }
  1619. /*virtual*/ void LLVOAvatarSelf::setImage(const U8 te, LLViewerTexture *imagep, const U32 index)
  1620. {
  1621. if (isIndexLocalTexture((ETextureIndex)te))
  1622. {
  1623. setLocalTexture((ETextureIndex)te, imagep, FALSE ,index);
  1624. }
  1625. else 
  1626. {
  1627. setTEImage(te,imagep);
  1628. }
  1629. }
  1631. /*virtual*/ LLViewerTexture* LLVOAvatarSelf::getImage(const U8 te, const U32 index) const
  1632. {
  1633. if (isIndexLocalTexture((ETextureIndex)te))
  1634. {
  1635. return getLocalTextureGL((ETextureIndex)te,index);
  1636. }
  1637. else 
  1638. {
  1639. return getTEImage(te);
  1640. }
  1641. }
  1644. // static
  1645. void LLVOAvatarSelf::dumpTotalLocalTextureByteCount()
  1646. {
  1647. S32 gl_bytes = 0;
  1648. gAgent.getAvatarObject()->getLocalTextureByteCount(&gl_bytes);
  1649. llinfos << "Total Avatar LocTex GL:" << (gl_bytes/1024) << "KB" << llendl;
  1650. }
  1652. BOOL LLVOAvatarSelf::updateIsFullyLoaded()
  1653. {
  1654. BOOL loading = FALSE;
  1656. // do we have a shape?
  1657. if (visualParamWeightsAreDefault())
  1658. {
  1659. loading = TRUE;
  1660. }
  1662. if (!isTextureDefined(TEX_HAIR, 0))
  1663. {
  1664. loading = TRUE;
  1665. }
  1667. if (!mPreviousFullyLoaded)
  1668. {
  1669. if (!isLocalTextureDataAvailable(mBakedTextureDatas[BAKED_LOWER].mTexLayerSet) &&
  1670. (!isTextureDefined(TEX_LOWER_BAKED, 0)))
  1671. {
  1672. loading = TRUE;
  1673. }
  1675. if (!isLocalTextureDataAvailable(mBakedTextureDatas[BAKED_UPPER].mTexLayerSet) &&
  1676. (!isTextureDefined(TEX_UPPER_BAKED, 0)))
  1677. {
  1678. loading = TRUE;
  1679. }
  1681. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1682. {
  1683. if (i == BAKED_SKIRT && !isWearingWearableType(WT_SKIRT))
  1684. continue;
  1686. BakedTextureData& texture_data = mBakedTextureDatas[i];
  1687. if (!isTextureDefined(texture_data.mTextureIndex, 0))
  1688. continue;
  1690. // Check for the case that texture is defined but not sufficiently loaded to display anything.
  1691. LLViewerTexture* baked_img = getImage( texture_data.mTextureIndex, 0 );
  1692. if (!baked_img || !baked_img->hasGLTexture())
  1693. {
  1694. loading = TRUE;
  1695. }
  1697. }
  1699. }
  1700. return processFullyLoadedChange(loading);
  1701. }
  1703. const LLUUID& LLVOAvatarSelf::grabLocalTexture(ETextureIndex type, U32 index) const
  1704. {
  1705. if (canGrabLocalTexture(type, index))
  1706. {
  1707. return getTEImage( type )->getID();
  1708. }
  1709. return LLUUID::null;
  1710. }
  1712. BOOL LLVOAvatarSelf::canGrabLocalTexture(ETextureIndex type, U32 index) const
  1713. {
  1714. // Check if the texture hasn't been baked yet.
  1715. if (!isTextureDefined(type, index))
  1716. {
  1717. lldebugs << "getTEImage( " << (U32) type << ", " << index << " )->getID() == IMG_DEFAULT_AVATAR" << llendl;
  1718. return FALSE;
  1719. }
  1721. if (gAgent.isGodlike())
  1722. return TRUE;
  1724. // Check permissions of textures that show up in the
  1725. // baked texture.  We don't want people copying people's
  1726. // work via baked textures.
  1727. /* switch(type)
  1728. case TEX_EYES_BAKED:
  1729. textures.push_back(TEX_EYES_IRIS); */
  1730. const LLVOAvatarDictionary::TextureEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture(type);
  1731. if (!texture_dict->mIsUsedByBakedTexture) return FALSE;
  1733. const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
  1734. const LLVOAvatarDictionary::BakedEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture(baked_index);
  1735. for (texture_vec_t::const_iterator iter = baked_dict->mLocalTextures.begin();
  1736.  iter != baked_dict->mLocalTextures.end();
  1737.  ++iter)
  1738. {
  1739. const ETextureIndex t_index = (*iter);
  1740. lldebugs << "Checking index " << (U32) t_index << llendl;
  1741. // MULTI-WEARABLE: old method. replace.
  1742. const LLUUID& texture_id = getTEImage( t_index )->getID();
  1743. if (texture_id != IMG_DEFAULT_AVATAR)
  1744. {
  1745. // Search inventory for this texture.
  1746. LLViewerInventoryCategory::cat_array_t cats;
  1747. LLViewerInventoryItem::item_array_t items;
  1748. LLAssetIDMatches asset_id_matches(texture_id);
  1749. gInventory.collectDescendentsIf(LLUUID::null,
  1750. cats,
  1751. items,
  1752. LLInventoryModel::INCLUDE_TRASH,
  1753. asset_id_matches);
  1755. BOOL can_grab = FALSE;
  1756. lldebugs << "item count for asset " << texture_id << ": " << items.count() << llendl;
  1757. if (items.count())
  1758. {
  1759. // search for full permissions version
  1760. for (S32 i = 0; i < items.count(); i++)
  1761. {
  1762. LLInventoryItem* itemp = items[i];
  1763. LLPermissions item_permissions = itemp->getPermissions();
  1764. if ( item_permissions.allowOperationBy(
  1765. PERM_MODIFY, gAgent.getID(), gAgent.getGroupID()) &&
  1766.  item_permissions.allowOperationBy(
  1767. PERM_COPY, gAgent.getID(), gAgent.getGroupID()) &&
  1768.  item_permissions.allowOperationBy(
  1769. PERM_TRANSFER, gAgent.getID(), gAgent.getGroupID()) )
  1770. {
  1771. can_grab = TRUE;
  1772. break;
  1773. }
  1774. }
  1775. }
  1776. if (!can_grab) return FALSE;
  1777. }
  1778. }
  1780. return TRUE;
  1781. }
  1783. void LLVOAvatarSelf::addLocalTextureStats( ETextureIndex type, LLViewerFetchedTexture* imagep,
  1784.    F32 texel_area_ratio, BOOL render_avatar, BOOL covered_by_baked, U32 index )
  1785. {
  1786. if (!isIndexLocalTexture(type)) return;
  1788. if (!covered_by_baked)
  1789. {
  1790. if (getLocalTextureID(type, index) != IMG_DEFAULT_AVATAR && imagep->getDiscardLevel() != 0)
  1791. {
  1792. F32 desired_pixels;
  1793. desired_pixels = llmin(mPixelArea, (F32)getTexImageArea());
  1794. imagep->setBoostLevel(getAvatarBoostLevel());
  1795. imagep->addTextureStats( desired_pixels / texel_area_ratio );
  1796. imagep->forceUpdateBindStats() ;
  1797. if (imagep->getDiscardLevel() < 0)
  1798. {
  1799. mHasGrey = TRUE; // for statistics gathering
  1800. }
  1801. }
  1802. else
  1803. {
  1804. // texture asset is missing
  1805. mHasGrey = TRUE; // for statistics gathering
  1806. }
  1807. }
  1808. }
  1810. LLLocalTextureObject* LLVOAvatarSelf::getLocalTextureObject(LLVOAvatarDefines::ETextureIndex i, U32 wearable_index) const
  1811. {
  1812. EWearableType type = LLVOAvatarDictionary::getInstance()->getTEWearableType(i);
  1813. LLWearable* wearable = gAgentWearables.getWearable(type, wearable_index);
  1814. if (wearable)
  1815. {
  1816. return wearable->getLocalTextureObject(i);
  1817. }
  1819. return NULL;
  1820. }
  1822. //-----------------------------------------------------------------------------
  1823. // getBakedTE()
  1824. // Used by the LayerSet.  (Layer sets don't in general know what textures depend on them.)
  1825. //-----------------------------------------------------------------------------
  1826. ETextureIndex LLVOAvatarSelf::getBakedTE( const LLTexLayerSet* layerset ) const
  1827. {
  1828. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1829. {
  1830. if (layerset == mBakedTextureDatas[i].mTexLayerSet )
  1831. {
  1832. return mBakedTextureDatas[i].mTextureIndex;
  1833. }
  1834. }
  1835. llassert(0);
  1836. return TEX_HEAD_BAKED;
  1837. }
  1840. void LLVOAvatarSelf::setNewBakedTexture(LLVOAvatarDefines::EBakedTextureIndex i, const LLUUID &uuid)
  1841. {
  1842. ETextureIndex index = LLVOAvatarDictionary::bakedToLocalTextureIndex(i);
  1843. setNewBakedTexture(index, uuid);
  1844. }
  1847. //-----------------------------------------------------------------------------
  1848. // setNewBakedTexture()
  1849. // A new baked texture has been successfully uploaded and we can start using it now.
  1850. //-----------------------------------------------------------------------------
  1851. void LLVOAvatarSelf::setNewBakedTexture( ETextureIndex te, const LLUUID& uuid )
  1852. {
  1853. // Baked textures live on other sims.
  1854. LLHost target_host = getObjectHost();
  1855. setTEImage( te, LLViewerTextureManager::getFetchedTextureFromHost( uuid, target_host ) );
  1856. updateMeshTextures();
  1857. dirtyMesh();
  1859. LLVOAvatar::cullAvatarsByPixelArea();
  1861. /* switch(te)
  1862. case TEX_HEAD_BAKED:
  1863. llinfos << "New baked texture: HEAD" << llendl; */
  1864. const LLVOAvatarDictionary::TextureEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture(te);
  1865. if (texture_dict->mIsBakedTexture)
  1866. {
  1867. llinfos << "New baked texture: " << texture_dict->mName << " UUID: " << uuid <<llendl;
  1868. }
  1869. else
  1870. {
  1871. llwarns << "New baked texture: unknown te " << te << llendl;
  1872. }
  1874. // dumpAvatarTEs( "setNewBakedTexture() send" );
  1875. // RN: throttle uploads
  1876. if (!hasPendingBakedUploads())
  1877. {
  1878. gAgent.sendAgentSetAppearance();
  1879. }
  1880. }
  1882. //-----------------------------------------------------------------------------
  1883. // setCachedBakedTexture()
  1884. // A baked texture id was received from a cache query, make it active
  1885. //-----------------------------------------------------------------------------
  1886. void LLVOAvatarSelf::setCachedBakedTexture( ETextureIndex te, const LLUUID& uuid )
  1887. {
  1888. setTETexture( te, uuid );
  1890. /* switch(te)
  1891. case TEX_HEAD_BAKED:
  1892. if( mHeadLayerSet )
  1893. mHeadLayerSet->cancelUpload(); */
  1894. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1895. {
  1896. if ( mBakedTextureDatas[i].mTextureIndex == te && mBakedTextureDatas[i].mTexLayerSet)
  1897. {
  1898. mBakedTextureDatas[i].mTexLayerSet->cancelUpload();
  1899. }
  1900. }
  1901. }
  1903. // static
  1904. void LLVOAvatarSelf::processRebakeAvatarTextures(LLMessageSystem* msg, void**)
  1905. {
  1906. LLUUID texture_id;
  1907. msg->getUUID("TextureData", "TextureID", texture_id);
  1909. LLVOAvatarSelf* self = gAgent.getAvatarObject();
  1910. if (!self) return;
  1912. // If this is a texture corresponding to one of our baked entries, 
  1913. // just rebake that layer set.
  1914. BOOL found = FALSE;
  1916. /* ETextureIndex baked_texture_indices[BAKED_NUM_INDICES] =
  1917. TEX_HEAD_BAKED,
  1918. TEX_UPPER_BAKED, */
  1919. for (LLVOAvatarDictionary::Textures::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
  1920.  iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
  1921.  ++iter)
  1922. {
  1923. const ETextureIndex index = iter->first;
  1924. const LLVOAvatarDictionary::TextureEntry *texture_dict = iter->second;
  1925. if (texture_dict->mIsBakedTexture)
  1926. {
  1927. if (texture_id == self->getTEImage(index)->getID())
  1928. {
  1929. LLTexLayerSet* layer_set = self->getLayerSet(index);
  1930. if (layer_set)
  1931. {
  1932. llinfos << "TAT: rebake - matched entry " << (S32)index << llendl;
  1933. self->invalidateComposite(layer_set, TRUE);
  1934. found = TRUE;
  1935. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TEX_REBAKES);
  1936. }
  1937. }
  1938. }
  1939. }
  1941. // If texture not found, rebake all entries.
  1942. if (!found)
  1943. {
  1944. self->forceBakeAllTextures();
  1945. }
  1946. else
  1947. {
  1948. // Not sure if this is necessary, but forceBakeAllTextures() does it.
  1949. self->updateMeshTextures();
  1950. }
  1951. }
  1953. void LLVOAvatarSelf::forceBakeAllTextures(bool slam_for_debug)
  1954. {
  1955. llinfos << "TAT: forced full rebake. " << llendl;
  1957. for (U32 i = 0; i < mBakedTextureDatas.size(); i++)
  1958. {
  1959. ETextureIndex baked_index = mBakedTextureDatas[i].mTextureIndex;
  1960. LLTexLayerSet* layer_set = getLayerSet(baked_index);
  1961. if (layer_set)
  1962. {
  1963. if (slam_for_debug)
  1964. {
  1965. layer_set->setUpdatesEnabled(TRUE);
  1966. layer_set->cancelUpload();
  1967. }
  1969. invalidateComposite(layer_set, TRUE);
  1970. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TEX_REBAKES);
  1971. }
  1972. else
  1973. {
  1974. llwarns << "TAT: NO LAYER SET FOR " << (S32)baked_index << llendl;
  1975. }
  1976. }
  1978. // Don't know if this is needed
  1979. updateMeshTextures();
  1981. }
  1983. //-----------------------------------------------------------------------------
  1984. // requestLayerSetUpdate()
  1985. //-----------------------------------------------------------------------------
  1986. void LLVOAvatarSelf::requestLayerSetUpdate(ETextureIndex index )
  1987. {
  1988. /* switch(index)
  1989. case LOCTEX_UPPER_BODYPAINT:  
  1990. case LOCTEX_UPPER_SHIRT:
  1991. if( mUpperBodyLayerSet )
  1992. mUpperBodyLayerSet->requestUpdate(); */
  1993. const LLVOAvatarDictionary::TextureEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
  1994. if (!texture_dict->mIsLocalTexture || !texture_dict->mIsUsedByBakedTexture)
  1995. return;
  1996. const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
  1997. if (mBakedTextureDatas[baked_index].mTexLayerSet)
  1998. {
  1999. mBakedTextureDatas[baked_index].mTexLayerSet->requestUpdate();
  2000. }
  2001. }
  2003. LLTexLayerSet* LLVOAvatarSelf::getLayerSet(ETextureIndex index) const
  2004. {
  2005. /* switch(index)
  2006. case TEX_HEAD_BAKED:
  2007. case TEX_HEAD_BODYPAINT:
  2008. return mHeadLayerSet; */
  2009. const LLVOAvatarDictionary::TextureEntry *texture_dict = LLVOAvatarDictionary::getInstance()->getTexture(index);
  2010. if (texture_dict->mIsUsedByBakedTexture)
  2011. {
  2012. const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex;
  2013. return mBakedTextureDatas[baked_index].mTexLayerSet;
  2014. }
  2015. return NULL;
  2016. }
  2018. // static
  2019. void LLVOAvatarSelf::onCustomizeStart()
  2020. {
  2021. // We're no longer doing any baking or invalidating on entering 
  2022. // appearance editing mode. Leaving function in place in case 
  2023. // further changes require us to do something at this point - Nyx
  2024. }
  2026. // static
  2027. void LLVOAvatarSelf::onCustomizeEnd()
  2028. {
  2029. LLVOAvatarSelf *avatarp = gAgent.getAvatarObject();
  2030. if (avatarp)
  2031. {
  2032. avatarp->invalidateAll();
  2033. }
  2034. }
  2036. // HACK: this will null out the avatar's local texture IDs before the TE message is sent
  2037. //       to ensure local texture IDs are not sent to other clients in the area.
  2038. //       this is a short-term solution. The long term solution will be to not set the texture
  2039. //       IDs in the avatar object, and keep them only in the wearable.
  2040. //       This will involve further refactoring that is too risky for the initial release of 2.0.
  2041. bool LLVOAvatarSelf::sendAppearanceMessage(LLMessageSystem *mesgsys) const
  2042. {
  2043. LLUUID texture_id[TEX_NUM_INDICES];
  2044. // pack away current TEs to make sure we don't send them out
  2045. for (LLVOAvatarDictionary::Textures::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
  2046.  iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
  2047.  ++iter)
  2048. {
  2049. const ETextureIndex index = iter->first;
  2050. const LLVOAvatarDictionary::TextureEntry *texture_dict = iter->second;
  2051. if (!texture_dict->mIsBakedTexture)
  2052. {
  2053. LLTextureEntry* entry = getTE((U8) index);
  2054. texture_id[index] = entry->getID();
  2055. entry->setID(IMG_DEFAULT_AVATAR);
  2056. }
  2057. }
  2059. bool success = packTEMessage(mesgsys);
  2061. // unpack TEs to make sure we don't re-trigger a bake
  2062. for (LLVOAvatarDictionary::Textures::const_iterator iter = LLVOAvatarDictionary::getInstance()->getTextures().begin();
  2063.  iter != LLVOAvatarDictionary::getInstance()->getTextures().end();
  2064.  ++iter)
  2065. {
  2066. const ETextureIndex index = iter->first;
  2067. const LLVOAvatarDictionary::TextureEntry *texture_dict = iter->second;
  2068. if (!texture_dict->mIsBakedTexture)
  2069. {
  2070. LLTextureEntry* entry = getTE((U8) index);
  2071. entry->setID(texture_id[index]);
  2072. }
  2073. }
  2075. return success;
  2076. }
  2079. //------------------------------------------------------------------------
  2080. // needsRenderBeam()
  2081. //------------------------------------------------------------------------
  2082. BOOL LLVOAvatarSelf::needsRenderBeam()
  2083. {
  2084. if (gNoRender)
  2085. {
  2086. return FALSE;
  2087. }
  2088. LLTool *tool = LLToolMgr::getInstance()->getCurrentTool();
  2090. BOOL is_touching_or_grabbing = (tool == LLToolGrab::getInstance() && LLToolGrab::getInstance()->isEditing());
  2091. if (LLToolGrab::getInstance()->getEditingObject() && 
  2092. LLToolGrab::getInstance()->getEditingObject()->isAttachment())
  2093. {
  2094. // don't render selection beam on hud objects
  2095. is_touching_or_grabbing = FALSE;
  2096. }
  2097. return is_touching_or_grabbing || (mState & AGENT_STATE_EDITING && LLSelectMgr::getInstance()->shouldShowSelection());
  2098. }
  2100. // static
  2101. void LLVOAvatarSelf::deleteScratchTextures()
  2102. {
  2103. if(gAuditTexture)
  2104. {
  2105. S32 total_tex_size = sScratchTexBytes ;
  2106. S32 tex_size = SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT ;
  2108. if( sScratchTexNames.checkData( GL_LUMINANCE ) )
  2109. {
  2110. LLImageGL::decTextureCounter(tex_size, 1, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2111. total_tex_size -= tex_size ;
  2112. }
  2113. if( sScratchTexNames.checkData( GL_ALPHA ) )
  2114. {
  2115. LLImageGL::decTextureCounter(tex_size, 1, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2116. total_tex_size -= tex_size ;
  2117. }
  2118. if( sScratchTexNames.checkData( GL_COLOR_INDEX ) )
  2119. {
  2120. LLImageGL::decTextureCounter(tex_size, 1, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2121. total_tex_size -= tex_size ;
  2122. }
  2123. if( sScratchTexNames.checkData( GL_LUMINANCE_ALPHA ) )
  2124. {
  2125. LLImageGL::decTextureCounter(tex_size, 2, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2126. total_tex_size -= 2 * tex_size ;
  2127. }
  2128. if( sScratchTexNames.checkData( GL_RGB ) )
  2129. {
  2130. LLImageGL::decTextureCounter(tex_size, 3, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2131. total_tex_size -= 3 * tex_size ;
  2132. }
  2133. if( sScratchTexNames.checkData( GL_RGBA ) )
  2134. {
  2135. LLImageGL::decTextureCounter(tex_size, 4, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2136. total_tex_size -= 4 * tex_size ;
  2137. }
  2138. //others
  2139. while(total_tex_size > 0)
  2140. {
  2141. LLImageGL::decTextureCounter(tex_size, 4, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2142. total_tex_size -= 4 * tex_size ;
  2143. }
  2144. }
  2146. for( LLGLuint* namep = sScratchTexNames.getFirstData(); 
  2147.  namep; 
  2148.  namep = sScratchTexNames.getNextData() )
  2149. {
  2150. LLImageGL::deleteTextures(1, (U32 *)namep );
  2151. stop_glerror();
  2152. }
  2154. if( sScratchTexBytes )
  2155. {
  2156. lldebugs << "Clearing Scratch Textures " << (sScratchTexBytes/1024) << "KB" << llendl;
  2158. sScratchTexNames.deleteAllData();
  2159. sScratchTexLastBindTime.deleteAllData();
  2160. LLImageGL::sGlobalTextureMemoryInBytes -= sScratchTexBytes;
  2161. sScratchTexBytes = 0;
  2162. }
  2163. }
  2165. BOOL LLVOAvatarSelf::bindScratchTexture( LLGLenum format )
  2166. {
  2167. U32 texture_bytes = 0;
  2168. S32 components = 0; 
  2169. GLuint gl_name = getScratchTexName( format, components, &texture_bytes );
  2170. if( gl_name )
  2171. {
  2172. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, gl_name);
  2173. stop_glerror();
  2175. F32* last_bind_time = sScratchTexLastBindTime.getIfThere( format );
  2176. if( last_bind_time )
  2177. {
  2178. if( *last_bind_time != LLImageGL::sLastFrameTime )
  2179. {
  2180. *last_bind_time = LLImageGL::sLastFrameTime;
  2181. LLImageGL::updateBoundTexMem(texture_bytes, components, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2182. }
  2183. }
  2184. else
  2185. {
  2186. LLImageGL::updateBoundTexMem(texture_bytes, components, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2187. sScratchTexLastBindTime.addData( format, new F32(LLImageGL::sLastFrameTime) );
  2188. }
  2189. return TRUE;
  2190. }
  2191. return FALSE;
  2192. }
  2194. LLGLuint LLVOAvatarSelf::getScratchTexName( LLGLenum format, S32& components, U32* texture_bytes )
  2195. {
  2196. GLenum internal_format;
  2197. switch( format )
  2198. {
  2199. case GL_LUMINANCE: components = 1; internal_format = GL_LUMINANCE8; break;
  2200. case GL_ALPHA: components = 1; internal_format = GL_ALPHA8; break;
  2201. case GL_COLOR_INDEX: components = 1; internal_format = GL_COLOR_INDEX8_EXT; break;
  2202. case GL_LUMINANCE_ALPHA: components = 2; internal_format = GL_LUMINANCE8_ALPHA8; break;
  2203. case GL_RGB: components = 3; internal_format = GL_RGB8; break;
  2204. case GL_RGBA: components = 4; internal_format = GL_RGBA8; break;
  2205. default: llassert(0); components = 4; internal_format = GL_RGBA8; break;
  2206. }
  2208. *texture_bytes = components * SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT;
  2210. if( sScratchTexNames.checkData( format ) )
  2211. {
  2212. return *( sScratchTexNames.getData( format ) );
  2213. }
  2215. LLGLSUIDefault gls_ui;
  2217. U32 name = 0;
  2218. LLImageGL::generateTextures(1, &name );
  2219. stop_glerror();
  2221. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, name);
  2222. stop_glerror();
  2224. LLImageGL::setManualImage(
  2225. GL_TEXTURE_2D, 0, internal_format, 
  2226. SCRATCH_TEX_WIDTH, SCRATCH_TEX_HEIGHT,
  2227. format, GL_UNSIGNED_BYTE, NULL );
  2228. stop_glerror();
  2230. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
  2231. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
  2232. stop_glerror();
  2234. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  2235. stop_glerror();
  2237. sScratchTexNames.addData( format, new LLGLuint( name ) );
  2239. sScratchTexBytes += *texture_bytes;
  2240. LLImageGL::sGlobalTextureMemoryInBytes += *texture_bytes;
  2242. if(gAuditTexture)
  2243. {
  2244. LLImageGL::incTextureCounter(SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT, components, LLViewerTexture::AVATAR_SCRATCH_TEX) ;
  2245. }
  2246. return name;
  2247. }
  2249. // static 
  2250. void LLVOAvatarSelf::dumpScratchTextureByteCount()
  2251. {
  2252. llinfos << "Scratch Texture GL: " << (sScratchTexBytes/1024) << "KB" << llendl;
  2253. }