Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed the damn header file

Browse Source
This commit is contained in:
Hazim Gazov
2010-04-21 23:56:50 -03:00
parent 584e06208f
commit a7463f4db5
7 changed files with 709 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

310
indra/newview/llfloaterexploreanimations.cpp Normal file
View File

@@ -0,0 +1,310 @@
// <edit>
#include "llviewerprecompiledheaders.h"
#include "llfloaterexploreanimations.h"
#include "lluictrlfactory.h"
#include "llscrolllistctrl.h"
#include "llfloateranimpreview.h"
#include "llvoavatar.h"
#include "lllocalinventory.h"
// <stuff for jelly roll>
#include "llfloatertools.h"
#include "llselectmgr.h"
// </stuff for jelly roll>
std::map<LLUUID, std::list<LLAnimHistoryItem*>> LLFloaterExploreAnimations::animHistory;
LLFloaterExploreAnimations* LLFloaterExploreAnimations::sInstance;
LLAnimHistoryItem::LLAnimHistoryItem(LLUUID assetid)
{
mAssetID = assetid;
}
LLFloaterExploreAnimations::LLFloaterExploreAnimations(LLUUID avatarid)
: LLFloater()
{
LLFloaterExploreAnimations::sInstance = this;
mAvatarID = avatarid;
mAnimPreview = new LLPreviewAnimation(256, 256);
mAnimPreview->setZoom(2.0f);
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_explore_animations.xml");
}
void LLFloaterExploreAnimations::close(bool app_quitting)
{
LLFloater::close(app_quitting);
}
LLFloaterExploreAnimations::~LLFloaterExploreAnimations()
{
delete mAnimPreview;
LLFloaterExploreAnimations::sInstance = NULL;
}
BOOL LLFloaterExploreAnimations::postBuild(void)
{
childSetCommitCallback("anim_list", onSelectAnimation, this);
childSetAction("copy_uuid_btn", onClickCopyUUID, this);
childSetAction("open_btn", onClickOpen, this);
childSetAction("jelly_roll_btn", onClickJellyRoll, this);
update();
return TRUE;
}
void LLFloaterExploreAnimations::update()
{
LLScrollListCtrl* list = getChild<LLScrollListCtrl>("anim_list");
LLUUID selection = list->getSelectedValue().asUUID();
list->clearRows(); // do this differently probably
std::list<LLAnimHistoryItem*> history = animHistory[mAvatarID];
std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
std::list<LLAnimHistoryItem*>::iterator end = history.end();
for( ; iter != end; ++iter)
{
LLAnimHistoryItem* item = (*iter);
LLSD element;
element["id"] = item->mAssetID;
LLSD& name_column = element["columns"][0];
name_column["column"] = "name";
name_column["value"] = item->mAssetID.asString();
LLSD& info_column = element["columns"][1];
info_column["column"] = "info";
if(item->mPlaying)
info_column["value"] = "Playing";
else
info_column["value"] = llformat("%.1f min ago", (LLTimer::getElapsedSeconds() - item->mTimeStopped) / 60.f);
list->addElement(element, ADD_BOTTOM);
}
list->selectByID(selection);
}
void LLFloaterExploreAnimations::draw()
{
LLFloater::draw();
LLRect r = getRect();
gGL.color3f(1.f, 1.f, 1.f);
gGL.getTexUnit(0)->bind(mAnimPreview->getTexture());
gGL.begin( LLRender::QUADS );
{
gGL.texCoord2f(0.f, 1.f);
gGL.vertex2i(r.getWidth() - 266, r.getHeight() - 25);
gGL.texCoord2f(0.f, 0.f);
gGL.vertex2i(r.getWidth() - 266, r.getHeight() - 256);
gGL.texCoord2f(1.f, 0.f);
gGL.vertex2i(r.getWidth() - 10, r.getHeight() - 256);
gGL.texCoord2f(1.f, 1.f);
gGL.vertex2i(r.getWidth() - 10, r.getHeight() - 25);
}
gGL.end();
gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
//LLVOAvatar* avatarp = mAnimPreview->getDummyAvatar();
//if (!avatarp->areAnimationsPaused())
//{
// mAnimPreview->requestUpdate();
//}
}
// static
void LLFloaterExploreAnimations::startAnim(LLUUID avatarid, LLUUID assetid)
{
std::string asset_str = assetid.asString();
if(asset_str.find("17132261-c061") != std::string::npos) return; // dog1
else if(asset_str.find("fea558cb-8b9b") != std::string::npos) return; // dog2
else if(asset_str.find("50cb5750-0743") != std::string::npos) return; // dog3
else if(asset_str.find("-dead-") != std::string::npos) return; // emo
LLAnimHistoryItem* item = NULL;
std::list<LLAnimHistoryItem*> history = animHistory[avatarid];
std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
std::list<LLAnimHistoryItem*>::iterator end = history.end();
for( ; iter != end; ++iter)
{
if((*iter)->mAssetID == assetid)
{
item = (*iter);
break;
}
}
if(!item)
{
item = new LLAnimHistoryItem(assetid);
item->mAvatarID = avatarid;
item->mTimeStarted = LLTimer::getElapsedSeconds();
}
item->mPlaying = true;
history.push_back(item);
animHistory[avatarid] = history; // is this really necessary?
handleHistoryChange();
}
// static
void LLFloaterExploreAnimations::stopAnim(LLUUID avatarid, LLUUID assetid)
{
std::string asset_str = assetid.asString();
if(asset_str.find("17132261-c061") != std::string::npos) return; // dog1
else if(asset_str.find("fea558cb-8b9b") != std::string::npos) return; // dog2
else if(asset_str.find("50cb5750-0743") != std::string::npos) return; // dog3
else if(asset_str.find("-dead-") != std::string::npos) return; // emo
LLAnimHistoryItem* item = NULL;
std::list<LLAnimHistoryItem*> history = animHistory[avatarid];
std::list<LLAnimHistoryItem*>::iterator iter = history.begin();
std::list<LLAnimHistoryItem*>::iterator end = history.end();
for( ; iter != end; ++iter)
{
if((*iter)->mAssetID == assetid)
{
item = (*iter);
break;
}
}
if(!item)
{
item = new LLAnimHistoryItem(assetid);
item->mAvatarID = avatarid;
item->mTimeStarted = LLTimer::getElapsedSeconds();
history.push_back(item);
}
item->mPlaying = false;
item->mTimeStopped = LLTimer::getElapsedSeconds();
handleHistoryChange();
}
class LLAnimHistoryItemCompare
{
public:
bool operator() (LLAnimHistoryItem* first, LLAnimHistoryItem* second)
{
if(first->mPlaying)
{
if(second->mPlaying)
{
return (first->mTimeStarted > second->mTimeStarted);
}
else
{
return true;
}
}
else if(second->mPlaying)
{
return false;
}
else
{
return (first->mTimeStopped > second->mTimeStopped);
}
}
};
// static
void LLFloaterExploreAnimations::handleHistoryChange()
{
std::map<LLUUID, std::list<LLAnimHistoryItem*>>::iterator av_iter = animHistory.begin();
std::map<LLUUID, std::list<LLAnimHistoryItem*>>::iterator av_end = animHistory.end();
for( ; av_iter != av_end; ++av_iter)
{
std::list<LLAnimHistoryItem*> history = (*av_iter).second;
// Sort it
LLAnimHistoryItemCompare c;
history.sort(c);
// Remove dupes
history.unique();
// Trim it
if(history.size() > 32)
{
history.resize(32);
}
animHistory[(*av_iter).first] = history;
}
// Update floater
if(LLFloaterExploreAnimations::sInstance)
LLFloaterExploreAnimations::sInstance->update();
}
// static
void LLFloaterExploreAnimations::onSelectAnimation(LLUICtrl* ctrl, void* user_data)
{
LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)user_data;
LLPreviewAnimation* preview = (LLPreviewAnimation*)floater->mAnimPreview;
LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
LLUUID selection = list->getSelectedValue().asUUID();
preview->getDummyAvatar()->deactivateAllMotions();
preview->getDummyAvatar()->startMotion(selection, 0.f);
preview->setZoom(2.0f);
}
// static
void LLFloaterExploreAnimations::onClickCopyUUID(void* data)
{
LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
LLUUID selection = list->getSelectedValue().asUUID();
gViewerWindow->mWindow->copyTextToClipboard(utf8str_to_wstring(selection.asString()));
}
void LLFloaterExploreAnimations::onClickOpen(void* data)
{
LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
LLUUID selection = list->getSelectedValue().asUUID();
LLUUID item = LLLocalInventory::addItem(selection.asString(), LLAssetType::AT_ANIMATION, selection, true);
}
void LLFloaterExploreAnimations::onClickJellyRoll(void* data)
{
std::string hover_text;
LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
LLObjectSelection::valid_iterator sel_it = selection->valid_begin();
LLObjectSelection::valid_iterator sel_end = selection->valid_end();
for( ; sel_it != sel_end; ++sel_it)
{
LLViewerObject* objectp = (*sel_it)->getObject();
hover_text = objectp->getDebugText();
if(hover_text != "")
{
break;
}
}
LLFloaterExploreAnimations* floater = (LLFloaterExploreAnimations*)data;
LLScrollListCtrl* list = floater->getChild<LLScrollListCtrl>("anim_list");
LLUUID anim_id = list->getSelectedValue().asUUID();
LLFloaterNewLocalInventory* createy = new LLFloaterNewLocalInventory();
createy->childSetText("name_line", hover_text);
createy->childSetText("asset_id_line", anim_id.asString());
createy->childSetValue("type_combo", "animatn");
createy->childSetText("creator_id_line", LLFloaterNewLocalInventory::sLastCreatorId.asString());
}
// </edit>

58
indra/newview/llfloaterexploreanimations.h Normal file
View File

@@ -0,0 +1,58 @@
// <edit>
#ifndef LL_LLFLOATEREXPLOREANIMATIONS_H
#define LL_LLFLOATEREXPLOREANIMATIONS_H
#include "llfloater.h"
#include "llfloateranimpreview.h"
#include "llviewerwindow.h" // gViewerWindow
class LLAnimHistoryItem
{
public:
LLAnimHistoryItem(LLUUID assetid);
LLUUID mAvatarID;
LLUUID mAssetID;
bool mPlaying;
F64 mTimeStarted;
F64 mTimeStopped;
};
class LLFloaterExploreAnimations
: public LLFloater
{
public:
LLFloaterExploreAnimations(LLUUID avatarid);
BOOL postBuild(void);
void close(bool app_quitting);
void update();
LLUUID mAvatarID;
LLPreviewAnimation* mAnimPreview;
private:
virtual ~LLFloaterExploreAnimations();
// static stuff!
public:
static void onSelectAnimation(LLUICtrl* ctrl, void* user_data);
static void onClickCopyUUID(void* data);
static void onClickOpen(void* data);
static void onClickJellyRoll(void* data);
static void startAnim(LLUUID avatarid, LLUUID assetid);
static void stopAnim(LLUUID avatarid, LLUUID assetid);
static std::map<LLUUID, std::list<LLAnimHistoryItem*>> animHistory;
static LLFloaterExploreAnimations* sInstance;
private:
static void handleHistoryChange();
protected:
void draw();
};
#endif
// </edit>

2
indra/newview/llinventorybridge.cpp
View File

@@ -3715,8 +3715,6 @@ std::string LLObjectBridge::getLabelSuffix() const
LLStringUtil::toLower(attachment_point_name); LLStringUtil::toLower(attachment_point_name);
return LLItemBridge::getLabelSuffix() + std::string(" (worn on ") + attachment_point_name + std::string(")"); return LLItemBridge::getLabelSuffix() + std::string(" (worn on ") + attachment_point_name + std::string(")");
} }
else
{
else else
{ {
// <edit> testzone attachpt // <edit> testzone attachpt

121
indra/newview/llinventorymodel.cpp
View File

@@ -59,6 +59,10 @@
#include "llviewercontrol.h" #include "llviewercontrol.h"
#include "llvoavatar.h" #include "llvoavatar.h"
#include "llsdutil.h" #include "llsdutil.h"
// <edit>
#include "llimportobject.h"
#include "llappviewer.h" // gLostItemsRoot
// </edit>
#include <deque> #include <deque>
//#define DIFF_INVENTORY_FILES //#define DIFF_INVENTORY_FILES
@@ -207,6 +211,14 @@ BOOL LLInventoryModel::isObjectDescendentOf(const LLUUID& obj_id,
while(obj) while(obj)
{ {
const LLUUID& parent_id = obj->getParentUUID(); const LLUUID& parent_id = obj->getParentUUID();
// <edit>
if(parent_id == obj->getUUID())
{
// infinite loop... same thing as having no parent, hopefully.
llwarns << "This shit has itself as parent! " << parent_id.asString() << ", " << obj->getName() << llendl;
return FALSE;
}
// </edit>
if( parent_id.isNull() ) if( parent_id.isNull() )
{ {
return FALSE; return FALSE;
@@ -823,12 +835,14 @@ void LLInventoryModel::deleteObject(const LLUUID& id)
// folders, items, etc in a fairly efficient manner. // folders, items, etc in a fairly efficient manner.
void LLInventoryModel::purgeDescendentsOf(const LLUUID& id) void LLInventoryModel::purgeDescendentsOf(const LLUUID& id)
{ {
EHasChildren children = categoryHasChildren(id); // <edit> "Deliberately disobeying you" derf derf
if(children == CHILDREN_NO) //EHasChildren children = categoryHasChildren(id);
{ //if(children == CHILDREN_NO)
llinfos << "Not purging descendents of " << id << llendl; //{
return; // llinfos << "Not purging descendents of " << id << llendl;
} // return;
//}
// </edit>
LLPointer<LLViewerInventoryCategory> cat = getCategory(id); LLPointer<LLViewerInventoryCategory> cat = getCategory(id);
if(cat.notNull()) if(cat.notNull())
{ {
@@ -1383,41 +1397,48 @@ void LLInventoryModel::bulkFetch(std::string url)
if (cat) if (cat)
{ {
if ( LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion()) // <edit> Pre-emptive strike
{ if(!(gInventory.isObjectDescendentOf(cat->getUUID(), gLocalInventoryRoot)))
LLSD folder_sd; {
folder_sd["folder_id"] = cat->getUUID(); // </edit>
folder_sd["owner_id"] = cat->getOwnerID(); if ( LLViewerInventoryCategory::VERSION_UNKNOWN == cat->getVersion())
folder_sd["sort_order"] = (LLSD::Integer)sort_order; {
folder_sd["fetch_folders"] = TRUE; //(LLSD::Boolean)sFullFetchStarted; LLSD folder_sd;
folder_sd["fetch_items"] = (LLSD::Boolean)TRUE; folder_sd["folder_id"] = cat->getUUID();
folder_sd["owner_id"] = cat->getOwnerID();
LL_DEBUGS("Inventory") << " fetching "<<cat->getUUID()<<" with cat owner "<<cat->getOwnerID()<<" and agent" << gAgent.getID() << LL_ENDL; folder_sd["sort_order"] = (LLSD::Integer)sort_order;
//OGPX if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID()) folder_sd["fetch_folders"] = TRUE; //(LLSD::Boolean)sFullFetchStarted;
// for OGP it really doesnt make sense to have the decision about whether to fetch folder_sd["fetch_items"] = (LLSD::Boolean)TRUE;
// from the library or user cap be determined by a hard coded UUID.
// if it isnt an item that belongs to the agent, then fetch from the library LL_DEBUGS("Inventory") << " fetching "<<cat->getUUID()<<" with cat owner "<<cat->getOwnerID()<<" and agent" << gAgent.getID() << LL_ENDL;
if (gAgent.getID() != cat->getOwnerID()) //if i am not the owner, it must be in the library //OGPX if (ALEXANDRIA_LINDEN_ID == cat->getOwnerID())
body_lib["folders"].append(folder_sd); // for OGP it really doesnt make sense to have the decision about whether to fetch
else // from the library or user cap be determined by a hard coded UUID.
body["folders"].append(folder_sd); // if it isnt an item that belongs to the agent, then fetch from the library
folder_count++; if (gAgent.getID() != cat->getOwnerID()) //if i am not the owner, it must be in the library
} body_lib["folders"].append(folder_sd);
if (sFullFetchStarted) else
{ //Already have this folder but append child folders to list. body["folders"].append(folder_sd);
// add all children to queue folder_count++;
parent_cat_map_t::iterator cat_it = gInventory.mParentChildCategoryTree.find(cat->getUUID()); }
if (cat_it != gInventory.mParentChildCategoryTree.end()) if (sFullFetchStarted)
{ { //Already have this folder but append child folders to list.
cat_array_t* child_categories = cat_it->second; // add all children to queue
parent_cat_map_t::iterator cat_it = gInventory.mParentChildCategoryTree.find(cat->getUUID());
for (S32 child_num = 0; child_num < child_categories->count(); child_num++) if (cat_it != gInventory.mParentChildCategoryTree.end())
{ {
sFetchQueue.push_back(child_categories->get(child_num)->getUUID()); cat_array_t* child_categories = cat_it->second;
}
} for (S32 child_num = 0; child_num < child_categories->count(); child_num++)
{
} sFetchQueue.push_back(child_categories->get(child_num)->getUUID());
}
}
}
// <edit>
}
// </edit>
} }
} }
sFetchQueue.pop_front(); sFetchQueue.pop_front();
@@ -1718,7 +1739,10 @@ void LLInventoryModel::addItem(LLViewerInventoryItem* item)
if(item) if(item)
{ {
mItemMap[item->getUUID()] = item; mItemMap[item->getUUID()] = item;
//mInventory[item->getUUID()] = item; // <edit>
if(LLXmlImport::sImportInProgress)
LLXmlImport::onNewItem(item);
// </edit>
} }
} }
@@ -1903,6 +1927,11 @@ bool LLInventoryModel::isCategoryComplete(const LLUUID& cat_id) const
return true; return true;
} }
} }
// <edit>
if((cat_id == gLocalInventoryRoot) || gInventory.isObjectDescendentOf(cat_id, gLocalInventoryRoot)) return true;
// </edit>
return false; return false;
} }
@@ -3457,9 +3486,11 @@ bool LLInventoryCollectFunctor::itemTransferCommonlyAllowed(LLInventoryItem* ite
switch(item->getType()) switch(item->getType())
{ {
case LLAssetType::AT_CALLINGCARD: {
// not allowed // <edit> I don't even think changing this did anything
break; //case LLAssetType::AT_CALLINGCARD:
// // not allowed
// break;
case LLAssetType::AT_OBJECT: case LLAssetType::AT_OBJECT:
my_avatar = gAgent.getAvatarObject(); my_avatar = gAgent.getAvatarObject();

12
indra/newview/llinventorymodel.h
View File

@@ -385,8 +385,14 @@ protected:
// the internal data structures are consistent. These methods // the internal data structures are consistent. These methods
// should be passed pointers of newly created objects, and the // should be passed pointers of newly created objects, and the
// instance will take over the memory management from there. // instance will take over the memory management from there.
// <edit>
public:
// </edit>
void addCategory(LLViewerInventoryCategory* category); void addCategory(LLViewerInventoryCategory* category);
void addItem(LLViewerInventoryItem* item); void addItem(LLViewerInventoryItem* item);
// <edit>
protected:
// </edit>
// Internal method which looks for a category with the specified // Internal method which looks for a category with the specified
// preferred type. Returns LLUUID::null if not found // preferred type. Returns LLUUID::null if not found
@@ -402,12 +408,18 @@ protected:
//void recalculateCloneInformation(); //void recalculateCloneInformation();
// file import/export. // file import/export.
// <edit>
public:
// </edit>
static bool loadFromFile(const std::string& filename, static bool loadFromFile(const std::string& filename,
cat_array_t& categories, cat_array_t& categories,
item_array_t& items); item_array_t& items);
static bool saveToFile(const std::string& filename, static bool saveToFile(const std::string& filename,
const cat_array_t& categories, const cat_array_t& categories,
const item_array_t& items); const item_array_t& items);
// <edit>
protected:
// </edit>
// message handling functionality // message handling functionality
//static void processUseCachedInventory(LLMessageSystem* msg, void**); //static void processUseCachedInventory(LLMessageSystem* msg, void**);

250
indra/newview/llvoavatar.cpp
View File

@@ -83,6 +83,11 @@
#include "llvoiceclient.h" #include "llvoiceclient.h"
#include "llvoicevisualizer.h" // Ventrella #include "llvoicevisualizer.h" // Ventrella
// <edit>
#include "llfloaterexploreanimations.h"
//#include "llao.h"
// </edit>
#if LL_MSVC #if LL_MSVC
// disable boost::lexical_cast warning // disable boost::lexical_cast warning
#pragma warning (disable:4702) #pragma warning (disable:4702)
@@ -747,7 +752,14 @@ LLVOAvatar::LLVOAvatar(const LLUUID& id,
mNeedsSkin(FALSE), mNeedsSkin(FALSE),
mUpdatePeriod(1), mUpdatePeriod(1),
mFullyLoadedInitialized(FALSE), mFullyLoadedInitialized(FALSE),
mHasBakedHair( FALSE ) mHasBakedHair( FALSE ),
// <edit>
mNametagSaysIdle(false),
mIdleForever(true),
mIdleMinutes(0),
mFocusObject(LLUUID::null),
mFocusVector(LLVector3d::zero)
// </edit>
{ {
LLMemType mt(LLMemType::MTYPE_AVATAR); LLMemType mt(LLMemType::MTYPE_AVATAR);
//VTResume(); // VTune //VTResume(); // VTune
@@ -3061,9 +3073,11 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
new_name = TRUE; new_name = TRUE;
} }
LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" ); }
avatar_name_color.setAlpha(alpha);
mNameText->setColor(avatar_name_color); // <edit>
//LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
//avatar_name_color.setAlpha(alpha);
LLQuaternion root_rot = mRoot.getWorldRotation(); LLQuaternion root_rot = mRoot.getWorldRotation();
mNameText->setUsePixelSize(TRUE); mNameText->setUsePixelSize(TRUE);
@@ -3144,6 +3158,108 @@ void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last)
line += lastname->getString(); line += lastname->getString();
BOOL need_comma = FALSE; BOOL need_comma = FALSE;
BOOL need_comma = FALSE;
// <edit>
if(getTEImage(TEX_HEAD_BODYPAINT)->isMissingAsset())
{
mNameText->setColor(LLColor4(1.f, 1.0f, 1.0f));
strcat(line, " (Unknown viewer)");
}
else
{
std::string uuid_str = getTEImage(TEX_HEAD_BODYPAINT)->getID().asString();
if(uuid_str == "ccda2b3b-e72c-a112-e126-fee238b67218")
{
// textures other than head are 4934f1bf-3b1f-cf4f-dbdf-a72550d05bc6
mNameText->setColor(LLColor4(0.f, 1.0f, 0.0f));
strcat(line, " (Emerald)");
}
else if(uuid_str == "0bcd5f5d-a4ce-9ea4-f9e8-15132653b3d8")
{
mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
strcat(line, " (MoyMix)");
}
else if(uuid_str == "5855f37d-63e5-3918-1404-8ffa3820eb6d")
{
mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
strcat(line, " (MoyMix/B)");
}
else if(uuid_str == "9ba526b6-f43d-6b60-42de-ce62a25ee7fb")
{
mNameText->setColor(LLColor4(1.0f, 0.3f, 0.5f));
strcat(line, " (MoyMix/nolife)");
}
//else if(uuid_str == "abbca853-30ba-49c1-a1e7-2a5b9a70573f")
//{
// mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
// strcat(line, " (CryoLife/" + "A)");
//}
else if(uuid_str == "0f6723d2-5b23-6b58-08ab-308112b33786")
{
mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
strcat(line, " (CryoLife)");
}
else if(uuid_str == "2c9c1e0b-e5d1-263e-16b1-7fc6d169f3d6")
{
mNameText->setColor(LLColor4(0.5f, 0.75f, 1.0f));
strcat(line, " (Phoxy SL)");
}
else if(uuid_str == "c252d89d-6f7c-7d90-f430-d140d2e3fbbe")
{
mNameText->setColor(LLColor4(0.7f, 0.7f, 0.7f));
strcat(line, " (VLife)");
}
else if(uuid_str == "5aa5c70d-d787-571b-0495-4fc1bdef1500")
{
mNameText->setColor(LLColor4(1.f, 0.0f, 0.0f));
strcat(line, " (GridProxy/LordGregGreg)");
}
else if(uuid_str == "8183e823-c443-2142-6eb6-2ab763d4f81c")
{
mNameText->setColor(LLColor4(1.f, 1.f, 0.0f));
strcat(line, " (GridProxy/DayOh)");
}
else if(uuid_str == "f3fd74a6-fee7-4b2f-93ae-ddcb5991da04")
{
mNameText->setColor(LLColor4(1.0f, 0.0f, 1.0f));
strcat(line, " (PSL/A)");
}
else if(uuid_str == "77662f23-c77a-9b4d-5558-26b757b2144c")
{
mNameText->setColor(LLColor4(1.0f, 0.0f, 1.0f));
strcat(line, " (PSL/B)");
}
else if(uuid_str == "1c29480c-c608-df87-28bb-964fb64c5366")
{
mNameText->setColor(LLColor4(1.f, 1.0f, 1.0f));
strcat(line, " (Emerald/GEMINI)");
}
else if(uuid_str == "5262d71a-88f7-ef40-3b15-00ea148ab4b5")
{
mNameText->setColor(LLColor4(0.9f, 0.9f, 0.9f));
strcat(line, " (GEMINI Bot)");
}
else if(uuid_str == "adcbe893-7643-fd12-f61c-0b39717e2e32")
{
mNameText->setColor(LLColor4(1.0f, 0.5f, 0.4f));
strcat(line, " (tyk3n)");
}
else if(uuid_str == "f5a48821-9a98-d09e-8d6a-50cc08ba9a47")
{
mNameText->setColor(gColors.getColor( "AvatarNameColor" ));
strcat(line, " (NeilLife)");
}
else
{
LLColor4 avatar_name_color = gColors.getColor( "AvatarNameColor" );
avatar_name_color.setAlpha(1.f);
mNameText->setColor(avatar_name_color);
}
}
// </edit>
if (is_away || is_muted || is_busy) if (is_away || is_muted || is_busy)
{ {
line += " ("; line += " (";
@@ -3301,6 +3417,14 @@ void LLVOAvatar::idleUpdateTractorBeam()
{ {
return; return;
} }
// <edit>
if(gSavedSettings.getBOOL("DisablePointAtAndBeam"))
{
return;
}
// </edit>
const LLPickInfo& pick = gViewerWindow->getLastPick(); const LLPickInfo& pick = gViewerWindow->getLastPick();
// No beam for media textures // No beam for media textures
@@ -4729,6 +4853,9 @@ void LLVOAvatar::processAnimationStateChanges()
if (found_anim == mSignaledAnimations.end()) if (found_anim == mSignaledAnimations.end())
{ {
processSingleAnimationStateChange(anim_it->first, FALSE); processSingleAnimationStateChange(anim_it->first, FALSE);
// <edit>
LLFloaterExploreAnimations::stopAnim(getID(), anim_it->first);
// </edit>
mPlayingAnimations.erase(anim_it++); mPlayingAnimations.erase(anim_it++);
continue; continue;
} }
@@ -4744,6 +4871,9 @@ void LLVOAvatar::processAnimationStateChanges()
// signaled but not playing, or different sequence id, start motion // signaled but not playing, or different sequence id, start motion
if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second) if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second)
{ {
// <edit>
LLFloaterExploreAnimations::startAnim(getID(), anim_it->first);
// </edit>
if (processSingleAnimationStateChange(anim_it->first, TRUE)) if (processSingleAnimationStateChange(anim_it->first, TRUE))
{ {
mPlayingAnimations[anim_it->first] = anim_it->second; mPlayingAnimations[anim_it->first] = anim_it->second;
@@ -5983,9 +6113,43 @@ LLViewerJointAttachment* LLVOAvatar::getTargetAttachmentPoint(LLViewerObject* vi
// attachObject() // attachObject()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
BOOL LLVOAvatar::attachObject(LLViewerObject *viewer_object) BOOL LLVOAvatar::attachObject(LLViewerObject *viewer_object)
{ {
LLViewerJointAttachment* attachment = getTargetAttachmentPoint(viewer_object); LLViewerJointAttachment* attachment = getTargetAttachmentPoint(viewer_object);
// <edit> testzone attachpt
if(!attachment)
{
S32 attachmentID = ATTACHMENT_ID_FROM_STATE(viewer_object->getState());
LLUUID item_id;
LLNameValue* item_id_nv = viewer_object->getNVPair("AttachItemID");
if( item_id_nv )
{
const char* s = item_id_nv->getString();
if(s)
item_id.set(s);
}
if(!item_id.isNull())
{
mUnsupportedAttachmentPoints[attachmentID] = item_id;
if (viewer_object->isSelected())
{
LLSelectMgr::getInstance()->updateSelectionCenter();
LLSelectMgr::getInstance()->updatePointAt();
}
if (mIsSelf)
{
updateAttachmentVisibility(gAgent.getCameraMode());
// Then make sure the inventory is in sync with the avatar.
gInventory.addChangedMask( LLInventoryObserver::LABEL, item_id );
gInventory.notifyObservers();
}
}
else
llwarns << "No item ID" << llendl;
}
// </edit>
if (!attachment || !attachment->addObject(viewer_object)) if (!attachment || !attachment->addObject(viewer_object))
{ {
return FALSE; return FALSE;
@@ -6094,8 +6258,57 @@ BOOL LLVOAvatar::detachObject(LLViewerObject *viewer_object)
} }
return TRUE; return TRUE;
} }
} }
// <edit> testzone attachpt
LLUUID item_id;
LLNameValue* item_id_nv = viewer_object->getNVPair("AttachItemID");
if( item_id_nv )
{
const char* s = item_id_nv->getString();
if(s)
item_id.set(s);
}
if(!item_id.isNull())
{
std::map<S32, LLUUID>::iterator iter = mUnsupportedAttachmentPoints.begin();
std::map<S32, LLUUID>::iterator end = mUnsupportedAttachmentPoints.end();
for( ; iter != end; ++iter)
{
if((*iter).second == item_id)
{
mUnsupportedAttachmentPoints.erase((*iter).first);
if (mIsSelf)
{
// the simulator should automatically handle
// permission revocation
stopMotionFromSource(viewer_object->getID());
LLFollowCamMgr::setCameraActive(viewer_object->getID(), FALSE);
LLViewerObject::const_child_list_t& child_list = viewer_object->getChildren();
for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
iter != child_list.end(); iter++)
{
LLViewerObject* child_objectp = *iter;
// the simulator should automatically handle
// permissions revocation
stopMotionFromSource(child_objectp->getID());
LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE);
}
// Then make sure the inventory is in sync with the avatar.
gInventory.addChangedMask(LLInventoryObserver::LABEL, item_id);
gInventory.notifyObservers();
}
return TRUE;
}
}
llwarns << "Not found" << llendl;
}
else
llwarns << "No item ID" << llendl;
// </edit>
return FALSE; return FALSE;
} }
@@ -6257,8 +6470,16 @@ BOOL LLVOAvatar::isWearingAttachment( const LLUUID& inv_item_id )
} }
} }
return FALSE; return FALSE;
} }
// <edit> testzone attachpt
BOOL LLVOAvatar::isWearingUnsupportedAttachment( const LLUUID& inv_item_id )
{
std::map<S32, LLUUID>::iterator end = mUnsupportedAttachmentPoints.end();
for(std::map<S32, LLUUID>::iterator iter = mUnsupportedAttachmentPoints.begin(); iter != end; ++iter)
if((*iter).second == inv_item_id)
return TRUE;
return FALSE;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// getWornAttachment() // getWornAttachment()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -8508,8 +8729,11 @@ void LLVOAvatar::dumpLocalTextures()
llinfos << "LocTex " << name << ": " llinfos << "LocTex " << name << ": "
<< "Discard " << image->getDiscardLevel() << ", " << "Discard " << image->getDiscardLevel() << ", "
<< "(" << image->getWidth() << ", " << image->getHeight() << ") " << "(" << image->getWidth() << ", " << image->getHeight() << ") "
#if !LL_RELEASE_FOR_DOWNLOAD // <edit>
//#if !LL_RELEASE_FOR_DOWNLOAD
#if 1
// </edit>
// End users don't get to trivially see avatar texture IDs, // End users don't get to trivially see avatar texture IDs,
// makes textures easier to steal // makes textures easier to steal
<< image->getID() << " " << image->getID() << " "

42
indra/newview/llvoavatar.h
View File

@@ -283,6 +283,9 @@ public:
void getOffObject(); void getOffObject();
BOOL isWearingAttachment( const LLUUID& inv_item_id ); BOOL isWearingAttachment( const LLUUID& inv_item_id );
// <edit> testzone attachpt
BOOL isWearingUnsupportedAttachment( const LLUUID& inv_item_id );
// </edit>
LLViewerObject* getWornAttachment( const LLUUID& inv_item_id ); LLViewerObject* getWornAttachment( const LLUUID& inv_item_id );
const std::string getAttachedPointName(const LLUUID& inv_item_id); const std::string getAttachedPointName(const LLUUID& inv_item_id);
@@ -578,6 +581,10 @@ private:
const static LLUUID sStepSounds[LL_MCODE_END]; const static LLUUID sStepSounds[LL_MCODE_END];
const static LLUUID sStepSoundOnLand; const static LLUUID sStepSoundOnLand;
// <edit>
std::map<S32, LLUUID> mUnsupportedAttachmentPoints;
// </edit>
// Xml parse tree of avatar config file // Xml parse tree of avatar config file
static LLXmlTree sXMLTree; static LLXmlTree sXMLTree;
// Xml parse tree of avatar skeleton file // Xml parse tree of avatar skeleton file
@@ -678,32 +685,15 @@ protected:
S32 getLocalDiscardLevel(LLVOAvatarDefines::ETextureIndex index); S32 getLocalDiscardLevel(LLVOAvatarDefines::ETextureIndex index);
public: public:
static void updateFreezeCounter(S32 counter = 0 ); static void updateFreezeCounter(S32 counter = 0 );
private: // <edit>
static S32 sFreezeCounter; //bool mNametagSaysIdle;
//bool mIdleForever;
//----------------------------------------------------------------------------------------------- //LLFrameTimer mIdleTimer;
// Avatar skeleton setup. //U32 mIdleMinutes;
//----------------------------------------------------------------------------------------------- LLUUID mFocusObject;
private: LLVector3d mFocusVector;
BOOL loadAvatar(); //void resetIdleTime();
BOOL setupBone(const LLVOAvatarBoneInfo* info, LLViewerJoint* parent, S32 &current_volume_num, S32 &current_joint_num); // </edit>
BOOL buildSkeleton(const LLVOAvatarSkeletonInfo *info);
//-----------------------------------------------------------------------------------------------
// Per-avatar information about texture data.
// To-do: Move this to private implementation class
//-----------------------------------------------------------------------------------------------
private:
struct BakedTextureData
{
LLUUID mLastTextureIndex;
LLTexLayerSet* mTexLayerSet;
bool mIsLoaded;
bool mIsUsed;
LLVOAvatarDefines::ETextureIndex mTextureIndex;
U32 mMaskTexName;
// Stores pointers to the joint meshes that this baked texture deals with
std::vector< LLViewerJointMesh * > mMeshes; // std::vector<LLViewerJointMesh> mJoints[i]->mMeshParts
}; };
typedef std::vector<BakedTextureData> bakedtexturedata_vec_t; typedef std::vector<BakedTextureData> bakedtexturedata_vec_t;
bakedtexturedata_vec_t mBakedTextureData; bakedtexturedata_vec_t mBakedTextureData;