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

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

游戏引擎

开发平台：

C++ Builder

llagentwearables.cpp：源码内容
  1. /** 
  2.  * @file llagentwearables.cpp
  3.  * @brief LLAgentWearables class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "llagent.h" 
  36. #include "llagentwearables.h"
  38. #include "llcallbacklist.h"
  39. #include "llfloatercustomize.h"
  40. #include "llinventorybridge.h"
  41. #include "llinventoryobserver.h"
  42. #include "llinventorypanel.h"
  43. #include "llnotificationsutil.h"
  44. #include "llviewerregion.h"
  45. #include "llvoavatarself.h"
  46. #include "llwearable.h"
  47. #include "llwearablelist.h"
  48. #include "llgesturemgr.h"
  49. #include "llappearancemgr.h"
  50. #include "lltexlayer.h"
  51. #include "llsidetray.h"
  52. #include "llpaneloutfitsinventory.h"
  53. #include "llfolderview.h"
  54. #include "llaccordionctrltab.h"
  56. #include <boost/scoped_ptr.hpp>
  58. #define USE_CURRENT_OUTFIT_FOLDER
  60. //--------------------------------------------------------------------
  61. // Classes for fetching initial wearables data
  62. //--------------------------------------------------------------------
  63. // Outfit folder fetching callback structure.
  64. class LLInitialWearablesFetch : public LLInventoryFetchDescendentsObserver
  65. {
  66. public:
  67. LLInitialWearablesFetch() {}
  68. ~LLInitialWearablesFetch();
  69. virtual void done();
  71. struct InitialWearableData
  72. {
  73. EWearableType mType;
  74. LLUUID mItemID;
  75. LLUUID mAssetID;
  76. InitialWearableData(EWearableType type, LLUUID& itemID, LLUUID& assetID) :
  77. mType(type),
  78. mItemID(itemID),
  79. mAssetID(assetID)
  80. {}
  81. };
  83. typedef std::vector<InitialWearableData> initial_wearable_data_vec_t;
  84. initial_wearable_data_vec_t mCOFInitialWearables; // Wearables from the Current Outfit Folder
  85. initial_wearable_data_vec_t mAgentInitialWearables; // Wearables from the old agent wearables msg
  87. protected:
  88. void processWearablesMessage();
  89. void processContents();
  90. };
  92. class LLLibraryOutfitsFetch : public LLInventoryFetchDescendentsObserver
  93. {
  94. public:
  95. enum ELibraryOutfitFetchStep {
  96. LOFS_FOLDER = 0,
  97. LOFS_OUTFITS,
  98. LOFS_LIBRARY,
  99. LOFS_IMPORTED,
  100. LOFS_CONTENTS
  101. };
  102. LLLibraryOutfitsFetch() : mCurrFetchStep(LOFS_FOLDER), mOutfitsPopulated(false) 
  103. {
  104. mMyOutfitsID = LLUUID::null;
  105. mClothingID = LLUUID::null;
  106. mLibraryClothingID = LLUUID::null;
  107. mImportedClothingID = LLUUID::null;
  108. mImportedClothingName = "Imported Library Clothing";
  109. }
  110. ~LLLibraryOutfitsFetch() {}
  111. virtual void done();
  112. void doneIdle();
  113. LLUUID mMyOutfitsID;
  114. void importedFolderFetch();
  115. protected:
  116. void folderDone(void);
  117. void outfitsDone(void);
  118. void libraryDone(void);
  119. void importedFolderDone(void);
  120. void contentsDone(void);
  121. enum ELibraryOutfitFetchStep mCurrFetchStep;
  122. typedef std::vector< std::pair< LLUUID, std::string > > cloth_folder_vec_t;
  123. cloth_folder_vec_t mLibraryClothingFolders;
  124. cloth_folder_vec_t mImportedClothingFolders;
  125. bool mOutfitsPopulated;
  126. LLUUID mClothingID;
  127. LLUUID mLibraryClothingID;
  128. LLUUID mImportedClothingID;
  129. std::string mImportedClothingName;
  130. };
  132. LLAgentWearables gAgentWearables;
  134. BOOL LLAgentWearables::mInitialWearablesUpdateReceived = FALSE;
  136. using namespace LLVOAvatarDefines;
  138. // HACK: For EXT-3923: Pants item shows in inventory with skin icon and messes with "current look"
  139. // Some db items are corrupted, have inventory flags = 0, implying wearable type = shape, even though
  140. // wearable type stored in asset is some other value.
  141. // Calling this function whenever a wearable is added to increase visibility if this problem
  142. // turns up in other inventories.
  143. void checkWearableAgainstInventory(LLWearable *wearable)
  144. {
  145. if (wearable->getItemID().isNull())
  146. return;
  148. // Check for wearable type consistent with inventory item wearable type.
  149. LLViewerInventoryItem *item = gInventory.getItem(wearable->getItemID());
  150. if (item)
  151. {
  152. if (!item->isWearableType())
  153. {
  154. llwarns << "wearable associated with non-wearable item" << llendl;
  155. }
  156. if (item->getWearableType() != wearable->getType())
  157. {
  158. llwarns << "type mismatch: wearable " << wearable->getName()
  159. << " has type " << wearable->getType()
  160. << " but inventory item " << item->getName()
  161. << " has type "  << item->getWearableType() << llendl;
  162. }
  163. }
  164. else
  165. {
  166. llwarns << "wearable inventory item not found" << wearable->getName()
  167. << " itemID " << wearable->getItemID().asString() << llendl;
  168. }
  169. }
  171. void LLAgentWearables::dump()
  172. {
  173. llinfos << "LLAgentWearablesDump" << llendl;
  174. for (S32 i = 0; i < WT_COUNT; i++)
  175. {
  176. U32 count = getWearableCount((EWearableType)i);
  177. llinfos << "Type: " << i << " count " << count << llendl;
  178. for (U32 j=0; j<count; j++)
  179. {
  180. LLWearable* wearable = getWearable((EWearableType)i,j);
  181. if (wearable == NULL)
  182. {
  183. llinfos << "    " << j << " NULL wearable" << llendl;
  184. }
  185. llinfos << "    " << j << " Name " << wearable->getName()
  186. << " description " << wearable->getDescription() << llendl;
  188. }
  189. }
  190. llinfos << "Total items awaiting wearable update " << mItemsAwaitingWearableUpdate.size() << llendl;
  191. for (std::set<LLUUID>::iterator it = mItemsAwaitingWearableUpdate.begin();
  192.  it != mItemsAwaitingWearableUpdate.end();
  193.  ++it)
  194. {
  195. llinfos << (*it).asString() << llendl;
  196. }
  197. }
  199. // MULTI-WEARABLE: debugging
  200. struct LLAgentDumper
  201. {
  202. LLAgentDumper(std::string name):
  203. mName(name)
  204. {
  205. llinfos << llendl;
  206. llinfos << "LLAgentDumper " << mName << llendl;
  207. gAgentWearables.dump();
  208. }
  210. ~LLAgentDumper()
  211. {
  212. llinfos << llendl;
  213. llinfos << "~LLAgentDumper " << mName << llendl;
  214. gAgentWearables.dump();
  215. }
  217. std::string mName;
  218. };
  220. LLAgentWearables::LLAgentWearables() :
  221. mWearablesLoaded(FALSE),
  222. mAvatarObject(NULL)
  223. {
  224. }
  226. LLAgentWearables::~LLAgentWearables()
  227. {
  228. cleanup();
  229. }
  231. void LLAgentWearables::cleanup()
  232. {
  233. mAvatarObject = NULL;
  234. }
  236. void LLAgentWearables::setAvatarObject(LLVOAvatarSelf *avatar)
  237. { 
  238. mAvatarObject = avatar;
  239. if (avatar)
  240. {
  241. sendAgentWearablesRequest();
  242. }
  243. }
  245. // wearables
  246. LLAgentWearables::createStandardWearablesAllDoneCallback::~createStandardWearablesAllDoneCallback()
  247. {
  248. gAgentWearables.createStandardWearablesAllDone();
  249. }
  251. LLAgentWearables::sendAgentWearablesUpdateCallback::~sendAgentWearablesUpdateCallback()
  252. {
  253. gAgentWearables.sendAgentWearablesUpdate();
  254. }
  256. /**
  257.  * @brief Construct a callback for dealing with the wearables.
  258.  *
  259.  * Would like to pass the agent in here, but we can't safely
  260.  * count on it being around later.  Just use gAgent directly.
  261.  * @param cb callback to execute on completion (??? unused ???)
  262.  * @param type Type for the wearable in the agent
  263.  * @param wearable The wearable data.
  264.  * @param todo Bitmask of actions to take on completion.
  265.  */
  266. LLAgentWearables::addWearableToAgentInventoryCallback::addWearableToAgentInventoryCallback(
  267. LLPointer<LLRefCount> cb, S32 type, U32 index, LLWearable* wearable, U32 todo) :
  268. mType(type),
  269. mIndex(index),
  270. mWearable(wearable),
  271. mTodo(todo),
  272. mCB(cb)
  273. {
  274. }
  276. void LLAgentWearables::addWearableToAgentInventoryCallback::fire(const LLUUID& inv_item)
  277. {
  278. if (inv_item.isNull())
  279. return;
  281. gAgentWearables.addWearabletoAgentInventoryDone(mType, mIndex, inv_item, mWearable);
  283. if (mTodo & CALL_UPDATE)
  284. {
  285. gAgentWearables.sendAgentWearablesUpdate();
  286. }
  287. if (mTodo & CALL_RECOVERDONE)
  288. {
  289. gAgentWearables.recoverMissingWearableDone();
  290. }
  291. /*
  292.  * Do this for every one in the loop
  293.  */
  294. if (mTodo & CALL_CREATESTANDARDDONE)
  295. {
  296. gAgentWearables.createStandardWearablesDone(mType, mIndex);
  297. }
  298. if (mTodo & CALL_MAKENEWOUTFITDONE)
  299. {
  300. gAgentWearables.makeNewOutfitDone(mType, mIndex);
  301. }
  302. if (mTodo & CALL_WEARITEM)
  303. {
  304. LLAppearanceManager::instance().addCOFItemLink(inv_item, true);
  305. }
  306. }
  308. void LLAgentWearables::addWearabletoAgentInventoryDone(const S32 type,
  309.    const U32 index,
  310.    const LLUUID& item_id,
  311.    LLWearable* wearable)
  312. {
  313. if (item_id.isNull())
  314. return;
  316. LLUUID old_item_id = getWearableItemID((EWearableType)type,index);
  318. if (wearable)
  319. {
  320. wearable->setItemID(item_id);
  322. if (old_item_id.notNull())
  323. {
  324. gInventory.addChangedMask(LLInventoryObserver::LABEL, old_item_id);
  325. setWearable((EWearableType)type,index,wearable);
  326. }
  327. else
  328. {
  329. pushWearable((EWearableType)type,wearable);
  330. }
  331. }
  333. gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
  335. LLViewerInventoryItem* item = gInventory.getItem(item_id);
  336. if (item && wearable)
  337. {
  338. // We're changing the asset id, so we both need to set it
  339. // locally via setAssetUUID() and via setTransactionID() which
  340. // will be decoded on the server. JC
  341. item->setAssetUUID(wearable->getAssetID());
  342. item->setTransactionID(wearable->getTransactionID());
  343. gInventory.addChangedMask(LLInventoryObserver::INTERNAL, item_id);
  344. item->updateServer(FALSE);
  345. }
  346. gInventory.notifyObservers();
  347. }
  349. void LLAgentWearables::sendAgentWearablesUpdate()
  350. {
  351. // MULTI-WEARABLE: call i "type" or something.
  352. // First make sure that we have inventory items for each wearable
  353. for (S32 type=0; type < WT_COUNT; ++type)
  354. {
  355. for (U32 j=0; j < getWearableCount((EWearableType)type); ++j)
  356. {
  357. LLWearable* wearable = getWearable((EWearableType)type,j);
  358. if (wearable)
  359. {
  360. if (wearable->getItemID().isNull())
  361. {
  362. LLPointer<LLInventoryCallback> cb =
  363. new addWearableToAgentInventoryCallback(
  364. LLPointer<LLRefCount>(NULL),
  365. type,
  366. j,
  367. wearable,
  368. addWearableToAgentInventoryCallback::CALL_NONE);
  369. addWearableToAgentInventory(cb, wearable);
  370. }
  371. else
  372. {
  373. gInventory.addChangedMask(LLInventoryObserver::LABEL,
  374.   wearable->getItemID());
  375. }
  376. }
  377. }
  378. }
  380. // Then make sure the inventory is in sync with the avatar.
  381. gInventory.notifyObservers();
  383. // Send the AgentIsNowWearing 
  384. gMessageSystem->newMessageFast(_PREHASH_AgentIsNowWearing);
  386. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  387. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  388. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  390. lldebugs << "sendAgentWearablesUpdate()" << llendl;
  391. // MULTI-WEARABLE: update for multi-wearables after server-side support is in.
  392. for (S32 type=0; type < WT_COUNT; ++type)
  393. {
  394. gMessageSystem->nextBlockFast(_PREHASH_WearableData);
  396. U8 type_u8 = (U8)type;
  397. gMessageSystem->addU8Fast(_PREHASH_WearableType, type_u8);
  399. // MULTI-WEARABLE: TODO: hacked index to 0, needs to loop over all once messages support this.
  400. LLWearable* wearable = getWearable((EWearableType)type, 0);
  401. if (wearable)
  402. {
  403. //llinfos << "Sending wearable " << wearable->getName() << llendl;
  404. LLUUID item_id = wearable->getItemID();
  405. const LLViewerInventoryItem *item = gInventory.getItem(item_id);
  406. if (item && item->getIsLinkType())
  407. {
  408. // Get the itemID that this item points to.  i.e. make sure
  409. // we are storing baseitems, not their links, in the database.
  410. item_id = item->getLinkedUUID();
  411. }
  412. gMessageSystem->addUUIDFast(_PREHASH_ItemID, item_id);
  413. }
  414. else
  415. {
  416. //llinfos << "Not wearing wearable type " << LLWearableDictionary::getInstance()->getWearable((EWearableType)i) << llendl;
  417. gMessageSystem->addUUIDFast(_PREHASH_ItemID, LLUUID::null);
  418. }
  420. lldebugs << "       " << LLWearableDictionary::getTypeLabel((EWearableType)type) << ": " << (wearable ? wearable->getAssetID() : LLUUID::null) << llendl;
  421. }
  422. gAgent.sendReliableMessage();
  423. }
  425. void LLAgentWearables::saveWearable(const EWearableType type, const U32 index, BOOL send_update)
  426. {
  427. LLWearable* old_wearable = getWearable(type, index);
  428. if (old_wearable && (old_wearable->isDirty() || old_wearable->isOldVersion()))
  429. {
  430. LLUUID old_item_id = old_wearable->getItemID();
  431. LLWearable* new_wearable = LLWearableList::instance().createCopy(old_wearable);
  432. new_wearable->setItemID(old_item_id); // should this be in LLWearable::copyDataFrom()?
  433. setWearable(type,index,new_wearable);
  435. LLInventoryItem* item = gInventory.getItem(old_item_id);
  436. if (item)
  437. {
  438. // Update existing inventory item
  439. LLPointer<LLViewerInventoryItem> template_item =
  440. new LLViewerInventoryItem(item->getUUID(),
  441.   item->getParentUUID(),
  442.   item->getPermissions(),
  443.   new_wearable->getAssetID(),
  444.   new_wearable->getAssetType(),
  445.   item->getInventoryType(),
  446.   item->getName(),
  447.   item->getDescription(),
  448.   item->getSaleInfo(),
  449.   item->getFlags(),
  450.   item->getCreationDate());
  451. template_item->setTransactionID(new_wearable->getTransactionID());
  452. template_item->updateServer(FALSE);
  453. gInventory.updateItem(template_item);
  454. }
  455. else
  456. {
  457. // Add a new inventory item (shouldn't ever happen here)
  458. U32 todo = addWearableToAgentInventoryCallback::CALL_NONE;
  459. if (send_update)
  460. {
  461. todo |= addWearableToAgentInventoryCallback::CALL_UPDATE;
  462. }
  463. LLPointer<LLInventoryCallback> cb =
  464. new addWearableToAgentInventoryCallback(
  465. LLPointer<LLRefCount>(NULL),
  466. (S32)type,
  467. index,
  468. new_wearable,
  469. todo);
  470. addWearableToAgentInventory(cb, new_wearable);
  471. return;
  472. }
  474. gAgent.getAvatarObject()->wearableUpdated( type, TRUE );
  476. if (send_update)
  477. {
  478. sendAgentWearablesUpdate();
  479. }
  480. }
  481. }
  483. void LLAgentWearables::saveWearableAs(const EWearableType type,
  484.   const U32 index,
  485.   const std::string& new_name,
  486.   BOOL save_in_lost_and_found)
  487. {
  488. if (!isWearableCopyable(type, index))
  489. {
  490. llwarns << "LLAgent::saveWearableAs() not copyable." << llendl;
  491. return;
  492. }
  493. LLWearable* old_wearable = getWearable(type, index);
  494. if (!old_wearable)
  495. {
  496. llwarns << "LLAgent::saveWearableAs() no old wearable." << llendl;
  497. return;
  498. }
  500. LLInventoryItem* item = gInventory.getItem(getWearableItemID(type,index));
  501. if (!item)
  502. {
  503. llwarns << "LLAgent::saveWearableAs() no inventory item." << llendl;
  504. return;
  505. }
  506. std::string trunc_name(new_name);
  507. LLStringUtil::truncate(trunc_name, DB_INV_ITEM_NAME_STR_LEN);
  508. LLWearable* new_wearable = LLWearableList::instance().createCopy(
  509. old_wearable,
  510. trunc_name);
  511. LLPointer<LLInventoryCallback> cb =
  512. new addWearableToAgentInventoryCallback(
  513. LLPointer<LLRefCount>(NULL),
  514. type,
  515. index,
  516. new_wearable,
  517. addWearableToAgentInventoryCallback::CALL_WEARITEM);
  518. LLUUID category_id;
  519. if (save_in_lost_and_found)
  520. {
  521. category_id = gInventory.findCategoryUUIDForType(
  522. LLFolderType::FT_LOST_AND_FOUND);
  523. }
  524. else
  525. {
  526. // put in same folder as original
  527. category_id = item->getParentUUID();
  528. }
  530. copy_inventory_item(
  531. gAgent.getID(),
  532. item->getPermissions().getOwner(),
  533. item->getUUID(),
  534. category_id,
  535. new_name,
  536. cb);
  537. }
  539. void LLAgentWearables::revertWearable(const EWearableType type, const U32 index)
  540. {
  541. LLWearable* wearable = getWearable(type, index);
  542. wearable->revertValues();
  544. gAgent.sendAgentSetAppearance();
  545. }
  547. void LLAgentWearables::saveAllWearables()
  548. {
  549. //if (!gInventory.isLoaded())
  550. //{
  551. // return;
  552. //}
  554. for (S32 i=0; i < WT_COUNT; i++)
  555. {
  556. for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
  557. saveWearable((EWearableType)i, j, FALSE);
  558. }
  559. sendAgentWearablesUpdate();
  560. }
  562. // Called when the user changes the name of a wearable inventory item that is currently being worn.
  563. void LLAgentWearables::setWearableName(const LLUUID& item_id, const std::string& new_name)
  564. {
  565. for (S32 i=0; i < WT_COUNT; i++)
  566. {
  567. for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
  568. {
  569. LLUUID curr_item_id = getWearableItemID((EWearableType)i,j);
  570. if (curr_item_id == item_id)
  571. {
  572. LLWearable* old_wearable = getWearable((EWearableType)i,j);
  573. llassert(old_wearable);
  575. std::string old_name = old_wearable->getName();
  576. old_wearable->setName(new_name);
  577. LLWearable* new_wearable = LLWearableList::instance().createCopy(old_wearable);
  578. new_wearable->setItemID(item_id);
  579. LLInventoryItem* item = gInventory.getItem(item_id);
  580. if (item)
  581. {
  582. new_wearable->setPermissions(item->getPermissions());
  583. }
  584. old_wearable->setName(old_name);
  586. setWearable((EWearableType)i,j,new_wearable);
  587. sendAgentWearablesUpdate();
  588. break;
  589. }
  590. }
  591. }
  592. }
  595. BOOL LLAgentWearables::isWearableModifiable(EWearableType type, U32 index) const
  596. {
  597. LLUUID item_id = getWearableItemID(type, index);
  598. if (!item_id.isNull())
  599. {
  600. LLInventoryItem* item = gInventory.getItem(item_id);
  601. if (item && item->getPermissions().allowModifyBy(gAgent.getID(),
  602.  gAgent.getGroupID()))
  603. {
  604. return TRUE;
  605. }
  606. }
  607. return FALSE;
  608. }
  610. BOOL LLAgentWearables::isWearableCopyable(EWearableType type, U32 index) const
  611. {
  612. LLUUID item_id = getWearableItemID(type, index);
  613. if (!item_id.isNull())
  614. {
  615. LLInventoryItem* item = gInventory.getItem(item_id);
  616. if (item && item->getPermissions().allowCopyBy(gAgent.getID(),
  617.    gAgent.getGroupID()))
  618. {
  619. return TRUE;
  620. }
  621. }
  622. return FALSE;
  623. }
  625. /*
  626.   U32 LLAgentWearables::getWearablePermMask(EWearableType type)
  627.   {
  628.   LLUUID item_id = getWearableItemID(type);
  629.   if (!item_id.isNull())
  630.   {
  631.   LLInventoryItem* item = gInventory.getItem(item_id);
  632.   if (item)
  633.   {
  634.   return item->getPermissions().getMaskOwner();
  635.   }
  636.   }
  637.   return PERM_NONE;
  638.   }
  639. */
  641. LLInventoryItem* LLAgentWearables::getWearableInventoryItem(EWearableType type, U32 index)
  642. {
  643. LLUUID item_id = getWearableItemID(type,index);
  644. LLInventoryItem* item = NULL;
  645. if (item_id.notNull())
  646. {
  647. item = gInventory.getItem(item_id);
  648. }
  649. return item;
  650. }
  652. const LLWearable* LLAgentWearables::getWearableFromItemID(const LLUUID& item_id) const
  653. {
  654. for (S32 i=0; i < WT_COUNT; i++)
  655. {
  656. for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
  657. {
  658. const LLWearable * curr_wearable = getWearable((EWearableType)i, j);
  659. if (curr_wearable && (curr_wearable->getItemID() == item_id))
  660. {
  661. return curr_wearable;
  662. }
  663. }
  664. }
  665. return NULL;
  666. }
  668. const LLWearable* LLAgentWearables::getWearableFromAssetID(const LLUUID& asset_id) const
  669. {
  670. for (S32 i=0; i < WT_COUNT; i++)
  671. {
  672. for (U32 j=0; j < getWearableCount((EWearableType)i); j++)
  673. {
  674. const LLWearable * curr_wearable = getWearable((EWearableType)i, j);
  675. if (curr_wearable && (curr_wearable->getAssetID() == asset_id))
  676. {
  677. return curr_wearable;
  678. }
  679. }
  680. }
  681. return NULL;
  682. }
  684. void LLAgentWearables::sendAgentWearablesRequest()
  685. {
  686. gMessageSystem->newMessageFast(_PREHASH_AgentWearablesRequest);
  687. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  688. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  689. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  690. gAgent.sendReliableMessage();
  691. }
  693. // static
  694. BOOL LLAgentWearables::selfHasWearable(EWearableType type)
  695. {
  696. return (gAgentWearables.getWearableCount(type) > 0);
  697. }
  699. LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 index)
  700. {
  701. wearableentry_map_t::iterator wearable_iter = mWearableDatas.find(type);
  702. if (wearable_iter == mWearableDatas.end())
  703. {
  704. return NULL;
  705. }
  706. wearableentry_vec_t& wearable_vec = wearable_iter->second;
  707. if (index>=wearable_vec.size())
  708. {
  709. return NULL;
  710. }
  711. else
  712. {
  713. return wearable_vec[index];
  714. }
  715. }
  717. void LLAgentWearables::setWearable(const EWearableType type, U32 index, LLWearable *wearable)
  718. {
  720. LLWearable *old_wearable = getWearable(type,index);
  721. if (!old_wearable)
  722. {
  723. pushWearable(type,wearable);
  724. return;
  725. }
  727. wearableentry_map_t::iterator wearable_iter = mWearableDatas.find(type);
  728. if (wearable_iter == mWearableDatas.end())
  729. {
  730. llwarns << "invalid type, type " << type << " index " << index << llendl; 
  731. return;
  732. }
  733. wearableentry_vec_t& wearable_vec = wearable_iter->second;
  734. if (index>=wearable_vec.size())
  735. {
  736. llwarns << "invalid index, type " << type << " index " << index << llendl; 
  737. }
  738. else
  739. {
  740. wearable_vec[index] = wearable;
  741. old_wearable->setLabelUpdated();
  742. wearableUpdated(wearable);
  743. checkWearableAgainstInventory(wearable);
  744. }
  745. }
  747. U32 LLAgentWearables::pushWearable(const EWearableType type, LLWearable *wearable)
  748. {
  749. if (wearable == NULL)
  750. {
  751. // no null wearables please!
  752. llwarns << "Null wearable sent for type " << type << llendl;
  753. return MAX_WEARABLES_PER_TYPE;
  754. }
  755. if (type < WT_COUNT || mWearableDatas[type].size() < MAX_WEARABLES_PER_TYPE)
  756. {
  757. mWearableDatas[type].push_back(wearable);
  758. wearableUpdated(wearable);
  759. checkWearableAgainstInventory(wearable);
  760. return mWearableDatas[type].size()-1;
  761. }
  762. return MAX_WEARABLES_PER_TYPE;
  763. }
  765. void LLAgentWearables::wearableUpdated(LLWearable *wearable)
  766. {
  767. mAvatarObject->wearableUpdated(wearable->getType(), TRUE);
  768. wearable->refreshName();
  769. wearable->setLabelUpdated();
  771. wearable->pullCrossWearableValues();
  773. // Hack pt 2. If the wearable we just loaded has definition version 24,
  774. // then force a re-save of this wearable after slamming the version number to 22.
  775. // This number was incorrectly incremented for internal builds before release, and
  776. // this fix will ensure that the affected wearables are re-saved with the right version number.
  777. // the versions themselves are compatible. This code can be removed before release.
  778. if( wearable->getDefinitionVersion() == 24 )
  779. {
  780. wearable->setDefinitionVersion(22);
  781. U32 index = getWearableIndex(wearable);
  782. llinfos << "forcing werable type " << wearable->getType() << " to version 22 from 24" << llendl;
  783. saveWearable(wearable->getType(),index,TRUE);
  784. }
  786. }
  788. void LLAgentWearables::popWearable(LLWearable *wearable)
  789. {
  790. if (wearable == NULL)
  791. {
  792. // nothing to do here. move along.
  793. return;
  794. }
  796. U32 index = getWearableIndex(wearable);
  797. EWearableType type = wearable->getType();
  799. if (index < MAX_WEARABLES_PER_TYPE && index < getWearableCount(type))
  800. {
  801. popWearable(type, index);
  802. }
  803. }
  805. void LLAgentWearables::popWearable(const EWearableType type, U32 index)
  806. {
  807. LLWearable *wearable = getWearable(type, index);
  808. if (wearable)
  809. {
  810. mWearableDatas[type].erase(mWearableDatas[type].begin() + index);
  811. mAvatarObject->wearableUpdated(wearable->getType(), TRUE);
  812. wearable->setLabelUpdated();
  813. }
  814. }
  816. U32 LLAgentWearables::getWearableIndex(LLWearable *wearable)
  817. {
  818. if (wearable == NULL)
  819. {
  820. return MAX_WEARABLES_PER_TYPE;
  821. }
  823. const EWearableType type = wearable->getType();
  824. wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
  825. if (wearable_iter == mWearableDatas.end())
  826. {
  827. llwarns << "tried to get wearable index with an invalid type!" << llendl;
  828. return MAX_WEARABLES_PER_TYPE;
  829. }
  830. const wearableentry_vec_t& wearable_vec = wearable_iter->second;
  831. for(U32 index = 0; index < wearable_vec.size(); index++)
  832. {
  833. if (wearable_vec[index] == wearable)
  834. {
  835. return index;
  836. }
  837. }
  839. return MAX_WEARABLES_PER_TYPE;
  840. }
  842. const LLWearable* LLAgentWearables::getWearable(const EWearableType type, U32 index) const
  843. {
  844. wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
  845. if (wearable_iter == mWearableDatas.end())
  846. {
  847. return NULL;
  848. }
  849. const wearableentry_vec_t& wearable_vec = wearable_iter->second;
  850. if (index>=wearable_vec.size())
  851. {
  852. return NULL;
  853. }
  854. else
  855. {
  856. return wearable_vec[index];
  857. }
  858. }
  860. LLWearable* LLAgentWearables::getTopWearable(const EWearableType type)
  861. {
  862. U32 count = getWearableCount(type);
  863. if ( count == 0)
  864. {
  865. return NULL;
  866. }
  868. return getWearable(type, count-1);
  869. }
  871. U32 LLAgentWearables::getWearableCount(const EWearableType type) const
  872. {
  873. wearableentry_map_t::const_iterator wearable_iter = mWearableDatas.find(type);
  874. if (wearable_iter == mWearableDatas.end())
  875. {
  876. return 0;
  877. }
  878. const wearableentry_vec_t& wearable_vec = wearable_iter->second;
  879. return wearable_vec.size();
  880. }
  882. U32 LLAgentWearables::getWearableCount(const U32 tex_index) const
  883. {
  884. const EWearableType wearable_type = LLVOAvatarDictionary::getTEWearableType((LLVOAvatarDefines::ETextureIndex)tex_index);
  885. return getWearableCount(wearable_type);
  886. }
  889. BOOL LLAgentWearables::itemUpdatePending(const LLUUID& item_id) const
  890. {
  891. return mItemsAwaitingWearableUpdate.find(item_id) != mItemsAwaitingWearableUpdate.end();
  892. }
  894. U32 LLAgentWearables::itemUpdatePendingCount() const
  895. {
  896. return mItemsAwaitingWearableUpdate.size();
  897. }
  899. const LLUUID LLAgentWearables::getWearableItemID(EWearableType type, U32 index) const
  900. {
  901. const LLWearable *wearable = getWearable(type,index);
  902. if (wearable)
  903. return wearable->getItemID();
  904. else
  905. return LLUUID();
  906. }
  908. const LLUUID LLAgentWearables::getWearableAssetID(EWearableType type, U32 index) const
  909. {
  910. const LLWearable *wearable = getWearable(type,index);
  911. if (wearable)
  912. return wearable->getAssetID();
  913. else
  914. return LLUUID();
  915. }
  917. BOOL LLAgentWearables::isWearingItem(const LLUUID& item_id) const
  918. {
  919. const LLUUID& base_item_id = gInventory.getLinkedItemID(item_id);
  920. if (getWearableFromItemID(base_item_id) != NULL) 
  921. {
  922. return TRUE;
  923. }
  924. return FALSE;
  925. }
  927. // MULTI-WEARABLE: update for multiple
  928. // static
  929. // ! BACKWARDS COMPATIBILITY ! When we stop supporting viewer1.23, we can assume
  930. // that viewers have a Current Outfit Folder and won't need this message, and thus
  931. // we can remove/ignore this whole function.
  932. void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgsys, void** user_data)
  933. {
  934. // We should only receive this message a single time.  Ignore subsequent AgentWearablesUpdates
  935. // that may result from AgentWearablesRequest having been sent more than once.
  936. if (mInitialWearablesUpdateReceived)
  937. return;
  938. mInitialWearablesUpdateReceived = true;
  940. LLUUID agent_id;
  941. gMessageSystem->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
  943. LLVOAvatar* avatar = gAgent.getAvatarObject();
  944. if (avatar && (agent_id == avatar->getID()))
  945. {
  946. gMessageSystem->getU32Fast(_PREHASH_AgentData, _PREHASH_SerialNum, gAgentQueryManager.mUpdateSerialNum);
  948. const S32 NUM_BODY_PARTS = 4;
  949. S32 num_wearables = gMessageSystem->getNumberOfBlocksFast(_PREHASH_WearableData);
  950. if (num_wearables < NUM_BODY_PARTS)
  951. {
  952. // Transitional state.  Avatars should always have at least their body parts (hair, eyes, shape and skin).
  953. // The fact that they don't have any here (only a dummy is sent) implies that either:
  954. // 1. This account existed before we had wearables
  955. // 2. The database has gotten messed up
  956. // 3. This is the account's first login (i.e. the wearables haven't been generated yet).
  957. return;
  958. }
  960. // Get the UUID of the current outfit folder (will be created if it doesn't exist)
  961. const LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
  963. LLInitialWearablesFetch* outfit = new LLInitialWearablesFetch();
  965. //lldebugs << "processAgentInitialWearablesUpdate()" << llendl;
  966. // Add wearables
  967. // MULTI-WEARABLE: TODO: update once messages change.  Currently use results to populate the zeroth element.
  968. gAgentWearables.mItemsAwaitingWearableUpdate.clear();
  969. for (S32 i=0; i < num_wearables; i++)
  970. {
  971. // Parse initial wearables data from message system
  972. U8 type_u8 = 0;
  973. gMessageSystem->getU8Fast(_PREHASH_WearableData, _PREHASH_WearableType, type_u8, i);
  974. if (type_u8 >= WT_COUNT)
  975. {
  976. continue;
  977. }
  978. const EWearableType type = (EWearableType) type_u8;
  980. LLUUID item_id;
  981. gMessageSystem->getUUIDFast(_PREHASH_WearableData, _PREHASH_ItemID, item_id, i);
  983. LLUUID asset_id;
  984. gMessageSystem->getUUIDFast(_PREHASH_WearableData, _PREHASH_AssetID, asset_id, i);
  985. if (asset_id.isNull())
  986. {
  987. LLWearable::removeFromAvatar(type, FALSE);
  988. }
  989. else
  990. {
  991. LLAssetType::EType asset_type = LLWearableDictionary::getAssetType(type);
  992. if (asset_type == LLAssetType::AT_NONE)
  993. {
  994. continue;
  995. }
  997. // MULTI-WEARABLE: TODO: update once messages change.  Currently use results to populate the zeroth element.
  999. // Store initial wearables data until we know whether we have the current outfit folder or need to use the data.
  1000. LLInitialWearablesFetch::InitialWearableData wearable_data(type, item_id, asset_id); // MULTI-WEARABLE: update
  1001. outfit->mAgentInitialWearables.push_back(wearable_data);
  1003. }
  1005. lldebugs << "       " << LLWearableDictionary::getTypeLabel(type) << llendl;
  1006. }
  1008. // Get the complete information on the items in the inventory and set up an observer
  1009. // that will trigger when the complete information is fetched.
  1010. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  1011. folders.push_back(current_outfit_id);
  1012. outfit->fetchDescendents(folders);
  1013. if(outfit->isEverythingComplete())
  1014. {
  1015. // everything is already here - call done.
  1016. outfit->done();
  1017. }
  1018. else
  1019. {
  1020. // it's all on it's way - add an observer, and the inventory
  1021. // will call done for us when everything is here.
  1022. gInventory.addObserver(outfit);
  1023. }
  1025. }
  1026. }
  1028. // A single wearable that the avatar was wearing on start-up has arrived from the database.
  1029. // static
  1030. void LLAgentWearables::onInitialWearableAssetArrived(LLWearable* wearable, void* userdata)
  1031. {
  1032. boost::scoped_ptr<LLInitialWearablesFetch::InitialWearableData> wear_data((LLInitialWearablesFetch::InitialWearableData*)userdata); 
  1033. const EWearableType type = wear_data->mType;
  1034. U32 index = 0;
  1036. LLVOAvatarSelf* avatar = gAgent.getAvatarObject();
  1037. if (!avatar)
  1038. {
  1039. return;
  1040. }
  1042. if (wearable)
  1043. {
  1044. llassert(type == wearable->getType());
  1045. wearable->setItemID(wear_data->mItemID);
  1046. index = gAgentWearables.pushWearable(type, wearable);
  1047. gAgentWearables.mItemsAwaitingWearableUpdate.erase(wear_data->mItemID);
  1049. // disable composites if initial textures are baked
  1050. avatar->setupComposites();
  1052. avatar->setCompositeUpdatesEnabled(TRUE);
  1053. gInventory.addChangedMask(LLInventoryObserver::LABEL, wearable->getItemID());
  1054. }
  1055. else
  1056. {
  1057. // Somehow the asset doesn't exist in the database.
  1058. gAgentWearables.recoverMissingWearable(type,index);
  1059. }
  1061. gInventory.notifyObservers();
  1063. // Have all the wearables that the avatar was wearing at log-in arrived?
  1064. // MULTI-WEARABLE: update when multiple wearables can arrive per type.
  1066. gAgentWearables.updateWearablesLoaded();
  1067. if (gAgentWearables.areWearablesLoaded())
  1068. {
  1070. // Can't query cache until all wearables have arrived, so calling this earlier is a no-op.
  1071. gAgentWearables.queryWearableCache();
  1073. // Make sure that the server's idea of the avatar's wearables actually match the wearables.
  1074. gAgent.sendAgentSetAppearance();
  1076. // Check to see if there are any baked textures that we hadn't uploaded before we logged off last time.
  1077. // If there are any, schedule them to be uploaded as soon as the layer textures they depend on arrive.
  1078. if (gAgent.cameraCustomizeAvatar())
  1079. {
  1080. avatar->requestLayerSetUploads();
  1081. }
  1082. }
  1083. }
  1085. // Normally, all wearables referred to "AgentWearablesUpdate" will correspond to actual assets in the
  1086. // database.  If for some reason, we can't load one of those assets, we can try to reconstruct it so that
  1087. // the user isn't left without a shape, for example.  (We can do that only after the inventory has loaded.)
  1088. void LLAgentWearables::recoverMissingWearable(const EWearableType type, U32 index)
  1089. {
  1090. // Try to recover by replacing missing wearable with a new one.
  1091. LLNotificationsUtil::add("ReplacedMissingWearable");
  1092. lldebugs << "Wearable " << LLWearableDictionary::getTypeLabel(type) << " could not be downloaded.  Replaced inventory item with default wearable." << llendl;
  1093. LLWearable* new_wearable = LLWearableList::instance().createNewWearable(type);
  1095. S32 type_s32 = (S32) type;
  1096. setWearable(type,index,new_wearable);
  1097. //new_wearable->writeToAvatar(TRUE);
  1099. // Add a new one in the lost and found folder.
  1100. // (We used to overwrite the "not found" one, but that could potentially
  1101. // destory content.) JC
  1102. const LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
  1103. LLPointer<LLInventoryCallback> cb =
  1104. new addWearableToAgentInventoryCallback(
  1105. LLPointer<LLRefCount>(NULL),
  1106. type_s32,
  1107. index,
  1108. new_wearable,
  1109. addWearableToAgentInventoryCallback::CALL_RECOVERDONE);
  1110. addWearableToAgentInventory(cb, new_wearable, lost_and_found_id, TRUE);
  1111. }
  1113. void LLAgentWearables::recoverMissingWearableDone()
  1114. {
  1115. // Have all the wearables that the avatar was wearing at log-in arrived or been fabricated?
  1116. updateWearablesLoaded();
  1117. if (areWearablesLoaded())
  1118. {
  1119. // Make sure that the server's idea of the avatar's wearables actually match the wearables.
  1120. gAgent.sendAgentSetAppearance();
  1121. }
  1122. else
  1123. {
  1124. gInventory.addChangedMask(LLInventoryObserver::LABEL, LLUUID::null);
  1125. gInventory.notifyObservers();
  1126. }
  1127. }
  1129. void LLAgentWearables::addLocalTextureObject(const EWearableType wearable_type, const LLVOAvatarDefines::ETextureIndex texture_type, U32 wearable_index)
  1130. {
  1131. LLWearable* wearable = getWearable((EWearableType)wearable_type, wearable_index);
  1132. if (!wearable)
  1133. {
  1134. llerrs << "Tried to add local texture object to invalid wearable with type " << wearable_type << " and index " << wearable_index << llendl;
  1135. return;
  1136. }
  1137. LLLocalTextureObject lto;
  1138. wearable->setLocalTextureObject(texture_type, lto);
  1139. }
  1141. void LLAgentWearables::createStandardWearables(BOOL female)
  1142. {
  1143. llwarns << "Creating Standard " << (female ? "female" : "male")
  1144. << " Wearables" << llendl;
  1146. if (mAvatarObject.isNull())
  1147. {
  1148. return;
  1149. }
  1151. mAvatarObject->setSex(female ? SEX_FEMALE : SEX_MALE);
  1153. const BOOL create[WT_COUNT] = 
  1154. {
  1155. TRUE,  //WT_SHAPE
  1156. TRUE,  //WT_SKIN
  1157. TRUE,  //WT_HAIR
  1158. TRUE,  //WT_EYES
  1159. TRUE,  //WT_SHIRT
  1160. TRUE,  //WT_PANTS
  1161. TRUE,  //WT_SHOES
  1162. TRUE,  //WT_SOCKS
  1163. FALSE, //WT_JACKET
  1164. FALSE, //WT_GLOVES
  1165. TRUE,  //WT_UNDERSHIRT
  1166. TRUE,  //WT_UNDERPANTS
  1167. FALSE  //WT_SKIRT
  1168. };
  1170. for (S32 i=0; i < WT_COUNT; i++)
  1171. {
  1172. bool once = false;
  1173. LLPointer<LLRefCount> donecb = NULL;
  1174. if (create[i])
  1175. {
  1176. if (!once)
  1177. {
  1178. once = true;
  1179. donecb = new createStandardWearablesAllDoneCallback;
  1180. }
  1181. llassert(getWearableCount((EWearableType)i) == 0);
  1182. LLWearable* wearable = LLWearableList::instance().createNewWearable((EWearableType)i);
  1183. U32 index = pushWearable((EWearableType)i,wearable);
  1184. // no need to update here...
  1185. LLPointer<LLInventoryCallback> cb =
  1186. new addWearableToAgentInventoryCallback(
  1187. donecb,
  1188. i,
  1189. index,
  1190. wearable,
  1191. addWearableToAgentInventoryCallback::CALL_CREATESTANDARDDONE);
  1192. addWearableToAgentInventory(cb, wearable, LLUUID::null, FALSE);
  1193. }
  1194. }
  1195. }
  1197. void LLAgentWearables::createStandardWearablesDone(S32 type, U32 index)
  1198. {
  1199. if (mAvatarObject)
  1200. {
  1201. mAvatarObject->updateVisualParams();
  1202. }
  1203. }
  1205. void LLAgentWearables::createStandardWearablesAllDone()
  1206. {
  1207. // ... because sendAgentWearablesUpdate will notify inventory
  1208. // observers.
  1209. mWearablesLoaded = TRUE; 
  1210. checkWearablesLoaded();
  1212. updateServer();
  1214. // Treat this as the first texture entry message, if none received yet
  1215. mAvatarObject->onFirstTEMessageReceived();
  1216. }
  1218. // MULTI-WEARABLE: Properly handle multiwearables later.
  1219. void LLAgentWearables::getAllWearablesArray(LLDynamicArray<S32>& wearables)
  1220. {
  1221. for( S32 i = 0; i < WT_COUNT; ++i )
  1222. {
  1223. if (getWearableCount((EWearableType) i) !=  0)
  1224. {
  1225. wearables.push_back(i);
  1226. }
  1227. }
  1228. }
  1230. // Note: wearables_to_include should be a list of EWearableType types
  1231. // attachments_to_include should be a list of attachment points
  1232. void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
  1233.  const LLDynamicArray<S32>& wearables_to_include,
  1234.  const LLDynamicArray<S32>& attachments_to_include,
  1235.  BOOL rename_clothing)
  1236. {
  1237. if (mAvatarObject.isNull())
  1238. {
  1239. return;
  1240. }
  1242. // First, make a folder in the Clothes directory.
  1243. LLUUID folder_id = gInventory.createNewCategory(
  1244. gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING),
  1245. LLFolderType::FT_NONE,
  1246. new_folder_name);
  1248. bool found_first_item = false;
  1250. ///////////////////
  1251. // Wearables
  1253. if (wearables_to_include.count())
  1254. {
  1255. // Then, iterate though each of the wearables and save copies of them in the folder.
  1256. S32 i;
  1257. S32 count = wearables_to_include.count();
  1258. LLDynamicArray<LLUUID> delete_items;
  1259. LLPointer<LLRefCount> cbdone = NULL;
  1260. for (i = 0; i < count; ++i)
  1261. {
  1262. const S32 type = wearables_to_include[i];
  1263. for (U32 j=0; j<getWearableCount((EWearableType)i); j++)
  1264. {
  1265. LLWearable* old_wearable = getWearable((EWearableType)type, j);
  1266. if (old_wearable)
  1267. {
  1268. std::string new_name;
  1269. LLWearable* new_wearable;
  1270. new_wearable = LLWearableList::instance().createCopy(old_wearable);
  1271. if (rename_clothing)
  1272. {
  1273. new_name = new_folder_name;
  1274. new_name.append(" ");
  1275. new_name.append(old_wearable->getTypeLabel());
  1276. LLStringUtil::truncate(new_name, DB_INV_ITEM_NAME_STR_LEN);
  1277. new_wearable->setName(new_name);
  1278. }
  1280. LLViewerInventoryItem* item = gInventory.getItem(getWearableItemID((EWearableType)type,j));
  1281. S32 todo = addWearableToAgentInventoryCallback::CALL_NONE;
  1282. if (!found_first_item)
  1283. {
  1284. found_first_item = true;
  1285. /* set the focus to the first item */
  1286. todo |= addWearableToAgentInventoryCallback::CALL_MAKENEWOUTFITDONE;
  1287. /* send the agent wearables update when done */
  1288. cbdone = new sendAgentWearablesUpdateCallback;
  1289. }
  1290. LLPointer<LLInventoryCallback> cb =
  1291. new addWearableToAgentInventoryCallback(
  1292. cbdone,
  1293. type,
  1294. j,
  1295. new_wearable,
  1296. todo);
  1297. llassert(item);
  1298. if (item)
  1299. {
  1300. if (isWearableCopyable((EWearableType)type, j))
  1301. {
  1302. copy_inventory_item(
  1303.     gAgent.getID(),
  1304.     item->getPermissions().getOwner(),
  1305.     item->getUUID(),
  1306.     folder_id,
  1307.     new_name,
  1308.     cb);
  1309. }
  1310. else
  1311. {
  1312. move_inventory_item(
  1313.     gAgent.getID(),
  1314.     gAgent.getSessionID(),
  1315.     item->getUUID(),
  1316.     folder_id,
  1317.     new_name,
  1318.     cb);
  1319. }
  1320. }
  1321. }
  1322. }
  1323. }
  1324. gInventory.notifyObservers();
  1325. }
  1328. ///////////////////
  1329. // Attachments
  1331. if (attachments_to_include.count())
  1332. {
  1333. BOOL msg_started = FALSE;
  1334. LLMessageSystem* msg = gMessageSystem;
  1335. for (S32 i = 0; i < attachments_to_include.count(); i++)
  1336. {
  1337. S32 attachment_pt = attachments_to_include[i];
  1338. LLViewerJointAttachment* attachment = get_if_there(mAvatarObject->mAttachmentPoints, attachment_pt, (LLViewerJointAttachment*)NULL);
  1339. if (!attachment) continue;
  1340. for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
  1341.  attachment_iter != attachment->mAttachedObjects.end();
  1342.  ++attachment_iter)
  1343. {
  1344. LLViewerObject *attached_object = (*attachment_iter);
  1345. if(!attached_object) continue;
  1346. const LLUUID& item_id = (*attachment_iter)->getItemID();
  1347. if(item_id.isNull()) continue;
  1348. LLInventoryItem* item = gInventory.getItem(item_id);
  1349. if(!item) continue;
  1350. if(!msg_started)
  1351. {
  1352. msg_started = TRUE;
  1353. msg->newMessage("CreateNewOutfitAttachments");
  1354. msg->nextBlock("AgentData");
  1355. msg->addUUID("AgentID", gAgent.getID());
  1356. msg->addUUID("SessionID", gAgent.getSessionID());
  1357. msg->nextBlock("HeaderData");
  1358. msg->addUUID("NewFolderID", folder_id);
  1359. }
  1360. msg->nextBlock("ObjectData");
  1361. msg->addUUID("OldItemID", item_id);
  1362. msg->addUUID("OldFolderID", item->getParentUUID());
  1363. }
  1364. }
  1366. if (msg_started)
  1367. {
  1368. gAgent.sendReliableMessage();
  1369. }
  1371. } 
  1372. }
  1374. class LLShowCreatedOutfit: public LLInventoryCallback
  1375. {
  1376. public:
  1377. LLShowCreatedOutfit(LLUUID& folder_id):
  1378. mFolderID(folder_id)
  1379. {
  1380. }
  1382. virtual ~LLShowCreatedOutfit()
  1383. {
  1384. LLSD key;
  1385. LLSideTray::getInstance()->showPanel("panel_outfits_inventory", key);
  1386. LLPanelOutfitsInventory *outfit_panel =
  1387. dynamic_cast<LLPanelOutfitsInventory*>(LLSideTray::getInstance()->getPanel("panel_outfits_inventory"));
  1388. if (outfit_panel)
  1389. {
  1390. outfit_panel->getRootFolder()->clearSelection();
  1391. outfit_panel->getRootFolder()->setSelectionByID(mFolderID, TRUE);
  1392. }
  1393. LLAccordionCtrlTab* tab_outfits = outfit_panel ? outfit_panel->findChild<LLAccordionCtrlTab>("tab_outfits") : 0;
  1394. if (tab_outfits && !tab_outfits->getDisplayChildren())
  1395. {
  1396. tab_outfits->changeOpenClose(tab_outfits->getDisplayChildren());
  1397. }
  1399. LLAppearanceManager::instance().updateIsDirty();
  1400. LLAppearanceManager::instance().updatePanelOutfitName("");
  1401. }
  1403. virtual void fire(const LLUUID&)
  1404. {
  1405. }
  1407. private:
  1408. LLUUID mFolderID;
  1409. };
  1411. LLUUID LLAgentWearables::makeNewOutfitLinks(const std::string& new_folder_name)
  1412. {
  1413. if (mAvatarObject.isNull())
  1414. {
  1415. return LLUUID::null;
  1416. }
  1418. // First, make a folder in the My Outfits directory.
  1419. const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
  1420. LLUUID folder_id = gInventory.createNewCategory(
  1421. parent_id,
  1422. LLFolderType::FT_OUTFIT,
  1423. new_folder_name);
  1425. LLPointer<LLInventoryCallback> cb = new LLShowCreatedOutfit(folder_id);
  1426. LLAppearanceManager::instance().shallowCopyCategoryContents(LLAppearanceManager::instance().getCOF(),folder_id, cb);
  1427. LLAppearanceManager::instance().createBaseOutfitLink(folder_id, cb);
  1429. return folder_id;
  1430. }
  1432. void LLAgentWearables::makeNewOutfitDone(S32 type, U32 index)
  1433. {
  1434. LLUUID first_item_id = getWearableItemID((EWearableType)type, index);
  1435. // Open the inventory and select the first item we added.
  1436. if (first_item_id.notNull())
  1437. {
  1438. LLInventoryPanel *active_panel = LLInventoryPanel::getActiveInventoryPanel();
  1439. if (active_panel)
  1440. {
  1441. active_panel->setSelection(first_item_id, TAKE_FOCUS_NO);
  1442. }
  1443. }
  1444. }
  1447. void LLAgentWearables::addWearableToAgentInventory(LLPointer<LLInventoryCallback> cb,
  1448.    LLWearable* wearable,
  1449.    const LLUUID& category_id,
  1450.    BOOL notify)
  1451. {
  1452. create_inventory_item(gAgent.getID(),
  1453.   gAgent.getSessionID(),
  1454.   category_id,
  1455.   wearable->getTransactionID(),
  1456.   wearable->getName(),
  1457.   wearable->getDescription(),
  1458.   wearable->getAssetType(),
  1459.   LLInventoryType::IT_WEARABLE,
  1460.   wearable->getType(),
  1461.   wearable->getPermissions().getMaskNextOwner(),
  1462.   cb);
  1463. }
  1465. void LLAgentWearables::removeWearable(const EWearableType type, bool do_remove_all, U32 index)
  1466. {
  1467. if (gAgent.isTeen() &&
  1468. (type == WT_UNDERSHIRT || type == WT_UNDERPANTS))
  1469. {
  1470. // Can't take off underclothing in simple UI mode or on PG accounts
  1471. // TODO: enable the removing of a single undershirt/underpants if multiple are worn. - Nyx
  1472. return;
  1473. }
  1474. if (getWearableCount(type) == 0)
  1475. {
  1476. // no wearables to remove
  1477. return;
  1478. }
  1480. if (do_remove_all)
  1481. {
  1482. removeWearableFinal(type, do_remove_all, index);
  1483. }
  1484. else
  1485. {
  1486. LLWearable* old_wearable = getWearable(type,index);
  1488. if (old_wearable)
  1489. {
  1490. if (old_wearable->isDirty())
  1491. {
  1492. LLSD payload;
  1493. payload["wearable_type"] = (S32)type;
  1494. // Bring up view-modal dialog: Save changes? Yes, No, Cancel
  1495. LLNotificationsUtil::add("WearableSave", LLSD(), payload, &LLAgentWearables::onRemoveWearableDialog);
  1496. return;
  1497. }
  1498. else
  1499. {
  1500. removeWearableFinal(type, do_remove_all, index);
  1501. }
  1502. }
  1503. }
  1504. }
  1507. // MULTI_WEARABLE: assuming one wearable per type.
  1508. // MULTI_WEARABLE: hardwiring 0th elt for now - notification needs to change.
  1509. // static 
  1510. bool LLAgentWearables::onRemoveWearableDialog(const LLSD& notification, const LLSD& response)
  1511. {
  1512. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1513. EWearableType type = (EWearableType)notification["payload"]["wearable_type"].asInteger();
  1514. switch(option)
  1515. {
  1516. case 0:  // "Save"
  1517. gAgentWearables.saveWearable(type, 0);
  1518. gAgentWearables.removeWearableFinal(type, false, 0);
  1519. break;
  1521. case 1:  // "Don't Save"
  1522. gAgentWearables.removeWearableFinal(type, false, 0);
  1523. break;
  1525. case 2: // "Cancel"
  1526. break;
  1528. default:
  1529. llassert(0);
  1530. break;
  1531. }
  1532. return false;
  1533. }
  1535. // Called by removeWearable() and onRemoveWearableDialog() to actually do the removal.
  1536. void LLAgentWearables::removeWearableFinal(const EWearableType type, bool do_remove_all, U32 index)
  1537. {
  1538. //LLAgentDumper dumper("removeWearable");
  1539. if (do_remove_all)
  1540. {
  1541. S32 max_entry = mWearableDatas[type].size()-1;
  1542. for (S32 i=max_entry; i>=0; i--)
  1543. {
  1544. LLWearable* old_wearable = getWearable(type,i);
  1545. //queryWearableCache(); // moved below
  1546. if (old_wearable)
  1547. {
  1548. popWearable(old_wearable);
  1549. old_wearable->removeFromAvatar(TRUE);
  1550. }
  1551. }
  1552. mWearableDatas[type].clear();
  1553. }
  1554. else
  1555. {
  1556. LLWearable* old_wearable = getWearable(type, index);
  1557. //queryWearableCache(); // moved below
  1559. if (old_wearable)
  1560. {
  1561. popWearable(old_wearable);
  1562. old_wearable->removeFromAvatar(TRUE);
  1563. }
  1564. }
  1566. queryWearableCache();
  1568. // Update the server
  1569. updateServer();
  1570. gInventory.notifyObservers();
  1571. }
  1573. // Assumes existing wearables are not dirty.
  1574. // MULTI_WEARABLE: assumes one wearable per type.
  1575. void LLAgentWearables::setWearableOutfit(const LLInventoryItem::item_array_t& items,
  1576.  const LLDynamicArray< LLWearable* >& wearables,
  1577.  BOOL remove)
  1578. {
  1579. lldebugs << "setWearableOutfit() start" << llendl;
  1581. BOOL wearables_to_remove[WT_COUNT];
  1582. wearables_to_remove[WT_SHAPE] = FALSE;
  1583. wearables_to_remove[WT_SKIN] = FALSE;
  1584. wearables_to_remove[WT_HAIR] = FALSE;
  1585. wearables_to_remove[WT_EYES] = FALSE;
  1586. wearables_to_remove[WT_SHIRT] = remove;
  1587. wearables_to_remove[WT_PANTS] = remove;
  1588. wearables_to_remove[WT_SHOES] = remove;
  1589. wearables_to_remove[WT_SOCKS] = remove;
  1590. wearables_to_remove[WT_JACKET] = remove;
  1591. wearables_to_remove[WT_GLOVES] = remove;
  1592. wearables_to_remove[WT_UNDERSHIRT] = (!gAgent.isTeen()) & remove;
  1593. wearables_to_remove[WT_UNDERPANTS] = (!gAgent.isTeen()) & remove;
  1594. wearables_to_remove[WT_SKIRT] = remove;
  1595. wearables_to_remove[WT_ALPHA] = remove;
  1596. wearables_to_remove[WT_TATTOO] = remove;
  1599. S32 count = wearables.count();
  1600. llassert(items.count() == count);
  1602. S32 i;
  1603. for (i = 0; i < count; i++)
  1604. {
  1605. LLWearable* new_wearable = wearables[i];
  1606. LLPointer<LLInventoryItem> new_item = items[i];
  1608. llassert(new_wearable);
  1609. if (new_wearable)
  1610. {
  1611. const EWearableType type = new_wearable->getType();
  1612. wearables_to_remove[type] = FALSE;
  1614. // MULTI_WEARABLE: using 0th
  1615. LLWearable* old_wearable = getWearable(type, 0);
  1616. if (old_wearable)
  1617. {
  1618. const LLUUID& old_item_id = getWearableItemID(type, 0);
  1619. if ((old_wearable->getAssetID() == new_wearable->getAssetID()) &&
  1620.     (old_item_id == new_item->getUUID()))
  1621. {
  1622. lldebugs << "No change to wearable asset and item: " << LLWearableDictionary::getInstance()->getWearableEntry(type) << llendl;
  1623. continue;
  1624. }
  1626. // Assumes existing wearables are not dirty.
  1627. if (old_wearable->isDirty())
  1628. {
  1629. llassert(0);
  1630. continue;
  1631. }
  1632. }
  1634. new_wearable->setItemID(new_item->getUUID());
  1635. setWearable(type,0,new_wearable);
  1636. }
  1637. }
  1639. std::vector<LLWearable*> wearables_being_removed;
  1641. for (i = 0; i < WT_COUNT; i++)
  1642. {
  1643. if (wearables_to_remove[i])
  1644. {
  1645. // MULTI_WEARABLE: assuming 0th
  1646. LLWearable* wearable = getWearable((EWearableType)i, 0);
  1647. const LLUUID &item_id = getWearableItemID((EWearableType)i,0);
  1648. gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
  1649. if (wearable)
  1650. {
  1651. wearables_being_removed.push_back(wearable);
  1652. }
  1653. removeWearable((EWearableType)i,true,0);
  1654. }
  1655. }
  1657. gInventory.notifyObservers();
  1660. std::vector<LLWearable*>::iterator wearable_iter;
  1662. for (wearable_iter = wearables_being_removed.begin(); 
  1663.  wearable_iter != wearables_being_removed.end();
  1664.  ++wearable_iter)
  1665. {
  1666. LLWearable* wearablep = *wearable_iter;
  1667. if (wearablep)
  1668. {
  1669. wearablep->removeFromAvatar(TRUE);
  1670. }
  1671. }
  1673. if (mAvatarObject)
  1674. {
  1675. mAvatarObject->updateVisualParams();
  1676. mAvatarObject->invalidateAll();
  1677. }
  1679. // Start rendering & update the server
  1680. mWearablesLoaded = TRUE; 
  1681. checkWearablesLoaded();
  1682. queryWearableCache();
  1683. updateServer();
  1685. lldebugs << "setWearableOutfit() end" << llendl;
  1686. }
  1689. // User has picked "wear on avatar" from a menu.
  1690. void LLAgentWearables::setWearableItem(LLInventoryItem* new_item, LLWearable* new_wearable, bool do_append)
  1691. {
  1692. //LLAgentDumper dumper("setWearableItem");
  1693. if (isWearingItem(new_item->getUUID()))
  1694. {
  1695. llwarns << "wearable " << new_item->getUUID() << " is already worn" << llendl;
  1696. return;
  1697. }
  1699. const EWearableType type = new_wearable->getType();
  1701. if (!do_append)
  1702. {
  1703. // Remove old wearable, if any
  1704. // MULTI_WEARABLE: hardwired to 0
  1705. LLWearable* old_wearable = getWearable(type,0);
  1706. if (old_wearable)
  1707. {
  1708. const LLUUID& old_item_id = old_wearable->getItemID();
  1709. if ((old_wearable->getAssetID() == new_wearable->getAssetID()) &&
  1710. (old_item_id == new_item->getUUID()))
  1711. {
  1712. lldebugs << "No change to wearable asset and item: " << LLWearableDictionary::getInstance()->getWearableEntry(type) << llendl;
  1713. return;
  1714. }
  1716. if (old_wearable->isDirty())
  1717. {
  1718. // Bring up modal dialog: Save changes? Yes, No, Cancel
  1719. LLSD payload;
  1720. payload["item_id"] = new_item->getUUID();
  1721. LLNotificationsUtil::add("WearableSave", LLSD(), payload, boost::bind(onSetWearableDialog, _1, _2, new_wearable));
  1722. return;
  1723. }
  1724. }
  1725. }
  1727. setWearableFinal(new_item, new_wearable, do_append);
  1728. }
  1730. // static 
  1731. bool LLAgentWearables::onSetWearableDialog(const LLSD& notification, const LLSD& response, LLWearable* wearable)
  1732. {
  1733. S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
  1734. LLInventoryItem* new_item = gInventory.getItem(notification["payload"]["item_id"].asUUID());
  1735. if (!new_item)
  1736. {
  1737. delete wearable;
  1738. return false;
  1739. }
  1741. switch(option)
  1742. {
  1743. case 0:  // "Save"
  1744. // MULTI_WEARABLE: assuming 0th
  1745. gAgentWearables.saveWearable(wearable->getType(),0);
  1746. gAgentWearables.setWearableFinal(new_item, wearable);
  1747. break;
  1749. case 1:  // "Don't Save"
  1750. gAgentWearables.setWearableFinal(new_item, wearable);
  1751. break;
  1753. case 2: // "Cancel"
  1754. break;
  1756. default:
  1757. llassert(0);
  1758. break;
  1759. }
  1761. delete wearable;
  1762. return false;
  1763. }
  1765. // Called from setWearableItem() and onSetWearableDialog() to actually set the wearable.
  1766. // MULTI_WEARABLE: unify code after null objects are gone.
  1767. void LLAgentWearables::setWearableFinal(LLInventoryItem* new_item, LLWearable* new_wearable, bool do_append)
  1768. {
  1769. const EWearableType type = new_wearable->getType();
  1771. if (do_append && getWearableItemID(type,0).notNull())
  1772. {
  1773. new_wearable->setItemID(new_item->getUUID());
  1774. mWearableDatas[type].push_back(new_wearable);
  1775. llinfos << "Added additional wearable for type " << type
  1776. << " size is now " << mWearableDatas[type].size() << llendl;
  1777. checkWearableAgainstInventory(new_wearable);
  1778. }
  1779. else
  1780. {
  1781. // Replace the old wearable with a new one.
  1782. llassert(new_item->getAssetUUID() == new_wearable->getAssetID());
  1784. LLWearable *old_wearable = getWearable(type,0);
  1785. LLUUID old_item_id;
  1786. if (old_wearable)
  1787. {
  1788. old_item_id = old_wearable->getItemID();
  1789. }
  1790. new_wearable->setItemID(new_item->getUUID());
  1791. setWearable(type,0,new_wearable);
  1793. if (old_item_id.notNull())
  1794. {
  1795. gInventory.addChangedMask(LLInventoryObserver::LABEL, old_item_id);
  1796. gInventory.notifyObservers();
  1797. }
  1798. llinfos << "Replaced current element 0 for type " << type
  1799. << " size is now " << mWearableDatas[type].size() << llendl;
  1800. }
  1802. //llinfos << "LLVOAvatar::setWearableItem()" << llendl;
  1803. queryWearableCache();
  1804. //new_wearable->writeToAvatar(TRUE);
  1806. updateServer();
  1807. }
  1809. void LLAgentWearables::queryWearableCache()
  1810. {
  1811. if (!areWearablesLoaded())
  1812. {
  1813. return;
  1814. }
  1816. // Look up affected baked textures.
  1817. // If they exist:
  1818. // disallow updates for affected layersets (until dataserver responds with cache request.)
  1819. // If cache miss, turn updates back on and invalidate composite.
  1820. // If cache hit, modify baked texture entries.
  1821. //
  1822. // Cache requests contain list of hashes for each baked texture entry.
  1823. // Response is list of valid baked texture assets. (same message)
  1825. gMessageSystem->newMessageFast(_PREHASH_AgentCachedTexture);
  1826. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1827. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1828. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1829. gMessageSystem->addS32Fast(_PREHASH_SerialNum, gAgentQueryManager.mWearablesCacheQueryID);
  1831. S32 num_queries = 0;
  1832. for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++)
  1833. {
  1834. const LLVOAvatarDictionary::BakedEntry *baked_dict = LLVOAvatarDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index);
  1835. LLUUID hash;
  1836. for (U8 i=0; i < baked_dict->mWearables.size(); i++)
  1837. {
  1838. const EWearableType baked_type = baked_dict->mWearables[i];
  1839. // MULTI_WEARABLE: not order-dependent
  1840. const U32 num_wearables = getWearableCount(baked_type);
  1841. for (U32 index = 0; index < num_wearables; ++index)
  1842. {
  1843. const LLWearable* wearable = getWearable(baked_type,index);
  1844. if (wearable)
  1845. {
  1846. hash ^= wearable->getAssetID();
  1847. }
  1848. }
  1849. }
  1850. if (hash.notNull())
  1851. {
  1852. hash ^= baked_dict->mWearablesHashID;
  1853. num_queries++;
  1854. // *NOTE: make sure at least one request gets packed
  1856. //llinfos << "Requesting texture for hash " << hash << " in baked texture slot " << baked_index << llendl;
  1857. gMessageSystem->nextBlockFast(_PREHASH_WearableData);
  1858. gMessageSystem->addUUIDFast(_PREHASH_ID, hash);
  1859. gMessageSystem->addU8Fast(_PREHASH_TextureIndex, (U8)baked_index);
  1860. }
  1862. gAgentQueryManager.mActiveCacheQueries[baked_index] = gAgentQueryManager.mWearablesCacheQueryID;
  1863. }
  1865. llinfos << "Requesting texture cache entry for " << num_queries << " baked textures" << llendl;
  1866. gMessageSystem->sendReliable(gAgent.getRegion()->getHost());
  1867. gAgentQueryManager.mNumPendingQueries++;
  1868. gAgentQueryManager.mWearablesCacheQueryID++;
  1869. }
  1871. // MULTI_WEARABLE: need a way to specify by wearable rather than by type.
  1872. // User has picked "remove from avatar" from a menu.
  1873. // static
  1874. void LLAgentWearables::userRemoveWearable(EWearableType& type)
  1875. {
  1876. if (!(type==WT_SHAPE || type==WT_SKIN || type==WT_HAIR)) //&&
  1877. //!((!gAgent.isTeen()) && (type==WT_UNDERPANTS || type==WT_UNDERSHIRT)))
  1878. {
  1879. // MULTI_WEARABLE: fixed to 0th for now.
  1880. gAgentWearables.removeWearable(type,false,0);
  1881. }
  1882. }
  1884. // static
  1885. void LLAgentWearables::userRemoveAllClothes()
  1886. {
  1887. // We have to do this up front to avoid having to deal with the case of multiple wearables being dirty.
  1888. if (gFloaterCustomize)
  1889. {
  1890. gFloaterCustomize->askToSaveIfDirty(userRemoveAllClothesStep2);
  1891. }
  1892. else
  1893. {
  1894. userRemoveAllClothesStep2(TRUE);
  1895. }
  1896. }
  1898. // static
  1899. void LLAgentWearables::userRemoveAllClothesStep2(BOOL proceed)
  1900. {
  1901. if (proceed)
  1902. {
  1903. gAgentWearables.removeWearable(WT_SHIRT,true,0);
  1904. gAgentWearables.removeWearable(WT_PANTS,true,0);
  1905. gAgentWearables.removeWearable(WT_SHOES,true,0);
  1906. gAgentWearables.removeWearable(WT_SOCKS,true,0);
  1907. gAgentWearables.removeWearable(WT_JACKET,true,0);
  1908. gAgentWearables.removeWearable(WT_GLOVES,true,0);
  1909. gAgentWearables.removeWearable(WT_UNDERSHIRT,true,0);
  1910. gAgentWearables.removeWearable(WT_UNDERPANTS,true,0);
  1911. gAgentWearables.removeWearable(WT_SKIRT,true,0);
  1912. gAgentWearables.removeWearable(WT_ALPHA,true,0);
  1913. gAgentWearables.removeWearable(WT_TATTOO,true,0);
  1914. }
  1915. }
  1917. // Combines userRemoveAllAttachments() and userAttachMultipleAttachments() logic to
  1918. // get attachments into desired state with minimal number of adds/removes.
  1919. void LLAgentWearables::userUpdateAttachments(LLInventoryModel::item_array_t& obj_item_array)
  1920. {
  1921. // Possible cases:
  1922. // already wearing but not in request set -> take off.
  1923. // already wearing and in request set -> leave alone.
  1924. // not wearing and in request set -> put on.
  1926. LLVOAvatar* avatarp = gAgent.getAvatarObject();
  1927. if (!avatarp)
  1928. {
  1929. llwarns << "No avatar found." << llendl;
  1930. return;
  1931. }
  1933. std::set<LLUUID> requested_item_ids;
  1934. std::set<LLUUID> current_item_ids;
  1935. for (S32 i=0; i<obj_item_array.count(); i++)
  1936. requested_item_ids.insert(obj_item_array[i].get()->getLinkedUUID());
  1938. // Build up list of objects to be removed and items currently attached.
  1939. llvo_vec_t objects_to_remove;
  1940. for (LLVOAvatar::attachment_map_t::iterator iter = avatarp->mAttachmentPoints.begin(); 
  1941.  iter != avatarp->mAttachmentPoints.end();)
  1942. {
  1943. LLVOAvatar::attachment_map_t::iterator curiter = iter++;
  1944. LLViewerJointAttachment* attachment = curiter->second;
  1945. for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
  1946.  attachment_iter != attachment->mAttachedObjects.end();
  1947.  ++attachment_iter)
  1948. {
  1949. LLViewerObject *objectp = (*attachment_iter);
  1950. if (objectp)
  1951. {
  1952. LLUUID object_item_id = objectp->getItemID();
  1953. if (requested_item_ids.find(object_item_id) != requested_item_ids.end())
  1954. {
  1955. // Object currently worn, was requested.
  1956. // Flag as currently worn so we won't have to add it again.
  1957. current_item_ids.insert(object_item_id);
  1958. }
  1959. else
  1960. {
  1961. // object currently worn, not requested.
  1962. objects_to_remove.push_back(objectp);
  1963. }
  1964. }
  1965. }
  1966. }
  1968. LLInventoryModel::item_array_t items_to_add;
  1969. for (LLInventoryModel::item_array_t::iterator it = obj_item_array.begin();
  1970.  it != obj_item_array.end();
  1971.  ++it)
  1972. {
  1973. LLUUID linked_id = (*it).get()->getLinkedUUID();
  1974. if (current_item_ids.find(linked_id) != current_item_ids.end())
  1975. {
  1976. // Requested attachment is already worn.
  1977. }
  1978. else
  1979. {
  1980. // Requested attachment is not worn yet.
  1981. items_to_add.push_back(*it);
  1982. }
  1983. }
  1984. // S32 remove_count = objects_to_remove.size();
  1985. // S32 add_count = items_to_add.size();
  1986. // llinfos << "remove " << remove_count << " add " << add_count << llendl;
  1988. // Remove everything in objects_to_remove
  1989. userRemoveMultipleAttachments(objects_to_remove);
  1991. // Add everything in items_to_add
  1992. userAttachMultipleAttachments(items_to_add);
  1993. }
  1995. void LLAgentWearables::userRemoveMultipleAttachments(llvo_vec_t& objects_to_remove)
  1996. {
  1997. LLVOAvatar* avatarp = gAgent.getAvatarObject();
  1998. if (!avatarp)
  1999. {
  2000. llwarns << "No avatar found." << llendl;
  2001. return;
  2002. }
  2004. if (objects_to_remove.empty())
  2005. return;
  2007. gMessageSystem->newMessage("ObjectDetach");
  2008. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  2009. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  2010. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  2012. for (llvo_vec_t::iterator it = objects_to_remove.begin();
  2013.  it != objects_to_remove.end();
  2014.  ++it)
  2015. {
  2016. LLViewerObject *objectp = *it;
  2017. gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
  2018. gMessageSystem->addU32Fast(_PREHASH_ObjectLocalID, objectp->getLocalID());
  2019. }
  2020. gMessageSystem->sendReliable(gAgent.getRegionHost());
  2021. }
  2023. void LLAgentWearables::userRemoveAllAttachments()
  2024. {
  2025. LLVOAvatar* avatarp = gAgent.getAvatarObject();
  2026. if (!avatarp)
  2027. {
  2028. llwarns << "No avatar found." << llendl;
  2029. return;
  2030. }
  2032. llvo_vec_t objects_to_remove;
  2034. for (LLVOAvatar::attachment_map_t::iterator iter = avatarp->mAttachmentPoints.begin(); 
  2035.  iter != avatarp->mAttachmentPoints.end();)
  2036. {
  2037. LLVOAvatar::attachment_map_t::iterator curiter = iter++;
  2038. LLViewerJointAttachment* attachment = curiter->second;
  2039. for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
  2040.  attachment_iter != attachment->mAttachedObjects.end();
  2041.  ++attachment_iter)
  2042. {
  2043. LLViewerObject *attached_object = (*attachment_iter);
  2044. if (attached_object)
  2045. {
  2046. objects_to_remove.push_back(attached_object);
  2047. }
  2048. }
  2049. }
  2050. userRemoveMultipleAttachments(objects_to_remove);
  2051. }
  2053. void LLAgentWearables::userAttachMultipleAttachments(LLInventoryModel::item_array_t& obj_item_array)
  2054. {
  2055. // Build a compound message to send all the objects that need to be rezzed.
  2056. S32 obj_count = obj_item_array.count();
  2058. // Limit number of packets to send
  2059. const S32 MAX_PACKETS_TO_SEND = 10;
  2060. const S32 OBJECTS_PER_PACKET = 4;
  2061. const S32 MAX_OBJECTS_TO_SEND = MAX_PACKETS_TO_SEND * OBJECTS_PER_PACKET;
  2062. if( obj_count > MAX_OBJECTS_TO_SEND )
  2063. {
  2064. obj_count = MAX_OBJECTS_TO_SEND;
  2065. }
  2067. // Create an id to keep the parts of the compound message together
  2068. LLUUID compound_msg_id;
  2069. compound_msg_id.generate();
  2070. LLMessageSystem* msg = gMessageSystem;
  2072. for(S32 i = 0; i < obj_count; ++i)
  2073. {
  2074. if( 0 == (i % OBJECTS_PER_PACKET) )
  2075. {
  2076. // Start a new message chunk
  2077. msg->newMessageFast(_PREHASH_RezMultipleAttachmentsFromInv);
  2078. msg->nextBlockFast(_PREHASH_AgentData);
  2079. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  2080. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  2081. msg->nextBlockFast(_PREHASH_HeaderData);
  2082. msg->addUUIDFast(_PREHASH_CompoundMsgID, compound_msg_id );
  2083. msg->addU8Fast(_PREHASH_TotalObjects, obj_count );
  2084. msg->addBOOLFast(_PREHASH_FirstDetachAll, false );
  2085. }
  2087. const LLInventoryItem* item = obj_item_array.get(i).get();
  2088. msg->nextBlockFast(_PREHASH_ObjectData );
  2089. msg->addUUIDFast(_PREHASH_ItemID, item->getLinkedUUID());
  2090. msg->addUUIDFast(_PREHASH_OwnerID, item->getPermissions().getOwner());
  2091. msg->addU8Fast(_PREHASH_AttachmentPt, 0 ); // Wear at the previous or default attachment point
  2092. pack_permissions_slam(msg, item->getFlags(), item->getPermissions());
  2093. msg->addStringFast(_PREHASH_Name, item->getName());
  2094. msg->addStringFast(_PREHASH_Description, item->getDescription());
  2096. if( (i+1 == obj_count) || ((OBJECTS_PER_PACKET-1) == (i % OBJECTS_PER_PACKET)) )
  2097. {
  2098. // End of message chunk
  2099. msg->sendReliable( gAgent.getRegion()->getHost() );
  2100. }
  2101. }
  2102. }
  2104. void LLAgentWearables::checkWearablesLoaded() const
  2105. {
  2106. #ifdef SHOW_ASSERT
  2107. U32 item_pend_count = itemUpdatePendingCount();
  2108. if (mWearablesLoaded)
  2109. {
  2110. llassert(item_pend_count==0);
  2111. }
  2112. #endif
  2113. }
  2115. BOOL LLAgentWearables::areWearablesLoaded() const
  2116. {
  2117. checkWearablesLoaded();
  2118. return mWearablesLoaded;
  2119. }
  2121. // MULTI-WEARABLE: update for multiple indices.
  2122. void LLAgentWearables::updateWearablesLoaded()
  2123. {
  2124. mWearablesLoaded = (itemUpdatePendingCount()==0);
  2125. }
  2127. bool LLAgentWearables::canWearableBeRemoved(const LLWearable* wearable) const
  2128. {
  2129. if (!wearable) return false;
  2131. EWearableType type = wearable->getType();
  2132. // Make sure the user always has at least one shape, skin, eyes, and hair type currently worn.
  2133. return !(((type == WT_SHAPE) || (type == WT_SKIN) || (type == WT_HAIR) || (type == WT_EYES))
  2134.  && (getWearableCount(type) <= 1) );   
  2135. }
  2136. void LLAgentWearables::animateAllWearableParams(F32 delta, BOOL upload_bake)
  2137. {
  2138. for( S32 type = 0; type < WT_COUNT; ++type )
  2139. {
  2140. for (S32 count = 0; count < (S32)getWearableCount((EWearableType)type); ++count)
  2141. {
  2142. LLWearable *wearable = getWearable((EWearableType)type,count);
  2143. wearable->animateParams(delta, upload_bake);
  2144. }
  2145. }
  2146. }
  2148. void LLAgentWearables::updateServer()
  2149. {
  2150. sendAgentWearablesUpdate();
  2151. gAgent.sendAgentSetAppearance();
  2152. }
  2154. void LLAgentWearables::populateMyOutfitsFolder(void)
  2155. {
  2156. llinfos << "starting outfit populate" << llendl;
  2158. LLLibraryOutfitsFetch* outfits = new LLLibraryOutfitsFetch();
  2160. // Get the complete information on the items in the inventory and 
  2161. // setup an observer that will wait for that to happen.
  2162. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  2163. outfits->mMyOutfitsID = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
  2165. folders.push_back(outfits->mMyOutfitsID);
  2166. gInventory.addObserver(outfits);
  2167. outfits->fetchDescendents(folders);
  2168. if (outfits->isEverythingComplete())
  2169. {
  2170. outfits->done();
  2171. }
  2172. }
  2174. void LLLibraryOutfitsFetch::done()
  2175. {
  2176. // Delay this until idle() routine, since it's a heavy operation and
  2177. // we also can't have it run within notifyObservers.
  2178. doOnIdle(boost::bind(&LLLibraryOutfitsFetch::doneIdle,this));
  2179. gInventory.removeObserver(this); // Prevent doOnIdle from being added twice.
  2180. }
  2182. void LLLibraryOutfitsFetch::doneIdle()
  2183. {
  2184. gInventory.addObserver(this); // Add this back in since it was taken out during ::done()
  2186. switch (mCurrFetchStep)
  2187. {
  2188. case LOFS_FOLDER:
  2189. folderDone();
  2190. mCurrFetchStep = LOFS_OUTFITS;
  2191. break;
  2192. case LOFS_OUTFITS:
  2193. outfitsDone();
  2194. mCurrFetchStep = LOFS_LIBRARY;
  2195. break;
  2196. case LOFS_LIBRARY:
  2197. libraryDone();
  2198. mCurrFetchStep = LOFS_IMPORTED;
  2199. break;
  2200. case LOFS_IMPORTED:
  2201. importedFolderDone();
  2202. mCurrFetchStep = LOFS_CONTENTS;
  2203. break;
  2204. case LOFS_CONTENTS:
  2205. contentsDone();
  2206. break;
  2207. default:
  2208. llwarns << "Got invalid state for outfit fetch: " << mCurrFetchStep << llendl;
  2209. mOutfitsPopulated = TRUE;
  2210. break;
  2211. }
  2213. // We're completely done.  Cleanup.
  2214. if (mOutfitsPopulated)
  2215. {
  2216. gInventory.removeObserver(this);
  2217. delete this;
  2218. return;
  2219. }
  2220. }
  2222. void LLLibraryOutfitsFetch::folderDone(void)
  2223. {
  2224. LLInventoryModel::cat_array_t cat_array;
  2225. LLInventoryModel::item_array_t wearable_array;
  2226. gInventory.collectDescendents(mMyOutfitsID, cat_array, wearable_array, 
  2227.   LLInventoryModel::EXCLUDE_TRASH);
  2229. // Early out if we already have items in My Outfits.
  2230. if (cat_array.count() > 0 || wearable_array.count() > 0)
  2231. {
  2232. mOutfitsPopulated = true;
  2233. return;
  2234. }
  2236. mClothingID = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
  2237. mLibraryClothingID = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING, false, true);
  2239. mCompleteFolders.clear();
  2241. // Get the complete information on the items in the inventory.
  2242. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  2243. folders.push_back(mClothingID);
  2244. folders.push_back(mLibraryClothingID);
  2245. fetchDescendents(folders);
  2246. if (isEverythingComplete())
  2247. {
  2248. done();
  2249. }
  2250. }
  2252. void LLLibraryOutfitsFetch::outfitsDone(void)
  2253. {
  2254. LLInventoryModel::cat_array_t cat_array;
  2255. LLInventoryModel::item_array_t wearable_array;
  2256. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  2258. // Collect the contents of the Library's Clothing folder
  2259. gInventory.collectDescendents(mLibraryClothingID, cat_array, wearable_array, 
  2260.   LLInventoryModel::EXCLUDE_TRASH);
  2262. llassert(cat_array.count() > 0);
  2263. for (LLInventoryModel::cat_array_t::const_iterator iter = cat_array.begin();
  2264.  iter != cat_array.end();
  2265.  ++iter)
  2266. {
  2267. const LLViewerInventoryCategory *cat = iter->get();
  2269. // Get the names and id's of every outfit in the library, except for ruth and other "misc" outfits.
  2270. if (cat->getName() != "More Outfits" && cat->getName() != "Ruth")
  2271. {
  2272. // Get the name of every outfit in the library 
  2273. folders.push_back(cat->getUUID());
  2274. mLibraryClothingFolders.push_back(std::make_pair(cat->getUUID(), cat->getName()));
  2275. }
  2276. }
  2278. // Collect the contents of your Inventory Clothing folder
  2279. cat_array.clear();
  2280. wearable_array.clear();
  2281. gInventory.collectDescendents(mClothingID, cat_array, wearable_array, 
  2282.   LLInventoryModel::EXCLUDE_TRASH);
  2284. // Check if you already have an "Imported Library Clothing" folder
  2285. for (LLInventoryModel::cat_array_t::const_iterator iter = cat_array.begin();
  2286.  iter != cat_array.end();
  2287.  ++iter)
  2288. {
  2289. const LLViewerInventoryCategory *cat = iter->get();
  2290. if (cat->getName() == mImportedClothingName)
  2291. {
  2292. mImportedClothingID = cat->getUUID();
  2293. }
  2294. }
  2296. mCompleteFolders.clear();
  2298. fetchDescendents(folders);
  2299. if (isEverythingComplete())
  2300. {
  2301. done();
  2302. }
  2303. }
  2305. class LLLibraryOutfitsCopyDone: public LLInventoryCallback
  2306. {
  2307. public:
  2308. LLLibraryOutfitsCopyDone(LLLibraryOutfitsFetch * fetcher):
  2309. mFireCount(0), mLibraryOutfitsFetcher(fetcher)
  2310. {
  2311. }
  2313. virtual ~LLLibraryOutfitsCopyDone()
  2314. {
  2315. if (!LLApp::isExiting() && mLibraryOutfitsFetcher)
  2316. {
  2317. gInventory.addObserver(mLibraryOutfitsFetcher);
  2318. mLibraryOutfitsFetcher->done();
  2319. }
  2320. }
  2322. /* virtual */ void fire(const LLUUID& inv_item)
  2323. {
  2324. mFireCount++;
  2325. }
  2326. private:
  2327. U32 mFireCount;
  2328. LLLibraryOutfitsFetch * mLibraryOutfitsFetcher;
  2329. };
  2331. void LLLibraryOutfitsFetch::libraryDone(void)
  2332. {
  2333. // Copy the clothing folders from the library into the imported clothing folder if necessary.
  2334. if (mImportedClothingID == LLUUID::null)
  2335. {
  2336. gInventory.removeObserver(this);
  2337. LLPointer<LLInventoryCallback> copy_waiter = new LLLibraryOutfitsCopyDone(this);
  2338. mImportedClothingID = gInventory.createNewCategory(mClothingID,
  2339.    LLFolderType::FT_NONE,
  2340.    mImportedClothingName);
  2342. for (cloth_folder_vec_t::const_iterator iter = mLibraryClothingFolders.begin();
  2343.  iter != mLibraryClothingFolders.end();
  2344.  ++iter)
  2345. {
  2346. LLUUID folder_id = gInventory.createNewCategory(mImportedClothingID,
  2347. LLFolderType::FT_NONE,
  2348. iter->second);
  2349. LLAppearanceManager::getInstance()->shallowCopyCategoryContents(iter->first, folder_id, copy_waiter);
  2350. }
  2351. }
  2352. else
  2353. {
  2354. // Skip straight to fetching the contents of the imported folder
  2355. importedFolderFetch();
  2356. }
  2357. }
  2359. void LLLibraryOutfitsFetch::importedFolderFetch(void)
  2360. {
  2361. // Fetch the contents of the Imported Clothing Folder
  2362. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  2363. folders.push_back(mImportedClothingID);
  2365. mCompleteFolders.clear();
  2367. fetchDescendents(folders);
  2368. if (isEverythingComplete())
  2369. {
  2370. done();
  2371. }
  2372. }
  2374. void LLLibraryOutfitsFetch::importedFolderDone(void)
  2375. {
  2376. LLInventoryModel::cat_array_t cat_array;
  2377. LLInventoryModel::item_array_t wearable_array;
  2378. LLInventoryFetchDescendentsObserver::folder_ref_t folders;
  2380. // Collect the contents of the Imported Clothing folder
  2381. gInventory.collectDescendents(mImportedClothingID, cat_array, wearable_array, 
  2382.   LLInventoryModel::EXCLUDE_TRASH);
  2384. for (LLInventoryModel::cat_array_t::const_iterator iter = cat_array.begin();
  2385.  iter != cat_array.end();
  2386.  ++iter)
  2387. {
  2388. const LLViewerInventoryCategory *cat = iter->get();
  2390. // Get the name of every imported outfit
  2391. folders.push_back(cat->getUUID());
  2392. mImportedClothingFolders.push_back(std::make_pair(cat->getUUID(), cat->getName()));
  2393. }
  2395. mCompleteFolders.clear();
  2396. fetchDescendents(folders);
  2397. if (isEverythingComplete())
  2398. {
  2399. done();
  2400. }
  2401. }
  2403. void LLLibraryOutfitsFetch::contentsDone(void)
  2404. {
  2405. LLInventoryModel::cat_array_t cat_array;
  2406. LLInventoryModel::item_array_t wearable_array;
  2408. for (cloth_folder_vec_t::const_iterator folder_iter = mImportedClothingFolders.begin();
  2409.  folder_iter != mImportedClothingFolders.end();
  2410.  ++folder_iter)
  2411. {
  2412. // First, make a folder in the My Outfits directory.
  2413. LLUUID new_outfit_folder_id = gInventory.createNewCategory(mMyOutfitsID, LLFolderType::FT_OUTFIT, folder_iter->second);
  2415. cat_array.clear();
  2416. wearable_array.clear();
  2417. // Collect the contents of each imported clothing folder, so we can create new outfit links for it
  2418. gInventory.collectDescendents(folder_iter->first, cat_array, wearable_array, 
  2419.   LLInventoryModel::EXCLUDE_TRASH);
  2421. for (LLInventoryModel::item_array_t::const_iterator wearable_iter = wearable_array.begin();
  2422.  wearable_iter != wearable_array.end();
  2423.  ++wearable_iter)
  2424. {
  2425. const LLViewerInventoryItem *item = wearable_iter->get();
  2426. link_inventory_item(gAgent.getID(),
  2427. item->getLinkedUUID(),
  2428. new_outfit_folder_id,
  2429. item->getName(),
  2430. LLAssetType::AT_LINK,
  2431. NULL);
  2432. }
  2433. }
  2435. mOutfitsPopulated = true;
  2436. }
  2438. //--------------------------------------------------------------------
  2439. // InitialWearablesFetch
  2440. // 
  2441. // This grabs contents from the COF and processes them.
  2442. // The processing is handled in idle(), i.e. outside of done(),
  2443. // to avoid gInventory.notifyObservers recursion.
  2444. //--------------------------------------------------------------------
  2446. LLInitialWearablesFetch::~LLInitialWearablesFetch()
  2447. {
  2448. }
  2450. // virtual
  2451. void LLInitialWearablesFetch::done()
  2452. {
  2453. // Delay processing the actual results of this so it's not handled within
  2454. // gInventory.notifyObservers.  The results will be handled in the next
  2455. // idle tick instead.
  2456. gInventory.removeObserver(this);
  2457. doOnIdle(boost::bind(&LLInitialWearablesFetch::processContents,this));
  2458. }
  2460. void LLInitialWearablesFetch::processContents()
  2461. {
  2462. // Fetch the wearable items from the Current Outfit Folder
  2463. LLInventoryModel::cat_array_t cat_array;
  2464. LLInventoryModel::item_array_t wearable_array;
  2465. LLFindWearables is_wearable;
  2466. gInventory.collectDescendentsIf(mCompleteFolders.front(), cat_array, wearable_array, 
  2467. LLInventoryModel::EXCLUDE_TRASH, is_wearable);
  2469. LLAppearanceManager::instance().setAttachmentInvLinkEnable(true);
  2470. if (wearable_array.count() > 0)
  2471. {
  2472. LLAppearanceManager::instance().updateAppearanceFromCOF();
  2473. }
  2474. else
  2475. {
  2476. // if we're constructing the COF from the wearables message, we don't have a proper outfit link
  2477. LLAppearanceManager::instance().setOutfitDirty(true);
  2478. processWearablesMessage();
  2479. }
  2480. delete this;
  2481. }
  2483. class LLFetchAndLinkObserver: public LLInventoryFetchObserver
  2484. {
  2485. public:
  2486. LLFetchAndLinkObserver(LLInventoryFetchObserver::item_ref_t& ids):
  2487. m_ids(ids),
  2488. LLInventoryFetchObserver(true)
  2489. {
  2490. }
  2491. ~LLFetchAndLinkObserver()
  2492. {
  2493. }
  2494. virtual void done()
  2495. {
  2496. gInventory.removeObserver(this);
  2497. // Link to all fetched items in COF.
  2498. for (LLInventoryFetchObserver::item_ref_t::iterator it = m_ids.begin();
  2499.  it != m_ids.end();
  2500.  ++it)
  2501. {
  2502. LLUUID id = *it;
  2503. LLViewerInventoryItem *item = gInventory.getItem(*it);
  2504. if (!item)
  2505. {
  2506. llwarns << "fetch failed!" << llendl;
  2507. continue;
  2508. }
  2509. link_inventory_item(gAgent.getID(), item->getLinkedUUID(), LLAppearanceManager::instance().getCOF(), item->getName(),
  2510. LLAssetType::AT_LINK, LLPointer<LLInventoryCallback>(NULL));
  2511. }
  2512. }
  2513. private:
  2514. LLInventoryFetchObserver::item_ref_t m_ids;
  2515. };
  2517. void LLInitialWearablesFetch::processWearablesMessage()
  2518. {
  2519. if (!mAgentInitialWearables.empty()) // We have an empty current outfit folder, use the message data instead.
  2520. {
  2521. const LLUUID current_outfit_id = LLAppearanceManager::instance().getCOF();
  2522. LLInventoryFetchObserver::item_ref_t ids;
  2523. for (U8 i = 0; i < mAgentInitialWearables.size(); ++i)
  2524. {
  2525. // Populate the current outfit folder with links to the wearables passed in the message
  2526. InitialWearableData *wearable_data = new InitialWearableData(mAgentInitialWearables[i]); // This will be deleted in the callback.
  2528. if (wearable_data->mAssetID.notNull())
  2529. {
  2530. #ifdef USE_CURRENT_OUTFIT_FOLDER
  2531. ids.push_back(wearable_data->mItemID);
  2532. #endif
  2533. // Fetch the wearables
  2534. LLWearableList::instance().getAsset(wearable_data->mAssetID,
  2535. LLStringUtil::null,
  2536. LLWearableDictionary::getAssetType(wearable_data->mType),
  2537. LLAgentWearables::onInitialWearableAssetArrived, (void*)(wearable_data));
  2538. }
  2539. else
  2540. {
  2541. llinfos << "Invalid wearable, type " << wearable_data->mType << " itemID "
  2542. << wearable_data->mItemID << " assetID " << wearable_data->mAssetID << llendl;
  2543. delete wearable_data;
  2544. }
  2545. }
  2547. // Add all current attachments to the requested items as well.
  2548. LLVOAvatarSelf* avatar = gAgent.getAvatarObject();
  2549. if( avatar )
  2550. {
  2551. for (LLVOAvatar::attachment_map_t::const_iterator iter = avatar->mAttachmentPoints.begin(); 
  2552.  iter != avatar->mAttachmentPoints.end(); ++iter)
  2553. {
  2554. LLViewerJointAttachment* attachment = iter->second;
  2555. if (!attachment) continue;
  2556. for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
  2557.  attachment_iter != attachment->mAttachedObjects.end();
  2558.  ++attachment_iter)
  2559. {
  2560. LLViewerObject* attached_object = (*attachment_iter);
  2561. if (!attached_object) continue;
  2562. const LLUUID& item_id = attached_object->getItemID();
  2563. if (item_id.isNull()) continue;
  2564. ids.push_back(item_id);
  2565. }
  2566. }
  2567. }
  2569. // Need to fetch the inventory items for ids, then create links to them after they arrive.
  2570. LLFetchAndLinkObserver *fetcher = new LLFetchAndLinkObserver(ids);
  2571. fetcher->fetchItems(ids);
  2572. // If no items to be fetched, done will never be triggered.
  2573. // TODO: Change LLInventoryFetchObserver::fetchItems to trigger done() on this condition.
  2574. if (fetcher->isEverythingComplete())
  2575. {
  2576. fetcher->done();
  2577. }
  2578. else
  2579. {
  2580. gInventory.addObserver(fetcher);
  2581. }
  2582. }
  2583. else
  2584. {
  2585. LL_WARNS("Wearables") << "No current outfit folder items found and no initial wearables fallback message received." << LL_ENDL;
  2586. }
  2587. }