From c55c7339ea950034d56ef61bdf34b450c28b510f Mon Sep 17 00:00:00 2001 From: McCabe Maxsted Date: Tue, 30 Mar 2010 22:53:55 -0700 Subject: Ported clientside AO from Emerald r1633 --- linden/indra/newview/CMakeLists.txt | 3 + linden/indra/newview/app_settings/settings.xml | 85 ++ linden/indra/newview/floaterao.cpp | 1358 ++++++++++++++++++++ linden/indra/newview/floaterao.h | 127 ++ linden/indra/newview/llagent.cpp | 4 +- linden/indra/newview/llviewermenu.cpp | 12 + linden/indra/newview/llvoavatar.cpp | 28 + .../newview/skins/default/xui/de/floater_ao.xml | 95 ++ .../newview/skins/default/xui/en-us/floater_ao.xml | 231 ++++ .../skins/default/xui/en-us/menu_viewer.xml | 5 + 10 files changed, 1947 insertions(+), 1 deletion(-) create mode 100644 linden/indra/newview/floaterao.cpp create mode 100644 linden/indra/newview/floaterao.h create mode 100644 linden/indra/newview/skins/default/xui/de/floater_ao.xml create mode 100644 linden/indra/newview/skins/default/xui/en-us/floater_ao.xml (limited to 'linden/indra') diff --git a/linden/indra/newview/CMakeLists.txt b/linden/indra/newview/CMakeLists.txt index 514811d..b339947 100644 --- a/linden/indra/newview/CMakeLists.txt +++ b/linden/indra/newview/CMakeLists.txt @@ -66,6 +66,7 @@ include_directories( set(viewer_SOURCE_FILES emeraldboobutils.cpp + floaterao.cpp floaterlogin.cpp hippoGridManager.cpp hippoLimits.cpp @@ -488,6 +489,7 @@ set(viewer_HEADER_FILES CMakeLists.txt ViewerInstall.cmake emeraldboobutils.h + floaterao.h floaterlogin.h hippoGridManager.h hippoLimits.h @@ -1082,6 +1084,7 @@ set(viewer_XUI_FILES skins/default/xui/en-us/floater_active_speakers.xml skins/default/xui/en-us/floater_animation_list.xml skins/default/xui/en-us/floater_animation_preview.xml + skins/default/xui/en-us/floater_ao.xml skins/default/xui/en-us/floater_asset_browser.xml skins/default/xui/en-us/floater_auction.xml skins/default/xui/en-us/floater_audio_volume.xml diff --git a/linden/indra/newview/app_settings/settings.xml b/linden/indra/newview/app_settings/settings.xml index 3026cc7..3cb13bb 100644 --- a/linden/indra/newview/app_settings/settings.xml +++ b/linden/indra/newview/app_settings/settings.xml @@ -2,6 +2,91 @@ + + + AOEnabled + + Comment + Turn on Animation Overrider + Persist + 1 + Type + Boolean + Value + 0 + + AOAdvanced + + Comment + Advanced options + Persist + 0 + Type + Boolean + Value + 0 + + AOSitsEnabled + + Comment + Overrides sit animations. + Persist + 1 + Type + Boolean + Value + 1 + + AONoStandsInMouselook + + Comment + Disables stand anims during mouselook + Persist + 1 + Type + Boolean + Value + 1 + + AOStandInterval + + Comment + AO stand time in seconds + Persist + 1 + Type + F32 + Value + 20 + + AOStandRandomize + + Comment + Randomize stand anims + Persist + 1 + Type + Boolean + Value + 0 + + AORect + + Comment + Rectangle for AO window + Persist + 1 + Type + Rect + Value + + 0 + 100 + 100 + 100 + + + ShowClientNameTag diff --git a/linden/indra/newview/floaterao.cpp b/linden/indra/newview/floaterao.cpp new file mode 100644 index 0000000..e3083d3 --- /dev/null +++ b/linden/indra/newview/floaterao.cpp @@ -0,0 +1,1358 @@ +/** + * @file llfloaterao.cpp + * @brief clientside animation overrider + * by Skills Hak + */ + +#include "llviewerprecompiledheaders.h" + +#include "floaterao.h" + +#include "llagent.h" +#include "llvoavatar.h" +#include "llanimationstates.h" +#include "lluictrlfactory.h" +#include "llinventoryview.h" +#include "llstartup.h" +#include "llpreviewnotecard.h" +#include "llviewertexteditor.h" +#include "llcheckboxctrl.h" +#include "llcombobox.h" +#include "llspinctrl.h" +// Uncomment and use instead if we ever add the chatbar as a command line - MC +//#include "chatbar_as_cmdline.h" +#include "llfloaterchat.h" + +#include "llinventory.h" +#include "llinventoryview.h" +#include "roles_constants.h" +#include "llviewerregion.h" + +#include "llpanelinventory.h" +#include "llinventorybridge.h" + +#include "llboost.h" +#include + +// Uncomment and use instead if we ever add the chatbar as a command line - MC +//void cmdline_printchat(std::string message); +void cmdline_printchat(std::string message) +{ + LLChat chat; + chat.mText = message; + chat.mSourceType = CHAT_SOURCE_SYSTEM; + LLFloaterChat::addChat(chat, FALSE, FALSE); +} + + +// ------------------------------------------------------- + +AOStandTimer* mAOStandTimer; + +AOStandTimer::AOStandTimer() : LLEventTimer( gSavedSettings.getF32("AOStandInterval") ) +{ + AOStandTimer::tick(); +} +AOStandTimer::~AOStandTimer() +{ +// llinfos << "dead" << llendl; +} +void AOStandTimer::reset() +{ + mPeriod = gSavedSettings.getF32("AOStandInterval"); + mEventTimer.reset(); +// llinfos << "reset" << llendl; +} +BOOL AOStandTimer::tick() +{ + LLFloaterAO::stand_iterator++; +// llinfos << "tick" << llendl; + LLFloaterAO::ChangeStand(); + return FALSE; +// return LLFloaterAO::ChangeStand(); //timer is always active now .. +} + +// ------------------------------------------------------- + +AOInvTimer::AOInvTimer() : LLEventTimer( (F32)1.0 ) +{ +} +AOInvTimer::~AOInvTimer() +{ +} +BOOL AOInvTimer::tick() +{ + if (!(gSavedSettings.getBOOL("AOEnabled"))) return TRUE; + if(LLStartUp::getStartupState() >= STATE_INVENTORY_SEND) + { + if(gInventory.isEverythingFetched()) + { +// cmdline_printchat("Inventory fetched, loading AO."); + LLFloaterAO::init(); + return TRUE; + } + } + return FALSE; +} +// NC DROP ------------------------------------------------------- + +class AONoteCardDropTarget : public LLView +{ +public: + AONoteCardDropTarget(const std::string& name, const LLRect& rect, void (*callback)(LLViewerInventoryItem*)); + ~AONoteCardDropTarget(); + + void doDrop(EDragAndDropType cargo_type, void* cargo_data); + + // + // LLView functionality + virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, + EDragAndDropType cargo_type, + void* cargo_data, + EAcceptance* accept, + std::string& tooltip_msg); +protected: + void (*mDownCallback)(LLViewerInventoryItem*); +}; + + +AONoteCardDropTarget::AONoteCardDropTarget(const std::string& name, const LLRect& rect, + void (*callback)(LLViewerInventoryItem*)) : + LLView(name, rect, NOT_MOUSE_OPAQUE, FOLLOWS_ALL), + mDownCallback(callback) +{ +} + +AONoteCardDropTarget::~AONoteCardDropTarget() +{ +} + +void AONoteCardDropTarget::doDrop(EDragAndDropType cargo_type, void* cargo_data) +{ +// llinfos << "AONoteCardDropTarget::doDrop()" << llendl; +} + +BOOL AONoteCardDropTarget::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, + EDragAndDropType cargo_type, + void* cargo_data, + EAcceptance* accept, + std::string& tooltip_msg) +{ + BOOL handled = FALSE; + if(getParent()) + { + handled = TRUE; + LLViewerInventoryItem* inv_item = (LLViewerInventoryItem*)cargo_data; + if(gInventory.getItem(inv_item->getUUID())) + { + *accept = ACCEPT_YES_COPY_SINGLE; + if(drop) + { + mDownCallback(inv_item); + } + } + else + { + *accept = ACCEPT_NO; + } + } + return handled; +} + +AONoteCardDropTarget * LLFloaterAO::mAOItemDropTarget; + + +// STUFF ------------------------------------------------------- + +int LLFloaterAO::mAnimationState = 0; +int LLFloaterAO::stand_iterator = 0; + +LLUUID LLFloaterAO::invfolderid = LLUUID::null; +LLUUID LLFloaterAO::mCurrentStandId = LLUUID::null; + +LLComboBox* mcomboBox_stands; +LLComboBox* mcomboBox_walks; +LLComboBox* mcomboBox_runs; +LLComboBox* mcomboBox_jumps; +LLComboBox* mcomboBox_sits; +LLComboBox* mcomboBox_gsits; +LLComboBox* mcomboBox_crouchs; +LLComboBox* mcomboBox_cwalks; +LLComboBox* mcomboBox_falls; +LLComboBox* mcomboBox_hovers; +LLComboBox* mcomboBox_flys; +LLComboBox* mcomboBox_flyslows; +LLComboBox* mcomboBox_flyups; +LLComboBox* mcomboBox_flydowns; +LLComboBox* mcomboBox_lands; +LLComboBox* mcomboBox_standups; +LLComboBox* mcomboBox_prejumps; + +struct struct_overrides +{ + LLUUID orig_id; + LLUUID ao_id; + int state; +}; +std::vector mAOOverrides; + +struct struct_stands +{ + LLUUID ao_id; + std::string anim_name; +}; +std::vector mAOStands; + +struct struct_tokens +{ + std::string token; + int state; +}; +std::vector mAOTokens; + +LLFloaterAO* LLFloaterAO::sInstance = NULL; + +LLFloaterAO::LLFloaterAO() +:LLFloater(std::string("floater_ao")) +{ +// init(); + llassert_always(sInstance == NULL); + LLUICtrlFactory::getInstance()->buildFloater(this, "floater_ao.xml"); + sInstance = this; +} + +LLFloaterAO::~LLFloaterAO() +{ + sInstance=NULL; + mcomboBox_stands = 0; + mcomboBox_walks = 0; + mcomboBox_runs = 0; + mcomboBox_jumps = 0; + mcomboBox_sits = 0; + mcomboBox_gsits = 0; + mcomboBox_crouchs = 0; + mcomboBox_cwalks = 0; + mcomboBox_falls = 0; + mcomboBox_hovers = 0; + mcomboBox_flys = 0; + mcomboBox_flyslows = 0; + mcomboBox_flyups = 0; + mcomboBox_flydowns = 0; + mcomboBox_lands = 0; + mcomboBox_standups = 0; + mcomboBox_prejumps = 0; + delete mAOItemDropTarget; + mAOItemDropTarget = NULL; +// llinfos << "floater destroyed" << llendl; +} + +void LLFloaterAO::show(void*) +{ + if (!sInstance) + sInstance = new LLFloaterAO(); + updateLayout(sInstance); + init(); + + sInstance->open(); +} + +BOOL LLFloaterAO::postBuild() +{ + LLView *target_view = getChild("ao_notecard"); + if(target_view) + { + if (mAOItemDropTarget) + { + delete mAOItemDropTarget; + } + mAOItemDropTarget = new AONoteCardDropTarget("drop target", target_view->getRect(), AOItemDrop);//, mAvatarID); + addChild(mAOItemDropTarget); + } + if(LLStartUp::getStartupState() == STATE_STARTED) + { + LLUUID itemidimport = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID"); + LLViewerInventoryItem* itemimport = gInventory.getItem(itemidimport); + if(itemimport) + { + childSetValue("ao_nc_text","Currently set to: "+itemimport->getName()); + } + else if(itemidimport.isNull()) + { + childSetValue("ao_nc_text","Currently not set"); + } + else + { + childSetValue("ao_nc_text","Currently set to a item not on this account"); + } + } + else + { + childSetValue("ao_nc_text","Not logged in"); + } + childSetAction("more_btn", onClickMore, this); + childSetAction("less_btn", onClickLess, this); + + childSetAction("reloadcard",onClickReloadCard,this); + childSetAction("opencard",onClickOpenCard,this); + childSetAction("prevstand",onClickPrevStand,this); + childSetAction("nextstand",onClickNextStand,this); + childSetCommitCallback("AOEnabled",onClickToggleAO); + childSetCommitCallback("AOSitsEnabled",onClickToggleSits); + childSetCommitCallback("standtime",onSpinnerCommit); + mcomboBox_stands = getChild("stands"); + mcomboBox_walks = getChild("walks"); + mcomboBox_runs = getChild("runs"); + mcomboBox_jumps = getChild("jumps"); + mcomboBox_sits = getChild("sits"); + mcomboBox_gsits = getChild("gsits"); + mcomboBox_crouchs = getChild("crouchs"); + mcomboBox_cwalks = getChild("cwalks"); + mcomboBox_falls = getChild("falls"); + mcomboBox_hovers = getChild("hovers"); + mcomboBox_flys = getChild("flys"); + mcomboBox_flyslows = getChild("flyslows"); + mcomboBox_flyups = getChild("flyups"); + mcomboBox_flydowns = getChild("flydowns"); + mcomboBox_lands = getChild("lands"); + mcomboBox_standups = getChild("standups"); + mcomboBox_prejumps = getChild("prejumps"); + getChild("stands")->setCommitCallback(onComboBoxCommit); + getChild("walks")->setCommitCallback(onComboBoxCommit); + getChild("runs")->setCommitCallback(onComboBoxCommit); + getChild("jumps")->setCommitCallback(onComboBoxCommit); + getChild("sits")->setCommitCallback(onComboBoxCommit); + getChild("gsits")->setCommitCallback(onComboBoxCommit); + getChild("crouchs")->setCommitCallback(onComboBoxCommit); + getChild("cwalks")->setCommitCallback(onComboBoxCommit); + getChild("falls")->setCommitCallback(onComboBoxCommit); + getChild("hovers")->setCommitCallback(onComboBoxCommit); + getChild("flys")->setCommitCallback(onComboBoxCommit); + getChild("flyslows")->setCommitCallback(onComboBoxCommit); + getChild("flyups")->setCommitCallback(onComboBoxCommit); + getChild("flydowns")->setCommitCallback(onComboBoxCommit); + getChild("lands")->setCommitCallback(onComboBoxCommit); + getChild("standups")->setCommitCallback(onComboBoxCommit); + getChild("prejumps")->setCommitCallback(onComboBoxCommit); + + return TRUE; +} + +void LLFloaterAO::onSpinnerCommit(LLUICtrl* ctrl, void* userdata) +{ + LLSpinCtrl* spin = (LLSpinCtrl*) ctrl; + if(spin) + { + if (spin->getName() == "standtime") + { + if (mAOStandTimer) mAOStandTimer->reset(); + } + } +} + +void LLFloaterAO::onComboBoxCommit(LLUICtrl* ctrl, void* userdata) +{ + LLComboBox* box = (LLComboBox*)ctrl; + if(box) + { + if (box->getName() == "stands") + { + stand_iterator = box->getCurrentIndex(); + cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str())); + ChangeStand(); + } + else + { + int state = STATE_AGENT_IDLE; + std::string stranim = box->getValue().asString(); +// llinfos << "state " << (gAgent.getAvatarObject()->mIsSitting) << " - " << getAnimationState() << llendl; + if (box->getName() == "walks") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_WALK), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultWalk",stranim); + state = STATE_AGENT_WALK; + } + else if (box->getName() == "runs") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_RUN), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultRun",stranim); + state = STATE_AGENT_RUN; + } + else if (box->getName() == "jumps") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_JUMP), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultJump",stranim); + state = STATE_AGENT_JUMP; + } + else if (box->getName() == "sits") + { + if (gAgent.getAvatarObject() && (gSavedSettings.getBOOL("AOEnabled")) && (gSavedSettings.getBOOL("AOSitsEnabled"))) + { + if ((gAgent.getAvatarObject()->mIsSitting) && (getAnimationState() == STATE_AGENT_SIT)) + { +// llinfos << "sitting " << GetAnimID(ANIM_AGENT_SIT) << " " << getAssetIDByName(stranim) << llendl; + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_SIT), ANIM_REQUEST_STOP); + gAgent.sendAnimationRequest(getAssetIDByName(stranim), ANIM_REQUEST_START); + } + } + gSavedPerAccountSettings.setString("AODefaultSit",stranim); + state = STATE_AGENT_SIT; + } + else if (box->getName() == "gsits") + { +// llinfos << "gsitting " << GetAnimID(ANIM_AGENT_SIT_GROUND) << " " << getAssetIDByName(stranim) << llendl; + if (gAgent.getAvatarObject()) + { + if ((gAgent.getAvatarObject()->mIsSitting) && (getAnimationState() == STATE_AGENT_GROUNDSIT)) + { +// llinfos << "gsitting " << GetAnimID(ANIM_AGENT_SIT_GROUND) << " " << getAssetIDByName(stranim) << llendl; + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_SIT_GROUND), ANIM_REQUEST_STOP); + gAgent.sendAnimationRequest(getAssetIDByName(stranim), ANIM_REQUEST_START); + } + } + gSavedPerAccountSettings.setString("AODefaultGroundSit",stranim); + state = STATE_AGENT_GROUNDSIT; + } + else if (box->getName() == "crouchs") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_CROUCH), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultCrouch",stranim); + state = STATE_AGENT_CROUCH; + } + else if (box->getName() == "cwalks") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_CROUCHWALK), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultCrouchWalk",stranim); + state = STATE_AGENT_CROUCHWALK; + } + else if (box->getName() == "falls") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FALLDOWN), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultFall",stranim); + state = STATE_AGENT_FALLDOWN; + } + else if (box->getName() == "hovers") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultHover",stranim); + state = STATE_AGENT_HOVER; + } + else if (box->getName() == "flys") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FLY), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultFly",stranim); + state = STATE_AGENT_FLY; + } + else if (box->getName() == "flyslows") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FLYSLOW), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultFlySlow",stranim); + state = STATE_AGENT_FLYSLOW; + } + else if (box->getName() == "flyups") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER_UP), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultFlyUp",stranim); + state = STATE_AGENT_HOVER_UP; + } + else if (box->getName() == "flydowns") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER_DOWN), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultFlyDown",stranim); + state = STATE_AGENT_HOVER_DOWN; + } + else if (box->getName() == "lands") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_LAND), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultLand",stranim); + state = STATE_AGENT_LAND; + } + else if (box->getName() == "standups") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_STAND), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultStandUp",stranim); + state = STATE_AGENT_STAND; + } + else if (box->getName() == "prejumps") + { + gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_PRE_JUMP), ANIM_REQUEST_STOP); + gSavedPerAccountSettings.setString("AODefaultPreJump",stranim); + state = STATE_AGENT_PRE_JUMP; + } + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + if (state == iter->state) + { + iter->ao_id = getAssetIDByName(stranim); + } + } + } + } +} + +void LLFloaterAO::updateLayout(LLFloaterAO* floater) +{ + if (floater) + { + BOOL advanced = gSavedSettings.getBOOL( "AOAdvanced"); + if (advanced) + { + floater->reshape(610,380); //view->getRect().getWidth(), view->getUIWinHeightLong()); + } + else + { + floater->reshape(200,380); //view->getRect().getWidth(), view->getUIWinHeightShort()); + } + + floater->childSetVisible("more_btn", !advanced); + floater->childSetVisible("less_btn", advanced); + + floater->childSetVisible("tabcontainer", advanced); + floater->childSetVisible("tabdefaultanims", advanced); + + floater->childSetVisible("textdefaultwalk", advanced); + floater->childSetVisible("textdefaultrun", advanced); + floater->childSetVisible("textdefaultjump", advanced); + floater->childSetVisible("textdefaultsit", advanced); + floater->childSetVisible("textdefaultgsit", advanced); + floater->childSetVisible("textdefaultcrouch", advanced); + floater->childSetVisible("textdefaultcrouchwalk", advanced); + floater->childSetVisible("textdefaultfall", advanced); + floater->childSetVisible("textdefaulthover", advanced); + floater->childSetVisible("textdefaultfly", advanced); + floater->childSetVisible("textdefaultflyslow", advanced); + floater->childSetVisible("textdefaultflyup", advanced); + floater->childSetVisible("textdefaultflydown", advanced); + floater->childSetVisible("textdefaultland", advanced); + floater->childSetVisible("textdefaultstandup", advanced); + floater->childSetVisible("textdefaultprejump", advanced); + + + floater->childSetVisible("walks", advanced); + floater->childSetVisible("runs", advanced); + floater->childSetVisible("jumps", advanced); + floater->childSetVisible("sits", advanced); + floater->childSetVisible("gsits", advanced); + floater->childSetVisible("crouchs", advanced); + floater->childSetVisible("crouchwalks", advanced); + floater->childSetVisible("falls", advanced); + floater->childSetVisible("hovers", advanced); + floater->childSetVisible("flys", advanced); + floater->childSetVisible("flyslows", advanced); + floater->childSetVisible("flyups", advanced); + floater->childSetVisible("flydowns", advanced); + floater->childSetVisible("lands", advanced); + floater->childSetVisible("standups", advanced); + floater->childSetVisible("prejumps", advanced); + } +} + +void LLFloaterAO::init() +{ + mAOStands.clear(); + mAOTokens.clear(); + mAOOverrides.clear(); + + struct_tokens tokenloader; + tokenloader.token = + tokenloader.token = "[ Sitting On Ground ]"; tokenloader.state = STATE_AGENT_GROUNDSIT; mAOTokens.push_back(tokenloader); // 0 + tokenloader.token = "[ Sitting ]"; tokenloader.state = STATE_AGENT_SIT; mAOTokens.push_back(tokenloader); // 1 + tokenloader.token = "[ Crouching ]"; tokenloader.state = STATE_AGENT_CROUCH; mAOTokens.push_back(tokenloader); // 3 + tokenloader.token = "[ Crouch Walking ]"; tokenloader.state = STATE_AGENT_CROUCHWALK; mAOTokens.push_back(tokenloader); // 4 + tokenloader.token = "[ Standing Up ]"; tokenloader.state = STATE_AGENT_STANDUP; mAOTokens.push_back(tokenloader); // 6 + tokenloader.token = "[ Falling ]"; tokenloader.state = STATE_AGENT_FALLDOWN; mAOTokens.push_back(tokenloader); // 7 + tokenloader.token = "[ Flying Down ]"; tokenloader.state = STATE_AGENT_HOVER_DOWN; mAOTokens.push_back(tokenloader); // 8 + tokenloader.token = "[ Flying Up ]"; tokenloader.state = STATE_AGENT_HOVER_UP; mAOTokens.push_back(tokenloader); // 9 + tokenloader.token = "[ Flying Slow ]"; tokenloader.state = STATE_AGENT_FLYSLOW; mAOTokens.push_back(tokenloader); // 10 + tokenloader.token = "[ Flying ]"; tokenloader.state = STATE_AGENT_FLY; mAOTokens.push_back(tokenloader); // 11 + tokenloader.token = "[ Hovering ]"; tokenloader.state = STATE_AGENT_HOVER; mAOTokens.push_back(tokenloader); // 12 + tokenloader.token = "[ Jumping ]"; tokenloader.state = STATE_AGENT_JUMP; mAOTokens.push_back(tokenloader); // 13 + tokenloader.token = "[ Pre Jumping ]"; tokenloader.state = STATE_AGENT_PRE_JUMP; mAOTokens.push_back(tokenloader); // 14 + tokenloader.token = "[ Running ]"; tokenloader.state = STATE_AGENT_RUN; mAOTokens.push_back(tokenloader); // 15 + tokenloader.token = "[ Turning Right ]"; tokenloader.state = STATE_AGENT_TURNRIGHT; mAOTokens.push_back(tokenloader); // 16 + tokenloader.token = "[ Turning Left ]"; tokenloader.state = STATE_AGENT_TURNLEFT; mAOTokens.push_back(tokenloader); // 17 + tokenloader.token = "[ Walking ]"; tokenloader.state = STATE_AGENT_WALK; mAOTokens.push_back(tokenloader); // 18 + tokenloader.token = "[ Landing ]"; tokenloader.state = STATE_AGENT_LAND; mAOTokens.push_back(tokenloader); // 19 + tokenloader.token = "[ Standing ]"; tokenloader.state = STATE_AGENT_STAND; mAOTokens.push_back(tokenloader); // 20 + tokenloader.token = "[ Swimming Down ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 21 + tokenloader.token = "[ Swimming Up ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 22 + tokenloader.token = "[ Swimming Forward ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 23 + tokenloader.token = "[ Floating ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 24 + + struct_overrides overrideloader; + overrideloader.orig_id = ANIM_AGENT_WALK; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_WALK; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_RUN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_RUN; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_PRE_JUMP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_PRE_JUMP; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_JUMP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_JUMP; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_TURNLEFT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_TURNLEFT; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_TURNRIGHT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_TURNRIGHT; mAOOverrides.push_back(overrideloader); + + overrideloader.orig_id = ANIM_AGENT_SIT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_SIT_FEMALE; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_SIT_GENERIC; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_SIT_GROUND; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_GROUNDSIT; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_SIT_GROUND_CONSTRAINED; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_GROUNDSIT; mAOOverrides.push_back(overrideloader); + + overrideloader.orig_id = ANIM_AGENT_HOVER; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_HOVER_DOWN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER_DOWN; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_HOVER_UP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER_UP; mAOOverrides.push_back(overrideloader); + + overrideloader.orig_id = ANIM_AGENT_CROUCH; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_CROUCH; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_CROUCHWALK; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_CROUCHWALK; mAOOverrides.push_back(overrideloader); + + overrideloader.orig_id = ANIM_AGENT_FALLDOWN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FALLDOWN; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_STANDUP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_STANDUP; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_LAND; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_LAND; mAOOverrides.push_back(overrideloader); + + overrideloader.orig_id = ANIM_AGENT_FLY; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FLY; mAOOverrides.push_back(overrideloader); + overrideloader.orig_id = ANIM_AGENT_FLYSLOW; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FLYSLOW; mAOOverrides.push_back(overrideloader); + + BOOL success = TRUE; + + if(LLStartUp::getStartupState() >= STATE_INVENTORY_SEND) + { + if(gInventory.isEverythingFetched()) + { + LLUUID configncitem = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID"); + if (configncitem.notNull()) + { + success = FALSE; + const LLInventoryItem* item = gInventory.getItem(configncitem); + if(item) + { + if (gAgent.allowOperation(PERM_COPY, item->getPermissions(),GP_OBJECT_MANIPULATE) || gAgent.isGodlike()) + { + if(!item->getAssetUUID().isNull()) + { + LLUUID* new_uuid = new LLUUID(configncitem); + LLHost source_sim = LLHost::invalid; + invfolderid = item->getParentUUID(); + gAssetStorage->getInvItemAsset(source_sim, + gAgent.getID(), + gAgent.getSessionID(), + item->getPermissions().getOwner(), + LLUUID::null, + item->getUUID(), + item->getAssetUUID(), + item->getType(), + &onNotecardLoadComplete, + (void*)new_uuid, + TRUE); + success = TRUE; + } + } + } + } + } + } + + if (!success) + { + cmdline_printchat("Could not read the specified Config Notecard"); + } + +// mAnimationState = 0; +// mCurrentStandId = LLUUID::null; +// setAnimationState(STATE_AGENT_IDLE); + +} + +void LLFloaterAO::onClickMore(void* data) +{ + gSavedSettings.setBOOL( "AOAdvanced", TRUE ); + updateLayout(sInstance); +} +void LLFloaterAO::onClickLess(void* data) +{ + gSavedSettings.setBOOL( "AOAdvanced", FALSE ); + updateLayout(sInstance); +} + +void LLFloaterAO::onClickToggleAO(LLUICtrl *, void*) +{ + run(); +} + +void LLFloaterAO::onClickToggleSits(LLUICtrl *, void*) +{ + run(); +} + + +void LLFloaterAO::run() +{ + setAnimationState(STATE_AGENT_IDLE); // reset state + int state = getAnimationState(); // check if sitting or hovering + if ((state == STATE_AGENT_IDLE) || (state == STATE_AGENT_STAND)) + { + if (gSavedSettings.getBOOL("AOEnabled")) + { + if (mAOStandTimer) + { + mAOStandTimer->reset(); + ChangeStand(); + } + else + { + mAOStandTimer = new AOStandTimer(); + } + } + else + { + stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state + setAnimationState(STATE_AGENT_IDLE); + } + } + else + { + if (state == STATE_AGENT_SIT) gAgent.sendAnimationRequest(GetAnimIDFromState(state), (gSavedSettings.getBOOL("AOEnabled") && gSavedSettings.getBOOL("AOSitsEnabled")) ? ANIM_REQUEST_START : ANIM_REQUEST_STOP); + else gAgent.sendAnimationRequest(GetAnimIDFromState(state), gSavedSettings.getBOOL("AOEnabled") ? ANIM_REQUEST_START : ANIM_REQUEST_STOP); + } +} + +int LLFloaterAO::getAnimationState() +{ + if (gAgent.getAvatarObject()) + { + if (gAgent.getAvatarObject()->mIsSitting) setAnimationState(STATE_AGENT_SIT); + else if (gAgent.getFlying()) setAnimationState(STATE_AGENT_HOVER); + } + return mAnimationState; +} + +void LLFloaterAO::setAnimationState(const int state) +{ + mAnimationState = state; +} + +LLUUID LLFloaterAO::getCurrentStandId() +{ + return mCurrentStandId; +} + +void LLFloaterAO::setCurrentStandId(const LLUUID& id) +{ + mCurrentStandId = id; +} + +void LLFloaterAO::AOItemDrop(LLViewerInventoryItem* item) +{ + gSavedPerAccountSettings.setString("AOConfigNotecardID", item->getUUID().asString()); + sInstance->childSetValue("ao_nc_text","Currently set to: "+item->getName()); +} + +LLUUID LLFloaterAO::GetAnimID(const LLUUID& id) +{ + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + if (iter->orig_id == id) return iter->ao_id; + } + return LLUUID::null; +} + +int LLFloaterAO::GetStateFromAnimID(const LLUUID& id) +{ + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + if (iter->orig_id == id) return iter->state; + } + return STATE_AGENT_IDLE; +} + +LLUUID LLFloaterAO::GetAnimIDFromState(const int state) +{ + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + if (iter->state == state) return iter->ao_id; + } + return LLUUID::null; +} + +int LLFloaterAO::GetStateFromToken(std::string strtoken) +{ + for (std::vector::iterator iter = mAOTokens.begin(); iter != mAOTokens.end(); ++iter) + { + if (iter->token == strtoken) return iter->state; + } + return STATE_AGENT_IDLE; +} + +void LLFloaterAO::onClickPrevStand(void* user_data) +{ + if (!(mAOStands.size() > 0)) return; + stand_iterator=stand_iterator-1; + if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator); + if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0; + cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str())); + ChangeStand(); +} + +void LLFloaterAO::onClickNextStand(void* user_data) +{ + if (!(mAOStands.size() > 0)) return; + stand_iterator=stand_iterator+1; + if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator); + if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0; + cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str())); + ChangeStand(); +} + +BOOL LLFloaterAO::ChangeStand() +{ + if (gSavedSettings.getBOOL("AOEnabled")) + { + if (gAgent.getAvatarObject()) + { + if (gSavedSettings.getBOOL("AONoStandsInMouselook") && gAgent.cameraMouselook()) return FALSE; + + if (gAgent.getAvatarObject()->mIsSitting) + { +// stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state +// if (getAnimationState() != STATE_AGENT_GROUNDSIT) setAnimationState(STATE_AGENT_SIT); +// setCurrentStandId(LLUUID::null); + return FALSE; + } + } + if ((getAnimationState() == STATE_AGENT_IDLE) || (getAnimationState() == STATE_AGENT_STAND))// stands have lowest priority + { + if (!(mAOStands.size() > 0)) return TRUE; + if (gSavedSettings.getBOOL("AOStandRandomize")) + { + stand_iterator = ll_rand(mAOStands.size()-1); + } + if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator); + if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0; + + int stand_iterator_previous = stand_iterator -1; + + if (stand_iterator_previous < 0) stand_iterator_previous = int( mAOStands.size()-1); + + if (mAOStands[stand_iterator].ao_id.notNull()) + { + stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state + startMotion(mAOStands[stand_iterator].ao_id, 0, TRUE); + + setAnimationState(STATE_AGENT_STAND); + setCurrentStandId(mAOStands[stand_iterator].ao_id); + if ((sInstance)&&(mcomboBox_stands)) mcomboBox_stands->selectNthItem(stand_iterator); +// llinfos << "changing stand to " << mAOStands[stand_iterator].anim_name << llendl; + return FALSE; + } + } + } + else + { + stopMotion(getCurrentStandId(), FALSE, TRUE); + return TRUE; //stop if ao is off + } + return TRUE; +} + + +BOOL LLFloaterAO::startMotion(const LLUUID& id, F32 time_offset, BOOL stand) +{ + if (stand) + { + if (id.notNull()) + { + BOOL sitting = FALSE; + if (gAgent.getAvatarObject()) + { + sitting = gAgent.getAvatarObject()->mIsSitting; + } + if (sitting) return FALSE; + gAgent.sendAnimationRequest(id, ANIM_REQUEST_START); + return TRUE; + } + } + else + { + if (GetAnimID(id).notNull() && gSavedSettings.getBOOL("AOEnabled")) + { + stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state + setAnimationState(GetStateFromAnimID(id)); + +// llinfos << " state " << getAnimationState() << " start anim " << id << " overriding with " << GetAnimID(id) << llendl; + if ((GetStateFromAnimID(id) == STATE_AGENT_SIT) && !(gSavedSettings.getBOOL("AOSitsEnabled"))) return TRUE; + gAgent.sendAnimationRequest(GetAnimID(id), ANIM_REQUEST_START); + return TRUE; + } + } + return FALSE; +} + +BOOL LLFloaterAO::stopMotion(const LLUUID& id, BOOL stop_immediate, BOOL stand) +{ + if (stand) + { + setAnimationState(STATE_AGENT_IDLE); + gAgent.sendAnimationRequest(id, ANIM_REQUEST_STOP); + return TRUE; + } + else + { + if (GetAnimID(id).notNull() && gSavedSettings.getBOOL("AOEnabled")) + { +// llinfos << " state " << getAnimationState() << "/" << GetStateFromAnimID(id) << "(now 0) stop anim " << id << " overriding with " << GetAnimID(id) << llendl; + if (getAnimationState() == GetStateFromAnimID(id)) + { + setAnimationState(STATE_AGENT_IDLE); + } + ChangeStand(); // startMotion(getCurrentStandId(), 0, TRUE); + gAgent.sendAnimationRequest(GetAnimID(id), ANIM_REQUEST_STOP); + return TRUE; + } + } + return FALSE; +} + +void LLFloaterAO::onClickReloadCard(void* user_data) +{ + if(gInventory.isEverythingFetched()) + { + LLFloaterAO::init(); + } +} + +void LLFloaterAO::onClickOpenCard(void* user_data) +{ + if(gInventory.isEverythingFetched()) + { + LLUUID configncitem = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID"); + if (configncitem.notNull()) + { + const LLInventoryItem* item = gInventory.getItem(configncitem); + if(item) + { + if (gAgent.allowOperation(PERM_COPY, item->getPermissions(),GP_OBJECT_MANIPULATE) || gAgent.isGodlike()) + { + if(!item->getAssetUUID().isNull()) + open_notecard((LLViewerInventoryItem*)item, std::string("Note: ") + item->getName(), LLUUID::null, FALSE); + // open_notecard((LLViewerInventoryItem*)item, std::string("Note: ") + item->getName(), LLUUID::null, FALSE, LLUUID::null, FALSE); + } + } + } + } +} + +struct AOAssetInfo +{ + std::string path; + std::string name; +}; + +void LLFloaterAO::onNotecardLoadComplete(LLVFS *vfs,const LLUUID& asset_uuid,LLAssetType::EType type,void* user_data, S32 status, LLExtStat ext_status) +{ + if(status == LL_ERR_NOERR) + { + S32 size = vfs->getSize(asset_uuid, type); + U8* buffer = new U8[size]; + vfs->getData(asset_uuid, type, buffer, 0, size); + + if(type == LLAssetType::AT_NOTECARD) + { + LLViewerTextEditor* edit = new LLViewerTextEditor("",LLRect(0,0,0,0),S32_MAX,""); + if(edit->importBuffer((char*)buffer, (S32)size)) + { + llinfos << "ao nc decode success" << llendl; + std::string card = edit->getText(); + edit->die(); + + if (mcomboBox_stands) + { + mcomboBox_stands->clear(); + mcomboBox_stands->removeall(); + } + if (mcomboBox_walks) mcomboBox_walks->clear(); + if (mcomboBox_runs) mcomboBox_runs->clear(); + if (mcomboBox_jumps) mcomboBox_jumps->clear(); + if (mcomboBox_sits) mcomboBox_sits->clear(); + if (mcomboBox_gsits) mcomboBox_gsits->clear(); + if (mcomboBox_crouchs) mcomboBox_cwalks->clear(); + if (mcomboBox_cwalks) mcomboBox_cwalks->clear(); + if (mcomboBox_falls) mcomboBox_falls->clear(); + if (mcomboBox_hovers) mcomboBox_hovers->clear(); + if (mcomboBox_flys) mcomboBox_flys->clear(); + if (mcomboBox_flyslows) mcomboBox_flyslows->clear(); + if (mcomboBox_flyups) mcomboBox_flyups->clear(); + if (mcomboBox_flydowns) mcomboBox_flydowns->clear(); + if (mcomboBox_lands) mcomboBox_lands->clear(); + if (mcomboBox_standups) mcomboBox_standups->clear(); + if (mcomboBox_prejumps) mcomboBox_prejumps->clear(); + + + struct_stands loader; + + typedef boost::tokenizer > tokenizer; + boost::char_separator sep("\n"); + tokenizer tokline(card, sep); + + for (tokenizer::iterator line = tokline.begin(); line != tokline.end(); ++line) + { +// llinfos << *line << llendl; + std::string strline(*line); +// llinfos << "uncommented line: " << strline << llendl; + + boost::regex type("^(\\s*)(\\[ )(.*)( \\])"); + boost::smatch what; + if (boost::regex_search(strline, what, type)) + { +// llinfos << "type: " << what[0] << llendl; +// llinfos << "anims in type: " << boost::regex_replace(strline, type, "") << llendl; + + boost::char_separator sep("|,"); + std::string stranimnames(boost::regex_replace(strline, type, "")); + tokenizer tokanimnames(stranimnames, sep); + for (tokenizer::iterator anim = tokanimnames.begin(); anim != tokanimnames.end(); ++anim) + { + std::string strtoken(what[0]); + std::string stranim(*anim); + LLUUID animid(getAssetIDByName(stranim)); + +// llinfos << invfolderid.asString().c_str() << llendl; +// llinfos << "anim: " << stranim.c_str() << " assetid: " << animid << llendl; + if (!(animid.notNull())) + { + cmdline_printchat(llformat("Warning: animation '%s' could not be found (Section: %s).",stranim.c_str(),strtoken.c_str())); + } + else + { + switch(GetStateFromToken(strtoken.c_str())) + { + case STATE_AGENT_STAND: + loader.ao_id = animid; loader.anim_name = stranim.c_str(); mAOStands.push_back(loader); + if(mcomboBox_stands != NULL) mcomboBox_stands->add(stranim.c_str(), ADD_BOTTOM, TRUE); + break; + case STATE_AGENT_WALK: + { + if (sInstance && (mcomboBox_walks != NULL)) + { + //llinfos << "1 anim: " << stranim.c_str() << " assetid: " << animid << llendl; + if (!(mcomboBox_walks->selectByValue(stranim.c_str()))) mcomboBox_walks->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_RUN: + { + if (sInstance && (mcomboBox_runs != NULL)) + { + if (!(mcomboBox_runs->selectByValue(stranim.c_str()))) mcomboBox_runs->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_JUMP: + { + if (sInstance && (mcomboBox_jumps != NULL)) + { + if (!(mcomboBox_jumps->selectByValue(stranim.c_str()))) mcomboBox_jumps->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_SIT: + { + if (sInstance && (mcomboBox_sits != NULL)) + { + if (!(mcomboBox_sits->selectByValue(stranim.c_str()))) mcomboBox_sits->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_GROUNDSIT: + { + if (sInstance && (mcomboBox_gsits != NULL)) + { + if (!(mcomboBox_gsits->selectByValue(stranim.c_str()))) mcomboBox_gsits->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_CROUCH: + { + if (sInstance && (mcomboBox_crouchs != NULL)) + { + if (!(mcomboBox_crouchs->selectByValue(stranim.c_str()))) mcomboBox_crouchs->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_CROUCHWALK: + { + if (sInstance && (mcomboBox_cwalks != NULL)) + { + if (!(mcomboBox_cwalks->selectByValue(stranim.c_str()))) mcomboBox_cwalks->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_FALLDOWN: + { + if (sInstance && (mcomboBox_falls != NULL)) + { + if (!(mcomboBox_falls->selectByValue(stranim.c_str()))) mcomboBox_falls->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_HOVER: + { + if (sInstance && (mcomboBox_hovers != NULL)) + { + if (!(mcomboBox_hovers->selectByValue(stranim.c_str()))) mcomboBox_hovers->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_FLY: + { + if (sInstance && (mcomboBox_flys != NULL)) + { + if (!(mcomboBox_flys->selectByValue(stranim.c_str()))) mcomboBox_flys->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_FLYSLOW: + { + if (sInstance && (mcomboBox_flyslows != NULL)) + { + if (!(mcomboBox_flyslows->selectByValue(stranim.c_str()))) mcomboBox_flyslows->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_HOVER_UP: + { + if (sInstance && (mcomboBox_flyups != NULL)) + { + if (!(mcomboBox_flyups->selectByValue(stranim.c_str()))) mcomboBox_flyups->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_HOVER_DOWN: + { + if (sInstance && (mcomboBox_flydowns != NULL)) + { + if (!(mcomboBox_flydowns->selectByValue(stranim.c_str()))) mcomboBox_flydowns->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_LAND: + { + if (sInstance && (mcomboBox_lands != NULL)) + { + if (!(mcomboBox_lands->selectByValue(stranim.c_str()))) mcomboBox_lands->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_STANDUP: + { + if (sInstance && (mcomboBox_standups != NULL)) + { + if (!(mcomboBox_standups->selectByValue(stranim.c_str()))) mcomboBox_standups->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + case STATE_AGENT_PRE_JUMP: + { + if (sInstance && (mcomboBox_prejumps != NULL)) + { + if (!(mcomboBox_prejumps->selectByValue(stranim.c_str()))) mcomboBox_prejumps->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist + } + } + break; + } + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + if (GetStateFromToken(strtoken.c_str()) == iter->state) + { + iter->ao_id = animid; + } + } + } + } + } + } + llinfos << "ao nc read sucess" << llendl; + + for (std::vector::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter) + { + switch(iter->state) + { + + case STATE_AGENT_WALK: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultWalk"); + SetDefault(mcomboBox_walks,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_RUN: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultRun"); + SetDefault(mcomboBox_runs,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_JUMP: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultJump"); + SetDefault(mcomboBox_jumps,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_SIT: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultSit"); + SetDefault(mcomboBox_sits,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_CROUCH: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultCrouch"); + SetDefault(mcomboBox_crouchs,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_GROUNDSIT: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultGroundSit"); + SetDefault(mcomboBox_gsits,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_CROUCHWALK: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultCrouchWalk"); + SetDefault(mcomboBox_cwalks,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_FALLDOWN: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFall"); + SetDefault(mcomboBox_falls,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_HOVER: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultHover"); + SetDefault(mcomboBox_hovers,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_FLY: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFly"); + SetDefault(mcomboBox_flys,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_HOVER_UP: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlyUp"); + SetDefault(mcomboBox_flyups,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_FLYSLOW: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlySlow"); + SetDefault(mcomboBox_flyslows,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_HOVER_DOWN: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlyDown"); + SetDefault(mcomboBox_flydowns,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_LAND: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultLand"); + SetDefault(mcomboBox_lands,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_STANDUP: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultStandUp"); + SetDefault(mcomboBox_standups,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + case STATE_AGENT_PRE_JUMP: + { + std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultPreJump"); + SetDefault(mcomboBox_prejumps,iter->ao_id,defaultanim); + if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim); + } + break; + } + } + run(); + } + else + { + llinfos << "ao nc decode error" << llendl; + } + } + } + else + { + llinfos << "ao nc read error" << llendl; + } +} + +BOOL LLFloaterAO::SetDefault(void* userdata, LLUUID ao_id, std::string defaultanim) +{ + if (sInstance && (userdata)) + { + LLComboBox *box = (LLComboBox *) userdata; + if (LLUUID::null == ao_id) + { + box->clear(); + box->removeall(); + } + else + { + box->selectByValue(defaultanim); + } + } + return TRUE; +} + +class ObjectNameMatches : public LLInventoryCollectFunctor +{ +public: + ObjectNameMatches(std::string name) + { + sName = name; + } + virtual ~ObjectNameMatches() {} + virtual bool operator()(LLInventoryCategory* cat, + LLInventoryItem* item) + { + if(item) + { + if (item->getParentUUID() == LLFloaterAO::invfolderid) + { + return (item->getName() == sName); + } + return false; + } + return false; + } +private: + std::string sName; +}; + +const LLUUID& LLFloaterAO::getAssetIDByName(const std::string& name) +{ + if (name.empty() || !(gInventory.isEverythingFetched())) return LLUUID::null; + + LLViewerInventoryCategory::cat_array_t cats; + LLViewerInventoryItem::item_array_t items; + ObjectNameMatches objectnamematches(name); + gInventory.collectDescendentsIf(LLUUID::null,cats,items,FALSE,objectnamematches); + + if (items.count()) + { + return items[0]->getAssetUUID(); + } + return LLUUID::null; +}; diff --git a/linden/indra/newview/floaterao.h b/linden/indra/newview/floaterao.h new file mode 100644 index 0000000..3ab06e0 --- /dev/null +++ b/linden/indra/newview/floaterao.h @@ -0,0 +1,127 @@ + +#ifndef LL_LLFLOATERAO_H +#define LL_LLFLOATERAO_H + +#include "llfloater.h" +#include "llviewercontrol.h" +#include "llagent.h" + + +class AONoteCardDropTarget; + +const int STATE_AGENT_IDLE = 0; +const int STATE_AGENT_WALK = 1; +const int STATE_AGENT_RUN = 2; +const int STATE_AGENT_STAND = 3; + +const int STATE_AGENT_PRE_JUMP = 4; +const int STATE_AGENT_JUMP = 5; +const int STATE_AGENT_TURNLEFT = 6; +const int STATE_AGENT_TURNRIGHT = 7; + +const int STATE_AGENT_SIT = 8; +const int STATE_AGENT_GROUNDSIT = 9; + +const int STATE_AGENT_HOVER = 10; +const int STATE_AGENT_HOVER_DOWN = 11; +const int STATE_AGENT_HOVER_UP = 12; + +const int STATE_AGENT_CROUCH = 13; +const int STATE_AGENT_CROUCHWALK = 14; +const int STATE_AGENT_FALLDOWN = 15; +const int STATE_AGENT_STANDUP = 16; +const int STATE_AGENT_LAND = 17; + +const int STATE_AGENT_FLY = 18; +const int STATE_AGENT_FLYSLOW = 19; + + + + + +class AOStandTimer : public LLEventTimer +{ +public: + AOStandTimer(); + ~AOStandTimer(); + virtual BOOL tick(); + virtual void reset(); +}; + +class AOInvTimer : public LLEventTimer +{ +public: + AOInvTimer(); + ~AOInvTimer(); + BOOL tick(); +}; + +class LLFloaterAO : public LLFloater +{ +public: + + LLFloaterAO(); + virtual BOOL postBuild(); + virtual ~LLFloaterAO(); + + static void show(void*); + static void init(); + + static void onClickToggleAO(LLUICtrl *, void*); + static void onClickToggleSits(LLUICtrl *, void*); + static void run(); + static void updateLayout(LLFloaterAO* floater); + + static BOOL loadAnims(); + + static int getAnimationState(); + static void setAnimationState(int state); + static void setStates(const LLUUID& id, BOOL start); + + static LLUUID getCurrentStandId(); + static void setCurrentStandId(const LLUUID& id); + static int stand_iterator; + static BOOL ChangeStand(); + + static BOOL startMotion(const LLUUID& id, F32 time_offset = 0.f, BOOL stand = FALSE); + static BOOL stopMotion(const LLUUID& id, BOOL stop_immediate, BOOL stand = FALSE); + + static LLUUID GetAnimID(const LLUUID& id); + + static int GetStateFromAnimID(const LLUUID& id); + static LLUUID GetAnimIDFromState(const int state); + static int GetStateFromToken(std::string strtoken); + + static void onClickLess(void* data) ; + static void onClickMore(void* data) ; + + static void onClickPrevStand(void* userdata); + static void onClickNextStand(void* userdata); + static void onClickReloadCard(void* userdata); + static void onClickOpenCard(void* userdata); + + + static LLUUID invfolderid; + static const LLUUID& getAssetIDByName(const std::string& name); + +private: + + static LLFloaterAO* sInstance; + static int mAnimationState; + static LLUUID mCurrentStandId; + + static AONoteCardDropTarget* mAOItemDropTarget; + static void AOItemDrop(LLViewerInventoryItem* item); + static void onSpinnerCommit(LLUICtrl* ctrl, void* userdata); + static void onComboBoxCommit(LLUICtrl* ctrl, void* userdata); + static BOOL SetDefault(void *userdata, LLUUID ao_id, std::string defaultanim); + + BOOL mDirty; + +protected: + + static void onNotecardLoadComplete(LLVFS *vfs,const LLUUID& asset_uuid,LLAssetType::EType type,void* user_data, S32 status, LLExtStat ext_status); + +}; + +#endif \ No newline at end of file diff --git a/linden/indra/newview/llagent.cpp b/linden/indra/newview/llagent.cpp index 0a1bd98..18475c6 100644 --- a/linden/indra/newview/llagent.cpp +++ b/linden/indra/newview/llagent.cpp @@ -67,6 +67,7 @@ #include "llface.h" #include "llfirstuse.h" #include "llfloater.h" +#include "floaterao.h" #include "llfloateractivespeakers.h" #include "llfloateravatarinfo.h" #include "llfloaterbuildoptions.h" @@ -4069,6 +4070,7 @@ void LLAgent::changeCameraToMouselook(BOOL animate) if( mCameraMode != CAMERA_MODE_MOUSELOOK ) { gFocusMgr.setKeyboardFocus( NULL ); + if (gSavedSettings.getBOOL("AONoStandsInMouselook")) LLFloaterAO::stopMotion(LLFloaterAO::getCurrentStandId(), FALSE,TRUE); mLastCameraMode = mCameraMode; mCameraMode = CAMERA_MODE_MOUSELOOK; @@ -6030,7 +6032,7 @@ bool LLAgent::teleportCore(bool is_local) if(TELEPORT_NONE != mTeleportState) { llwarns << "Attempt to teleport when already teleporting." << llendl; - return false; + //return false; //This seems to fix getting stuck in TPs in the first place. --Liny } #if 0 diff --git a/linden/indra/newview/llviewermenu.cpp b/linden/indra/newview/llviewermenu.cpp index 0aec752..7a2cddf 100644 --- a/linden/indra/newview/llviewermenu.cpp +++ b/linden/indra/newview/llviewermenu.cpp @@ -81,6 +81,7 @@ #include "llface.h" #include "llfirstuse.h" #include "llfloater.h" +#include "floaterao.h" #include "llfloaterabout.h" #include "llfloaterbuycurrency.h" #include "llfloateractivespeakers.h" @@ -8596,6 +8597,16 @@ class LLAdvancedTogglePhantom: public view_listener_t }; + +class LLAO : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + LLFloaterAO::show(NULL); + return true; + } +}; + class LLAdvancedCheckPhantom: public view_listener_t { bool handleEvent(LLPointer event, const LLSD& userdata) @@ -10732,6 +10743,7 @@ void initialize_menus() addMenu(new LLViewCheckHighlightTransparent(), "View.CheckHighlightTransparent"); addMenu(new LLViewCheckRenderType(), "View.CheckRenderType"); addMenu(new LLViewCheckHUDAttachments(), "View.CheckHUDAttachments"); + addMenu(new LLAO(), "View.AO"); addMenu(new LLViewCheckAdvanced(), "View.CheckAdvanced"); // World menu diff --git a/linden/indra/newview/llvoavatar.cpp b/linden/indra/newview/llvoavatar.cpp index 10e2ec7..5350d78 100644 --- a/linden/indra/newview/llvoavatar.cpp +++ b/linden/indra/newview/llvoavatar.cpp @@ -46,6 +46,7 @@ #include "lldriverparam.h" #include "lleditingmotion.h" #include "llemote.h" +#include "floaterao.h" #include "llfirstuse.h" #include "llheadrotmotion.h" #include "llhudeffecttrail.h" @@ -5212,6 +5213,14 @@ void LLVOAvatar::processAnimationStateChanges() // playing, but not signaled, so stop if (found_anim == mSignaledAnimations.end()) { + if (mIsSelf) + { + if ((gSavedSettings.getBOOL("AOEnabled")) && LLFloaterAO::stopMotion(anim_it->first, FALSE)) // if the AO replaced this anim serverside then stop it serverside + { +// return TRUE; //no local stop needed + } + } + processSingleAnimationStateChange(anim_it->first, FALSE); mPlayingAnimations.erase(anim_it++); continue; @@ -5230,6 +5239,19 @@ void LLVOAvatar::processAnimationStateChanges() { if (processSingleAnimationStateChange(anim_it->first, TRUE)) { + + if (mIsSelf) // AO is only for ME + { + if (gSavedSettings.getBOOL("EmeraldAOEnabled")) + { + if (LLFloaterAO::startMotion(anim_it->first, 0,FALSE)) // AO overrides the anim if needed + { +// return TRUE; // not playing it locally + } + } + } + + mPlayingAnimations[anim_it->first] = anim_it->second; ++anim_it; continue; @@ -5427,6 +5449,11 @@ void LLVOAvatar::stopMotionFromSource(const LLUUID& source_id) //----------------------------------------------------------------------------- LLVector3 LLVOAvatar::getVolumePos(S32 joint_index, LLVector3& volume_offset) { + if(joint_index < 0) + { + return LLVector3::zero; + } + if (joint_index > mNumCollisionVolumes) { return LLVector3::zero; @@ -6615,6 +6642,7 @@ void LLVOAvatar::sitOnObject(LLViewerObject *sit_object) gPipeline.markMoved(mDrawable, TRUE); mIsSitting = TRUE; + LLFloaterAO::ChangeStand(); // [RLVa:KB] - Checked: 2009-07-08 (RLVa-1.0.0e) | Added: RLVa-0.2.1d #ifdef RLV_EXTENSION_STARTLOCATION if (rlv_handler_t::isEnabled()) diff --git a/linden/indra/newview/skins/default/xui/de/floater_ao.xml b/linden/indra/newview/skins/default/xui/de/floater_ao.xml new file mode 100644 index 0000000..c0731ea --- /dev/null +++ b/linden/indra/newview/skins/default/xui/de/floater_ao.xml @@ -0,0 +1,95 @@ + + + + + + ZHAO II Konfiguration hier fallen lassen. + + + + Aktuell: ITEM + +