/** * @File llvoavatar.cpp * @brief Implementation of LLVOAvatar class which is a derivation of LLViewerObject * * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llvoavatar.h" #include <stdio.h> #include <ctype.h> #include <sstream> #include "llaudioengine.h" #include "noise.h" #include "sound_ids.h" #include "raytrace.h" #include "llagent.h" // Get state values from here #include "llagentcamera.h" #include "llagentwearables.h" #include "llanimationstates.h" #include "llavatarnamecache.h" #include "llavatarpropertiesprocessor.h" #include "llavatarrendernotifier.h" #include "llexperiencecache.h" #include "llphysicsmotion.h" #include "llviewercontrol.h" #include "llcallingcard.h" // IDEVO for LLAvatarTracker #include "lldrawpoolavatar.h" #include "lldriverparam.h" #include "llpolyskeletaldistortion.h" #include "lleditingmotion.h" #include "llemote.h" #include "llfloatertools.h" #include "llheadrotmotion.h" #include "llhudeffecttrail.h" #include "llhudmanager.h" #include "llhudnametag.h" #include "llhudtext.h" // for mText/mDebugText #include "llimview.h" #include "llinitparam.h" #include "llkeyframefallmotion.h" #include "llkeyframestandmotion.h" #include "llkeyframewalkmotion.h" #include "llmanipscale.h" // for get_default_max_prim_scale() #include "llmeshrepository.h" #include "llmutelist.h" #include "llmoveview.h" #include "llnotificationsutil.h" #include "llphysicsshapebuilderutil.h" #include "llquantize.h" #include "llrand.h" #include "llregionhandle.h" #include "llresmgr.h" #include "llselectmgr.h" #include "llsprite.h" #include "lltargetingmotion.h" #include "lltoolmorph.h" #include "llviewercamera.h" #include "llviewertexlayer.h" #include "llviewertexturelist.h" #include "llviewermenu.h" #include "llviewerobjectlist.h" #include "llviewerparcelmgr.h" #include "llviewerregion.h" #include "llviewershadermgr.h" #include "llviewerstats.h" #include "llviewerwearable.h" #include "llvoavatarself.h" #include "llvovolume.h" #include "llworld.h" #include "pipeline.h" #include "llviewershadermgr.h" #include "llsky.h" #include "llanimstatelabels.h" #include "lltrans.h" #include "llappearancemgr.h" #include "llgesturemgr.h" //needed to trigger the voice gesticulations #include "llvoiceclient.h" #include "llvoicevisualizer.h" // Ventrella #include "lldebugmessagebox.h" #include "llsdutil.h" #include "llscenemonitor.h" #include "llsdserialize.h" #include "llcallstack.h" #include "llrendersphere.h" extern F32 SPEED_ADJUST_MAX; extern F32 SPEED_ADJUST_MAX_SEC; extern F32 ANIM_SPEED_MAX; extern F32 ANIM_SPEED_MIN; extern U32 JOINT_COUNT_REQUIRED_FOR_FULLRIG; const F32 MAX_HOVER_Z = 2.0; const F32 MIN_HOVER_Z = -2.0; const F32 MIN_ATTACHMENT_COMPLEXITY = 0.f; const F32 DEFAULT_MAX_ATTACHMENT_COMPLEXITY = 1.0e6f; using namespace LLAvatarAppearanceDefines; //----------------------------------------------------------------------------- // Global constants //----------------------------------------------------------------------------- const LLUUID ANIM_AGENT_BODY_NOISE = LLUUID("9aa8b0a6-0c6f-9518-c7c3-4f41f2c001ad"); //"body_noise" const LLUUID ANIM_AGENT_BREATHE_ROT = LLUUID("4c5a103e-b830-2f1c-16bc-224aa0ad5bc8"); //"breathe_rot" const LLUUID ANIM_AGENT_EDITING = LLUUID("2a8eba1d-a7f8-5596-d44a-b4977bf8c8bb"); //"editing" const LLUUID ANIM_AGENT_EYE = LLUUID("5c780ea8-1cd1-c463-a128-48c023f6fbea"); //"eye" const LLUUID ANIM_AGENT_FLY_ADJUST = LLUUID("db95561f-f1b0-9f9a-7224-b12f71af126e"); //"fly_adjust" const LLUUID ANIM_AGENT_HAND_MOTION = LLUUID("ce986325-0ba7-6e6e-cc24-b17c4b795578"); //"hand_motion" const LLUUID ANIM_AGENT_HEAD_ROT = LLUUID("e6e8d1dd-e643-fff7-b238-c6b4b056a68d"); //"head_rot" const LLUUID ANIM_AGENT_PELVIS_FIX = LLUUID("0c5dd2a2-514d-8893-d44d-05beffad208b"); //"pelvis_fix" const LLUUID ANIM_AGENT_TARGET = LLUUID("0e4896cb-fba4-926c-f355-8720189d5b55"); //"target" const LLUUID ANIM_AGENT_WALK_ADJUST = LLUUID("829bc85b-02fc-ec41-be2e-74cc6dd7215d"); //"walk_adjust" const LLUUID ANIM_AGENT_PHYSICS_MOTION = LLUUID("7360e029-3cb8-ebc4-863e-212df440d987"); //"physics_motion" //----------------------------------------------------------------------------- // Constants //----------------------------------------------------------------------------- const F32 DELTA_TIME_MIN = 0.01f; // we clamp measured deltaTime to this const F32 DELTA_TIME_MAX = 0.2f; // range to insure stability of computations. const F32 PELVIS_LAG_FLYING = 0.22f;// pelvis follow half life while flying const F32 PELVIS_LAG_WALKING = 0.4f; // ...while walking const F32 PELVIS_LAG_MOUSELOOK = 0.15f; const F32 MOUSELOOK_PELVIS_FOLLOW_FACTOR = 0.5f; const F32 TORSO_NOISE_AMOUNT = 1.0f; // Amount of deviation from up-axis, in degrees const F32 TORSO_NOISE_SPEED = 0.2f; // Time scale factor on torso noise. const F32 BREATHE_ROT_MOTION_STRENGTH = 0.05f; const S32 MIN_REQUIRED_PIXEL_AREA_BODY_NOISE = 10000; const S32 MIN_REQUIRED_PIXEL_AREA_BREATHE = 10000; const S32 MIN_REQUIRED_PIXEL_AREA_PELVIS_FIX = 40; const S32 TEX_IMAGE_SIZE_OTHER = 512 / 4; // The size of local textures for other (!isSelf()) avatars const F32 HEAD_MOVEMENT_AVG_TIME = 0.9f; const S32 MORPH_MASK_REQUESTED_DISCARD = 0; const F32 MAX_STANDOFF_FROM_ORIGIN = 3; const F32 MAX_STANDOFF_DISTANCE_CHANGE = 32; // Discard level at which to switch to baked textures // Should probably be 4 or 3, but didn't want to change it while change other logic - SJB const S32 SWITCH_TO_BAKED_DISCARD = 5; const F32 FOOT_COLLIDE_FUDGE = 0.04f; const F32 HOVER_EFFECT_MAX_SPEED = 3.f; const F32 HOVER_EFFECT_STRENGTH = 0.f; const F32 UNDERWATER_EFFECT_STRENGTH = 0.1f; const F32 UNDERWATER_FREQUENCY_DAMP = 0.33f; const F32 APPEARANCE_MORPH_TIME = 0.65f; const F32 TIME_BEFORE_MESH_CLEANUP = 5.f; // seconds const S32 AVATAR_RELEASE_THRESHOLD = 10; // number of avatar instances before releasing memory const F32 FOOT_GROUND_COLLISION_TOLERANCE = 0.25f; const F32 AVATAR_LOD_TWEAK_RANGE = 0.7f; const S32 MAX_BUBBLE_CHAT_LENGTH = DB_CHAT_MSG_STR_LEN; const S32 MAX_BUBBLE_CHAT_UTTERANCES = 12; const F32 CHAT_FADE_TIME = 8.0; const F32 BUBBLE_CHAT_TIME = CHAT_FADE_TIME * 3.f; const F32 NAMETAG_UPDATE_THRESHOLD = 0.3f; const F32 NAMETAG_VERTICAL_SCREEN_OFFSET = 25.f; const F32 NAMETAG_VERT_OFFSET_WEIGHT = 0.17f; const U32 LLVOAvatar::VISUAL_COMPLEXITY_UNKNOWN = 0; const F64 HUD_OVERSIZED_TEXTURE_DATA_SIZE = 1024 * 1024; enum ERenderName { RENDER_NAME_NEVER, RENDER_NAME_ALWAYS, RENDER_NAME_FADE }; //----------------------------------------------------------------------------- // Callback data //----------------------------------------------------------------------------- struct LLTextureMaskData { LLTextureMaskData( const LLUUID& id ) : mAvatarID(id), mLastDiscardLevel(S32_MAX) {} LLUUID mAvatarID; S32 mLastDiscardLevel; }; /********************************************************************************* ** ** ** Begin private LLVOAvatar Support classes ** **/ struct LLAppearanceMessageContents: public LLRefCount { LLAppearanceMessageContents(): mAppearanceVersion(-1), mParamAppearanceVersion(-1), mCOFVersion(LLViewerInventoryCategory::VERSION_UNKNOWN) { } LLTEContents mTEContents; S32 mAppearanceVersion; S32 mParamAppearanceVersion; S32 mCOFVersion; // For future use: //U32 appearance_flags = 0; std::vector<F32> mParamWeights; std::vector<LLVisualParam*> mParams; LLVector3 mHoverOffset; bool mHoverOffsetWasSet; }; //----------------------------------------------------------------------------- // class LLBodyNoiseMotion //----------------------------------------------------------------------------- class LLBodyNoiseMotion : public LLMotion { public: // Constructor LLBodyNoiseMotion(const LLUUID &id) : LLMotion(id) { mName = "body_noise"; mTorsoState = new LLJointState; } // Destructor virtual ~LLBodyNoiseMotion() { } public: //------------------------------------------------------------------------- // functions to support MotionController and MotionRegistry //------------------------------------------------------------------------- // static constructor // all subclasses must implement such a function and register it static LLMotion *create(const LLUUID &id) { return new LLBodyNoiseMotion(id); } public: //------------------------------------------------------------------------- // animation callbacks to be implemented by subclasses //------------------------------------------------------------------------- // motions must specify whether or not they loop virtual BOOL getLoop() { return TRUE; } // motions must report their total duration virtual F32 getDuration() { return 0.0; } // motions must report their "ease in" duration virtual F32 getEaseInDuration() { return 0.0; } // motions must report their "ease out" duration. virtual F32 getEaseOutDuration() { return 0.0; } // motions must report their priority virtual LLJoint::JointPriority getPriority() { return LLJoint::HIGH_PRIORITY; } virtual LLMotionBlendType getBlendType() { return ADDITIVE_BLEND; } // called to determine when a motion should be activated/deactivated based on avatar pixel coverage virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_BODY_NOISE; } // run-time (post constructor) initialization, // called after parameters have been set // must return true to indicate success and be available for activation virtual LLMotionInitStatus onInitialize(LLCharacter *character) { if( !mTorsoState->setJoint( character->getJoint("mTorso") )) { return STATUS_FAILURE; } mTorsoState->setUsage(LLJointState::ROT); addJointState( mTorsoState ); return STATUS_SUCCESS; } // called when a motion is activated // must return TRUE to indicate success, or else // it will be deactivated virtual BOOL onActivate() { return TRUE; } // called per time step // must return TRUE while it is active, and // must return FALSE when the motion is completed. virtual BOOL onUpdate(F32 time, U8* joint_mask) { F32 nx[2]; nx[0]=time*TORSO_NOISE_SPEED; nx[1]=0.0f; F32 ny[2]; ny[0]=0.0f; ny[1]=time*TORSO_NOISE_SPEED; F32 noiseX = noise2(nx); F32 noiseY = noise2(ny); F32 rx = TORSO_NOISE_AMOUNT * DEG_TO_RAD * noiseX / 0.42f; F32 ry = TORSO_NOISE_AMOUNT * DEG_TO_RAD * noiseY / 0.42f; LLQuaternion tQn; tQn.setQuat( rx, ry, 0.0f ); mTorsoState->setRotation( tQn ); return TRUE; } // called when a motion is deactivated virtual void onDeactivate() {} private: //------------------------------------------------------------------------- // joint states to be animated //------------------------------------------------------------------------- LLPointer<LLJointState> mTorsoState; }; //----------------------------------------------------------------------------- // class LLBreatheMotionRot //----------------------------------------------------------------------------- class LLBreatheMotionRot : public LLMotion { public: // Constructor LLBreatheMotionRot(const LLUUID &id) : LLMotion(id), mBreatheRate(1.f), mCharacter(NULL) { mName = "breathe_rot"; mChestState = new LLJointState; } // Destructor virtual ~LLBreatheMotionRot() {} public: //------------------------------------------------------------------------- // functions to support MotionController and MotionRegistry //------------------------------------------------------------------------- // static constructor // all subclasses must implement such a function and register it static LLMotion *create(const LLUUID &id) { return new LLBreatheMotionRot(id); } public: //------------------------------------------------------------------------- // animation callbacks to be implemented by subclasses //------------------------------------------------------------------------- // motions must specify whether or not they loop virtual BOOL getLoop() { return TRUE; } // motions must report their total duration virtual F32 getDuration() { return 0.0; } // motions must report their "ease in" duration virtual F32 getEaseInDuration() { return 0.0; } // motions must report their "ease out" duration. virtual F32 getEaseOutDuration() { return 0.0; } // motions must report their priority virtual LLJoint::JointPriority getPriority() { return LLJoint::MEDIUM_PRIORITY; } virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; } // called to determine when a motion should be activated/deactivated based on avatar pixel coverage virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_BREATHE; } // run-time (post constructor) initialization, // called after parameters have been set // must return true to indicate success and be available for activation virtual LLMotionInitStatus onInitialize(LLCharacter *character) { mCharacter = character; BOOL success = true; if ( !mChestState->setJoint( character->getJoint( "mChest" ) ) ) { success = false; } if ( success ) { mChestState->setUsage(LLJointState::ROT); addJointState( mChestState ); } if ( success ) { return STATUS_SUCCESS; } else { return STATUS_FAILURE; } } // called when a motion is activated // must return TRUE to indicate success, or else // it will be deactivated virtual BOOL onActivate() { return TRUE; } // called per time step // must return TRUE while it is active, and // must return FALSE when the motion is completed. virtual BOOL onUpdate(F32 time, U8* joint_mask) { mBreatheRate = 1.f; F32 breathe_amt = (sinf(mBreatheRate * time) * BREATHE_ROT_MOTION_STRENGTH); mChestState->setRotation(LLQuaternion(breathe_amt, LLVector3(0.f, 1.f, 0.f))); return TRUE; } // called when a motion is deactivated virtual void onDeactivate() {} private: //------------------------------------------------------------------------- // joint states to be animated //------------------------------------------------------------------------- LLPointer<LLJointState> mChestState; F32 mBreatheRate; LLCharacter* mCharacter; }; //----------------------------------------------------------------------------- // class LLPelvisFixMotion //----------------------------------------------------------------------------- class LLPelvisFixMotion : public LLMotion { public: // Constructor LLPelvisFixMotion(const LLUUID &id) : LLMotion(id), mCharacter(NULL) { mName = "pelvis_fix"; mPelvisState = new LLJointState; } // Destructor virtual ~LLPelvisFixMotion() { } public: //------------------------------------------------------------------------- // functions to support MotionController and MotionRegistry //------------------------------------------------------------------------- // static constructor // all subclasses must implement such a function and register it static LLMotion *create(const LLUUID& id) { return new LLPelvisFixMotion(id); } public: //------------------------------------------------------------------------- // animation callbacks to be implemented by subclasses //------------------------------------------------------------------------- // motions must specify whether or not they loop virtual BOOL getLoop() { return TRUE; } // motions must report their total duration virtual F32 getDuration() { return 0.0; } // motions must report their "ease in" duration virtual F32 getEaseInDuration() { return 0.5f; } // motions must report their "ease out" duration. virtual F32 getEaseOutDuration() { return 0.5f; } // motions must report their priority virtual LLJoint::JointPriority getPriority() { return LLJoint::LOW_PRIORITY; } virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; } // called to determine when a motion should be activated/deactivated based on avatar pixel coverage virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_PELVIS_FIX; } // run-time (post constructor) initialization, // called after parameters have been set // must return true to indicate success and be available for activation virtual LLMotionInitStatus onInitialize(LLCharacter *character) { mCharacter = character; if (!mPelvisState->setJoint( character->getJoint("mPelvis"))) { return STATUS_FAILURE; } mPelvisState->setUsage(LLJointState::POS); addJointState( mPelvisState ); return STATUS_SUCCESS; } // called when a motion is activated // must return TRUE to indicate success, or else // it will be deactivated virtual BOOL onActivate() { return TRUE; } // called per time step // must return TRUE while it is active, and // must return FALSE when the motion is completed. virtual BOOL onUpdate(F32 time, U8* joint_mask) { mPelvisState->setPosition(LLVector3::zero); return TRUE; } // called when a motion is deactivated virtual void onDeactivate() {} private: //------------------------------------------------------------------------- // joint states to be animated //------------------------------------------------------------------------- LLPointer<LLJointState> mPelvisState; LLCharacter* mCharacter; }; /** ** ** End LLVOAvatar Support classes ** ** *********************************************************************************/ //----------------------------------------------------------------------------- // Static Data //----------------------------------------------------------------------------- LLAvatarAppearanceDictionary *LLVOAvatar::sAvatarDictionary = NULL; S32 LLVOAvatar::sFreezeCounter = 0; U32 LLVOAvatar::sMaxNonImpostors = 12; // overridden based on graphics setting F32 LLVOAvatar::sRenderDistance = 256.f; S32 LLVOAvatar::sNumVisibleAvatars = 0; S32 LLVOAvatar::sNumLODChangesThisFrame = 0; const LLUUID LLVOAvatar::sStepSoundOnLand("e8af4a28-aa83-4310-a7c4-c047e15ea0df"); const LLUUID LLVOAvatar::sStepSounds[LL_MCODE_END] = { SND_STONE_RUBBER, SND_METAL_RUBBER, SND_GLASS_RUBBER, SND_WOOD_RUBBER, SND_FLESH_RUBBER, SND_RUBBER_PLASTIC, SND_RUBBER_RUBBER }; S32 LLVOAvatar::sRenderName = RENDER_NAME_ALWAYS; BOOL LLVOAvatar::sRenderGroupTitles = TRUE; S32 LLVOAvatar::sNumVisibleChatBubbles = 0; BOOL LLVOAvatar::sDebugInvisible = FALSE; BOOL LLVOAvatar::sShowAttachmentPoints = FALSE; BOOL LLVOAvatar::sShowAnimationDebug = FALSE; BOOL LLVOAvatar::sShowFootPlane = FALSE; BOOL LLVOAvatar::sVisibleInFirstPerson = FALSE; F32 LLVOAvatar::sLODFactor = 1.f; F32 LLVOAvatar::sPhysicsLODFactor = 1.f; bool LLVOAvatar::sUseImpostors = false; // overwridden by RenderAvatarMaxNonImpostors BOOL LLVOAvatar::sJointDebug = FALSE; F32 LLVOAvatar::sUnbakedTime = 0.f; F32 LLVOAvatar::sUnbakedUpdateTime = 0.f; F32 LLVOAvatar::sGreyTime = 0.f; F32 LLVOAvatar::sGreyUpdateTime = 0.f; //----------------------------------------------------------------------------- // Helper functions //----------------------------------------------------------------------------- static F32 calc_bouncy_animation(F32 x); //----------------------------------------------------------------------------- // LLVOAvatar() //----------------------------------------------------------------------------- LLVOAvatar::LLVOAvatar(const LLUUID& id, const LLPCode pcode, LLViewerRegion* regionp) : LLAvatarAppearance(&gAgentWearables), LLViewerObject(id, pcode, regionp), mSpecialRenderMode(0), mAttachmentSurfaceArea(0.f), mReportedVisualComplexity(VISUAL_COMPLEXITY_UNKNOWN), mTurning(FALSE), mLastSkeletonSerialNum( 0 ), mIsSitting(FALSE), mTimeVisible(), mTyping(FALSE), mMeshValid(FALSE), mVisible(FALSE), mWindFreq(0.f), mRipplePhase( 0.f ), mBelowWater(FALSE), mLastAppearanceBlendTime(0.f), mAppearanceAnimating(FALSE), mNameIsSet(false), mTitle(), mNameAway(false), mNameDoNotDisturb(false), mNameMute(false), mNameAppearance(false), mNameFriend(false), mNameAlpha(0.f), mRenderGroupTitles(sRenderGroupTitles), mNameCloud(false), mFirstTEMessageReceived( FALSE ), mFirstAppearanceMessageReceived( FALSE ), mCulled( FALSE ), mVisibilityRank(0), mNeedsSkin(FALSE), mLastSkinTime(0.f), mUpdatePeriod(1), mVisualComplexityStale(true), mVisuallyMuteSetting(AV_RENDER_NORMALLY), mMutedAVColor(LLColor4::white /* used for "uninitialize" */), mFirstFullyVisible(TRUE), mFullyLoaded(FALSE), mPreviousFullyLoaded(FALSE), mFullyLoadedInitialized(FALSE), mVisualComplexity(VISUAL_COMPLEXITY_UNKNOWN), mLoadedCallbacksPaused(FALSE), mRenderUnloadedAvatar(LLCachedControl<bool>(gSavedSettings, "RenderUnloadedAvatar", false)), mLastRezzedStatus(-1), mIsEditingAppearance(FALSE), mUseLocalAppearance(FALSE), mLastUpdateRequestCOFVersion(-1), mLastUpdateReceivedCOFVersion(-1), mCachedMuteListUpdateTime(0), mCachedInMuteList(false) { LL_DEBUGS("AvatarRender") << "LLVOAvatar Constructor (0x" << this << ") id:" << mID << LL_ENDL; //VTResume(); // VTune setHoverOffset(LLVector3(0.0, 0.0, 0.0)); // mVoiceVisualizer is created by the hud effects manager and uses the HUD Effects pipeline const BOOL needsSendToSim = false; // currently, this HUD effect doesn't need to pack and unpack data to do its job mVoiceVisualizer = ( LLVoiceVisualizer *)LLHUDManager::getInstance()->createViewerEffect( LLHUDObject::LL_HUD_EFFECT_VOICE_VISUALIZER, needsSendToSim ); LL_DEBUGS("Avatar","Message") << "LLVOAvatar Constructor (0x" << this << ") id:" << mID << LL_ENDL; mPelvisp = NULL; mDirtyMesh = 2; // Dirty geometry, need to regenerate. mMeshTexturesDirty = FALSE; mHeadp = NULL; // set up animation variables mSpeed = 0.f; setAnimationData("Speed", &mSpeed); mNeedsImpostorUpdate = TRUE; mNeedsAnimUpdate = TRUE; mImpostorDistance = 0; mImpostorPixelArea = 0; setNumTEs(TEX_NUM_INDICES); mbCanSelect = TRUE; mSignaledAnimations.clear(); mPlayingAnimations.clear(); mWasOnGroundLeft = FALSE; mWasOnGroundRight = FALSE; mTimeLast = 0.0f; mSpeedAccum = 0.0f; mRippleTimeLast = 0.f; mInAir = FALSE; mStepOnLand = TRUE; mStepMaterial = 0; mLipSyncActive = false; mOohMorph = NULL; mAahMorph = NULL; mCurrentGesticulationLevel = 0; mRuthTimer.reset(); mRuthDebugTimer.reset(); mDebugExistenceTimer.reset(); mLastAppearanceMessageTimer.reset(); if(LLSceneMonitor::getInstance()->isEnabled()) { LLSceneMonitor::getInstance()->freezeAvatar((LLCharacter*)this); } mVisuallyMuteSetting = LLVOAvatar::VisualMuteSettings(LLRenderMuteList::getInstance()->getSavedVisualMuteSetting(getID())); } std::string LLVOAvatar::avString() const { std::string viz_string = LLVOAvatar::rezStatusToString(getRezzedStatus()); return " Avatar '" + getFullname() + "' " + viz_string + " "; } void LLVOAvatar::debugAvatarRezTime(std::string notification_name, std::string comment) { LL_INFOS("Avatar") << "REZTIME: [ " << (U32)mDebugExistenceTimer.getElapsedTimeF32() << "sec ]" << avString() << "RuthTimer " << (U32)mRuthDebugTimer.getElapsedTimeF32() << " Notification " << notification_name << " : " << comment << LL_ENDL; if (gSavedSettings.getBOOL("DebugAvatarRezTime")) { LLSD args; args["EXISTENCE"] = llformat("%d",(U32)mDebugExistenceTimer.getElapsedTimeF32()); args["TIME"] = llformat("%d",(U32)mRuthDebugTimer.getElapsedTimeF32()); args["NAME"] = getFullname(); LLNotificationsUtil::add(notification_name,args); } } //------------------------------------------------------------------------ // LLVOAvatar::~LLVOAvatar() //------------------------------------------------------------------------ LLVOAvatar::~LLVOAvatar() { if (!mFullyLoaded) { debugAvatarRezTime("AvatarRezLeftCloudNotification","left after ruth seconds as cloud"); } else { debugAvatarRezTime("AvatarRezLeftNotification","left sometime after declouding"); } logPendingPhases(); LL_DEBUGS("Avatar") << "LLVOAvatar Destructor (0x" << this << ") id:" << mID << LL_ENDL; std::for_each(mAttachmentPoints.begin(), mAttachmentPoints.end(), DeletePairedPointer()); mAttachmentPoints.clear(); mDead = TRUE; mAnimationSources.clear(); LLLoadedCallbackEntry::cleanUpCallbackList(&mCallbackTextureList) ; getPhases().clearPhases(); LL_DEBUGS() << "LLVOAvatar Destructor end" << LL_ENDL; } void LLVOAvatar::markDead() { if (mNameText) { mNameText->markDead(); mNameText = NULL; sNumVisibleChatBubbles--; } mVoiceVisualizer->markDead(); LLLoadedCallbackEntry::cleanUpCallbackList(&mCallbackTextureList) ; LLViewerObject::markDead(); } BOOL LLVOAvatar::isFullyBaked() { if (mIsDummy) return TRUE; if (getNumTEs() == 0) return FALSE; for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { if (!isTextureDefined(mBakedTextureDatas[i].mTextureIndex) && ( (i != BAKED_SKIRT) || isWearingWearableType(LLWearableType::WT_SKIRT) ) ) { return FALSE; } } return TRUE; } BOOL LLVOAvatar::isFullyTextured() const { for (S32 i = 0; i < mMeshLOD.size(); i++) { LLAvatarJoint* joint = mMeshLOD[i]; if (i==MESH_ID_SKIRT && !isWearingWearableType(LLWearableType::WT_SKIRT)) { continue; // don't care about skirt textures if we're not wearing one. } if (!joint) { continue; // nonexistent LOD OK. } avatar_joint_mesh_list_t::iterator meshIter = joint->mMeshParts.begin(); if (meshIter != joint->mMeshParts.end()) { LLAvatarJointMesh *mesh = (*meshIter); if (!mesh) { continue; // nonexistent mesh OK } if (mesh->hasGLTexture()) { continue; // Mesh exists and has a baked texture. } if (mesh->hasComposite()) { continue; // Mesh exists and has a composite texture. } // Fail return FALSE; } } return TRUE; } BOOL LLVOAvatar::hasGray() const { return !getIsCloud() && !isFullyTextured(); } S32 LLVOAvatar::getRezzedStatus() const { if (getIsCloud()) return 0; if (isFullyTextured() && allBakedTexturesCompletelyDownloaded()) return 3; if (isFullyTextured()) return 2; llassert(hasGray()); return 1; // gray } void LLVOAvatar::deleteLayerSetCaches(bool clearAll) { for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { if (mBakedTextureDatas[i].mTexLayerSet) { // ! BACKWARDS COMPATIBILITY ! // Can be removed after hair baking is mandatory on the grid if ((i != BAKED_HAIR || isSelf()) && !clearAll) { mBakedTextureDatas[i].mTexLayerSet->deleteCaches(); } } if (mBakedTextureDatas[i].mMaskTexName) { LLImageGL::deleteTextures(1, (GLuint*)&(mBakedTextureDatas[i].mMaskTexName)); mBakedTextureDatas[i].mMaskTexName = 0 ; } } } // static BOOL LLVOAvatar::areAllNearbyInstancesBaked(S32& grey_avatars) { BOOL res = TRUE; grey_avatars = 0; for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; if( inst->isDead() ) { continue; } else if( !inst->isFullyBaked() ) { res = FALSE; if (inst->mHasGrey) { ++grey_avatars; } } } return res; } // static void LLVOAvatar::getNearbyRezzedStats(std::vector<S32>& counts) { counts.clear(); counts.resize(4); for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; if (inst) { S32 rez_status = inst->getRezzedStatus(); counts[rez_status]++; } } } // static std::string LLVOAvatar::rezStatusToString(S32 rez_status) { if (rez_status==0) return "cloud"; if (rez_status==1) return "gray"; if (rez_status==2) return "downloading"; if (rez_status==3) return "full"; return "unknown"; } // static void LLVOAvatar::dumpBakedStatus() { LLVector3d camera_pos_global = gAgentCamera.getCameraPositionGlobal(); for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; LL_INFOS() << "Avatar "; LLNameValue* firstname = inst->getNVPair("FirstName"); LLNameValue* lastname = inst->getNVPair("LastName"); if( firstname ) { LL_CONT << firstname->getString(); } if( lastname ) { LL_CONT << " " << lastname->getString(); } LL_CONT << " " << inst->mID; if( inst->isDead() ) { LL_CONT << " DEAD ("<< inst->getNumRefs() << " refs)"; } if( inst->isSelf() ) { LL_CONT << " (self)"; } F64 dist_to_camera = (inst->getPositionGlobal() - camera_pos_global).length(); LL_CONT << " " << dist_to_camera << "m "; LL_CONT << " " << inst->mPixelArea << " pixels"; if( inst->isVisible() ) { LL_CONT << " (visible)"; } else { LL_CONT << " (not visible)"; } if( inst->isFullyBaked() ) { LL_CONT << " Baked"; } else { LL_CONT << " Unbaked ("; for (LLAvatarAppearanceDictionary::BakedTextures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().begin(); iter != LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().end(); ++iter) { const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = iter->second; const ETextureIndex index = baked_dict->mTextureIndex; if (!inst->isTextureDefined(index)) { LL_CONT << " " << LLAvatarAppearanceDictionary::getInstance()->getTexture(index)->mName; } } LL_CONT << " ) " << inst->getUnbakedPixelAreaRank(); if( inst->isCulled() ) { LL_CONT << " culled"; } } LL_CONT << LL_ENDL; } } //static void LLVOAvatar::restoreGL() { if (!isAgentAvatarValid()) return; gAgentAvatarp->setCompositeUpdatesEnabled(TRUE); for (U32 i = 0; i < gAgentAvatarp->mBakedTextureDatas.size(); i++) { gAgentAvatarp->invalidateComposite(gAgentAvatarp->getTexLayerSet(i)); } gAgentAvatarp->updateMeshTextures(); } //static void LLVOAvatar::destroyGL() { deleteCachedImages(); resetImpostors(); } //static void LLVOAvatar::resetImpostors() { for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* avatar = (LLVOAvatar*) *iter; avatar->mImpostor.release(); avatar->mNeedsImpostorUpdate = TRUE; } } // static void LLVOAvatar::deleteCachedImages(bool clearAll) { if (LLViewerTexLayerSet::sHasCaches) { for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; inst->deleteLayerSetCaches(clearAll); } LLViewerTexLayerSet::sHasCaches = FALSE; } LLVOAvatarSelf::deleteScratchTextures(); LLTexLayerStaticImageList::getInstance()->deleteCachedImages(); } //------------------------------------------------------------------------ // static // LLVOAvatar::initClass() //------------------------------------------------------------------------ void LLVOAvatar::initClass() { gAnimLibrary.animStateSetString(ANIM_AGENT_BODY_NOISE,"body_noise"); gAnimLibrary.animStateSetString(ANIM_AGENT_BREATHE_ROT,"breathe_rot"); gAnimLibrary.animStateSetString(ANIM_AGENT_PHYSICS_MOTION,"physics_motion"); gAnimLibrary.animStateSetString(ANIM_AGENT_EDITING,"editing"); gAnimLibrary.animStateSetString(ANIM_AGENT_EYE,"eye"); gAnimLibrary.animStateSetString(ANIM_AGENT_FLY_ADJUST,"fly_adjust"); gAnimLibrary.animStateSetString(ANIM_AGENT_HAND_MOTION,"hand_motion"); gAnimLibrary.animStateSetString(ANIM_AGENT_HEAD_ROT,"head_rot"); gAnimLibrary.animStateSetString(ANIM_AGENT_PELVIS_FIX,"pelvis_fix"); gAnimLibrary.animStateSetString(ANIM_AGENT_TARGET,"target"); gAnimLibrary.animStateSetString(ANIM_AGENT_WALK_ADJUST,"walk_adjust"); // Where should this be set initially? LLJoint::setDebugJointNames(gSavedSettings.getString("DebugAvatarJoints")); } void LLVOAvatar::cleanupClass() { } // virtual void LLVOAvatar::initInstance(void) { //------------------------------------------------------------------------- // register motions //------------------------------------------------------------------------- if (LLCharacter::sInstances.size() == 1) { LLKeyframeMotion::setVFS(gStaticVFS); registerMotion( ANIM_AGENT_DO_NOT_DISTURB, LLNullMotion::create ); registerMotion( ANIM_AGENT_CROUCH, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_CROUCHWALK, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_EXPRESS_AFRAID, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_ANGER, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_BORED, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_CRY, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_DISDAIN, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_EMBARRASSED, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_FROWN, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_KISS, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_LAUGH, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_OPEN_MOUTH, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_REPULSED, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_SAD, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_SHRUG, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_SMILE, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_SURPRISE, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_TONGUE_OUT, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_TOOTHSMILE, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_WINK, LLEmote::create ); registerMotion( ANIM_AGENT_EXPRESS_WORRY, LLEmote::create ); registerMotion( ANIM_AGENT_FEMALE_RUN_NEW, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_FEMALE_WALK, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_FEMALE_WALK_NEW, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_RUN, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_RUN_NEW, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_STAND, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_STAND_1, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_STAND_2, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_STAND_3, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_STAND_4, LLKeyframeStandMotion::create ); registerMotion( ANIM_AGENT_STANDUP, LLKeyframeFallMotion::create ); registerMotion( ANIM_AGENT_TURNLEFT, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_TURNRIGHT, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_WALK, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_WALK_NEW, LLKeyframeWalkMotion::create ); // motions without a start/stop bit registerMotion( ANIM_AGENT_BODY_NOISE, LLBodyNoiseMotion::create ); registerMotion( ANIM_AGENT_BREATHE_ROT, LLBreatheMotionRot::create ); registerMotion( ANIM_AGENT_PHYSICS_MOTION, LLPhysicsMotionController::create ); registerMotion( ANIM_AGENT_EDITING, LLEditingMotion::create ); registerMotion( ANIM_AGENT_EYE, LLEyeMotion::create ); registerMotion( ANIM_AGENT_FEMALE_WALK, LLKeyframeWalkMotion::create ); registerMotion( ANIM_AGENT_FLY_ADJUST, LLFlyAdjustMotion::create ); registerMotion( ANIM_AGENT_HAND_MOTION, LLHandMotion::create ); registerMotion( ANIM_AGENT_HEAD_ROT, LLHeadRotMotion::create ); registerMotion( ANIM_AGENT_PELVIS_FIX, LLPelvisFixMotion::create ); registerMotion( ANIM_AGENT_SIT_FEMALE, LLKeyframeMotion::create ); registerMotion( ANIM_AGENT_TARGET, LLTargetingMotion::create ); registerMotion( ANIM_AGENT_WALK_ADJUST, LLWalkAdjustMotion::create ); } LLAvatarAppearance::initInstance(); // preload specific motions here createMotion( ANIM_AGENT_CUSTOMIZE); createMotion( ANIM_AGENT_CUSTOMIZE_DONE); //VTPause(); // VTune mVoiceVisualizer->setVoiceEnabled( LLVoiceClient::getInstance()->getVoiceEnabled( mID ) ); } // virtual LLAvatarJoint* LLVOAvatar::createAvatarJoint() { return new LLViewerJoint(); } // virtual LLAvatarJoint* LLVOAvatar::createAvatarJoint(S32 joint_num) { return new LLViewerJoint(joint_num); } // virtual LLAvatarJointMesh* LLVOAvatar::createAvatarJointMesh() { return new LLViewerJointMesh(); } // virtual LLTexLayerSet* LLVOAvatar::createTexLayerSet() { return new LLViewerTexLayerSet(this); } const LLVector3 LLVOAvatar::getRenderPosition() const { if (mDrawable.isNull() || mDrawable->getGeneration() < 0) { return getPositionAgent(); } else if (isRoot()) { F32 fixup; if ( hasPelvisFixup( fixup) ) { //Apply a pelvis fixup (as defined by the avs skin) LLVector3 pos = mDrawable->getPositionAgent(); pos[VZ] += fixup; return pos; } else { return mDrawable->getPositionAgent(); } } else { return getPosition() * mDrawable->getParent()->getRenderMatrix(); } } void LLVOAvatar::updateDrawable(BOOL force_damped) { clearChanged(SHIFTED); } void LLVOAvatar::onShift(const LLVector4a& shift_vector) { const LLVector3& shift = reinterpret_cast<const LLVector3&>(shift_vector); mLastAnimExtents[0] += shift; mLastAnimExtents[1] += shift; } void LLVOAvatar::updateSpatialExtents(LLVector4a& newMin, LLVector4a &newMax) { if (isImpostor() && !needsImpostorUpdate()) { LLVector3 delta = getRenderPosition() - ((LLVector3(mDrawable->getPositionGroup().getF32ptr())-mImpostorOffset)); newMin.load3( (mLastAnimExtents[0] + delta).mV); newMax.load3( (mLastAnimExtents[1] + delta).mV); } else { getSpatialExtents(newMin,newMax); mLastAnimExtents[0].set(newMin.getF32ptr()); mLastAnimExtents[1].set(newMax.getF32ptr()); LLVector4a pos_group; pos_group.setAdd(newMin,newMax); pos_group.mul(0.5f); mImpostorOffset = LLVector3(pos_group.getF32ptr())-getRenderPosition(); mDrawable->setPositionGroup(pos_group); } } void LLVOAvatar::getSpatialExtents(LLVector4a& newMin, LLVector4a& newMax) { LLVector4a buffer(0.25f); LLVector4a pos; pos.load3(getRenderPosition().mV); newMin.setSub(pos, buffer); newMax.setAdd(pos, buffer); float max_attachment_span = get_default_max_prim_scale() * 5.0f; //stretch bounding box by joint positions for (polymesh_map_t::iterator i = mPolyMeshes.begin(); i != mPolyMeshes.end(); ++i) { LLPolyMesh* mesh = i->second; for (S32 joint_num = 0; joint_num < mesh->mJointRenderData.size(); joint_num++) { LLVector4a trans; trans.load3( mesh->mJointRenderData[joint_num]->mWorldMatrix->getTranslation().mV); update_min_max(newMin, newMax, trans); } } LLVector4a center, size; center.setAdd(newMin, newMax); center.mul(0.5f); size.setSub(newMax,newMin); size.mul(0.5f); mPixelArea = LLPipeline::calcPixelArea(center, size, *LLViewerCamera::getInstance()); //stretch bounding box by attachments for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment->getValid()) { for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { const LLViewerObject* attached_object = (*attachment_iter); if (attached_object && !attached_object->isHUDAttachment()) { LLDrawable* drawable = attached_object->mDrawable; if (drawable && !drawable->isState(LLDrawable::RIGGED)) { LLSpatialBridge* bridge = drawable->getSpatialBridge(); if (bridge) { const LLVector4a* ext = bridge->getSpatialExtents(); LLVector4a distance; distance.setSub(ext[1], ext[0]); LLVector4a max_span(max_attachment_span); S32 lt = distance.lessThan(max_span).getGatheredBits() & 0x7; // Only add the prim to spatial extents calculations if it isn't a megaprim. // max_attachment_span calculated at the start of the function // (currently 5 times our max prim size) if (lt == 0x7) { update_min_max(newMin,newMax,ext[0]); update_min_max(newMin,newMax,ext[1]); } } } } } } } //pad bounding box newMin.sub(buffer); newMax.add(buffer); } void render_sphere_and_line(const LLVector3& begin_pos, const LLVector3& end_pos, F32 sphere_scale, const LLVector3& occ_color, const LLVector3& visible_color) { // Unoccluded bone portions LLGLDepthTest normal_depth(GL_TRUE); // Draw line segment for unoccluded joint gGL.diffuseColor3f(visible_color[0], visible_color[1], visible_color[2]); gGL.begin(LLRender::LINES); gGL.vertex3fv(begin_pos.mV); gGL.vertex3fv(end_pos.mV); gGL.end(); // Draw sphere representing joint pos gGL.pushMatrix(); gGL.scalef(sphere_scale, sphere_scale, sphere_scale); gSphere.renderGGL(); gGL.popMatrix(); LLGLDepthTest depth_under(GL_TRUE, GL_FALSE, GL_GREATER); // Occluded bone portions gGL.diffuseColor3f(occ_color[0], occ_color[1], occ_color[2]); gGL.begin(LLRender::LINES); gGL.vertex3fv(begin_pos.mV); gGL.vertex3fv(end_pos.mV); gGL.end(); // Draw sphere representing joint pos gGL.pushMatrix(); gGL.scalef(sphere_scale, sphere_scale, sphere_scale); gSphere.renderGGL(); gGL.popMatrix(); } //----------------------------------------------------------------------------- // renderCollisionVolumes() //----------------------------------------------------------------------------- void LLVOAvatar::renderCollisionVolumes() { std::ostringstream ostr; for (S32 i = 0; i < mNumCollisionVolumes; i++) { ostr << mCollisionVolumes[i].getName() << ", "; LLAvatarJointCollisionVolume& collision_volume = mCollisionVolumes[i]; collision_volume.updateWorldMatrix(); gGL.pushMatrix(); gGL.multMatrix( &collision_volume.getXform()->getWorldMatrix().mMatrix[0][0] ); LLVector3 begin_pos(0,0,0); LLVector3 end_pos(collision_volume.getEnd()); static F32 sphere_scale = 1.0f; static F32 center_dot_scale = 0.05f; static LLVector3 CV_COLOR_OCCLUDED(0.0f, 0.0f, 1.0f); static LLVector3 CV_COLOR_VISIBLE(0.5f, 0.5f, 1.0f); static LLVector3 DOT_COLOR_OCCLUDED(1.0f, 1.0f, 1.0f); static LLVector3 DOT_COLOR_VISIBLE(1.0f, 1.0f, 1.0f); render_sphere_and_line(begin_pos, end_pos, sphere_scale, CV_COLOR_OCCLUDED, CV_COLOR_VISIBLE); render_sphere_and_line(begin_pos, end_pos, center_dot_scale, DOT_COLOR_OCCLUDED, DOT_COLOR_VISIBLE); gGL.popMatrix(); } if (mNameText.notNull()) { LLVector4a unused; mNameText->lineSegmentIntersect(unused, unused, unused, TRUE); } mDebugText.clear(); addDebugText(ostr.str()); } void LLVOAvatar::renderBones() { LLGLEnable blend(GL_BLEND); avatar_joint_list_t::iterator iter = mSkeleton.begin(); avatar_joint_list_t::iterator end = mSkeleton.end(); // For bones with position overrides defined static LLVector3 OVERRIDE_COLOR_OCCLUDED(1.0f, 0.0f, 0.0f); static LLVector3 OVERRIDE_COLOR_VISIBLE(0.5f, 0.5f, 0.5f); // For bones which are rigged to by at least one attachment static LLVector3 RIGGED_COLOR_OCCLUDED(0.0f, 1.0f, 1.0f); static LLVector3 RIGGED_COLOR_VISIBLE(0.5f, 0.5f, 0.5f); // For bones not otherwise colored static LLVector3 OTHER_COLOR_OCCLUDED(0.0f, 1.0f, 0.0f); static LLVector3 OTHER_COLOR_VISIBLE(0.5f, 0.5f, 0.5f); static F32 SPHERE_SCALEF = 0.001f; for (; iter != end; ++iter) { LLJoint* jointp = *iter; if (!jointp) { continue; } jointp->updateWorldMatrix(); LLVector3 occ_color, visible_color; LLVector3 pos; LLUUID mesh_id; if (jointp->hasAttachmentPosOverride(pos,mesh_id)) { occ_color = OVERRIDE_COLOR_OCCLUDED; visible_color = OVERRIDE_COLOR_VISIBLE; } else { if (jointIsRiggedTo(jointp->getName())) { occ_color = RIGGED_COLOR_OCCLUDED; visible_color = RIGGED_COLOR_VISIBLE; } else { occ_color = OTHER_COLOR_OCCLUDED; visible_color = OTHER_COLOR_VISIBLE; } } LLVector3 begin_pos(0,0,0); LLVector3 end_pos(jointp->getEnd()); F32 sphere_scale = SPHERE_SCALEF; gGL.pushMatrix(); gGL.multMatrix( &jointp->getXform()->getWorldMatrix().mMatrix[0][0] ); render_sphere_and_line(begin_pos, end_pos, sphere_scale, occ_color, visible_color); gGL.popMatrix(); } } void LLVOAvatar::renderJoints() { std::ostringstream ostr; std::ostringstream nullstr; for (joint_map_t::iterator iter = mJointMap.begin(); iter != mJointMap.end(); ++iter) { LLJoint* jointp = iter->second; if (!jointp) { nullstr << iter->first << " is NULL" << std::endl; continue; } ostr << jointp->getName() << ", "; jointp->updateWorldMatrix(); gGL.pushMatrix(); gGL.multMatrix( &jointp->getXform()->getWorldMatrix().mMatrix[0][0] ); gGL.diffuseColor3f( 1.f, 0.f, 1.f ); gGL.begin(LLRender::LINES); LLVector3 v[] = { LLVector3(1,0,0), LLVector3(-1,0,0), LLVector3(0,1,0), LLVector3(0,-1,0), LLVector3(0,0,-1), LLVector3(0,0,1), }; //sides gGL.vertex3fv(v[0].mV); gGL.vertex3fv(v[2].mV); gGL.vertex3fv(v[0].mV); gGL.vertex3fv(v[3].mV); gGL.vertex3fv(v[1].mV); gGL.vertex3fv(v[2].mV); gGL.vertex3fv(v[1].mV); gGL.vertex3fv(v[3].mV); //top gGL.vertex3fv(v[0].mV); gGL.vertex3fv(v[4].mV); gGL.vertex3fv(v[1].mV); gGL.vertex3fv(v[4].mV); gGL.vertex3fv(v[2].mV); gGL.vertex3fv(v[4].mV); gGL.vertex3fv(v[3].mV); gGL.vertex3fv(v[4].mV); //bottom gGL.vertex3fv(v[0].mV); gGL.vertex3fv(v[5].mV); gGL.vertex3fv(v[1].mV); gGL.vertex3fv(v[5].mV); gGL.vertex3fv(v[2].mV); gGL.vertex3fv(v[5].mV); gGL.vertex3fv(v[3].mV); gGL.vertex3fv(v[5].mV); gGL.end(); gGL.popMatrix(); } mDebugText.clear(); addDebugText(ostr.str()); addDebugText(nullstr.str()); } BOOL LLVOAvatar::lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end, S32 face, BOOL pick_transparent, BOOL pick_rigged, S32* face_hit, LLVector4a* intersection, LLVector2* tex_coord, LLVector4a* normal, LLVector4a* tangent) { if ((isSelf() && !gAgent.needsRenderAvatar()) || !LLPipeline::sPickAvatar) { return FALSE; } if (lineSegmentBoundingBox(start, end)) { for (S32 i = 0; i < mNumCollisionVolumes; ++i) { mCollisionVolumes[i].updateWorldMatrix(); glh::matrix4f mat((F32*) mCollisionVolumes[i].getXform()->getWorldMatrix().mMatrix); glh::matrix4f inverse = mat.inverse(); glh::matrix4f norm_mat = inverse.transpose(); glh::vec3f p1(start.getF32ptr()); glh::vec3f p2(end.getF32ptr()); inverse.mult_matrix_vec(p1); inverse.mult_matrix_vec(p2); LLVector3 position; LLVector3 norm; if (linesegment_sphere(LLVector3(p1.v), LLVector3(p2.v), LLVector3(0,0,0), 1.f, position, norm)) { glh::vec3f res_pos(position.mV); mat.mult_matrix_vec(res_pos); norm.normalize(); glh::vec3f res_norm(norm.mV); norm_mat.mult_matrix_dir(res_norm); if (intersection) { intersection->load3(res_pos.v); } if (normal) { normal->load3(res_norm.v); } return TRUE; } } if (isSelf()) { for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { LLViewerObject* attached_object = (*attachment_iter); if (attached_object && !attached_object->isDead() && attachment->getValid()) { LLDrawable* drawable = attached_object->mDrawable; if (drawable->isState(LLDrawable::RIGGED)) { //regenerate octree for rigged attachment gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_RIGGED, TRUE); } } } } } } LLVector4a position; if (mNameText.notNull() && mNameText->lineSegmentIntersect(start, end, position)) { if (intersection) { *intersection = position; } return TRUE; } return FALSE; } LLViewerObject* LLVOAvatar::lineSegmentIntersectRiggedAttachments(const LLVector4a& start, const LLVector4a& end, S32 face, BOOL pick_transparent, BOOL pick_rigged, S32* face_hit, LLVector4a* intersection, LLVector2* tex_coord, LLVector4a* normal, LLVector4a* tangent) { if (isSelf() && !gAgent.needsRenderAvatar()) { return NULL; } LLViewerObject* hit = NULL; if (lineSegmentBoundingBox(start, end)) { LLVector4a local_end = end; LLVector4a local_intersection; for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { LLViewerObject* attached_object = (*attachment_iter); if (attached_object->lineSegmentIntersect(start, local_end, face, pick_transparent, pick_rigged, face_hit, &local_intersection, tex_coord, normal, tangent)) { local_end = local_intersection; if (intersection) { *intersection = local_intersection; } hit = attached_object; } } } } return hit; } LLVOAvatar* LLVOAvatar::asAvatar() { return this; } //----------------------------------------------------------------------------- // LLVOAvatar::startDefaultMotions() //----------------------------------------------------------------------------- void LLVOAvatar::startDefaultMotions() { //------------------------------------------------------------------------- // start default motions //------------------------------------------------------------------------- startMotion( ANIM_AGENT_HEAD_ROT ); startMotion( ANIM_AGENT_EYE ); startMotion( ANIM_AGENT_BODY_NOISE ); startMotion( ANIM_AGENT_BREATHE_ROT ); startMotion( ANIM_AGENT_PHYSICS_MOTION ); startMotion( ANIM_AGENT_HAND_MOTION ); startMotion( ANIM_AGENT_PELVIS_FIX ); //------------------------------------------------------------------------- // restart any currently active motions //------------------------------------------------------------------------- processAnimationStateChanges(); } //----------------------------------------------------------------------------- // LLVOAvatar::buildCharacter() // Deferred initialization and rebuild of the avatar. //----------------------------------------------------------------------------- // virtual void LLVOAvatar::buildCharacter() { LLAvatarAppearance::buildCharacter(); // Not done building yet; more to do. mIsBuilt = FALSE; //------------------------------------------------------------------------- // set head offset from pelvis //------------------------------------------------------------------------- updateHeadOffset(); //------------------------------------------------------------------------- // initialize lip sync morph pointers //------------------------------------------------------------------------- mOohMorph = getVisualParam( "Lipsync_Ooh" ); mAahMorph = getVisualParam( "Lipsync_Aah" ); // If we don't have the Ooh morph, use the Kiss morph if (!mOohMorph) { LL_WARNS() << "Missing 'Ooh' morph for lipsync, using fallback." << LL_ENDL; mOohMorph = getVisualParam( "Express_Kiss" ); } // If we don't have the Aah morph, use the Open Mouth morph if (!mAahMorph) { LL_WARNS() << "Missing 'Aah' morph for lipsync, using fallback." << LL_ENDL; mAahMorph = getVisualParam( "Express_Open_Mouth" ); } startDefaultMotions(); //------------------------------------------------------------------------- // restart any currently active motions //------------------------------------------------------------------------- processAnimationStateChanges(); mIsBuilt = TRUE; stop_glerror(); mMeshValid = TRUE; } //----------------------------------------------------------------------------- // resetVisualParams() //----------------------------------------------------------------------------- void LLVOAvatar::resetVisualParams() { // Skeletal params { LLAvatarXmlInfo::skeletal_distortion_info_list_t::iterator iter; for (iter = sAvatarXmlInfo->mSkeletalDistortionInfoList.begin(); iter != sAvatarXmlInfo->mSkeletalDistortionInfoList.end(); ++iter) { LLPolySkeletalDistortionInfo *info = (LLPolySkeletalDistortionInfo*)*iter; LLPolySkeletalDistortion *param = dynamic_cast<LLPolySkeletalDistortion*>(getVisualParam(info->getID())); *param = LLPolySkeletalDistortion(this); llassert(param); if (!param->setInfo(info)) { llassert(false); } } } // Driver parameters for (LLAvatarXmlInfo::driver_info_list_t::iterator iter = sAvatarXmlInfo->mDriverInfoList.begin(); iter != sAvatarXmlInfo->mDriverInfoList.end(); ++iter) { LLDriverParamInfo *info = *iter; LLDriverParam *param = dynamic_cast<LLDriverParam*>(getVisualParam(info->getID())); LLDriverParam::entry_list_t driven_list = param->getDrivenList(); *param = LLDriverParam(this); llassert(param); if (!param->setInfo(info)) { llassert(false); } param->setDrivenList(driven_list); } } //----------------------------------------------------------------------------- // resetSkeleton() //----------------------------------------------------------------------------- void LLVOAvatar::resetSkeleton(bool reset_animations) { LL_DEBUGS("Avatar") << avString() << " reset starts" << LL_ENDL; if (!mLastProcessedAppearance) { LL_WARNS() << "Can't reset avatar; no appearance message has been received yet." << LL_ENDL; return; } // Save mPelvis state //LLVector3 pelvis_pos = getJoint("mPelvis")->getPosition(); //LLQuaternion pelvis_rot = getJoint("mPelvis")->getRotation(); // Clear all attachment pos and scale overrides clearAttachmentOverrides(); // Note that we call buildSkeleton twice in this function. The first time is // just to get the right scale for the collision volumes, because // this will be used in setting the mJointScales for the // LLPolySkeletalDistortions of which the CVs are children. if( !buildSkeleton(sAvatarSkeletonInfo) ) { LL_ERRS() << "Error resetting skeleton" << LL_ENDL; } // Reset some params to default state, without propagating changes downstream. resetVisualParams(); // Now we have to reset the skeleton again, because its state // got clobbered by the resetVisualParams() calls // above. if( !buildSkeleton(sAvatarSkeletonInfo) ) { LL_ERRS() << "Error resetting skeleton" << LL_ENDL; } // Reset attachment points (buildSkeleton only does bones and CVs) bool ignore_hud_joints = true; initAttachmentPoints(ignore_hud_joints); // Fix up collision volumes for (LLVisualParam *param = getFirstVisualParam(); param; param = getNextVisualParam()) { LLPolyMorphTarget *poly_morph = dynamic_cast<LLPolyMorphTarget*>(param); if (poly_morph) { // This is a kludgy way to correct for the fact that the // collision volumes have been reset out from under the // poly morph sliders. F32 delta_weight = poly_morph->getLastWeight() - poly_morph->getDefaultWeight(); poly_morph->applyVolumeChanges(delta_weight); } } // Reset tweakable params to preserved state bool slam_params = true; applyParsedAppearanceMessage(*mLastProcessedAppearance, slam_params); updateVisualParams(); // Restore attachment pos overrides rebuildAttachmentOverrides(); // Animations if (reset_animations) { if (isSelf()) { // This is equivalent to "Stop Animating Me". Will reset // all animations and propagate the changes to other // viewers. gAgent.stopCurrentAnimations(); } else { // Local viewer-side reset for non-self avatars. resetAnimations(); } } LL_DEBUGS("Avatar") << avString() << " reset ends" << LL_ENDL; } //----------------------------------------------------------------------------- // releaseMeshData() //----------------------------------------------------------------------------- void LLVOAvatar::releaseMeshData() { if (sInstances.size() < AVATAR_RELEASE_THRESHOLD || mIsDummy) { return; } // cleanup mesh data for (avatar_joint_list_t::iterator iter = mMeshLOD.begin(); iter != mMeshLOD.end(); ++iter) { LLAvatarJoint* joint = (*iter); joint->setValid(FALSE, TRUE); } //cleanup data if (mDrawable.notNull()) { LLFace* facep = mDrawable->getFace(0); if (facep) { facep->setSize(0, 0); for(S32 i = mNumInitFaces ; i < mDrawable->getNumFaces(); i++) { facep = mDrawable->getFace(i); if (facep) { facep->setSize(0, 0); } } } } for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (!attachment->getIsHUDAttachment()) { attachment->setAttachmentVisibility(FALSE); } } mMeshValid = FALSE; } //----------------------------------------------------------------------------- // restoreMeshData() //----------------------------------------------------------------------------- // virtual void LLVOAvatar::restoreMeshData() { llassert(!isSelf()); //LL_INFOS() << "Restoring" << LL_ENDL; mMeshValid = TRUE; updateJointLODs(); for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (!attachment->getIsHUDAttachment()) { attachment->setAttachmentVisibility(TRUE); } } // force mesh update as LOD might not have changed to trigger this gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_GEOMETRY, TRUE); } //----------------------------------------------------------------------------- // updateMeshData() //----------------------------------------------------------------------------- void LLVOAvatar::updateMeshData() { if (mDrawable.notNull()) { stop_glerror(); S32 f_num = 0 ; const U32 VERTEX_NUMBER_THRESHOLD = 128 ;//small number of this means each part of an avatar has its own vertex buffer. const S32 num_parts = mMeshLOD.size(); // this order is determined by number of LODS // if a mesh earlier in this list changed LODs while a later mesh doesn't, // the later mesh's index offset will be inaccurate for(S32 part_index = 0 ; part_index < num_parts ;) { S32 j = part_index ; U32 last_v_num = 0, num_vertices = 0 ; U32 last_i_num = 0, num_indices = 0 ; while(part_index < num_parts && num_vertices < VERTEX_NUMBER_THRESHOLD) { last_v_num = num_vertices ; last_i_num = num_indices ; LLViewerJoint* part_mesh = getViewerJoint(part_index++); if (part_mesh) { part_mesh->updateFaceSizes(num_vertices, num_indices, mAdjustedPixelArea); } } if(num_vertices < 1)//skip empty meshes { continue ; } if(last_v_num > 0)//put the last inserted part into next vertex buffer. { num_vertices = last_v_num ; num_indices = last_i_num ; part_index-- ; } LLFace* facep = NULL; if(f_num < mDrawable->getNumFaces()) { facep = mDrawable->getFace(f_num); } else { facep = mDrawable->getFace(0); if (facep) { facep = mDrawable->addFace(facep->getPool(), facep->getTexture()) ; } } if (!facep) continue; // resize immediately facep->setSize(num_vertices, num_indices); bool terse_update = false; facep->setGeomIndex(0); facep->setIndicesIndex(0); LLVertexBuffer* buff = facep->getVertexBuffer(); if(!facep->getVertexBuffer()) { buff = new LLVertexBufferAvatar(); if (!buff->allocateBuffer(num_vertices, num_indices, TRUE)) { LL_WARNS() << "Failed to allocate Vertex Buffer for Mesh to " << num_vertices << " vertices and " << num_indices << " indices" << LL_ENDL; // Attempt to create a dummy triangle (one vertex, 3 indices, all 0) facep->setSize(1, 3); buff->allocateBuffer(1, 3, true); memset((U8*) buff->getMappedData(), 0, buff->getSize()); memset((U8*) buff->getMappedIndices(), 0, buff->getIndicesSize()); } facep->setVertexBuffer(buff); } else { if (buff->getNumIndices() == num_indices && buff->getNumVerts() == num_vertices) { terse_update = true; } else { if (!buff->resizeBuffer(num_vertices, num_indices)) { LL_WARNS() << "Failed to allocate vertex buffer for Mesh, Substituting" << LL_ENDL; // Attempt to create a dummy triangle (one vertex, 3 indices, all 0) facep->setSize(1, 3); buff->resizeBuffer(1, 3); memset((U8*) buff->getMappedData(), 0, buff->getSize()); memset((U8*) buff->getMappedIndices(), 0, buff->getIndicesSize()); } } } // This is a hack! Avatars have their own pool, so we are detecting // the case of more than one avatar in the pool (thus > 0 instead of >= 0) if (facep->getGeomIndex() > 0) { LL_ERRS() << "non-zero geom index: " << facep->getGeomIndex() << " in LLVOAvatar::restoreMeshData" << LL_ENDL; } if (num_vertices == buff->getNumVerts() && num_indices == buff->getNumIndices()) { for(S32 k = j ; k < part_index ; k++) { bool rigid = false; if (k == MESH_ID_EYEBALL_LEFT || k == MESH_ID_EYEBALL_RIGHT) { //eyeballs can't have terse updates since they're never rendered with //the hardware skinning shader rigid = true; } LLViewerJoint* mesh = getViewerJoint(k); if (mesh) { mesh->updateFaceData(facep, mAdjustedPixelArea, k == MESH_ID_HAIR, terse_update && !rigid); } } } stop_glerror(); buff->flush(); if(!f_num) { f_num += mNumInitFaces ; } else { f_num++ ; } } } } //------------------------------------------------------------------------ //------------------------------------------------------------------------ // LLVOAvatar::processUpdateMessage() //------------------------------------------------------------------------ U32 LLVOAvatar::processUpdateMessage(LLMessageSystem *mesgsys, void **user_data, U32 block_num, const EObjectUpdateType update_type, LLDataPacker *dp) { const BOOL has_name = !getNVPair("FirstName"); // Do base class updates... U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp); // Print out arrival information once we have name of avatar. if (has_name && getNVPair("FirstName")) { mDebugExistenceTimer.reset(); debugAvatarRezTime("AvatarRezArrivedNotification","avatar arrived"); } if(retval & LLViewerObject::INVALID_UPDATE) { if (isSelf()) { //tell sim to cancel this update gAgent.teleportViaLocation(gAgent.getPositionGlobal()); } } return retval; } LLViewerFetchedTexture *LLVOAvatar::getBakedTextureImage(const U8 te, const LLUUID& uuid) { LLViewerFetchedTexture *result = NULL; if (uuid == IMG_DEFAULT_AVATAR || uuid == IMG_DEFAULT || uuid == IMG_INVISIBLE) { // Should already exist, don't need to find it on sim or baked-texture host. result = gTextureList.findImage(uuid, TEX_LIST_STANDARD); } if (!result) { const std::string url = getImageURL(te,uuid); if (url.empty()) { LL_WARNS() << "unable to determine URL for te " << te << " uuid " << uuid << LL_ENDL; return NULL; } LL_DEBUGS("Avatar") << avString() << "get server-bake image from URL " << url << LL_ENDL; result = LLViewerTextureManager::getFetchedTextureFromUrl( url, FTT_SERVER_BAKE, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, uuid); if (result->isMissingAsset()) { result->setIsMissingAsset(false); } } return result; } // virtual S32 LLVOAvatar::setTETexture(const U8 te, const LLUUID& uuid) { if (!isIndexBakedTexture((ETextureIndex)te)) { // Sim still sends some uuids for non-baked slots sometimes - ignore. return LLViewerObject::setTETexture(te, LLUUID::null); } LLViewerFetchedTexture *image = getBakedTextureImage(te,uuid); llassert(image); return setTETextureCore(te, image); } static LLTrace::BlockTimerStatHandle FTM_AVATAR_UPDATE("Avatar Update"); static LLTrace::BlockTimerStatHandle FTM_JOINT_UPDATE("Update Joints"); //------------------------------------------------------------------------ // LLVOAvatar::dumpAnimationState() //------------------------------------------------------------------------ void LLVOAvatar::dumpAnimationState() { LL_INFOS() << "==============================================" << LL_ENDL; for (LLVOAvatar::AnimIterator it = mSignaledAnimations.begin(); it != mSignaledAnimations.end(); ++it) { LLUUID id = it->first; std::string playtag = ""; if (mPlayingAnimations.find(id) != mPlayingAnimations.end()) { playtag = "*"; } LL_INFOS() << gAnimLibrary.animationName(id) << playtag << LL_ENDL; } for (LLVOAvatar::AnimIterator it = mPlayingAnimations.begin(); it != mPlayingAnimations.end(); ++it) { LLUUID id = it->first; bool is_signaled = mSignaledAnimations.find(id) != mSignaledAnimations.end(); if (!is_signaled) { LL_INFOS() << gAnimLibrary.animationName(id) << "!S" << LL_ENDL; } } } //------------------------------------------------------------------------ // idleUpdate() //------------------------------------------------------------------------ void LLVOAvatar::idleUpdate(LLAgent &agent, const F64 &time) { LL_RECORD_BLOCK_TIME(FTM_AVATAR_UPDATE); if (isDead()) { LL_INFOS() << "Warning! Idle on dead avatar" << LL_ENDL; return; } if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_AVATAR)) && !(gSavedSettings.getBOOL("DisableAllRenderTypes")) && !isSelf()) { return; } LLScopedContextString str("avatar_idle_update " + getFullname()); checkTextureLoading() ; // force immediate pixel area update on avatars using last frames data (before drawable or camera updates) setPixelAreaAndAngle(gAgent); // force asynchronous drawable update if(mDrawable.notNull()) { LL_RECORD_BLOCK_TIME(FTM_JOINT_UPDATE); if (mIsSitting && getParent()) { LLViewerObject *root_object = (LLViewerObject*)getRoot(); LLDrawable* drawablep = root_object->mDrawable; // if this object hasn't already been updated by another avatar... if (drawablep) // && !drawablep->isState(LLDrawable::EARLY_MOVE)) { if (root_object->isSelected()) { gPipeline.updateMoveNormalAsync(drawablep); } else { gPipeline.updateMoveDampedAsync(drawablep); } } } else { gPipeline.updateMoveDampedAsync(mDrawable); } } //-------------------------------------------------------------------- // set alpha flag depending on state //-------------------------------------------------------------------- if (isSelf()) { LLViewerObject::idleUpdate(agent, time); // trigger fidget anims if (isAnyAnimationSignaled(AGENT_STAND_ANIMS, NUM_AGENT_STAND_ANIMS)) { agent.fidget(); } } else { // Should override the idleUpdate stuff and leave out the angular update part. LLQuaternion rotation = getRotation(); LLViewerObject::idleUpdate(agent, time); setRotation(rotation); } // attach objects that were waiting for a drawable lazyAttach(); // animate the character // store off last frame's root position to be consistent with camera position mLastRootPos = mRoot->getWorldPosition(); BOOL detailed_update = updateCharacter(agent); static LLUICachedControl<bool> visualizers_in_calls("ShowVoiceVisualizersInCalls", false); bool voice_enabled = (visualizers_in_calls || LLVoiceClient::getInstance()->inProximalChannel()) && LLVoiceClient::getInstance()->getVoiceEnabled(mID); idleUpdateVoiceVisualizer( voice_enabled ); idleUpdateMisc( detailed_update ); idleUpdateAppearanceAnimation(); if (detailed_update) { idleUpdateLipSync( voice_enabled ); idleUpdateLoadingEffect(); idleUpdateBelowWater(); // wind effect uses this idleUpdateWindEffect(); } idleUpdateNameTag( mLastRootPos ); idleUpdateRenderComplexity(); } void LLVOAvatar::idleUpdateVoiceVisualizer(bool voice_enabled) { bool render_visualizer = voice_enabled; // Don't render the user's own voice visualizer when in mouselook, or when opening the mic is disabled. if(isSelf()) { if(gAgentCamera.cameraMouselook() || gSavedSettings.getBOOL("VoiceDisableMic")) { render_visualizer = false; } } mVoiceVisualizer->setVoiceEnabled(render_visualizer); if ( voice_enabled ) { //---------------------------------------------------------------- // Only do gesture triggering for your own avatar, and only when you're in a proximal channel. //---------------------------------------------------------------- if( isSelf() ) { //---------------------------------------------------------------------------------------- // The following takes the voice signal and uses that to trigger gesticulations. //---------------------------------------------------------------------------------------- int lastGesticulationLevel = mCurrentGesticulationLevel; mCurrentGesticulationLevel = mVoiceVisualizer->getCurrentGesticulationLevel(); //--------------------------------------------------------------------------------------------------- // If "current gesticulation level" changes, we catch this, and trigger the new gesture //--------------------------------------------------------------------------------------------------- if ( lastGesticulationLevel != mCurrentGesticulationLevel ) { if ( mCurrentGesticulationLevel != VOICE_GESTICULATION_LEVEL_OFF ) { std::string gestureString = "unInitialized"; if ( mCurrentGesticulationLevel == 0 ) { gestureString = "/voicelevel1"; } else if ( mCurrentGesticulationLevel == 1 ) { gestureString = "/voicelevel2"; } else if ( mCurrentGesticulationLevel == 2 ) { gestureString = "/voicelevel3"; } else { LL_INFOS() << "oops - CurrentGesticulationLevel can be only 0, 1, or 2" << LL_ENDL; } // this is the call that Karl S. created for triggering gestures from within the code. LLGestureMgr::instance().triggerAndReviseString( gestureString ); } } } //if( isSelf() ) //----------------------------------------------------------------------------------------------------------------- // If the avatar is speaking, then the voice amplitude signal is passed to the voice visualizer. // Also, here we trigger voice visualizer start and stop speaking, so it can animate the voice symbol. // // Notice the calls to "gAwayTimer.reset()". This resets the timer that determines how long the avatar has been // "away", so that the avatar doesn't lapse into away-mode (and slump over) while the user is still talking. //----------------------------------------------------------------------------------------------------------------- if (LLVoiceClient::getInstance()->getIsSpeaking( mID )) { if (!mVoiceVisualizer->getCurrentlySpeaking()) { mVoiceVisualizer->setStartSpeaking(); //printf( "gAwayTimer.reset();\n" ); } mVoiceVisualizer->setSpeakingAmplitude( LLVoiceClient::getInstance()->getCurrentPower( mID ) ); if( isSelf() ) { gAgent.clearAFK(); } } else { if ( mVoiceVisualizer->getCurrentlySpeaking() ) { mVoiceVisualizer->setStopSpeaking(); if ( mLipSyncActive ) { if( mOohMorph ) mOohMorph->setWeight(mOohMorph->getMinWeight()); if( mAahMorph ) mAahMorph->setWeight(mAahMorph->getMinWeight()); mLipSyncActive = false; LLCharacter::updateVisualParams(); dirtyMesh(); } } } //-------------------------------------------------------------------------------------------- // here we get the approximate head position and set as sound source for the voice symbol // (the following version uses a tweak of "mHeadOffset" which handle sitting vs. standing) //-------------------------------------------------------------------------------------------- if ( mIsSitting ) { LLVector3 headOffset = LLVector3( 0.0f, 0.0f, mHeadOffset.mV[2] ); mVoiceVisualizer->setVoiceSourceWorldPosition( mRoot->getWorldPosition() + headOffset ); } else { LLVector3 tagPos = mRoot->getWorldPosition(); tagPos[VZ] -= mPelvisToFoot; tagPos[VZ] += ( mBodySize[VZ] + 0.125f ); // does not need mAvatarOffset -Nyx mVoiceVisualizer->setVoiceSourceWorldPosition( tagPos ); } }//if ( voiceEnabled ) } static LLTrace::BlockTimerStatHandle FTM_ATTACHMENT_UPDATE("Update Attachments"); void LLVOAvatar::idleUpdateMisc(bool detailed_update) { if (LLVOAvatar::sJointDebug) { LL_INFOS() << getFullname() << ": joint touches: " << LLJoint::sNumTouches << " updates: " << LLJoint::sNumUpdates << LL_ENDL; } LLJoint::sNumUpdates = 0; LLJoint::sNumTouches = 0; BOOL visible = isVisible() || mNeedsAnimUpdate; // update attachments positions if (detailed_update || !sUseImpostors) { LL_RECORD_BLOCK_TIME(FTM_ATTACHMENT_UPDATE); for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { LLViewerObject* attached_object = (*attachment_iter); BOOL visibleAttachment = visible || (attached_object && !(attached_object->mDrawable->getSpatialBridge() && attached_object->mDrawable->getSpatialBridge()->getRadius() < 2.0)); if (visibleAttachment && attached_object && !attached_object->isDead() && attachment->getValid()) { // if selecting any attachments, update all of them as non-damped if (LLSelectMgr::getInstance()->getSelection()->getObjectCount() && LLSelectMgr::getInstance()->getSelection()->isAttachment()) { gPipeline.updateMoveNormalAsync(attached_object->mDrawable); } else { gPipeline.updateMoveDampedAsync(attached_object->mDrawable); } LLSpatialBridge* bridge = attached_object->mDrawable->getSpatialBridge(); if (bridge) { gPipeline.updateMoveNormalAsync(bridge); } attached_object->updateText(); } } } } mNeedsAnimUpdate = FALSE; if (isImpostor() && !mNeedsImpostorUpdate) { LL_ALIGN_16(LLVector4a ext[2]); F32 distance; LLVector3 angle; getImpostorValues(ext, angle, distance); for (U32 i = 0; i < 3 && !mNeedsImpostorUpdate; i++) { F32 cur_angle = angle.mV[i]; F32 old_angle = mImpostorAngle.mV[i]; F32 angle_diff = fabsf(cur_angle-old_angle); if (angle_diff > F_PI/512.f*distance*mUpdatePeriod) { mNeedsImpostorUpdate = TRUE; } } if (detailed_update && !mNeedsImpostorUpdate) { //update impostor if view angle, distance, or bounding box change //significantly F32 dist_diff = fabsf(distance-mImpostorDistance); if (dist_diff/mImpostorDistance > 0.1f) { mNeedsImpostorUpdate = TRUE; } else { //VECTORIZE THIS getSpatialExtents(ext[0], ext[1]); LLVector4a diff; diff.setSub(ext[1], mImpostorExtents[1]); if (diff.getLength3().getF32() > 0.05f) { mNeedsImpostorUpdate = TRUE; } else { diff.setSub(ext[0], mImpostorExtents[0]); if (diff.getLength3().getF32() > 0.05f) { mNeedsImpostorUpdate = TRUE; } } } } } mDrawable->movePartition(); //force a move if sitting on an active object if (getParent() && ((LLViewerObject*) getParent())->mDrawable->isActive()) { gPipeline.markMoved(mDrawable, TRUE); } } void LLVOAvatar::idleUpdateAppearanceAnimation() { // update morphing params if (mAppearanceAnimating) { ESex avatar_sex = getSex(); F32 appearance_anim_time = mAppearanceMorphTimer.getElapsedTimeF32(); if (appearance_anim_time >= APPEARANCE_MORPH_TIME) { mAppearanceAnimating = FALSE; for (LLVisualParam *param = getFirstVisualParam(); param; param = getNextVisualParam()) { if (param->isTweakable()) { param->stopAnimating(); } } updateVisualParams(); } else { F32 morph_amt = calcMorphAmount(); LLVisualParam *param; if (!isSelf()) { // animate only top level params for non-self avatars for (param = getFirstVisualParam(); param; param = getNextVisualParam()) { if (param->isTweakable()) { param->animate(morph_amt); } } } // apply all params for (param = getFirstVisualParam(); param; param = getNextVisualParam()) { param->apply(avatar_sex); } mLastAppearanceBlendTime = appearance_anim_time; } dirtyMesh(); } } F32 LLVOAvatar::calcMorphAmount() { F32 appearance_anim_time = mAppearanceMorphTimer.getElapsedTimeF32(); F32 blend_frac = calc_bouncy_animation(appearance_anim_time / APPEARANCE_MORPH_TIME); F32 last_blend_frac = calc_bouncy_animation(mLastAppearanceBlendTime / APPEARANCE_MORPH_TIME); F32 morph_amt; if (last_blend_frac == 1.f) { morph_amt = 1.f; } else { morph_amt = (blend_frac - last_blend_frac) / (1.f - last_blend_frac); } return morph_amt; } void LLVOAvatar::idleUpdateLipSync(bool voice_enabled) { // Use the Lipsync_Ooh and Lipsync_Aah morphs for lip sync if ( voice_enabled && (LLVoiceClient::getInstance()->lipSyncEnabled()) && LLVoiceClient::getInstance()->getIsSpeaking( mID ) ) { F32 ooh_morph_amount = 0.0f; F32 aah_morph_amount = 0.0f; mVoiceVisualizer->lipSyncOohAah( ooh_morph_amount, aah_morph_amount ); if( mOohMorph ) { F32 ooh_weight = mOohMorph->getMinWeight() + ooh_morph_amount * (mOohMorph->getMaxWeight() - mOohMorph->getMinWeight()); mOohMorph->setWeight( ooh_weight); } if( mAahMorph ) { F32 aah_weight = mAahMorph->getMinWeight() + aah_morph_amount * (mAahMorph->getMaxWeight() - mAahMorph->getMinWeight()); mAahMorph->setWeight( aah_weight); } mLipSyncActive = true; LLCharacter::updateVisualParams(); dirtyMesh(); } } void LLVOAvatar::idleUpdateLoadingEffect() { // update visibility when avatar is partially loaded if (updateIsFullyLoaded()) // changed? { if (isFullyLoaded()) { if (mFirstFullyVisible) { mFirstFullyVisible = FALSE; if (isSelf()) { LL_INFOS("Avatar") << avString() << "self isFullyLoaded, mFirstFullyVisible" << LL_ENDL; LLAppearanceMgr::instance().onFirstFullyVisible(); } else { LL_INFOS("Avatar") << avString() << "other isFullyLoaded, mFirstFullyVisible" << LL_ENDL; } } deleteParticleSource(); updateLOD(); } else { LLPartSysData particle_parameters; // fancy particle cloud designed by Brent particle_parameters.mPartData.mMaxAge = 4.f; particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f; particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f; particle_parameters.mPartData.mStartScale.mV[VY] = 1.0f; particle_parameters.mPartData.mEndScale.mV[VX] = 0.02f; particle_parameters.mPartData.mEndScale.mV[VY] = 0.02f; particle_parameters.mPartData.mStartColor = LLColor4(1, 1, 1, 0.5f); particle_parameters.mPartData.mEndColor = LLColor4(1, 1, 1, 0.0f); particle_parameters.mPartData.mStartScale.mV[VX] = 0.8f; LLViewerTexture* cloud = LLViewerTextureManager::getFetchedTextureFromFile("cloud-particle.j2c"); particle_parameters.mPartImageID = cloud->getID(); particle_parameters.mMaxAge = 0.f; particle_parameters.mPattern = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE; particle_parameters.mInnerAngle = F_PI; particle_parameters.mOuterAngle = 0.f; particle_parameters.mBurstRate = 0.02f; particle_parameters.mBurstRadius = 0.0f; particle_parameters.mBurstPartCount = 1; particle_parameters.mBurstSpeedMin = 0.1f; particle_parameters.mBurstSpeedMax = 1.f; particle_parameters.mPartData.mFlags = ( LLPartData::LL_PART_INTERP_COLOR_MASK | LLPartData::LL_PART_INTERP_SCALE_MASK | LLPartData::LL_PART_EMISSIVE_MASK | // LLPartData::LL_PART_FOLLOW_SRC_MASK | LLPartData::LL_PART_TARGET_POS_MASK ); if (!isTooComplex()) // do not generate particles for overly-complex avatars { setParticleSource(particle_parameters, getID()); } } } } void LLVOAvatar::idleUpdateWindEffect() { // update wind effect if ((LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR) >= LLDrawPoolAvatar::SHADER_LEVEL_CLOTH)) { F32 hover_strength = 0.f; F32 time_delta = mRippleTimer.getElapsedTimeF32() - mRippleTimeLast; mRippleTimeLast = mRippleTimer.getElapsedTimeF32(); LLVector3 velocity = getVelocity(); F32 speed = velocity.length(); //RN: velocity varies too much frame to frame for this to work mRippleAccel.clearVec();//lerp(mRippleAccel, (velocity - mLastVel) * time_delta, LLSmoothInterpolation::getInterpolant(0.02f)); mLastVel = velocity; LLVector4 wind; wind.setVec(getRegion()->mWind.getVelocityNoisy(getPositionAgent(), 4.f) - velocity); if (mInAir) { hover_strength = HOVER_EFFECT_STRENGTH * llmax(0.f, HOVER_EFFECT_MAX_SPEED - speed); } if (mBelowWater) { // TODO: make cloth flow more gracefully when underwater hover_strength += UNDERWATER_EFFECT_STRENGTH; } wind.mV[VZ] += hover_strength; wind.normalize(); wind.mV[VW] = llmin(0.025f + (speed * 0.015f) + hover_strength, 0.5f); F32 interp; if (wind.mV[VW] > mWindVec.mV[VW]) { interp = LLSmoothInterpolation::getInterpolant(0.2f); } else { interp = LLSmoothInterpolation::getInterpolant(0.4f); } mWindVec = lerp(mWindVec, wind, interp); F32 wind_freq = hover_strength + llclamp(8.f + (speed * 0.7f) + (noise1(mRipplePhase) * 4.f), 8.f, 25.f); mWindFreq = lerp(mWindFreq, wind_freq, interp); if (mBelowWater) { mWindFreq *= UNDERWATER_FREQUENCY_DAMP; } mRipplePhase += (time_delta * mWindFreq); if (mRipplePhase > F_TWO_PI) { mRipplePhase = fmodf(mRipplePhase, F_TWO_PI); } } } void LLVOAvatar::idleUpdateNameTag(const LLVector3& root_pos_last) { // update chat bubble //-------------------------------------------------------------------- // draw text label over character's head //-------------------------------------------------------------------- if (mChatTimer.getElapsedTimeF32() > BUBBLE_CHAT_TIME) { mChats.clear(); } const F32 time_visible = mTimeVisible.getElapsedTimeF32(); const F32 NAME_SHOW_TIME = gSavedSettings.getF32("RenderNameShowTime"); // seconds const F32 FADE_DURATION = gSavedSettings.getF32("RenderNameFadeDuration"); // seconds BOOL visible_avatar = isVisible() || mNeedsAnimUpdate; BOOL visible_chat = gSavedSettings.getBOOL("UseChatBubbles") && (mChats.size() || mTyping); BOOL render_name = visible_chat || (visible_avatar && ((sRenderName == RENDER_NAME_ALWAYS) || (sRenderName == RENDER_NAME_FADE && time_visible < NAME_SHOW_TIME))); // If it's your own avatar, don't draw in mouselook, and don't // draw if we're specifically hiding our own name. if (isSelf()) { render_name = render_name && !gAgentCamera.cameraMouselook() && (visible_chat || (gSavedSettings.getBOOL("RenderNameShowSelf") && gSavedSettings.getS32("AvatarNameTagMode") )); } if ( !render_name ) { if (mNameText) { // ...clean up old name tag mNameText->markDead(); mNameText = NULL; sNumVisibleChatBubbles--; } return; } BOOL new_name = FALSE; if (visible_chat != mVisibleChat) { mVisibleChat = visible_chat; new_name = TRUE; } if (sRenderGroupTitles != mRenderGroupTitles) { mRenderGroupTitles = sRenderGroupTitles; new_name = TRUE; } // First Calculate Alpha // If alpha > 0, create mNameText if necessary, otherwise delete it F32 alpha = 0.f; if (mAppAngle > 5.f) { const F32 START_FADE_TIME = NAME_SHOW_TIME - FADE_DURATION; if (!visible_chat && sRenderName == RENDER_NAME_FADE && time_visible > START_FADE_TIME) { alpha = 1.f - (time_visible - START_FADE_TIME) / FADE_DURATION; } else { // ...not fading, full alpha alpha = 1.f; } } else if (mAppAngle > 2.f) { // far away is faded out also alpha = (mAppAngle-2.f)/3.f; } if (alpha <= 0.f) { if (mNameText) { mNameText->markDead(); mNameText = NULL; sNumVisibleChatBubbles--; } return; } if (!mNameText) { mNameText = static_cast<LLHUDNameTag*>( LLHUDObject::addHUDObject( LLHUDObject::LL_HUD_NAME_TAG) ); //mNameText->setMass(10.f); mNameText->setSourceObject(this); mNameText->setVertAlignment(LLHUDNameTag::ALIGN_VERT_TOP); mNameText->setVisibleOffScreen(TRUE); mNameText->setMaxLines(11); mNameText->setFadeDistance(CHAT_NORMAL_RADIUS, 5.f); sNumVisibleChatBubbles++; new_name = TRUE; } idleUpdateNameTagPosition(root_pos_last); idleUpdateNameTagText(new_name); idleUpdateNameTagAlpha(new_name, alpha); } void LLVOAvatar::idleUpdateNameTagText(BOOL new_name) { LLNameValue *title = getNVPair("Title"); LLNameValue* firstname = getNVPair("FirstName"); LLNameValue* lastname = getNVPair("LastName"); // Avatars must have a first and last name if (!firstname || !lastname) return; bool is_away = mSignaledAnimations.find(ANIM_AGENT_AWAY) != mSignaledAnimations.end(); bool is_do_not_disturb = mSignaledAnimations.find(ANIM_AGENT_DO_NOT_DISTURB) != mSignaledAnimations.end(); bool is_appearance = mSignaledAnimations.find(ANIM_AGENT_CUSTOMIZE) != mSignaledAnimations.end(); bool is_muted; if (isSelf()) { is_muted = false; } else { is_muted = isInMuteList(); } bool is_friend = LLAvatarTracker::instance().isBuddy(getID()); bool is_cloud = getIsCloud(); if (is_appearance != mNameAppearance) { if (is_appearance) { debugAvatarRezTime("AvatarRezEnteredAppearanceNotification","entered appearance mode"); } else { debugAvatarRezTime("AvatarRezLeftAppearanceNotification","left appearance mode"); } } // Rebuild name tag if state change detected if (!mNameIsSet || new_name || (!title && !mTitle.empty()) || (title && mTitle != title->getString()) || is_away != mNameAway || is_do_not_disturb != mNameDoNotDisturb || is_muted != mNameMute || is_appearance != mNameAppearance || is_friend != mNameFriend || is_cloud != mNameCloud) { LLColor4 name_tag_color = getNameTagColor(is_friend); clearNameTag(); if (is_away || is_muted || is_do_not_disturb || is_appearance) { std::string line; if (is_away) { line += LLTrans::getString("AvatarAway"); line += ", "; } if (is_do_not_disturb) { line += LLTrans::getString("AvatarDoNotDisturb"); line += ", "; } if (is_muted) { line += LLTrans::getString("AvatarMuted"); line += ", "; } if (is_appearance) { line += LLTrans::getString("AvatarEditingAppearance"); line += ", "; } if (is_cloud) { line += LLTrans::getString("LoadingData"); line += ", "; } // trim last ", " line.resize( line.length() - 2 ); addNameTagLine(line, name_tag_color, LLFontGL::NORMAL, LLFontGL::getFontSansSerifSmall()); } if (sRenderGroupTitles && title && title->getString() && title->getString()[0] != '\0') { std::string title_str = title->getString(); LLStringFn::replace_ascii_controlchars(title_str,LL_UNKNOWN_CHAR); addNameTagLine(title_str, name_tag_color, LLFontGL::NORMAL, LLFontGL::getFontSansSerifSmall()); } static LLUICachedControl<bool> show_display_names("NameTagShowDisplayNames", true); static LLUICachedControl<bool> show_usernames("NameTagShowUsernames", true); if (LLAvatarName::useDisplayNames()) { LLAvatarName av_name; if (!LLAvatarNameCache::get(getID(), &av_name)) { // Force a rebuild at next idle // Note: do not connect a callback on idle(). clearNameTag(); } // Might be blank if name not available yet, that's OK if (show_display_names) { addNameTagLine(av_name.getDisplayName(), name_tag_color, LLFontGL::NORMAL, LLFontGL::getFontSansSerif()); } // Suppress SLID display if display name matches exactly (ugh) if (show_usernames && !av_name.isDisplayNameDefault()) { // *HACK: Desaturate the color LLColor4 username_color = name_tag_color * 0.83f; addNameTagLine(av_name.getUserName(), username_color, LLFontGL::NORMAL, LLFontGL::getFontSansSerifSmall()); } } else { const LLFontGL* font = LLFontGL::getFontSansSerif(); std::string full_name = LLCacheName::buildFullName( firstname->getString(), lastname->getString() ); addNameTagLine(full_name, name_tag_color, LLFontGL::NORMAL, font); } mNameAway = is_away; mNameDoNotDisturb = is_do_not_disturb; mNameMute = is_muted; mNameAppearance = is_appearance; mNameFriend = is_friend; mNameCloud = is_cloud; mTitle = title ? title->getString() : ""; LLStringFn::replace_ascii_controlchars(mTitle,LL_UNKNOWN_CHAR); new_name = TRUE; } if (mVisibleChat) { mNameText->setFont(LLFontGL::getFontSansSerif()); mNameText->setTextAlignment(LLHUDNameTag::ALIGN_TEXT_LEFT); mNameText->setFadeDistance(CHAT_NORMAL_RADIUS * 2.f, 5.f); std::deque<LLChat>::iterator chat_iter = mChats.begin(); mNameText->clearString(); LLColor4 new_chat = LLUIColorTable::instance().getColor( isSelf() ? "UserChatColor" : "AgentChatColor" ); LLColor4 normal_chat = lerp(new_chat, LLColor4(0.8f, 0.8f, 0.8f, 1.f), 0.7f); LLColor4 old_chat = lerp(normal_chat, LLColor4(0.6f, 0.6f, 0.6f, 1.f), 0.7f); if (mTyping && mChats.size() >= MAX_BUBBLE_CHAT_UTTERANCES) { ++chat_iter; } for(; chat_iter != mChats.end(); ++chat_iter) { F32 chat_fade_amt = llclamp((F32)((LLFrameTimer::getElapsedSeconds() - chat_iter->mTime) / CHAT_FADE_TIME), 0.f, 4.f); LLFontGL::StyleFlags style; switch(chat_iter->mChatType) { case CHAT_TYPE_WHISPER: style = LLFontGL::ITALIC; break; case CHAT_TYPE_SHOUT: style = LLFontGL::BOLD; break; default: style = LLFontGL::NORMAL; break; } if (chat_fade_amt < 1.f) { F32 u = clamp_rescale(chat_fade_amt, 0.9f, 1.f, 0.f, 1.f); mNameText->addLine(chat_iter->mText, lerp(new_chat, normal_chat, u), style); } else if (chat_fade_amt < 2.f) { F32 u = clamp_rescale(chat_fade_amt, 1.9f, 2.f, 0.f, 1.f); mNameText->addLine(chat_iter->mText, lerp(normal_chat, old_chat, u), style); } else if (chat_fade_amt < 3.f) { // *NOTE: only remove lines down to minimum number mNameText->addLine(chat_iter->mText, old_chat, style); } } mNameText->setVisibleOffScreen(TRUE); if (mTyping) { S32 dot_count = (llfloor(mTypingTimer.getElapsedTimeF32() * 3.f) + 2) % 3 + 1; switch(dot_count) { case 1: mNameText->addLine(".", new_chat); break; case 2: mNameText->addLine("..", new_chat); break; case 3: mNameText->addLine("...", new_chat); break; } } } else { // ...not using chat bubbles, just names mNameText->setTextAlignment(LLHUDNameTag::ALIGN_TEXT_CENTER); mNameText->setFadeDistance(CHAT_NORMAL_RADIUS, 5.f); mNameText->setVisibleOffScreen(FALSE); } } void LLVOAvatar::addNameTagLine(const std::string& line, const LLColor4& color, S32 style, const LLFontGL* font) { llassert(mNameText); if (mVisibleChat) { mNameText->addLabel(line); } else { mNameText->addLine(line, color, (LLFontGL::StyleFlags)style, font); } mNameIsSet |= !line.empty(); } void LLVOAvatar::clearNameTag() { mNameIsSet = false; if (mNameText) { mNameText->setLabel(""); mNameText->setString(""); } mTimeVisible.reset(); } //static void LLVOAvatar::invalidateNameTag(const LLUUID& agent_id) { LLViewerObject* obj = gObjectList.findObject(agent_id); if (!obj) return; LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(obj); if (!avatar) return; avatar->clearNameTag(); } //static void LLVOAvatar::invalidateNameTags() { std::vector<LLCharacter*>::iterator it = LLCharacter::sInstances.begin(); for ( ; it != LLCharacter::sInstances.end(); ++it) { LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(*it); if (!avatar) continue; if (avatar->isDead()) continue; avatar->clearNameTag(); } } // Compute name tag position during idle update void LLVOAvatar::idleUpdateNameTagPosition(const LLVector3& root_pos_last) { LLQuaternion root_rot = mRoot->getWorldRotation(); LLQuaternion inv_root_rot = ~root_rot; LLVector3 pixel_right_vec; LLVector3 pixel_up_vec; LLViewerCamera::getInstance()->getPixelVectors(root_pos_last, pixel_up_vec, pixel_right_vec); LLVector3 camera_to_av = root_pos_last - LLViewerCamera::getInstance()->getOrigin(); camera_to_av.normalize(); LLVector3 local_camera_at = camera_to_av * inv_root_rot; LLVector3 local_camera_up = camera_to_av % LLViewerCamera::getInstance()->getLeftAxis(); local_camera_up.normalize(); local_camera_up = local_camera_up * inv_root_rot; // position is based on head position, does not require mAvatarOffset here. - Nyx LLVector3 avatar_ellipsoid(mBodySize.mV[VX] * 0.4f, mBodySize.mV[VY] * 0.4f, mBodySize.mV[VZ] * NAMETAG_VERT_OFFSET_WEIGHT); local_camera_up.scaleVec(avatar_ellipsoid); local_camera_at.scaleVec(avatar_ellipsoid); LLVector3 head_offset = (mHeadp->getLastWorldPosition() - mRoot->getLastWorldPosition()) * inv_root_rot; if (dist_vec(head_offset, mTargetRootToHeadOffset) > NAMETAG_UPDATE_THRESHOLD) { mTargetRootToHeadOffset = head_offset; } mCurRootToHeadOffset = lerp(mCurRootToHeadOffset, mTargetRootToHeadOffset, LLSmoothInterpolation::getInterpolant(0.2f)); LLVector3 name_position = mRoot->getLastWorldPosition() + (mCurRootToHeadOffset * root_rot); name_position += (local_camera_up * root_rot) - (projected_vec(local_camera_at * root_rot, camera_to_av)); name_position += pixel_up_vec * NAMETAG_VERTICAL_SCREEN_OFFSET; mNameText->setPositionAgent(name_position); } void LLVOAvatar::idleUpdateNameTagAlpha(BOOL new_name, F32 alpha) { llassert(mNameText); if (new_name || alpha != mNameAlpha) { mNameText->setAlpha(alpha); mNameAlpha = alpha; } } LLColor4 LLVOAvatar::getNameTagColor(bool is_friend) { static LLUICachedControl<bool> show_friends("NameTagShowFriends", false); const char* color_name; if (show_friends && is_friend) { color_name = "NameTagFriend"; } else if (LLAvatarName::useDisplayNames()) { // ...color based on whether username "matches" a computed display name LLAvatarName av_name; if (LLAvatarNameCache::get(getID(), &av_name) && av_name.isDisplayNameDefault()) { color_name = "NameTagMatch"; } else { color_name = "NameTagMismatch"; } } else { // ...not using display names color_name = "NameTagLegacy"; } return LLUIColorTable::getInstance()->getColor( color_name ); } void LLVOAvatar::idleUpdateBelowWater() { F32 avatar_height = (F32)(getPositionGlobal().mdV[VZ]); F32 water_height; water_height = getRegion()->getWaterHeight(); mBelowWater = avatar_height < water_height; } void LLVOAvatar::slamPosition() { gAgent.setPositionAgent(getPositionAgent()); // SL-315 mRoot->setWorldPosition(getPositionAgent()); // teleport setChanged(TRANSLATED); if (mDrawable.notNull()) { gPipeline.updateMoveNormalAsync(mDrawable); } mRoot->updateWorldMatrixChildren(); } bool LLVOAvatar::isVisuallyMuted() { bool muted = false; // Priority order (highest priority first) // * own avatar is never visually muted // * if on the "always draw normally" list, draw them normally // * if on the "always visually mute" list, mute them // * check against the render cost and attachment limits if (!isSelf()) { if (mVisuallyMuteSetting == AV_ALWAYS_RENDER) { muted = false; } else if (mVisuallyMuteSetting == AV_DO_NOT_RENDER) { // Always want to see this AV as an impostor muted = true; } else if (isInMuteList()) { muted = true; } else { muted = isTooComplex(); } } return muted; } bool LLVOAvatar::isInMuteList() { bool muted = false; F64 now = LLFrameTimer::getTotalSeconds(); if (now < mCachedMuteListUpdateTime) { muted = mCachedInMuteList; } else { muted = LLMuteList::getInstance()->isMuted(getID()); const F64 SECONDS_BETWEEN_MUTE_UPDATES = 1; mCachedMuteListUpdateTime = now + SECONDS_BETWEEN_MUTE_UPDATES; mCachedInMuteList = muted; } return muted; } void LLVOAvatar::updateDebugText() { // clear debug text mDebugText.clear(); if (gSavedSettings.getBOOL("DebugAvatarAppearanceMessage")) { S32 central_bake_version = -1; if (getRegion()) { central_bake_version = getRegion()->getCentralBakeVersion(); } bool all_baked_downloaded = allBakedTexturesCompletelyDownloaded(); bool all_local_downloaded = allLocalTexturesCompletelyDownloaded(); std::string debug_line = llformat("%s%s - mLocal: %d, mEdit: %d, mUSB: %d, CBV: %d", isSelf() ? (all_local_downloaded ? "L" : "l") : "-", all_baked_downloaded ? "B" : "b", mUseLocalAppearance, mIsEditingAppearance, 1, central_bake_version); std::string origin_string = bakedTextureOriginInfo(); debug_line += " [" + origin_string + "]"; S32 curr_cof_version = LLAppearanceMgr::instance().getCOFVersion(); S32 last_request_cof_version = mLastUpdateRequestCOFVersion; S32 last_received_cof_version = mLastUpdateReceivedCOFVersion; if (isSelf()) { debug_line += llformat(" - cof: %d req: %d rcv:%d", curr_cof_version, last_request_cof_version, last_received_cof_version); if (gSavedSettings.getBOOL("DebugForceAppearanceRequestFailure")) { debug_line += " FORCING ERRS"; } } else { debug_line += llformat(" - cof rcv:%d", last_received_cof_version); } debug_line += llformat(" bsz-z: %.3f", mBodySize[2]); if (mAvatarOffset[2] != 0.0f) { debug_line += llformat("avofs-z: %.3f", mAvatarOffset[2]); } bool hover_enabled = getRegion() && getRegion()->avatarHoverHeightEnabled(); debug_line += hover_enabled ? " H" : " h"; const LLVector3& hover_offset = getHoverOffset(); if (hover_offset[2] != 0.0) { debug_line += llformat(" hov_z: %.3f", hover_offset[2]); debug_line += llformat(" %s", (mIsSitting ? "S" : "T")); debug_line += llformat("%s", (isMotionActive(ANIM_AGENT_SIT_GROUND_CONSTRAINED) ? "G" : "-")); } LLVector3 ankle_right_pos_agent = mFootRightp->getWorldPosition(); LLVector3 normal; LLVector3 ankle_right_ground_agent = ankle_right_pos_agent; resolveHeightAgent(ankle_right_pos_agent, ankle_right_ground_agent, normal); F32 rightElev = llmax(-0.2f, ankle_right_pos_agent.mV[VZ] - ankle_right_ground_agent.mV[VZ]); debug_line += llformat(" relev %.3f", rightElev); LLVector3 root_pos = mRoot->getPosition(); LLVector3 pelvis_pos = mPelvisp->getPosition(); debug_line += llformat(" rp %.3f pp %.3f", root_pos[2], pelvis_pos[2]); addDebugText(debug_line); } if (gSavedSettings.getBOOL("DebugAvatarCompositeBaked")) { if (!mBakedTextureDebugText.empty()) addDebugText(mBakedTextureDebugText); } if (LLVOAvatar::sShowAnimationDebug) { for (LLMotionController::motion_list_t::iterator iter = mMotionController.getActiveMotions().begin(); iter != mMotionController.getActiveMotions().end(); ++iter) { LLMotion* motionp = *iter; if (motionp->getMinPixelArea() < getPixelArea()) { std::string output; if (motionp->getName().empty()) { std::string name; if (gAgent.isGodlikeWithoutAdminMenuFakery() || isSelf()) { name = motionp->getID().asString(); LLVOAvatar::AnimSourceIterator anim_it = mAnimationSources.begin(); for (; anim_it != mAnimationSources.end(); ++anim_it) { if (anim_it->second == motionp->getID()) { LLViewerObject* object = gObjectList.findObject(anim_it->first); if (!object) { break; } if (object->isAvatar()) { if (mMotionController.mIsSelf) { // Searching inventory by asset id is really long // so just mark as inventory // Also item is likely to be named by LLPreviewAnim name += "(inventory)"; } } else { LLViewerInventoryItem* item = NULL; if (!object->isInventoryDirty()) { item = object->getInventoryItemByAsset(motionp->getID()); } if (item) { name = item->getName(); } else if (object->isAttachment()) { name += "(" + getAttachmentItemName() + ")"; } else { // in-world object, name or content unknown name += "(in-world)"; } } break; } } } else { name = LLUUID::null.asString(); } output = llformat("%s - %d", name.c_str(), (U32)motionp->getPriority()); } else { output = llformat("%s - %d", motionp->getName().c_str(), (U32)motionp->getPriority()); } addDebugText(output); } } } if (!mDebugText.size() && mText.notNull()) { mText->markDead(); mText = NULL; } else if (mDebugText.size()) { setDebugText(mDebugText); } mDebugText.clear(); } //------------------------------------------------------------------------ // updateCharacter() // called on both your avatar and other avatars //------------------------------------------------------------------------ BOOL LLVOAvatar::updateCharacter(LLAgent &agent) { updateDebugText(); if (!mIsBuilt) { return FALSE; } BOOL visible = isVisible(); // For fading out the names above heads, only let the timer // run if we're visible. if (mDrawable.notNull() && !visible) { mTimeVisible.reset(); } //-------------------------------------------------------------------- // the rest should only be done occasionally for far away avatars //-------------------------------------------------------------------- bool visually_muted = isVisuallyMuted(); if (visible && (!isSelf() || visually_muted) && !mIsDummy && sUseImpostors && !mNeedsAnimUpdate && !sFreezeCounter) { const LLVector4a* ext = mDrawable->getSpatialExtents(); LLVector4a size; size.setSub(ext[1],ext[0]); F32 mag = size.getLength3().getF32()*0.5f; F32 impostor_area = 256.f*512.f*(8.125f - LLVOAvatar::sLODFactor*8.f); if (visually_muted) { // visually muted avatars update at 16 hz mUpdatePeriod = 16; } else if ( ! shouldImpostor() || mDrawable->mDistanceWRTCamera < 1.f + mag) { // first 25% of max visible avatars are not impostored // also, don't impostor avatars whose bounding box may be penetrating the // impostor camera near clip plane mUpdatePeriod = 1; } else if ( shouldImpostor(4) ) { //background avatars are REALLY slow updating impostors mUpdatePeriod = 16; } else if ( shouldImpostor(3) ) { //back 25% of max visible avatars are slow updating impostors mUpdatePeriod = 8; } else if (mImpostorPixelArea <= impostor_area) { // stuff in between gets an update period based on pixel area mUpdatePeriod = llclamp((S32) sqrtf(impostor_area*4.f/mImpostorPixelArea), 2, 8); } else { //nearby avatars, update the impostors more frequently. mUpdatePeriod = 4; } visible = (LLDrawable::getCurrentFrame()+mID.mData[0])%mUpdatePeriod == 0 ? TRUE : FALSE; } else { mUpdatePeriod = 1; } // don't early out for your own avatar, as we rely on your animations playing reliably // for example, the "turn around" animation when entering customize avatar needs to trigger // even when your avatar is offscreen if (!visible && !isSelf()) { updateMotions(LLCharacter::HIDDEN_UPDATE); return FALSE; } // change animation time quanta based on avatar render load if (!isSelf() && !mIsDummy) { F32 time_quantum = clamp_rescale((F32)sInstances.size(), 10.f, 35.f, 0.f, 0.25f); F32 pixel_area_scale = clamp_rescale(mPixelArea, 100, 5000, 1.f, 0.f); F32 time_step = time_quantum * pixel_area_scale; if (time_step != 0.f) { // disable walk motion servo controller as it doesn't work with motion timesteps stopMotion(ANIM_AGENT_WALK_ADJUST); removeAnimationData("Walk Speed"); } mMotionController.setTimeStep(time_step); // LL_INFOS() << "Setting timestep to " << time_quantum * pixel_area_scale << LL_ENDL; } if (getParent() && !mIsSitting) { sitOnObject((LLViewerObject*)getParent()); } else if (!getParent() && mIsSitting && !isMotionActive(ANIM_AGENT_SIT_GROUND_CONSTRAINED)) { getOffObject(); } //-------------------------------------------------------------------- // create local variables in world coords for region position values //-------------------------------------------------------------------- F32 speed; LLVector3 normal; LLVector3 xyVel = getVelocity(); xyVel.mV[VZ] = 0.0f; speed = xyVel.length(); // remembering the value here prevents a display glitch if the // animation gets toggled during this update. bool was_sit_ground_constrained = isMotionActive(ANIM_AGENT_SIT_GROUND_CONSTRAINED); if (!(mIsSitting && getParent())) { // This case includes all configurations except sitting on an // object, so does include ground sit. //-------------------------------------------------------------------- // get timing info // handle initial condition case //-------------------------------------------------------------------- F32 animation_time = mAnimTimer.getElapsedTimeF32(); if (mTimeLast == 0.0f) { mTimeLast = animation_time; // put the pelvis at slaved position/mRotation // SL-315 mRoot->setWorldPosition( getPositionAgent() ); // first frame mRoot->setWorldRotation( getRotation() ); } //-------------------------------------------------------------------- // dont' let dT get larger than 1/5th of a second //-------------------------------------------------------------------- F32 deltaTime = animation_time - mTimeLast; deltaTime = llclamp( deltaTime, DELTA_TIME_MIN, DELTA_TIME_MAX ); mTimeLast = animation_time; mSpeedAccum = (mSpeedAccum * 0.95f) + (speed * 0.05f); //-------------------------------------------------------------------- // compute the position of the avatar's root //-------------------------------------------------------------------- LLVector3d root_pos; LLVector3d ground_under_pelvis; if (isSelf()) { gAgent.setPositionAgent(getRenderPosition()); } root_pos = gAgent.getPosGlobalFromAgent(getRenderPosition()); root_pos.mdV[VZ] += getVisualParamWeight(AVATAR_HOVER); resolveHeightGlobal(root_pos, ground_under_pelvis, normal); F32 foot_to_ground = (F32) (root_pos.mdV[VZ] - mPelvisToFoot - ground_under_pelvis.mdV[VZ]); BOOL in_air = ((!LLWorld::getInstance()->getRegionFromPosGlobal(ground_under_pelvis)) || foot_to_ground > FOOT_GROUND_COLLISION_TOLERANCE); if (in_air && !mInAir) { mTimeInAir.reset(); } mInAir = in_air; // SL-402: with the ability to animate the position of joints // that affect the body size calculation, computed body size // can get stale much more easily. Simplest fix is to update // it frequently. // SL-427: this appears to be too frequent, moving to only do on animation state change. //computeBodySize(); // correct for the fact that the pelvis is not necessarily the center // of the agent's physical representation root_pos.mdV[VZ] -= (0.5f * mBodySize.mV[VZ]) - mPelvisToFoot; if (!mIsSitting && !was_sit_ground_constrained) { root_pos += LLVector3d(getHoverOffset()); } LLVector3 newPosition = gAgent.getPosAgentFromGlobal(root_pos); if (newPosition != mRoot->getXform()->getWorldPosition()) { mRoot->touch(); // SL-315 mRoot->setWorldPosition( newPosition ); // regular update } //-------------------------------------------------------------------- // Propagate viewer object rotation to root of avatar //-------------------------------------------------------------------- if (!isAnyAnimationSignaled(AGENT_NO_ROTATE_ANIMS, NUM_AGENT_NO_ROTATE_ANIMS)) { LLQuaternion iQ; LLVector3 upDir( 0.0f, 0.0f, 1.0f ); // Compute a forward direction vector derived from the primitive rotation // and the velocity vector. When walking or jumping, don't let body deviate // more than 90 from the view, if necessary, flip the velocity vector. LLVector3 primDir; if (isSelf()) { primDir = agent.getAtAxis() - projected_vec(agent.getAtAxis(), agent.getReferenceUpVector()); primDir.normalize(); } else { primDir = getRotation().getMatrix3().getFwdRow(); } LLVector3 velDir = getVelocity(); velDir.normalize(); if ( mSignaledAnimations.find(ANIM_AGENT_WALK) != mSignaledAnimations.end()) { F32 vpD = velDir * primDir; if (vpD < -0.5f) { velDir *= -1.0f; } } LLVector3 fwdDir = lerp(primDir, velDir, clamp_rescale(speed, 0.5f, 2.0f, 0.0f, 1.0f)); if (isSelf() && gAgentCamera.cameraMouselook()) { // make sure fwdDir stays in same general direction as primdir if (gAgent.getFlying()) { fwdDir = LLViewerCamera::getInstance()->getAtAxis(); } else { LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis(); LLVector3 up_vector = gAgent.getReferenceUpVector(); at_axis -= up_vector * (at_axis * up_vector); at_axis.normalize(); F32 dot = fwdDir * at_axis; if (dot < 0.f) { fwdDir -= 2.f * at_axis * dot; fwdDir.normalize(); } } } LLQuaternion root_rotation = mRoot->getWorldMatrix().quaternion(); F32 root_roll, root_pitch, root_yaw; root_rotation.getEulerAngles(&root_roll, &root_pitch, &root_yaw); // When moving very slow, the pelvis is allowed to deviate from the // forward direction to allow it to hold it's position while the torso // and head turn. Once in motion, it must conform however. BOOL self_in_mouselook = isSelf() && gAgentCamera.cameraMouselook(); LLVector3 pelvisDir( mRoot->getWorldMatrix().getFwdRow4().mV ); static LLCachedControl<F32> s_pelvis_rot_threshold_slow(gSavedSettings, "AvatarRotateThresholdSlow", 60.0); static LLCachedControl<F32> s_pelvis_rot_threshold_fast(gSavedSettings, "AvatarRotateThresholdFast", 2.0); F32 pelvis_rot_threshold = clamp_rescale(speed, 0.1f, 1.0f, s_pelvis_rot_threshold_slow, s_pelvis_rot_threshold_fast); if (self_in_mouselook) { pelvis_rot_threshold *= MOUSELOOK_PELVIS_FOLLOW_FACTOR; } pelvis_rot_threshold *= DEG_TO_RAD; F32 angle = angle_between( pelvisDir, fwdDir ); // The avatar's root is allowed to have a yaw that deviates widely // from the forward direction, but if roll or pitch are off even // a little bit we need to correct the rotation. if(root_roll < 1.f * DEG_TO_RAD && root_pitch < 5.f * DEG_TO_RAD) { // smaller correction vector means pelvis follows prim direction more closely if (!mTurning && angle > pelvis_rot_threshold*0.75f) { mTurning = TRUE; } // use tighter threshold when turning if (mTurning) { pelvis_rot_threshold *= 0.4f; } // am I done turning? if (angle < pelvis_rot_threshold) { mTurning = FALSE; } LLVector3 correction_vector = (pelvisDir - fwdDir) * clamp_rescale(angle, pelvis_rot_threshold*0.75f, pelvis_rot_threshold, 1.0f, 0.0f); fwdDir += correction_vector; } else { mTurning = FALSE; } // Now compute the full world space rotation for the whole body (wQv) LLVector3 leftDir = upDir % fwdDir; leftDir.normalize(); fwdDir = leftDir % upDir; LLQuaternion wQv( fwdDir, leftDir, upDir ); if (isSelf() && mTurning) { if ((fwdDir % pelvisDir) * upDir > 0.f) { gAgent.setControlFlags(AGENT_CONTROL_TURN_RIGHT); } else { gAgent.setControlFlags(AGENT_CONTROL_TURN_LEFT); } } // Set the root rotation, but do so incrementally so that it // lags in time by some fixed amount. //F32 u = LLSmoothInterpolation::getInterpolant(PELVIS_LAG); F32 pelvis_lag_time = 0.f; if (self_in_mouselook) { pelvis_lag_time = PELVIS_LAG_MOUSELOOK; } else if (mInAir) { pelvis_lag_time = PELVIS_LAG_FLYING; // increase pelvis lag time when moving slowly pelvis_lag_time *= clamp_rescale(mSpeedAccum, 0.f, 15.f, 3.f, 1.f); } else { pelvis_lag_time = PELVIS_LAG_WALKING; } F32 u = llclamp((deltaTime / pelvis_lag_time), 0.0f, 1.0f); mRoot->setWorldRotation( slerp(u, mRoot->getWorldRotation(), wQv) ); } } else if (mDrawable.notNull()) { LLVector3 pos = mDrawable->getPosition(); pos += getHoverOffset() * mDrawable->getRotation(); // SL-315 mRoot->setPosition(pos); mRoot->setRotation(mDrawable->getRotation()); } //------------------------------------------------------------------------- // Update character motions //------------------------------------------------------------------------- // store data relevant to motions mSpeed = speed; // update animations if (mSpecialRenderMode == 1) // Animation Preview { updateMotions(LLCharacter::FORCE_UPDATE); } else { updateMotions(LLCharacter::NORMAL_UPDATE); } // Special handling for sitting on ground. if (!getParent() && (mIsSitting || was_sit_ground_constrained)) { F32 off_z = LLVector3d(getHoverOffset()).mdV[VZ]; if (off_z != 0.0) { LLVector3 pos = mRoot->getWorldPosition(); pos.mV[VZ] += off_z; mRoot->touch(); // SL-315 mRoot->setWorldPosition(pos); } } // update head position updateHeadOffset(); //------------------------------------------------------------------------- // Find the ground under each foot, these are used for a variety // of things that follow //------------------------------------------------------------------------- LLVector3 ankle_left_pos_agent = mFootLeftp->getWorldPosition(); LLVector3 ankle_right_pos_agent = mFootRightp->getWorldPosition(); LLVector3 ankle_left_ground_agent = ankle_left_pos_agent; LLVector3 ankle_right_ground_agent = ankle_right_pos_agent; resolveHeightAgent(ankle_left_pos_agent, ankle_left_ground_agent, normal); resolveHeightAgent(ankle_right_pos_agent, ankle_right_ground_agent, normal); F32 leftElev = llmax(-0.2f, ankle_left_pos_agent.mV[VZ] - ankle_left_ground_agent.mV[VZ]); F32 rightElev = llmax(-0.2f, ankle_right_pos_agent.mV[VZ] - ankle_right_ground_agent.mV[VZ]); if (!mIsSitting) { //------------------------------------------------------------------------- // Figure out which foot is on ground //------------------------------------------------------------------------- if (!mInAir) { if ((leftElev < 0.0f) || (rightElev < 0.0f)) { ankle_left_pos_agent = mFootLeftp->getWorldPosition(); ankle_right_pos_agent = mFootRightp->getWorldPosition(); leftElev = ankle_left_pos_agent.mV[VZ] - ankle_left_ground_agent.mV[VZ]; rightElev = ankle_right_pos_agent.mV[VZ] - ankle_right_ground_agent.mV[VZ]; } } } //------------------------------------------------------------------------- // Generate footstep sounds when feet hit the ground //------------------------------------------------------------------------- const LLUUID AGENT_FOOTSTEP_ANIMS[] = {ANIM_AGENT_WALK, ANIM_AGENT_RUN, ANIM_AGENT_LAND}; const S32 NUM_AGENT_FOOTSTEP_ANIMS = LL_ARRAY_SIZE(AGENT_FOOTSTEP_ANIMS); if ( gAudiop && isAnyAnimationSignaled(AGENT_FOOTSTEP_ANIMS, NUM_AGENT_FOOTSTEP_ANIMS) ) { BOOL playSound = FALSE; LLVector3 foot_pos_agent; BOOL onGroundLeft = (leftElev <= 0.05f); BOOL onGroundRight = (rightElev <= 0.05f); // did left foot hit the ground? if ( onGroundLeft && !mWasOnGroundLeft ) { foot_pos_agent = ankle_left_pos_agent; playSound = TRUE; } // did right foot hit the ground? if ( onGroundRight && !mWasOnGroundRight ) { foot_pos_agent = ankle_right_pos_agent; playSound = TRUE; } mWasOnGroundLeft = onGroundLeft; mWasOnGroundRight = onGroundRight; if ( playSound ) { const F32 STEP_VOLUME = 0.1f; const LLUUID& step_sound_id = getStepSound(); LLVector3d foot_pos_global = gAgent.getPosGlobalFromAgent(foot_pos_agent); if (LLViewerParcelMgr::getInstance()->canHearSound(foot_pos_global) && !LLMuteList::getInstance()->isMuted(getID(), LLMute::flagObjectSounds)) { gAudiop->triggerSound(step_sound_id, getID(), STEP_VOLUME, LLAudioEngine::AUDIO_TYPE_AMBIENT, foot_pos_global); } } } mRoot->updateWorldMatrixChildren(); //mesh vertices need to be reskinned mNeedsSkin = TRUE; return TRUE; } //----------------------------------------------------------------------------- // updateHeadOffset() //----------------------------------------------------------------------------- void LLVOAvatar::updateHeadOffset() { // since we only care about Z, just grab one of the eyes LLVector3 midEyePt = mEyeLeftp->getWorldPosition(); midEyePt -= mDrawable.notNull() ? mDrawable->getWorldPosition() : mRoot->getWorldPosition(); midEyePt.mV[VZ] = llmax(-mPelvisToFoot + LLViewerCamera::getInstance()->getNear(), midEyePt.mV[VZ]); if (mDrawable.notNull()) { midEyePt = midEyePt * ~mDrawable->getWorldRotation(); } if (mIsSitting) { mHeadOffset = midEyePt; } else { F32 u = llmax(0.f, HEAD_MOVEMENT_AVG_TIME - (1.f / gFPSClamped)); mHeadOffset = lerp(midEyePt, mHeadOffset, u); } } void LLVOAvatar::debugBodySize() const { LLVector3 pelvis_scale = mPelvisp->getScale(); // some of the joints have not been cached LLVector3 skull = mSkullp->getPosition(); LL_DEBUGS("Avatar") << "skull pos " << skull << LL_ENDL; //LLVector3 skull_scale = mSkullp->getScale(); LLVector3 neck = mNeckp->getPosition(); LLVector3 neck_scale = mNeckp->getScale(); LL_DEBUGS("Avatar") << "neck pos " << neck << " neck_scale " << neck_scale << LL_ENDL; LLVector3 chest = mChestp->getPosition(); LLVector3 chest_scale = mChestp->getScale(); LL_DEBUGS("Avatar") << "chest pos " << chest << " chest_scale " << chest_scale << LL_ENDL; // the rest of the joints have been cached LLVector3 head = mHeadp->getPosition(); LLVector3 head_scale = mHeadp->getScale(); LL_DEBUGS("Avatar") << "head pos " << head << " head_scale " << head_scale << LL_ENDL; LLVector3 torso = mTorsop->getPosition(); LLVector3 torso_scale = mTorsop->getScale(); LL_DEBUGS("Avatar") << "torso pos " << torso << " torso_scale " << torso_scale << LL_ENDL; LLVector3 hip = mHipLeftp->getPosition(); LLVector3 hip_scale = mHipLeftp->getScale(); LL_DEBUGS("Avatar") << "hip pos " << hip << " hip_scale " << hip_scale << LL_ENDL; LLVector3 knee = mKneeLeftp->getPosition(); LLVector3 knee_scale = mKneeLeftp->getScale(); LL_DEBUGS("Avatar") << "knee pos " << knee << " knee_scale " << knee_scale << LL_ENDL; LLVector3 ankle = mAnkleLeftp->getPosition(); LLVector3 ankle_scale = mAnkleLeftp->getScale(); LL_DEBUGS("Avatar") << "ankle pos " << ankle << " ankle_scale " << ankle_scale << LL_ENDL; LLVector3 foot = mFootLeftp->getPosition(); LL_DEBUGS("Avatar") << "foot pos " << foot << LL_ENDL; F32 new_offset = (const_cast<LLVOAvatar*>(this))->getVisualParamWeight(AVATAR_HOVER); LL_DEBUGS("Avatar") << "new_offset " << new_offset << LL_ENDL; F32 new_pelvis_to_foot = hip.mV[VZ] * pelvis_scale.mV[VZ] - knee.mV[VZ] * hip_scale.mV[VZ] - ankle.mV[VZ] * knee_scale.mV[VZ] - foot.mV[VZ] * ankle_scale.mV[VZ]; LL_DEBUGS("Avatar") << "new_pelvis_to_foot " << new_pelvis_to_foot << LL_ENDL; LLVector3 new_body_size; new_body_size.mV[VZ] = new_pelvis_to_foot + // the sqrt(2) correction below is an approximate // correction to get to the top of the head F_SQRT2 * (skull.mV[VZ] * head_scale.mV[VZ]) + head.mV[VZ] * neck_scale.mV[VZ] + neck.mV[VZ] * chest_scale.mV[VZ] + chest.mV[VZ] * torso_scale.mV[VZ] + torso.mV[VZ] * pelvis_scale.mV[VZ]; // TODO -- measure the real depth and width new_body_size.mV[VX] = DEFAULT_AGENT_DEPTH; new_body_size.mV[VY] = DEFAULT_AGENT_WIDTH; LL_DEBUGS("Avatar") << "new_body_size " << new_body_size << LL_ENDL; } //------------------------------------------------------------------------ // postPelvisSetRecalc //------------------------------------------------------------------------ void LLVOAvatar::postPelvisSetRecalc() { mRoot->updateWorldMatrixChildren(); computeBodySize(); dirtyMesh(2); } //------------------------------------------------------------------------ // updateVisibility() //------------------------------------------------------------------------ void LLVOAvatar::updateVisibility() { BOOL visible = FALSE; if (mIsDummy) { visible = TRUE; } else if (mDrawable.isNull()) { visible = FALSE; } else { if (!mDrawable->getSpatialGroup() || mDrawable->getSpatialGroup()->isVisible()) { visible = TRUE; } else { visible = FALSE; } if(isSelf()) { if (!gAgentWearables.areWearablesLoaded()) { visible = FALSE; } } else if( !mFirstAppearanceMessageReceived ) { visible = FALSE; } if (sDebugInvisible) { LLNameValue* firstname = getNVPair("FirstName"); if (firstname) { LL_DEBUGS("Avatar") << avString() << " updating visibility" << LL_ENDL; } else { LL_INFOS() << "Avatar " << this << " updating visiblity" << LL_ENDL; } if (visible) { LL_INFOS() << "Visible" << LL_ENDL; } else { LL_INFOS() << "Not visible" << LL_ENDL; } /*if (avatar_in_frustum) { LL_INFOS() << "Avatar in frustum" << LL_ENDL; } else { LL_INFOS() << "Avatar not in frustum" << LL_ENDL; }*/ /*if (LLViewerCamera::getInstance()->sphereInFrustum(sel_pos_agent, 2.0f)) { LL_INFOS() << "Sel pos visible" << LL_ENDL; } if (LLViewerCamera::getInstance()->sphereInFrustum(wrist_right_pos_agent, 0.2f)) { LL_INFOS() << "Wrist pos visible" << LL_ENDL; } if (LLViewerCamera::getInstance()->sphereInFrustum(getPositionAgent(), getMaxScale()*2.f)) { LL_INFOS() << "Agent visible" << LL_ENDL; }*/ LL_INFOS() << "PA: " << getPositionAgent() << LL_ENDL; /*LL_INFOS() << "SPA: " << sel_pos_agent << LL_ENDL; LL_INFOS() << "WPA: " << wrist_right_pos_agent << LL_ENDL;*/ for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { if (LLViewerObject *attached_object = (*attachment_iter)) { if(attached_object->mDrawable->isVisible()) { LL_INFOS() << attachment->getName() << " visible" << LL_ENDL; } else { LL_INFOS() << attachment->getName() << " not visible at " << mDrawable->getWorldPosition() << " and radius " << mDrawable->getRadius() << LL_ENDL; } } } } } } if (!visible && mVisible) { mMeshInvisibleTime.reset(); } if (visible) { if (!mMeshValid) { restoreMeshData(); } } else { if (mMeshValid && mMeshInvisibleTime.getElapsedTimeF32() > TIME_BEFORE_MESH_CLEANUP) { releaseMeshData(); } } if ( visible != mVisible ) { LL_DEBUGS("AvatarRender") << "visible was " << mVisible << " now " << visible << LL_ENDL; } mVisible = visible; } // private bool LLVOAvatar::shouldAlphaMask() { const bool should_alpha_mask = !LLDrawPoolAlpha::sShowDebugAlpha // Don't alpha mask if "Highlight Transparent" checked && !LLDrawPoolAvatar::sSkipTransparent; return should_alpha_mask; } //----------------------------------------------------------------------------- // renderSkinned() //----------------------------------------------------------------------------- U32 LLVOAvatar::renderSkinned() { U32 num_indices = 0; if (!mIsBuilt) { return num_indices; } LLFace* face = mDrawable->getFace(0); bool needs_rebuild = !face || !face->getVertexBuffer() || mDrawable->isState(LLDrawable::REBUILD_GEOMETRY); if (needs_rebuild || mDirtyMesh) { //LOD changed or new mesh created, allocate new vertex buffer if needed if (needs_rebuild || mDirtyMesh >= 2 || mVisibilityRank <= 4) { updateMeshData(); mDirtyMesh = 0; mNeedsSkin = TRUE; mDrawable->clearState(LLDrawable::REBUILD_GEOMETRY); } } if (LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_AVATAR) <= 0) { if (mNeedsSkin) { //generate animated mesh LLViewerJoint* lower_mesh = getViewerJoint(MESH_ID_LOWER_BODY); LLViewerJoint* upper_mesh = getViewerJoint(MESH_ID_UPPER_BODY); LLViewerJoint* skirt_mesh = getViewerJoint(MESH_ID_SKIRT); LLViewerJoint* eyelash_mesh = getViewerJoint(MESH_ID_EYELASH); LLViewerJoint* head_mesh = getViewerJoint(MESH_ID_HEAD); LLViewerJoint* hair_mesh = getViewerJoint(MESH_ID_HAIR); if(upper_mesh) { upper_mesh->updateJointGeometry(); } if (lower_mesh) { lower_mesh->updateJointGeometry(); } if( isWearingWearableType( LLWearableType::WT_SKIRT ) ) { if(skirt_mesh) { skirt_mesh->updateJointGeometry(); } } if (!isSelf() || gAgent.needsRenderHead() || LLPipeline::sShadowRender) { if(eyelash_mesh) { eyelash_mesh->updateJointGeometry(); } if(head_mesh) { head_mesh->updateJointGeometry(); } if(hair_mesh) { hair_mesh->updateJointGeometry(); } } mNeedsSkin = FALSE; mLastSkinTime = gFrameTimeSeconds; LLFace * face = mDrawable->getFace(0); if (face) { LLVertexBuffer* vb = face->getVertexBuffer(); if (vb) { vb->flush(); } } } } else { mNeedsSkin = FALSE; } if (sDebugInvisible) { LLNameValue* firstname = getNVPair("FirstName"); if (firstname) { LL_DEBUGS("Avatar") << avString() << " in render" << LL_ENDL; } else { LL_INFOS() << "Avatar " << this << " in render" << LL_ENDL; } if (!mIsBuilt) { LL_INFOS() << "Not built!" << LL_ENDL; } else if (!gAgent.needsRenderAvatar()) { LL_INFOS() << "Doesn't need avatar render!" << LL_ENDL; } else { LL_INFOS() << "Rendering!" << LL_ENDL; } } if (!mIsBuilt) { return num_indices; } if (isSelf() && !gAgent.needsRenderAvatar()) { return num_indices; } // render collision normal // *NOTE: this is disabled (there is no UI for enabling sShowFootPlane) due // to DEV-14477. the code is left here to aid in tracking down the cause // of the crash in the future. -brad if (sShowFootPlane && mDrawable.notNull()) { LLVector3 slaved_pos = mDrawable->getPositionAgent(); LLVector3 foot_plane_normal(mFootPlane.mV[VX], mFootPlane.mV[VY], mFootPlane.mV[VZ]); F32 dist_from_plane = (slaved_pos * foot_plane_normal) - mFootPlane.mV[VW]; LLVector3 collide_point = slaved_pos; collide_point.mV[VZ] -= foot_plane_normal.mV[VZ] * (dist_from_plane + COLLISION_TOLERANCE - FOOT_COLLIDE_FUDGE); gGL.begin(LLRender::LINES); { F32 SQUARE_SIZE = 0.2f; gGL.color4f(1.f, 0.f, 0.f, 1.f); gGL.vertex3f(collide_point.mV[VX] - SQUARE_SIZE, collide_point.mV[VY] - SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] + SQUARE_SIZE, collide_point.mV[VY] - SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] + SQUARE_SIZE, collide_point.mV[VY] - SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] + SQUARE_SIZE, collide_point.mV[VY] + SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] + SQUARE_SIZE, collide_point.mV[VY] + SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] - SQUARE_SIZE, collide_point.mV[VY] + SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] - SQUARE_SIZE, collide_point.mV[VY] + SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] - SQUARE_SIZE, collide_point.mV[VY] - SQUARE_SIZE, collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX], collide_point.mV[VY], collide_point.mV[VZ]); gGL.vertex3f(collide_point.mV[VX] + mFootPlane.mV[VX], collide_point.mV[VY] + mFootPlane.mV[VY], collide_point.mV[VZ] + mFootPlane.mV[VZ]); } gGL.end(); gGL.flush(); } //-------------------------------------------------------------------- // render all geometry attached to the skeleton //-------------------------------------------------------------------- bool should_alpha_mask = shouldAlphaMask(); LLGLState test(GL_ALPHA_TEST, should_alpha_mask); if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction) { gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f); } BOOL first_pass = TRUE; if (!LLDrawPoolAvatar::sSkipOpaque) { if (!isSelf() || gAgent.needsRenderHead() || LLPipeline::sShadowRender) { if (isTextureVisible(TEX_HEAD_BAKED) || mIsDummy) { LLViewerJoint* head_mesh = getViewerJoint(MESH_ID_HEAD); if (head_mesh) { num_indices += head_mesh->render(mAdjustedPixelArea, TRUE, mIsDummy); } first_pass = FALSE; } } if (isTextureVisible(TEX_UPPER_BAKED) || mIsDummy) { LLViewerJoint* upper_mesh = getViewerJoint(MESH_ID_UPPER_BODY); if (upper_mesh) { num_indices += upper_mesh->render(mAdjustedPixelArea, first_pass, mIsDummy); } first_pass = FALSE; } if (isTextureVisible(TEX_LOWER_BAKED) || mIsDummy) { LLViewerJoint* lower_mesh = getViewerJoint(MESH_ID_LOWER_BODY); if (lower_mesh) { num_indices += lower_mesh->render(mAdjustedPixelArea, first_pass, mIsDummy); } first_pass = FALSE; } } if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction) { gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); } if (!LLDrawPoolAvatar::sSkipTransparent || LLPipeline::sImpostorRender) { LLGLState blend(GL_BLEND, !mIsDummy); LLGLState test(GL_ALPHA_TEST, !mIsDummy); num_indices += renderTransparent(first_pass); } return num_indices; } U32 LLVOAvatar::renderTransparent(BOOL first_pass) { U32 num_indices = 0; if( isWearingWearableType( LLWearableType::WT_SKIRT ) && (mIsDummy || isTextureVisible(TEX_SKIRT_BAKED)) ) { gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.25f); LLViewerJoint* skirt_mesh = getViewerJoint(MESH_ID_SKIRT); if (skirt_mesh) { num_indices += skirt_mesh->render(mAdjustedPixelArea, FALSE); } first_pass = FALSE; gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); } if (!isSelf() || gAgent.needsRenderHead() || LLPipeline::sShadowRender) { if (LLPipeline::sImpostorRender) { gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f); } if (isTextureVisible(TEX_HEAD_BAKED)) { LLViewerJoint* eyelash_mesh = getViewerJoint(MESH_ID_EYELASH); if (eyelash_mesh) { num_indices += eyelash_mesh->render(mAdjustedPixelArea, first_pass, mIsDummy); } first_pass = FALSE; } // Can't test for baked hair being defined, since that won't always be the case (not all viewers send baked hair) // TODO: 1.25 will be able to switch this logic back to calling isTextureVisible(); if ( (getImage(TEX_HAIR_BAKED, 0) && getImage(TEX_HAIR_BAKED, 0)->getID() != IMG_INVISIBLE) || LLDrawPoolAlpha::sShowDebugAlpha) { LLViewerJoint* hair_mesh = getViewerJoint(MESH_ID_HAIR); if (hair_mesh) { num_indices += hair_mesh->render(mAdjustedPixelArea, first_pass, mIsDummy); } first_pass = FALSE; } if (LLPipeline::sImpostorRender) { gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); } } return num_indices; } //----------------------------------------------------------------------------- // renderRigid() //----------------------------------------------------------------------------- U32 LLVOAvatar::renderRigid() { U32 num_indices = 0; if (!mIsBuilt) { return 0; } if (isSelf() && (!gAgent.needsRenderAvatar() || !gAgent.needsRenderHead())) { return 0; } if (!mIsBuilt) { return 0; } bool should_alpha_mask = shouldAlphaMask(); LLGLState test(GL_ALPHA_TEST, should_alpha_mask); if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction) { gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.5f); } if (isTextureVisible(TEX_EYES_BAKED) || mIsDummy) { LLViewerJoint* eyeball_left = getViewerJoint(MESH_ID_EYEBALL_LEFT); LLViewerJoint* eyeball_right = getViewerJoint(MESH_ID_EYEBALL_RIGHT); if (eyeball_left) { num_indices += eyeball_left->render(mAdjustedPixelArea, TRUE, mIsDummy); } if(eyeball_right) { num_indices += eyeball_right->render(mAdjustedPixelArea, TRUE, mIsDummy); } } if (should_alpha_mask && !LLGLSLShader::sNoFixedFunction) { gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT); } return num_indices; } U32 LLVOAvatar::renderImpostor(LLColor4U color, S32 diffuse_channel) { if (!mImpostor.isComplete()) { return 0; } LLVector3 pos(getRenderPosition()+mImpostorOffset); LLVector3 at = (pos - LLViewerCamera::getInstance()->getOrigin()); at.normalize(); LLVector3 left = LLViewerCamera::getInstance()->getUpAxis() % at; LLVector3 up = at%left; left *= mImpostorDim.mV[0]; up *= mImpostorDim.mV[1]; LLGLEnable test(GL_ALPHA_TEST); gGL.setAlphaRejectSettings(LLRender::CF_GREATER, 0.f); gGL.color4ubv(color.mV); gGL.getTexUnit(diffuse_channel)->bind(&mImpostor); gGL.begin(LLRender::QUADS); gGL.texCoord2f(0,0); gGL.vertex3fv((pos+left-up).mV); gGL.texCoord2f(1,0); gGL.vertex3fv((pos-left-up).mV); gGL.texCoord2f(1,1); gGL.vertex3fv((pos-left+up).mV); gGL.texCoord2f(0,1); gGL.vertex3fv((pos+left+up).mV); gGL.end(); gGL.flush(); return 6; } bool LLVOAvatar::allTexturesCompletelyDownloaded(std::set<LLUUID>& ids) const { for (std::set<LLUUID>::const_iterator it = ids.begin(); it != ids.end(); ++it) { LLViewerFetchedTexture *imagep = gTextureList.findImage(*it, TEX_LIST_STANDARD); if (imagep && imagep->getDiscardLevel()!=0) { return false; } } return true; } bool LLVOAvatar::allLocalTexturesCompletelyDownloaded() const { std::set<LLUUID> local_ids; collectLocalTextureUUIDs(local_ids); return allTexturesCompletelyDownloaded(local_ids); } bool LLVOAvatar::allBakedTexturesCompletelyDownloaded() const { std::set<LLUUID> baked_ids; collectBakedTextureUUIDs(baked_ids); return allTexturesCompletelyDownloaded(baked_ids); } std::string LLVOAvatar::bakedTextureOriginInfo() { std::string result; std::set<LLUUID> baked_ids; collectBakedTextureUUIDs(baked_ids); for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { ETextureIndex texture_index = mBakedTextureDatas[i].mTextureIndex; LLViewerFetchedTexture *imagep = LLViewerTextureManager::staticCastToFetchedTexture(getImage(texture_index,0), TRUE); if (!imagep || imagep->getID() == IMG_DEFAULT || imagep->getID() == IMG_DEFAULT_AVATAR) { result += "-"; } else { bool has_url = false, has_host = false; if (!imagep->getUrl().empty()) { has_url = true; } if (imagep->getTargetHost().isOk()) { has_host = true; } S32 discard = imagep->getDiscardLevel(); if (has_url && !has_host) result += discard ? "u" : "U"; // server-bake texture with url else if (has_host && !has_url) result += discard ? "h" : "H"; // old-style texture on sim else if (has_host && has_url) result += discard ? "x" : "X"; // both origins? else if (!has_host && !has_url) result += discard ? "n" : "N"; // no origin? if (discard != 0) { result += llformat("(%d/%d)",discard,imagep->getDesiredDiscardLevel()); } } } return result; } S32Bytes LLVOAvatar::totalTextureMemForUUIDS(std::set<LLUUID>& ids) { S32Bytes result(0); for (std::set<LLUUID>::const_iterator it = ids.begin(); it != ids.end(); ++it) { LLViewerFetchedTexture *imagep = gTextureList.findImage(*it, TEX_LIST_STANDARD); if (imagep) { result += imagep->getTextureMemory(); } } return result; } void LLVOAvatar::collectLocalTextureUUIDs(std::set<LLUUID>& ids) const { for (U32 texture_index = 0; texture_index < getNumTEs(); texture_index++) { LLWearableType::EType wearable_type = LLAvatarAppearanceDictionary::getTEWearableType((ETextureIndex)texture_index); U32 num_wearables = gAgentWearables.getWearableCount(wearable_type); LLViewerFetchedTexture *imagep = NULL; for (U32 wearable_index = 0; wearable_index < num_wearables; wearable_index++) { imagep = LLViewerTextureManager::staticCastToFetchedTexture(getImage(texture_index, wearable_index), TRUE); if (imagep) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = LLAvatarAppearanceDictionary::getInstance()->getTexture((ETextureIndex)texture_index); if (texture_dict->mIsLocalTexture) { ids.insert(imagep->getID()); } } } } ids.erase(IMG_DEFAULT); ids.erase(IMG_DEFAULT_AVATAR); ids.erase(IMG_INVISIBLE); } void LLVOAvatar::collectBakedTextureUUIDs(std::set<LLUUID>& ids) const { for (U32 texture_index = 0; texture_index < getNumTEs(); texture_index++) { LLViewerFetchedTexture *imagep = NULL; if (isIndexBakedTexture((ETextureIndex) texture_index)) { imagep = LLViewerTextureManager::staticCastToFetchedTexture(getImage(texture_index,0), TRUE); if (imagep) { ids.insert(imagep->getID()); } } } ids.erase(IMG_DEFAULT); ids.erase(IMG_DEFAULT_AVATAR); ids.erase(IMG_INVISIBLE); } void LLVOAvatar::collectTextureUUIDs(std::set<LLUUID>& ids) { collectLocalTextureUUIDs(ids); collectBakedTextureUUIDs(ids); } void LLVOAvatar::releaseOldTextures() { S32Bytes current_texture_mem; // Any textures that we used to be using but are no longer using should no longer be flagged as "NO_DELETE" std::set<LLUUID> baked_texture_ids; collectBakedTextureUUIDs(baked_texture_ids); S32Bytes new_baked_mem = totalTextureMemForUUIDS(baked_texture_ids); std::set<LLUUID> local_texture_ids; collectLocalTextureUUIDs(local_texture_ids); //S32 new_local_mem = totalTextureMemForUUIDS(local_texture_ids); std::set<LLUUID> new_texture_ids; new_texture_ids.insert(baked_texture_ids.begin(),baked_texture_ids.end()); new_texture_ids.insert(local_texture_ids.begin(),local_texture_ids.end()); S32Bytes new_total_mem = totalTextureMemForUUIDS(new_texture_ids); //S32 old_total_mem = totalTextureMemForUUIDS(mTextureIDs); //LL_DEBUGS("Avatar") << getFullname() << " old_total_mem: " << old_total_mem << " new_total_mem (L/B): " << new_total_mem << " (" << new_local_mem <<", " << new_baked_mem << ")" << LL_ENDL; if (!isSelf() && new_total_mem > new_baked_mem) { LL_WARNS() << "extra local textures stored for non-self av" << LL_ENDL; } for (std::set<LLUUID>::iterator it = mTextureIDs.begin(); it != mTextureIDs.end(); ++it) { if (new_texture_ids.find(*it) == new_texture_ids.end()) { LLViewerFetchedTexture *imagep = gTextureList.findImage(*it, TEX_LIST_STANDARD); if (imagep) { current_texture_mem += imagep->getTextureMemory(); if (imagep->getTextureState() == LLGLTexture::NO_DELETE) { // This will allow the texture to be deleted if not in use. imagep->forceActive(); // This resets the clock to texture being flagged // as unused, preventing the texture from being // deleted immediately. If other avatars or // objects are using it, it can still be flagged // no-delete by them. imagep->forceUpdateBindStats(); } } } } mTextureIDs = new_texture_ids; } void LLVOAvatar::updateTextures() { releaseOldTextures(); BOOL render_avatar = TRUE; if (mIsDummy) { return; } if( isSelf() ) { render_avatar = TRUE; } else { if(!isVisible()) { return ;//do not update for invisible avatar. } render_avatar = !mCulled; //visible and not culled. } std::vector<BOOL> layer_baked; // GL NOT ACTIVE HERE - *TODO for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { layer_baked.push_back(isTextureDefined(mBakedTextureDatas[i].mTextureIndex)); // bind the texture so that they'll be decoded slightly // inefficient, we can short-circuit this if we have to if (render_avatar && !gGLManager.mIsDisabled) { if (layer_baked[i] && !mBakedTextureDatas[i].mIsLoaded) { gGL.getTexUnit(0)->bind(getImage( mBakedTextureDatas[i].mTextureIndex, 0 )); } } } mMaxPixelArea = 0.f; mMinPixelArea = 99999999.f; mHasGrey = FALSE; // debug for (U32 texture_index = 0; texture_index < getNumTEs(); texture_index++) { LLWearableType::EType wearable_type = LLAvatarAppearanceDictionary::getTEWearableType((ETextureIndex)texture_index); U32 num_wearables = gAgentWearables.getWearableCount(wearable_type); const LLTextureEntry *te = getTE(texture_index); // getTE can return 0. // Not sure yet why it does, but of course it crashes when te->mScale? gets used. // Put safeguard in place so this corner case get better handling and does not result in a crash. F32 texel_area_ratio = 1.0f; if( te ) { texel_area_ratio = fabs(te->mScaleS * te->mScaleT); } else { LL_WARNS() << "getTE( " << texture_index << " ) returned 0" <<LL_ENDL; } LLViewerFetchedTexture *imagep = NULL; for (U32 wearable_index = 0; wearable_index < num_wearables; wearable_index++) { imagep = LLViewerTextureManager::staticCastToFetchedTexture(getImage(texture_index, wearable_index), TRUE); if (imagep) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = LLAvatarAppearanceDictionary::getInstance()->getTexture((ETextureIndex)texture_index); const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex; if (texture_dict->mIsLocalTexture) { addLocalTextureStats((ETextureIndex)texture_index, imagep, texel_area_ratio, render_avatar, mBakedTextureDatas[baked_index].mIsUsed); } } } if (isIndexBakedTexture((ETextureIndex) texture_index) && render_avatar) { const S32 boost_level = getAvatarBakedBoostLevel(); imagep = LLViewerTextureManager::staticCastToFetchedTexture(getImage(texture_index,0), TRUE); addBakedTextureStats( imagep, mPixelArea, texel_area_ratio, boost_level ); } } if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA)) { setDebugText(llformat("%4.0f:%4.0f", (F32) sqrt(mMinPixelArea),(F32) sqrt(mMaxPixelArea))); } } void LLVOAvatar::addLocalTextureStats( ETextureIndex idx, LLViewerFetchedTexture* imagep, F32 texel_area_ratio, BOOL render_avatar, BOOL covered_by_baked) { // No local texture stats for non-self avatars return; } const S32 MAX_TEXTURE_UPDATE_INTERVAL = 64 ; //need to call updateTextures() at least every 32 frames. const S32 MAX_TEXTURE_VIRTUAL_SIZE_RESET_INTERVAL = S32_MAX ; //frames void LLVOAvatar::checkTextureLoading() { static const F32 MAX_INVISIBLE_WAITING_TIME = 15.f ; //seconds BOOL pause = !isVisible() ; if(!pause) { mInvisibleTimer.reset() ; } if(mLoadedCallbacksPaused == pause) { return ; } if(mCallbackTextureList.empty()) //when is self or no callbacks. Note: this list for self is always empty. { mLoadedCallbacksPaused = pause ; return ; //nothing to check. } if(pause && mInvisibleTimer.getElapsedTimeF32() < MAX_INVISIBLE_WAITING_TIME) { return ; //have not been invisible for enough time. } for(LLLoadedCallbackEntry::source_callback_list_t::iterator iter = mCallbackTextureList.begin(); iter != mCallbackTextureList.end(); ++iter) { LLViewerFetchedTexture* tex = gTextureList.findImage(*iter) ; if(tex) { if(pause)//pause texture fetching. { tex->pauseLoadedCallbacks(&mCallbackTextureList) ; //set to terminate texture fetching after MAX_TEXTURE_UPDATE_INTERVAL frames. tex->setMaxVirtualSizeResetInterval(MAX_TEXTURE_UPDATE_INTERVAL); tex->resetMaxVirtualSizeResetCounter() ; } else//unpause { static const F32 START_AREA = 100.f ; tex->unpauseLoadedCallbacks(&mCallbackTextureList) ; tex->addTextureStats(START_AREA); //jump start the fetching again } } } if(!pause) { updateTextures() ; //refresh texture stats. } mLoadedCallbacksPaused = pause ; return ; } const F32 SELF_ADDITIONAL_PRI = 0.75f ; const F32 ADDITIONAL_PRI = 0.5f; void LLVOAvatar::addBakedTextureStats( LLViewerFetchedTexture* imagep, F32 pixel_area, F32 texel_area_ratio, S32 boost_level) { //Note: //if this function is not called for the last MAX_TEXTURE_VIRTUAL_SIZE_RESET_INTERVAL frames, //the texture pipeline will stop fetching this texture. imagep->resetTextureStats(); imagep->setMaxVirtualSizeResetInterval(MAX_TEXTURE_VIRTUAL_SIZE_RESET_INTERVAL); imagep->resetMaxVirtualSizeResetCounter() ; mMaxPixelArea = llmax(pixel_area, mMaxPixelArea); mMinPixelArea = llmin(pixel_area, mMinPixelArea); imagep->addTextureStats(pixel_area / texel_area_ratio); imagep->setBoostLevel(boost_level); if(boost_level != LLGLTexture::BOOST_AVATAR_BAKED_SELF) { imagep->setAdditionalDecodePriority(ADDITIONAL_PRI) ; } else { imagep->setAdditionalDecodePriority(SELF_ADDITIONAL_PRI) ; } } //virtual void LLVOAvatar::setImage(const U8 te, LLViewerTexture *imagep, const U32 index) { setTEImage(te, imagep); } //virtual LLViewerTexture* LLVOAvatar::getImage(const U8 te, const U32 index) const { return getTEImage(te); } //virtual const LLTextureEntry* LLVOAvatar::getTexEntry(const U8 te_num) const { return getTE(te_num); } //virtual void LLVOAvatar::setTexEntry(const U8 index, const LLTextureEntry &te) { setTE(index, te); } const std::string LLVOAvatar::getImageURL(const U8 te, const LLUUID &uuid) { llassert(isIndexBakedTexture(ETextureIndex(te))); std::string url = ""; const std::string& appearance_service_url = LLAppearanceMgr::instance().getAppearanceServiceURL(); if (appearance_service_url.empty()) { // Probably a server-side issue if we get here: LL_WARNS() << "AgentAppearanceServiceURL not set - Baked texture requests will fail" << LL_ENDL; return url; } const LLAvatarAppearanceDictionary::TextureEntry* texture_entry = LLAvatarAppearanceDictionary::getInstance()->getTexture((ETextureIndex)te); if (texture_entry != NULL) { url = appearance_service_url + "texture/" + getID().asString() + "/" + texture_entry->mDefaultImageName + "/" + uuid.asString(); //LL_INFOS() << "baked texture url: " << url << LL_ENDL; } return url; } //----------------------------------------------------------------------------- // resolveHeight() //----------------------------------------------------------------------------- void LLVOAvatar::resolveHeightAgent(const LLVector3 &in_pos_agent, LLVector3 &out_pos_agent, LLVector3 &out_norm) { LLVector3d in_pos_global, out_pos_global; in_pos_global = gAgent.getPosGlobalFromAgent(in_pos_agent); resolveHeightGlobal(in_pos_global, out_pos_global, out_norm); out_pos_agent = gAgent.getPosAgentFromGlobal(out_pos_global); } void LLVOAvatar::resolveRayCollisionAgent(const LLVector3d start_pt, const LLVector3d end_pt, LLVector3d &out_pos, LLVector3 &out_norm) { LLViewerObject *obj; LLWorld::getInstance()->resolveStepHeightGlobal(this, start_pt, end_pt, out_pos, out_norm, &obj); } void LLVOAvatar::resolveHeightGlobal(const LLVector3d &inPos, LLVector3d &outPos, LLVector3 &outNorm) { LLVector3d zVec(0.0f, 0.0f, 0.5f); LLVector3d p0 = inPos + zVec; LLVector3d p1 = inPos - zVec; LLViewerObject *obj; LLWorld::getInstance()->resolveStepHeightGlobal(this, p0, p1, outPos, outNorm, &obj); if (!obj) { mStepOnLand = TRUE; mStepMaterial = 0; mStepObjectVelocity.setVec(0.0f, 0.0f, 0.0f); } else { mStepOnLand = FALSE; mStepMaterial = obj->getMaterial(); // We want the primitive velocity, not our velocity... (which actually subtracts the // step object velocity) LLVector3 angularVelocity = obj->getAngularVelocity(); LLVector3 relativePos = gAgent.getPosAgentFromGlobal(outPos) - obj->getPositionAgent(); LLVector3 linearComponent = angularVelocity % relativePos; // LL_INFOS() << "Linear Component of Rotation Velocity " << linearComponent << LL_ENDL; mStepObjectVelocity = obj->getVelocity() + linearComponent; } } //----------------------------------------------------------------------------- // getStepSound() //----------------------------------------------------------------------------- const LLUUID& LLVOAvatar::getStepSound() const { if ( mStepOnLand ) { return sStepSoundOnLand; } return sStepSounds[mStepMaterial]; } //----------------------------------------------------------------------------- // processAnimationStateChanges() //----------------------------------------------------------------------------- void LLVOAvatar::processAnimationStateChanges() { if ( isAnyAnimationSignaled(AGENT_WALK_ANIMS, NUM_AGENT_WALK_ANIMS) ) { startMotion(ANIM_AGENT_WALK_ADJUST); stopMotion(ANIM_AGENT_FLY_ADJUST); } else if (mInAir && !mIsSitting) { stopMotion(ANIM_AGENT_WALK_ADJUST); startMotion(ANIM_AGENT_FLY_ADJUST); } else { stopMotion(ANIM_AGENT_WALK_ADJUST); stopMotion(ANIM_AGENT_FLY_ADJUST); } if ( isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) ) { startMotion(ANIM_AGENT_TARGET); stopMotion(ANIM_AGENT_BODY_NOISE); } else { stopMotion(ANIM_AGENT_TARGET); startMotion(ANIM_AGENT_BODY_NOISE); } // clear all current animations AnimIterator anim_it; for (anim_it = mPlayingAnimations.begin(); anim_it != mPlayingAnimations.end();) { AnimIterator found_anim = mSignaledAnimations.find(anim_it->first); // playing, but not signaled, so stop if (found_anim == mSignaledAnimations.end()) { processSingleAnimationStateChange(anim_it->first, FALSE); mPlayingAnimations.erase(anim_it++); continue; } ++anim_it; } // start up all new anims for (anim_it = mSignaledAnimations.begin(); anim_it != mSignaledAnimations.end();) { AnimIterator found_anim = mPlayingAnimations.find(anim_it->first); // signaled but not playing, or different sequence id, start motion if (found_anim == mPlayingAnimations.end() || found_anim->second != anim_it->second) { if (processSingleAnimationStateChange(anim_it->first, TRUE)) { mPlayingAnimations[anim_it->first] = anim_it->second; ++anim_it; continue; } } ++anim_it; } // clear source information for animations which have been stopped if (isSelf()) { AnimSourceIterator source_it = mAnimationSources.begin(); for (source_it = mAnimationSources.begin(); source_it != mAnimationSources.end();) { if (mSignaledAnimations.find(source_it->second) == mSignaledAnimations.end()) { mAnimationSources.erase(source_it++); } else { ++source_it; } } } stop_glerror(); } //----------------------------------------------------------------------------- // processSingleAnimationStateChange(); //----------------------------------------------------------------------------- BOOL LLVOAvatar::processSingleAnimationStateChange( const LLUUID& anim_id, BOOL start ) { // SL-402, SL-427 - we need to update body size often enough to // keep appearances in sync, but not so often that animations // cause constant jiggling of the body or camera. Possible // compromise is to do it on animation changes: computeBodySize(); BOOL result = FALSE; if ( start ) // start animation { if (anim_id == ANIM_AGENT_TYPE) { if (gAudiop) { LLVector3d char_pos_global = gAgent.getPosGlobalFromAgent(getCharacterPosition()); if (LLViewerParcelMgr::getInstance()->canHearSound(char_pos_global) && !LLMuteList::getInstance()->isMuted(getID(), LLMute::flagObjectSounds)) { // RN: uncomment this to play on typing sound at fixed volume once sound engine is fixed // to support both spatialized and non-spatialized instances of the same sound //if (isSelf()) //{ // gAudiop->triggerSound(LLUUID(gSavedSettings.getString("UISndTyping")), 1.0f, LLAudioEngine::AUDIO_TYPE_UI); //} //else { LLUUID sound_id = LLUUID(gSavedSettings.getString("UISndTyping")); gAudiop->triggerSound(sound_id, getID(), 1.0f, LLAudioEngine::AUDIO_TYPE_SFX, char_pos_global); } } } } else if (anim_id == ANIM_AGENT_SIT_GROUND_CONSTRAINED) { sitDown(TRUE); } if (startMotion(anim_id)) { result = TRUE; } else { LL_WARNS() << "Failed to start motion!" << LL_ENDL; } } else //stop animation { if (anim_id == ANIM_AGENT_SIT_GROUND_CONSTRAINED) { sitDown(FALSE); } if ((anim_id == ANIM_AGENT_DO_NOT_DISTURB) && gAgent.isDoNotDisturb()) { // re-assert DND tag animation gAgent.sendAnimationRequest(ANIM_AGENT_DO_NOT_DISTURB, ANIM_REQUEST_START); return result; } stopMotion(anim_id); result = TRUE; } return result; } //----------------------------------------------------------------------------- // isAnyAnimationSignaled() //----------------------------------------------------------------------------- BOOL LLVOAvatar::isAnyAnimationSignaled(const LLUUID *anim_array, const S32 num_anims) const { for (S32 i = 0; i < num_anims; i++) { if(mSignaledAnimations.find(anim_array[i]) != mSignaledAnimations.end()) { return TRUE; } } return FALSE; } //----------------------------------------------------------------------------- // resetAnimations() //----------------------------------------------------------------------------- void LLVOAvatar::resetAnimations() { LLKeyframeMotion::flushKeyframeCache(); flushAllMotions(); } // Override selectively based on avatar sex and whether we're using new // animations. LLUUID LLVOAvatar::remapMotionID(const LLUUID& id) { BOOL use_new_walk_run = gSavedSettings.getBOOL("UseNewWalkRun"); LLUUID result = id; // start special case female walk for female avatars if (getSex() == SEX_FEMALE) { if (id == ANIM_AGENT_WALK) { if (use_new_walk_run) result = ANIM_AGENT_FEMALE_WALK_NEW; else result = ANIM_AGENT_FEMALE_WALK; } else if (id == ANIM_AGENT_RUN) { // There is no old female run animation, so only override // in one case. if (use_new_walk_run) result = ANIM_AGENT_FEMALE_RUN_NEW; } else if (id == ANIM_AGENT_SIT) { result = ANIM_AGENT_SIT_FEMALE; } } else { // Male avatar. if (id == ANIM_AGENT_WALK) { if (use_new_walk_run) result = ANIM_AGENT_WALK_NEW; } else if (id == ANIM_AGENT_RUN) { if (use_new_walk_run) result = ANIM_AGENT_RUN_NEW; } } return result; } //----------------------------------------------------------------------------- // startMotion() // id is the asset if of the animation to start // time_offset is the offset into the animation at which to start playing //----------------------------------------------------------------------------- BOOL LLVOAvatar::startMotion(const LLUUID& id, F32 time_offset) { LL_DEBUGS() << "motion requested " << id.asString() << " " << gAnimLibrary.animationName(id) << LL_ENDL; LLUUID remap_id = remapMotionID(id); if (remap_id != id) { LL_DEBUGS() << "motion resultant " << remap_id.asString() << " " << gAnimLibrary.animationName(remap_id) << LL_ENDL; } if (isSelf() && remap_id == ANIM_AGENT_AWAY) { gAgent.setAFK(); } return LLCharacter::startMotion(remap_id, time_offset); } //----------------------------------------------------------------------------- // stopMotion() //----------------------------------------------------------------------------- BOOL LLVOAvatar::stopMotion(const LLUUID& id, BOOL stop_immediate) { LL_DEBUGS() << "motion requested " << id.asString() << " " << gAnimLibrary.animationName(id) << LL_ENDL; LLUUID remap_id = remapMotionID(id); if (remap_id != id) { LL_DEBUGS() << "motion resultant " << remap_id.asString() << " " << gAnimLibrary.animationName(remap_id) << LL_ENDL; } if (isSelf()) { gAgent.onAnimStop(remap_id); } return LLCharacter::stopMotion(remap_id, stop_immediate); } //----------------------------------------------------------------------------- // hasMotionFromSource() //----------------------------------------------------------------------------- // virtual bool LLVOAvatar::hasMotionFromSource(const LLUUID& source_id) { return false; } //----------------------------------------------------------------------------- // stopMotionFromSource() //----------------------------------------------------------------------------- // virtual void LLVOAvatar::stopMotionFromSource(const LLUUID& source_id) { } //----------------------------------------------------------------------------- // addDebugText() //----------------------------------------------------------------------------- void LLVOAvatar::addDebugText(const std::string& text) { mDebugText.append(1, '\n'); mDebugText.append(text); } //----------------------------------------------------------------------------- // getID() //----------------------------------------------------------------------------- const LLUUID& LLVOAvatar::getID() const { return mID; } //----------------------------------------------------------------------------- // getJoint() //----------------------------------------------------------------------------- // RN: avatar joints are multi-rooted to include screen-based attachments LLJoint *LLVOAvatar::getJoint( const std::string &name ) { joint_map_t::iterator iter = mJointMap.find(name); LLJoint* jointp = NULL; if (iter == mJointMap.end() || iter->second == NULL) { //search for joint and cache found joint in lookup table jointp = mRoot->findJoint(name); mJointMap[name] = jointp; } else { //return cached pointer jointp = iter->second; } #ifndef LL_RELEASE_FOR_DOWNLOAD if (jointp && jointp->getName()!="mScreen" && jointp->getName()!="mRoot") { llassert(getJoint(jointp->getJointNum())==jointp); } #endif return jointp; } LLJoint *LLVOAvatar::getJoint( S32 joint_num ) { LLJoint *pJoint = NULL; S32 collision_start = mNumBones; S32 attachment_start = mNumBones + mNumCollisionVolumes; if (joint_num>=attachment_start) { // Attachment IDs start at 1 S32 attachment_id = joint_num - attachment_start + 1; attachment_map_t::iterator iter = mAttachmentPoints.find(attachment_id); if (iter != mAttachmentPoints.end()) { pJoint = iter->second; } } else if (joint_num>=collision_start) { S32 collision_id = joint_num-collision_start; pJoint = &mCollisionVolumes[collision_id]; } else if (joint_num>=0) { pJoint = mSkeleton[joint_num]; } llassert(!pJoint || pJoint->getJointNum() == joint_num); return pJoint; } //----------------------------------------------------------------------------- // getRiggedMeshID // // If viewer object is a rigged mesh, set the mesh id and return true. // Otherwise, null out the id and return false. //----------------------------------------------------------------------------- // static bool LLVOAvatar::getRiggedMeshID(LLViewerObject* pVO, LLUUID& mesh_id) { mesh_id.setNull(); //If a VO has a skin that we'll reset the joint positions to their default if ( pVO && pVO->mDrawable ) { LLVOVolume* pVObj = pVO->mDrawable->getVOVolume(); if ( pVObj ) { const LLMeshSkinInfo* pSkinData = gMeshRepo.getSkinInfo( pVObj->getVolume()->getParams().getSculptID(), pVObj ); if (pSkinData && pSkinData->mJointNames.size() > JOINT_COUNT_REQUIRED_FOR_FULLRIG // full rig && pSkinData->mAlternateBindMatrix.size() > 0 ) { mesh_id = pSkinData->mMeshID; return true; } } } return false; } bool LLVOAvatar::jointIsRiggedTo(const std::string& joint_name) { for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { const LLViewerObject* attached_object = (*attachment_iter); if (attached_object && jointIsRiggedTo(joint_name, attached_object)) { return true; } } } return false; } bool LLVOAvatar::jointIsRiggedTo(const std::string& joint_name, const LLViewerObject *vo) { // Process all children LLViewerObject::const_child_list_t& children = vo->getChildren(); for (LLViewerObject::const_child_list_t::const_iterator it = children.begin(); it != children.end(); ++it) { LLViewerObject *childp = *it; if (jointIsRiggedTo(joint_name,childp)) { return true; } } const LLVOVolume *vobj = dynamic_cast<const LLVOVolume*>(vo); if (!vobj) { return false; } LLUUID currentId = vobj->getVolume()->getParams().getSculptID(); const LLMeshSkinInfo* pSkinData = gMeshRepo.getSkinInfo( currentId, vobj ); if ( vobj && vobj->isAttachment() && vobj->isMesh() && pSkinData ) { if (std::find(pSkinData->mJointNames.begin(), pSkinData->mJointNames.end(), joint_name) != pSkinData->mJointNames.end()) { return true; } } return false; } void LLVOAvatar::clearAttachmentOverrides() { LLScopedContextString str("clearAttachmentOverrides " + getFullname()); for (S32 i=0; i<LL_CHARACTER_MAX_ANIMATED_JOINTS; i++) { LLJoint *pJoint = getJoint(i); if (pJoint) { pJoint->clearAttachmentPosOverrides(); pJoint->clearAttachmentScaleOverrides(); } } } //----------------------------------------------------------------------------- // rebuildAttachmentOverrides //----------------------------------------------------------------------------- void LLVOAvatar::rebuildAttachmentOverrides() { LLScopedContextString str("rebuildAttachmentOverrides " + getFullname()); // Attachment points for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment *attachment_pt = (*iter).second; if (attachment_pt) { for (LLViewerJointAttachment::attachedobjs_vec_t::iterator at_it = attachment_pt->mAttachedObjects.begin(); at_it != attachment_pt->mAttachedObjects.end(); ++at_it) { addAttachmentOverridesForObject(*at_it); } } } } //----------------------------------------------------------------------------- // addAttachmentPosOverridesForObject //----------------------------------------------------------------------------- void LLVOAvatar::addAttachmentOverridesForObject(LLViewerObject *vo) { LLVOAvatar *av = vo->getAvatarAncestor(); if (!av || (av != this)) { LL_WARNS("Avatar") << "called with invalid avatar" << LL_ENDL; return; } LLScopedContextString str("addAttachmentOverridesForObject " + av->getFullname()); // Process all children LLViewerObject::const_child_list_t& children = vo->getChildren(); for (LLViewerObject::const_child_list_t::const_iterator it = children.begin(); it != children.end(); ++it) { LLViewerObject *childp = *it; addAttachmentOverridesForObject(childp); } LLVOVolume *vobj = dynamic_cast<LLVOVolume*>(vo); bool pelvisGotSet = false; if (!vobj) { return; } if (vobj->isMesh() && ((vobj->getVolume() && !vobj->getVolume()->isMeshAssetLoaded()) || !gMeshRepo.meshRezEnabled())) { return; } LLUUID currentId = vobj->getVolume()->getParams().getSculptID(); const LLMeshSkinInfo* pSkinData = gMeshRepo.getSkinInfo( currentId, vobj ); if ( vobj && vobj->isAttachment() && vobj->isMesh() && pSkinData ) { const int bindCnt = pSkinData->mAlternateBindMatrix.size(); const int jointCnt = pSkinData->mJointNames.size(); if ((bindCnt > 0) && (bindCnt != jointCnt)) { LL_WARNS_ONCE() << "invalid mesh, bindCnt " << bindCnt << "!= jointCnt " << jointCnt << ", joint overrides will be ignored." << LL_ENDL; } if ((bindCnt > 0) && (bindCnt == jointCnt)) { const F32 pelvisZOffset = pSkinData->mPelvisOffset; const LLUUID& mesh_id = pSkinData->mMeshID; bool fullRig = (jointCnt>=JOINT_COUNT_REQUIRED_FOR_FULLRIG) ? true : false; if ( fullRig ) { for ( int i=0; i<jointCnt; ++i ) { std::string lookingForJoint = pSkinData->mJointNames[i].c_str(); LLJoint* pJoint = getJoint( lookingForJoint ); if (pJoint) { const LLVector3& jointPos = pSkinData->mAlternateBindMatrix[i].getTranslation(); if (pJoint->aboveJointPosThreshold(jointPos)) { bool override_changed; pJoint->addAttachmentPosOverride( jointPos, mesh_id, avString(), override_changed ); if (override_changed) { //If joint is a pelvis then handle old/new pelvis to foot values if ( lookingForJoint == "mPelvis" ) { pelvisGotSet = true; } } if (pSkinData->mLockScaleIfJointPosition) { // Note that unlike positions, there's no threshold check here, // just a lock at the default value. pJoint->addAttachmentScaleOverride(pJoint->getDefaultScale(), mesh_id, avString()); } } } } if (pelvisZOffset != 0.0F) { F32 pelvis_fixup_before; bool has_fixup_before = hasPelvisFixup(pelvis_fixup_before); addPelvisFixup( pelvisZOffset, mesh_id ); F32 pelvis_fixup_after; hasPelvisFixup(pelvis_fixup_after); // Don't have to check bool here because we just added it... if (!has_fixup_before || (pelvis_fixup_before != pelvis_fixup_after)) { pelvisGotSet = true; } } } } } //Rebuild body data if we altered joints/pelvis if ( pelvisGotSet ) { postPelvisSetRecalc(); } } //----------------------------------------------------------------------------- // getAttachmentOverrideNames //----------------------------------------------------------------------------- void LLVOAvatar::getAttachmentOverrideNames(std::set<std::string>& pos_names, std::set<std::string>& scale_names) const { LLVector3 pos; LLVector3 scale; LLUUID mesh_id; // Bones for (avatar_joint_list_t::const_iterator iter = mSkeleton.begin(); iter != mSkeleton.end(); ++iter) { const LLJoint* pJoint = (*iter); if (pJoint && pJoint->hasAttachmentPosOverride(pos,mesh_id)) { pos_names.insert(pJoint->getName()); } if (pJoint && pJoint->hasAttachmentScaleOverride(scale,mesh_id)) { scale_names.insert(pJoint->getName()); } } // Attachment points for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { const LLViewerJointAttachment *attachment_pt = (*iter).second; if (attachment_pt && attachment_pt->hasAttachmentPosOverride(pos,mesh_id)) { pos_names.insert(attachment_pt->getName()); } // Attachment points don't have scales. } } //----------------------------------------------------------------------------- // showAttachmentOverrides //----------------------------------------------------------------------------- void LLVOAvatar::showAttachmentOverrides(bool verbose) const { std::set<std::string> pos_names, scale_names; getAttachmentOverrideNames(pos_names, scale_names); if (pos_names.size()) { std::stringstream ss; std::copy(pos_names.begin(), pos_names.end(), std::ostream_iterator<std::string>(ss, ",")); LL_INFOS() << getFullname() << " attachment positions defined for joints: " << ss.str() << "\n" << LL_ENDL; } else { LL_DEBUGS("Avatar") << getFullname() << " no attachment positions defined for any joints" << "\n" << LL_ENDL; } if (scale_names.size()) { std::stringstream ss; std::copy(scale_names.begin(), scale_names.end(), std::ostream_iterator<std::string>(ss, ",")); LL_INFOS() << getFullname() << " attachment scales defined for joints: " << ss.str() << "\n" << LL_ENDL; } else { LL_INFOS() << getFullname() << " no attachment scales defined for any joints" << "\n" << LL_ENDL; } if (!verbose) { return; } LLVector3 pos, scale; LLUUID mesh_id; S32 count = 0; // Bones for (avatar_joint_list_t::const_iterator iter = mSkeleton.begin(); iter != mSkeleton.end(); ++iter) { const LLJoint* pJoint = (*iter); if (pJoint && pJoint->hasAttachmentPosOverride(pos,mesh_id)) { pJoint->showAttachmentPosOverrides(getFullname()); count++; } if (pJoint && pJoint->hasAttachmentScaleOverride(scale,mesh_id)) { pJoint->showAttachmentScaleOverrides(getFullname()); count++; } } // Attachment points for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { const LLViewerJointAttachment *attachment_pt = (*iter).second; if (attachment_pt && attachment_pt->hasAttachmentPosOverride(pos,mesh_id)) { attachment_pt->showAttachmentPosOverrides(getFullname()); count++; } } if (count) { LL_DEBUGS("Avatar") << avString() << " end of pos, scale overrides" << LL_ENDL; LL_DEBUGS("Avatar") << "=================================" << LL_ENDL; } } //----------------------------------------------------------------------------- // resetJointsOnDetach //----------------------------------------------------------------------------- void LLVOAvatar::resetJointsOnDetach(LLViewerObject *vo) { LLVOAvatar *av = vo->getAvatarAncestor(); if (!av || (av != this)) { LL_WARNS("Avatar") << "called with invalid avatar" << LL_ENDL; } // Process all children LLViewerObject::const_child_list_t& children = vo->getChildren(); for (LLViewerObject::const_child_list_t::const_iterator it = children.begin(); it != children.end(); ++it) { LLViewerObject *childp = *it; resetJointsOnDetach(childp); } // Process self. LLUUID mesh_id; if (getRiggedMeshID(vo,mesh_id)) { resetJointsOnDetach(mesh_id); } } //----------------------------------------------------------------------------- // resetJointsOnDetach //----------------------------------------------------------------------------- void LLVOAvatar::resetJointsOnDetach(const LLUUID& mesh_id) { //Subsequent joints are relative to pelvis avatar_joint_list_t::iterator iter = mSkeleton.begin(); avatar_joint_list_t::iterator end = mSkeleton.end(); LLJoint* pJointPelvis = getJoint("mPelvis"); for (; iter != end; ++iter) { LLJoint* pJoint = (*iter); //Reset joints except for pelvis if ( pJoint ) { bool dummy; // unused pJoint->removeAttachmentPosOverride(mesh_id, avString(),dummy); pJoint->removeAttachmentScaleOverride(mesh_id, avString()); } if ( pJoint && pJoint == pJointPelvis) { removePelvisFixup( mesh_id ); // SL-315 pJoint->setPosition( LLVector3( 0.0f, 0.0f, 0.0f) ); } } postPelvisSetRecalc(); } //----------------------------------------------------------------------------- // getCharacterPosition() //----------------------------------------------------------------------------- LLVector3 LLVOAvatar::getCharacterPosition() { if (mDrawable.notNull()) { return mDrawable->getPositionAgent(); } else { return getPositionAgent(); } } //----------------------------------------------------------------------------- // LLVOAvatar::getCharacterRotation() //----------------------------------------------------------------------------- LLQuaternion LLVOAvatar::getCharacterRotation() { return getRotation(); } //----------------------------------------------------------------------------- // LLVOAvatar::getCharacterVelocity() //----------------------------------------------------------------------------- LLVector3 LLVOAvatar::getCharacterVelocity() { return getVelocity() - mStepObjectVelocity; } //----------------------------------------------------------------------------- // LLVOAvatar::getCharacterAngularVelocity() //----------------------------------------------------------------------------- LLVector3 LLVOAvatar::getCharacterAngularVelocity() { return getAngularVelocity(); } //----------------------------------------------------------------------------- // LLVOAvatar::getGround() //----------------------------------------------------------------------------- void LLVOAvatar::getGround(const LLVector3 &in_pos_agent, LLVector3 &out_pos_agent, LLVector3 &outNorm) { LLVector3d z_vec(0.0f, 0.0f, 1.0f); LLVector3d p0_global, p1_global; if (mIsDummy) { outNorm.setVec(z_vec); out_pos_agent = in_pos_agent; return; } p0_global = gAgent.getPosGlobalFromAgent(in_pos_agent) + z_vec; p1_global = gAgent.getPosGlobalFromAgent(in_pos_agent) - z_vec; LLViewerObject *obj; LLVector3d out_pos_global; LLWorld::getInstance()->resolveStepHeightGlobal(this, p0_global, p1_global, out_pos_global, outNorm, &obj); out_pos_agent = gAgent.getPosAgentFromGlobal(out_pos_global); } //----------------------------------------------------------------------------- // LLVOAvatar::getTimeDilation() //----------------------------------------------------------------------------- F32 LLVOAvatar::getTimeDilation() { return mRegionp ? mRegionp->getTimeDilation() : 1.f; } //----------------------------------------------------------------------------- // LLVOAvatar::getPixelArea() //----------------------------------------------------------------------------- F32 LLVOAvatar::getPixelArea() const { if (mIsDummy) { return 100000.f; } return mPixelArea; } //----------------------------------------------------------------------------- // LLVOAvatar::getPosGlobalFromAgent() //----------------------------------------------------------------------------- LLVector3d LLVOAvatar::getPosGlobalFromAgent(const LLVector3 &position) { return gAgent.getPosGlobalFromAgent(position); } //----------------------------------------------------------------------------- // getPosAgentFromGlobal() //----------------------------------------------------------------------------- LLVector3 LLVOAvatar::getPosAgentFromGlobal(const LLVector3d &position) { return gAgent.getPosAgentFromGlobal(position); } //----------------------------------------------------------------------------- // requestStopMotion() //----------------------------------------------------------------------------- // virtual void LLVOAvatar::requestStopMotion( LLMotion* motion ) { // Only agent avatars should handle the stop motion notifications. } //----------------------------------------------------------------------------- // loadSkeletonNode(): loads <skeleton> node from XML tree //----------------------------------------------------------------------------- //virtual BOOL LLVOAvatar::loadSkeletonNode () { if (!LLAvatarAppearance::loadSkeletonNode()) { return FALSE; } bool ignore_hud_joints = false; initAttachmentPoints(ignore_hud_joints); return TRUE; } //----------------------------------------------------------------------------- // initAttachmentPoints(): creates attachment points if needed, sets state based on avatar_lad.xml. //----------------------------------------------------------------------------- void LLVOAvatar::initAttachmentPoints(bool ignore_hud_joints) { LLAvatarXmlInfo::attachment_info_list_t::iterator iter; for (iter = sAvatarXmlInfo->mAttachmentInfoList.begin(); iter != sAvatarXmlInfo->mAttachmentInfoList.end(); ++iter) { LLAvatarXmlInfo::LLAvatarAttachmentInfo *info = *iter; if (info->mIsHUDAttachment && (!isSelf() || ignore_hud_joints)) { //don't process hud joint for other avatars, or when doing a skeleton reset. continue; } S32 attachmentID = info->mAttachmentID; if (attachmentID < 1 || attachmentID > 255) { LL_WARNS() << "Attachment point out of range [1-255]: " << attachmentID << " on attachment point " << info->mName << LL_ENDL; continue; } LLViewerJointAttachment* attachment = NULL; bool newly_created = false; if (mAttachmentPoints.find(attachmentID) == mAttachmentPoints.end()) { attachment = new LLViewerJointAttachment(); newly_created = true; } else { attachment = mAttachmentPoints[attachmentID]; } attachment->setName(info->mName); LLJoint *parent_joint = getJoint(info->mJointName); if (!parent_joint) { // If the intended parent for attachment point is unavailable, avatar_lad.xml is corrupt. LL_WARNS() << "No parent joint by name " << info->mJointName << " found for attachment point " << info->mName << LL_ENDL; LL_ERRS() << "Invalid avatar_lad.xml file" << LL_ENDL; } if (info->mHasPosition) { attachment->setOriginalPosition(info->mPosition); attachment->setDefaultPosition(info->mPosition); } if (info->mHasRotation) { LLQuaternion rotation; rotation.setQuat(info->mRotationEuler.mV[VX] * DEG_TO_RAD, info->mRotationEuler.mV[VY] * DEG_TO_RAD, info->mRotationEuler.mV[VZ] * DEG_TO_RAD); attachment->setRotation(rotation); } int group = info->mGroup; if (group >= 0) { if (group < 0 || group > 9) { LL_WARNS() << "Invalid group number (" << group << ") for attachment point " << info->mName << LL_ENDL; } else { attachment->setGroup(group); } } attachment->setPieSlice(info->mPieMenuSlice); attachment->setVisibleInFirstPerson(info->mVisibleFirstPerson); attachment->setIsHUDAttachment(info->mIsHUDAttachment); // attachment can potentially be animated, needs a number. attachment->setJointNum(mNumBones + mNumCollisionVolumes + attachmentID - 1); if (newly_created) { mAttachmentPoints[attachmentID] = attachment; // now add attachment joint parent_joint->addChild(attachment); } } } //----------------------------------------------------------------------------- // updateVisualParams() //----------------------------------------------------------------------------- void LLVOAvatar::updateVisualParams() { setSex( (getVisualParamWeight( "male" ) > 0.5f) ? SEX_MALE : SEX_FEMALE ); LLCharacter::updateVisualParams(); if (mLastSkeletonSerialNum != mSkeletonSerialNum) { computeBodySize(); mLastSkeletonSerialNum = mSkeletonSerialNum; mRoot->updateWorldMatrixChildren(); } dirtyMesh(); updateHeadOffset(); } //----------------------------------------------------------------------------- // isActive() //----------------------------------------------------------------------------- BOOL LLVOAvatar::isActive() const { return TRUE; } //----------------------------------------------------------------------------- // setPixelAreaAndAngle() //----------------------------------------------------------------------------- void LLVOAvatar::setPixelAreaAndAngle(LLAgent &agent) { if (mDrawable.isNull()) { return; } const LLVector4a* ext = mDrawable->getSpatialExtents(); LLVector4a center; center.setAdd(ext[1], ext[0]); center.mul(0.5f); LLVector4a size; size.setSub(ext[1], ext[0]); size.mul(0.5f); mImpostorPixelArea = LLPipeline::calcPixelArea(center, size, *LLViewerCamera::getInstance()); F32 range = mDrawable->mDistanceWRTCamera; if (range < 0.001f) // range == zero { mAppAngle = 180.f; } else { F32 radius = size.getLength3().getF32(); mAppAngle = (F32) atan2( radius, range) * RAD_TO_DEG; } // We always want to look good to ourselves if( isSelf() ) { mPixelArea = llmax( mPixelArea, F32(getTexImageSize() / 16) ); } } //----------------------------------------------------------------------------- // updateJointLODs() //----------------------------------------------------------------------------- BOOL LLVOAvatar::updateJointLODs() { const F32 MAX_PIXEL_AREA = 100000000.f; F32 lod_factor = (sLODFactor * AVATAR_LOD_TWEAK_RANGE + (1.f - AVATAR_LOD_TWEAK_RANGE)); F32 avatar_num_min_factor = clamp_rescale(sLODFactor, 0.f, 1.f, 0.25f, 0.6f); F32 avatar_num_factor = clamp_rescale((F32)sNumVisibleAvatars, 8, 25, 1.f, avatar_num_min_factor); F32 area_scale = 0.16f; if (isSelf()) { if(gAgentCamera.cameraCustomizeAvatar() || gAgentCamera.cameraMouselook()) { mAdjustedPixelArea = MAX_PIXEL_AREA; } else { mAdjustedPixelArea = mPixelArea*area_scale; } } else if (mIsDummy) { mAdjustedPixelArea = MAX_PIXEL_AREA; } else { // reported avatar pixel area is dependent on avatar render load, based on number of visible avatars mAdjustedPixelArea = (F32)mPixelArea * area_scale * lod_factor * lod_factor * avatar_num_factor * avatar_num_factor; } // now select meshes to render based on adjusted pixel area LLViewerJoint* root = dynamic_cast<LLViewerJoint*>(mRoot); BOOL res = FALSE; if (root) { res = root->updateLOD(mAdjustedPixelArea, TRUE); } if (res) { sNumLODChangesThisFrame++; dirtyMesh(2); return TRUE; } return FALSE; } //----------------------------------------------------------------------------- // createDrawable() //----------------------------------------------------------------------------- LLDrawable *LLVOAvatar::createDrawable(LLPipeline *pipeline) { pipeline->allocDrawable(this); mDrawable->setLit(FALSE); LLDrawPoolAvatar *poolp = (LLDrawPoolAvatar*) gPipeline.getPool(LLDrawPool::POOL_AVATAR); // Only a single face (one per avatar) //this face will be splitted into several if its vertex buffer is too long. mDrawable->setState(LLDrawable::ACTIVE); mDrawable->addFace(poolp, NULL); mDrawable->setRenderType(LLPipeline::RENDER_TYPE_AVATAR); mNumInitFaces = mDrawable->getNumFaces() ; dirtyMesh(2); return mDrawable; } void LLVOAvatar::updateGL() { if (mMeshTexturesDirty) { updateMeshTextures(); mMeshTexturesDirty = FALSE; } } //----------------------------------------------------------------------------- // updateGeometry() //----------------------------------------------------------------------------- static LLTrace::BlockTimerStatHandle FTM_UPDATE_AVATAR("Update Avatar"); BOOL LLVOAvatar::updateGeometry(LLDrawable *drawable) { LL_RECORD_BLOCK_TIME(FTM_UPDATE_AVATAR); if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_AVATAR))) { return TRUE; } if (!mMeshValid) { return TRUE; } if (!drawable) { LL_ERRS() << "LLVOAvatar::updateGeometry() called with NULL drawable" << LL_ENDL; } return TRUE; } //----------------------------------------------------------------------------- // updateSexDependentLayerSets() //----------------------------------------------------------------------------- void LLVOAvatar::updateSexDependentLayerSets() { invalidateComposite( mBakedTextureDatas[BAKED_HEAD].mTexLayerSet); invalidateComposite( mBakedTextureDatas[BAKED_UPPER].mTexLayerSet); invalidateComposite( mBakedTextureDatas[BAKED_LOWER].mTexLayerSet); } //----------------------------------------------------------------------------- // dirtyMesh() //----------------------------------------------------------------------------- void LLVOAvatar::dirtyMesh() { dirtyMesh(1); } void LLVOAvatar::dirtyMesh(S32 priority) { mDirtyMesh = llmax(mDirtyMesh, priority); } //----------------------------------------------------------------------------- // getViewerJoint() //----------------------------------------------------------------------------- LLViewerJoint* LLVOAvatar::getViewerJoint(S32 idx) { return dynamic_cast<LLViewerJoint*>(mMeshLOD[idx]); } //----------------------------------------------------------------------------- // hideSkirt() //----------------------------------------------------------------------------- void LLVOAvatar::hideSkirt() { mMeshLOD[MESH_ID_SKIRT]->setVisible(FALSE, TRUE); } BOOL LLVOAvatar::setParent(LLViewerObject* parent) { BOOL ret ; if (parent == NULL) { getOffObject(); ret = LLViewerObject::setParent(parent); if (isSelf()) { gAgentCamera.resetCamera(); } } else { ret = LLViewerObject::setParent(parent); if(ret) { sitOnObject(parent); } } return ret ; } void LLVOAvatar::addChild(LLViewerObject *childp) { childp->extractAttachmentItemID(); // find the inventory item this object is associated with. if (isSelf()) { const LLUUID& item_id = childp->getAttachmentItemID(); LLViewerInventoryItem *item = gInventory.getItem(item_id); LL_DEBUGS("Avatar") << "ATT attachment child added " << (item ? item->getName() : "UNKNOWN") << " id " << item_id << LL_ENDL; } LLViewerObject::addChild(childp); if (childp->mDrawable) { if (!attachObject(childp)) { LL_WARNS() << "ATT addChild() failed for " << childp->getID() << " item " << childp->getAttachmentItemID() << LL_ENDL; // MAINT-3312 backout // mPendingAttachment.push_back(childp); } } else { mPendingAttachment.push_back(childp); } } void LLVOAvatar::removeChild(LLViewerObject *childp) { LLViewerObject::removeChild(childp); if (!detachObject(childp)) { LL_WARNS() << "Calling detach on non-attached object " << LL_ENDL; } } LLViewerJointAttachment* LLVOAvatar::getTargetAttachmentPoint(LLViewerObject* viewer_object) { S32 attachmentID = ATTACHMENT_ID_FROM_STATE(viewer_object->getState()); // This should never happen unless the server didn't process the attachment point // correctly, but putting this check in here to be safe. if (attachmentID & ATTACHMENT_ADD) { LL_WARNS() << "Got an attachment with ATTACHMENT_ADD mask, removing ( attach pt:" << attachmentID << " )" << LL_ENDL; attachmentID &= ~ATTACHMENT_ADD; } LLViewerJointAttachment* attachment = get_if_there(mAttachmentPoints, attachmentID, (LLViewerJointAttachment*)NULL); if (!attachment) { LL_WARNS() << "Object attachment point invalid: " << attachmentID << " trying to use 1 (chest)" << LL_ENDL; attachment = get_if_there(mAttachmentPoints, 1, (LLViewerJointAttachment*)NULL); // Arbitrary using 1 (chest) if (attachment) { LL_WARNS() << "Object attachment point invalid: " << attachmentID << " on object " << viewer_object->getID() << " attachment item " << viewer_object->getAttachmentItemID() << " falling back to 1 (chest)" << LL_ENDL; } else { LL_WARNS() << "Object attachment point invalid: " << attachmentID << " on object " << viewer_object->getID() << " attachment item " << viewer_object->getAttachmentItemID() << "Unable to use fallback attachment point 1 (chest)" << LL_ENDL; } } return attachment; } //----------------------------------------------------------------------------- // attachObject() //----------------------------------------------------------------------------- const LLViewerJointAttachment *LLVOAvatar::attachObject(LLViewerObject *viewer_object) { if (isSelf()) { const LLUUID& item_id = viewer_object->getAttachmentItemID(); LLViewerInventoryItem *item = gInventory.getItem(item_id); LL_DEBUGS("Avatar") << "ATT attaching object " << (item ? item->getName() : "UNKNOWN") << " id " << item_id << LL_ENDL; } LLViewerJointAttachment* attachment = getTargetAttachmentPoint(viewer_object); if (!attachment || !attachment->addObject(viewer_object)) { const LLUUID& item_id = viewer_object->getAttachmentItemID(); LLViewerInventoryItem *item = gInventory.getItem(item_id); LL_WARNS("Avatar") << "ATT attach failed " << (item ? item->getName() : "UNKNOWN") << " id " << item_id << LL_ENDL; return 0; } updateVisualComplexity(); if (viewer_object->isSelected()) { LLSelectMgr::getInstance()->updateSelectionCenter(); LLSelectMgr::getInstance()->updatePointAt(); } return attachment; } //----------------------------------------------------------------------------- // getNumAttachments() //----------------------------------------------------------------------------- U32 LLVOAvatar::getNumAttachments() const { U32 num_attachments = 0; for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { const LLViewerJointAttachment *attachment_pt = (*iter).second; num_attachments += attachment_pt->getNumObjects(); } return num_attachments; } //----------------------------------------------------------------------------- // canAttachMoreObjects() //----------------------------------------------------------------------------- BOOL LLVOAvatar::canAttachMoreObjects() const { return (getNumAttachments() < MAX_AGENT_ATTACHMENTS); } //----------------------------------------------------------------------------- // canAttachMoreObjects() // Returns true if we can attach <n> more objects. //----------------------------------------------------------------------------- BOOL LLVOAvatar::canAttachMoreObjects(U32 n) const { return (getNumAttachments() + n) <= MAX_AGENT_ATTACHMENTS; } //----------------------------------------------------------------------------- // lazyAttach() //----------------------------------------------------------------------------- void LLVOAvatar::lazyAttach() { std::vector<LLPointer<LLViewerObject> > still_pending; for (U32 i = 0; i < mPendingAttachment.size(); i++) { LLPointer<LLViewerObject> cur_attachment = mPendingAttachment[i]; if (cur_attachment->mDrawable) { if (isSelf()) { const LLUUID& item_id = cur_attachment->getAttachmentItemID(); LLViewerInventoryItem *item = gInventory.getItem(item_id); LL_DEBUGS("Avatar") << "ATT attaching object " << (item ? item->getName() : "UNKNOWN") << " id " << item_id << LL_ENDL; } if (!attachObject(cur_attachment)) { // Drop it LL_WARNS() << "attachObject() failed for " << cur_attachment->getID() << " item " << cur_attachment->getAttachmentItemID() << LL_ENDL; // MAINT-3312 backout //still_pending.push_back(cur_attachment); } } else { still_pending.push_back(cur_attachment); } } mPendingAttachment = still_pending; } void LLVOAvatar::resetHUDAttachments() { for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment->getIsHUDAttachment()) { for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { const LLViewerObject* attached_object = (*attachment_iter); if (attached_object && attached_object->mDrawable.notNull()) { gPipeline.markMoved(attached_object->mDrawable); } } } } } void LLVOAvatar::rebuildRiggedAttachments( void ) { for ( attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter ) { LLViewerJointAttachment* pAttachment = iter->second; LLViewerJointAttachment::attachedobjs_vec_t::iterator attachmentIterEnd = pAttachment->mAttachedObjects.end(); for ( LLViewerJointAttachment::attachedobjs_vec_t::iterator attachmentIter = pAttachment->mAttachedObjects.begin(); attachmentIter != attachmentIterEnd; ++attachmentIter) { const LLViewerObject* pAttachedObject = *attachmentIter; if ( pAttachment && pAttachedObject->mDrawable.notNull() ) { gPipeline.markRebuild(pAttachedObject->mDrawable); } } } } //----------------------------------------------------------------------------- // cleanupAttachedMesh() //----------------------------------------------------------------------------- void LLVOAvatar::cleanupAttachedMesh( LLViewerObject* pVO ) { LLUUID mesh_id; if (getRiggedMeshID(pVO, mesh_id)) { resetJointsOnDetach(mesh_id); if ( gAgentCamera.cameraCustomizeAvatar() ) { gAgent.unpauseAnimation(); //Still want to refocus on head bone gAgentCamera.changeCameraToCustomizeAvatar(); } } } //----------------------------------------------------------------------------- // detachObject() //----------------------------------------------------------------------------- BOOL LLVOAvatar::detachObject(LLViewerObject *viewer_object) { for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment->isObjectAttached(viewer_object)) { updateVisualComplexity(); cleanupAttachedMesh( viewer_object ); attachment->removeObject(viewer_object); LL_DEBUGS() << "Detaching object " << viewer_object->mID << " from " << attachment->getName() << LL_ENDL; return TRUE; } } std::vector<LLPointer<LLViewerObject> >::iterator iter = std::find(mPendingAttachment.begin(), mPendingAttachment.end(), viewer_object); if (iter != mPendingAttachment.end()) { mPendingAttachment.erase(iter); return TRUE; } return FALSE; } //----------------------------------------------------------------------------- // sitDown() //----------------------------------------------------------------------------- void LLVOAvatar::sitDown(BOOL bSitting) { mIsSitting = bSitting; if (isSelf()) { // Update Movement Controls according to own Sitting mode LLFloaterMove::setSittingMode(bSitting); } } //----------------------------------------------------------------------------- // sitOnObject() //----------------------------------------------------------------------------- void LLVOAvatar::sitOnObject(LLViewerObject *sit_object) { if (isSelf()) { // Might be first sit //LLFirstUse::useSit(); gAgent.setFlying(FALSE); gAgentCamera.setThirdPersonHeadOffset(LLVector3::zero); //interpolate to new camera position gAgentCamera.startCameraAnimation(); // make sure we are not trying to autopilot gAgent.stopAutoPilot(); gAgentCamera.setupSitCamera(); if (gAgentCamera.getForceMouselook()) { gAgentCamera.changeCameraToMouselook(); } } if (mDrawable.isNull()) { return; } LLQuaternion inv_obj_rot = ~sit_object->getRenderRotation(); LLVector3 obj_pos = sit_object->getRenderPosition(); LLVector3 rel_pos = getRenderPosition() - obj_pos; rel_pos.rotVec(inv_obj_rot); mDrawable->mXform.setPosition(rel_pos); mDrawable->mXform.setRotation(mDrawable->getWorldRotation() * inv_obj_rot); gPipeline.markMoved(mDrawable, TRUE); // Notice that removing sitDown() from here causes avatars sitting on // objects to be not rendered for new arrivals. See EXT-6835 and EXT-1655. sitDown(TRUE); mRoot->getXform()->setParent(&sit_object->mDrawable->mXform); // LLVOAvatar::sitOnObject // SL-315 mRoot->setPosition(getPosition()); mRoot->updateWorldMatrixChildren(); stopMotion(ANIM_AGENT_BODY_NOISE); } //----------------------------------------------------------------------------- // getOffObject() //----------------------------------------------------------------------------- void LLVOAvatar::getOffObject() { if (mDrawable.isNull()) { return; } LLViewerObject* sit_object = (LLViewerObject*)getParent(); if (sit_object) { stopMotionFromSource(sit_object->getID()); LLFollowCamMgr::setCameraActive(sit_object->getID(), FALSE); LLViewerObject::const_child_list_t& child_list = sit_object->getChildren(); for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin(); iter != child_list.end(); ++iter) { LLViewerObject* child_objectp = *iter; stopMotionFromSource(child_objectp->getID()); LLFollowCamMgr::setCameraActive(child_objectp->getID(), FALSE); } } // assumes that transform will not be updated with drawable still having a parent // or that drawable had no parent from the start LLVector3 cur_position_world = mDrawable->getWorldPosition(); LLQuaternion cur_rotation_world = mDrawable->getWorldRotation(); if (mLastRootPos.length() >= MAX_STANDOFF_FROM_ORIGIN && (cur_position_world.length() < MAX_STANDOFF_FROM_ORIGIN || dist_vec(cur_position_world, mLastRootPos) > MAX_STANDOFF_DISTANCE_CHANGE)) { // Most likely drawable got updated too early or some updates were missed - we got relative position to non-existing parent // restore coordinates from cache cur_position_world = mLastRootPos; } // set *local* position based on last *world* position, since we're unparenting the avatar mDrawable->mXform.setPosition(cur_position_world); mDrawable->mXform.setRotation(cur_rotation_world); gPipeline.markMoved(mDrawable, TRUE); sitDown(FALSE); mRoot->getXform()->setParent(NULL); // LLVOAvatar::getOffObject // SL-315 mRoot->setPosition(cur_position_world); mRoot->setRotation(cur_rotation_world); mRoot->getXform()->update(); startMotion(ANIM_AGENT_BODY_NOISE); if (isSelf()) { LLQuaternion av_rot = gAgent.getFrameAgent().getQuaternion(); LLQuaternion obj_rot = sit_object ? sit_object->getRenderRotation() : LLQuaternion::DEFAULT; av_rot = av_rot * obj_rot; LLVector3 at_axis = LLVector3::x_axis; at_axis = at_axis * av_rot; at_axis.mV[VZ] = 0.f; at_axis.normalize(); gAgent.resetAxes(at_axis); gAgentCamera.setThirdPersonHeadOffset(LLVector3(0.f, 0.f, 1.f)); gAgentCamera.setSitCamera(LLUUID::null); } } //----------------------------------------------------------------------------- // findAvatarFromAttachment() //----------------------------------------------------------------------------- // static LLVOAvatar* LLVOAvatar::findAvatarFromAttachment( LLViewerObject* obj ) { if( obj->isAttachment() ) { do { obj = (LLViewerObject*) obj->getParent(); } while( obj && !obj->isAvatar() ); if( obj && !obj->isDead() ) { return (LLVOAvatar*)obj; } } return NULL; } S32 LLVOAvatar::getAttachmentCount() { S32 count = mAttachmentPoints.size(); return count; } BOOL LLVOAvatar::isWearingWearableType(LLWearableType::EType type) const { if (mIsDummy) return TRUE; if (isSelf()) { return LLAvatarAppearance::isWearingWearableType(type); } switch(type) { case LLWearableType::WT_SHAPE: case LLWearableType::WT_SKIN: case LLWearableType::WT_HAIR: case LLWearableType::WT_EYES: return TRUE; // everyone has all bodyparts default: break; // Do nothing } for (LLAvatarAppearanceDictionary::Textures::const_iterator tex_iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin(); tex_iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end(); ++tex_iter) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = tex_iter->second; if (texture_dict->mWearableType == type) { // Thus, you must check to see if the corresponding baked texture is defined. // NOTE: this is a poor substitute if you actually want to know about individual pieces of clothing // this works for detecting a skirt (most important), but is ineffective at any piece of clothing that // gets baked into a texture that always exists (upper or lower). if (texture_dict->mIsUsedByBakedTexture) { const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex; return isTextureDefined(LLAvatarAppearanceDictionary::getInstance()->getBakedTexture(baked_index)->mTextureIndex); } return FALSE; } } return FALSE; } LLViewerObject * LLVOAvatar::findAttachmentByID( const LLUUID & target_id ) const { for(attachment_map_t::const_iterator attachment_points_iter = mAttachmentPoints.begin(); attachment_points_iter != gAgentAvatarp->mAttachmentPoints.end(); ++attachment_points_iter) { LLViewerJointAttachment* attachment = attachment_points_iter->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { LLViewerObject *attached_object = (*attachment_iter); if (attached_object && attached_object->getID() == target_id) { return attached_object; } } } return NULL; } // virtual void LLVOAvatar::invalidateComposite( LLTexLayerSet* layerset) { } void LLVOAvatar::invalidateAll() { } // virtual void LLVOAvatar::onGlobalColorChanged(const LLTexGlobalColor* global_color) { if (global_color == mTexSkinColor) { invalidateComposite( mBakedTextureDatas[BAKED_HEAD].mTexLayerSet); invalidateComposite( mBakedTextureDatas[BAKED_UPPER].mTexLayerSet); invalidateComposite( mBakedTextureDatas[BAKED_LOWER].mTexLayerSet); } else if (global_color == mTexHairColor) { invalidateComposite( mBakedTextureDatas[BAKED_HEAD].mTexLayerSet); invalidateComposite( mBakedTextureDatas[BAKED_HAIR].mTexLayerSet); // ! BACKWARDS COMPATIBILITY ! // Fix for dealing with avatars from viewers that don't bake hair. if (!isTextureDefined(mBakedTextureDatas[BAKED_HAIR].mTextureIndex)) { LLColor4 color = mTexHairColor->getColor(); avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[BAKED_HAIR].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[BAKED_HAIR].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setColor( color ); } } } } else if (global_color == mTexEyeColor) { // LL_INFOS() << "invalidateComposite cause: onGlobalColorChanged( eyecolor )" << LL_ENDL; invalidateComposite( mBakedTextureDatas[BAKED_EYES].mTexLayerSet); } updateMeshTextures(); } BOOL LLVOAvatar::isVisible() const { return mDrawable.notNull() && (!mOrphaned || isSelf()) && (mDrawable->isVisible() || mIsDummy); } // Determine if we have enough avatar data to render bool LLVOAvatar::getIsCloud() const { return ( ((const_cast<LLVOAvatar*>(this))->visualParamWeightsAreDefault())// Do we have a shape? || ( !isTextureDefined(TEX_LOWER_BAKED) || !isTextureDefined(TEX_UPPER_BAKED) || !isTextureDefined(TEX_HEAD_BAKED) ) ); } void LLVOAvatar::updateRezzedStatusTimers() { // State machine for rezzed status. Statuses are -1 on startup, 0 // = cloud, 1 = gray, 2 = downloading, 3 = full. // Purpose is to collect time data for each it takes avatar to reach // various loading landmarks: gray, textured (partial), textured fully. S32 rez_status = getRezzedStatus(); if (rez_status != mLastRezzedStatus) { LL_DEBUGS("Avatar") << avString() << "rez state change: " << mLastRezzedStatus << " -> " << rez_status << LL_ENDL; if (mLastRezzedStatus == -1 && rez_status != -1) { // First time initialization, start all timers. for (S32 i = 1; i < 4; i++) { startPhase("load_" + LLVOAvatar::rezStatusToString(i)); startPhase("first_load_" + LLVOAvatar::rezStatusToString(i)); } } if (rez_status < mLastRezzedStatus) { // load level has decreased. start phase timers for higher load levels. for (S32 i = rez_status+1; i <= mLastRezzedStatus; i++) { startPhase("load_" + LLVOAvatar::rezStatusToString(i)); } } else if (rez_status > mLastRezzedStatus) { // load level has increased. stop phase timers for lower and equal load levels. for (S32 i = llmax(mLastRezzedStatus+1,1); i <= rez_status; i++) { stopPhase("load_" + LLVOAvatar::rezStatusToString(i)); stopPhase("first_load_" + LLVOAvatar::rezStatusToString(i), false); } if (rez_status == 3) { // "fully loaded", mark any pending appearance change complete. selfStopPhase("update_appearance_from_cof"); selfStopPhase("wear_inventory_category", false); selfStopPhase("process_initial_wearables_update", false); updateVisualComplexity(); } } mLastRezzedStatus = rez_status; } } void LLVOAvatar::clearPhases() { getPhases().clearPhases(); } void LLVOAvatar::startPhase(const std::string& phase_name) { F32 elapsed = 0.0; bool completed = false; bool found = getPhases().getPhaseValues(phase_name, elapsed, completed); //LL_DEBUGS("Avatar") << avString() << " phase state " << phase_name // << " found " << found << " elapsed " << elapsed << " completed " << completed << LL_ENDL; if (found) { if (!completed) { LL_DEBUGS("Avatar") << avString() << "no-op, start when started already for " << phase_name << LL_ENDL; return; } } LL_DEBUGS("Avatar") << "started phase " << phase_name << LL_ENDL; getPhases().startPhase(phase_name); } void LLVOAvatar::stopPhase(const std::string& phase_name, bool err_check) { F32 elapsed = 0.0; bool completed = false; if (getPhases().getPhaseValues(phase_name, elapsed, completed)) { if (!completed) { getPhases().stopPhase(phase_name); completed = true; logMetricsTimerRecord(phase_name, elapsed, completed); LL_DEBUGS("Avatar") << avString() << "stopped phase " << phase_name << " elapsed " << elapsed << LL_ENDL; } else { if (err_check) { LL_DEBUGS("Avatar") << "no-op, stop when stopped already for " << phase_name << LL_ENDL; } } } else { if (err_check) { LL_DEBUGS("Avatar") << "no-op, stop when not started for " << phase_name << LL_ENDL; } } } void LLVOAvatar::logPendingPhases() { if (!isAgentAvatarValid()) { return; } for (LLViewerStats::phase_map_t::iterator it = getPhases().begin(); it != getPhases().end(); ++it) { const std::string& phase_name = it->first; F32 elapsed; bool completed; if (getPhases().getPhaseValues(phase_name, elapsed, completed)) { if (!completed) { logMetricsTimerRecord(phase_name, elapsed, completed); } } } } //static void LLVOAvatar::logPendingPhasesAllAvatars() { for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; if( inst->isDead() ) { continue; } inst->logPendingPhases(); } } void LLVOAvatar::logMetricsTimerRecord(const std::string& phase_name, F32 elapsed, bool completed) { if (!isAgentAvatarValid()) { return; } LLSD record; record["timer_name"] = phase_name; record["avatar_id"] = getID(); record["elapsed"] = elapsed; record["completed"] = completed; U32 grid_x(0), grid_y(0); if (getRegion() && LLWorld::instance().isRegionListed(getRegion())) { record["central_bake_version"] = LLSD::Integer(getRegion()->getCentralBakeVersion()); grid_from_region_handle(getRegion()->getHandle(), &grid_x, &grid_y); } record["grid_x"] = LLSD::Integer(grid_x); record["grid_y"] = LLSD::Integer(grid_y); record["is_using_server_bakes"] = true; record["is_self"] = isSelf(); if (isAgentAvatarValid()) { gAgentAvatarp->addMetricsTimerRecord(record); } } // call periodically to keep isFullyLoaded up to date. // returns true if the value has changed. BOOL LLVOAvatar::updateIsFullyLoaded() { const bool loading = getIsCloud(); updateRezzedStatusTimers(); updateRuthTimer(loading); return processFullyLoadedChange(loading); } void LLVOAvatar::updateRuthTimer(bool loading) { if (isSelf() || !loading) { return; } if (mPreviousFullyLoaded) { mRuthTimer.reset(); debugAvatarRezTime("AvatarRezCloudNotification","became cloud"); } const F32 LOADING_TIMEOUT__SECONDS = 120.f; if (mRuthTimer.getElapsedTimeF32() > LOADING_TIMEOUT__SECONDS) { LL_DEBUGS("Avatar") << avString() << "Ruth Timer timeout: Missing texture data for '" << getFullname() << "' " << "( Params loaded : " << !visualParamWeightsAreDefault() << " ) " << "( Lower : " << isTextureDefined(TEX_LOWER_BAKED) << " ) " << "( Upper : " << isTextureDefined(TEX_UPPER_BAKED) << " ) " << "( Head : " << isTextureDefined(TEX_HEAD_BAKED) << " )." << LL_ENDL; LLAvatarPropertiesProcessor::getInstance()->sendAvatarTexturesRequest(getID()); mRuthTimer.reset(); } } BOOL LLVOAvatar::processFullyLoadedChange(bool loading) { // we wait a little bit before giving the all clear, // to let textures settle down const F32 PAUSE = 1.f; if (loading) mFullyLoadedTimer.reset(); mFullyLoaded = (mFullyLoadedTimer.getElapsedTimeF32() > PAUSE); if (!mPreviousFullyLoaded && !loading && mFullyLoaded) { debugAvatarRezTime("AvatarRezNotification","fully loaded"); } // did our loading state "change" from last call? // runway - why are we updating every 30 calls even if nothing has changed? const S32 UPDATE_RATE = 30; BOOL changed = ((mFullyLoaded != mPreviousFullyLoaded) || // if the value is different from the previous call (!mFullyLoadedInitialized) || // if we've never been called before (mFullyLoadedFrameCounter % UPDATE_RATE == 0)); // every now and then issue a change mPreviousFullyLoaded = mFullyLoaded; mFullyLoadedInitialized = TRUE; mFullyLoadedFrameCounter++; if (changed && isSelf()) { // to know about outfit switching LLAvatarRenderNotifier::getInstance()->updateNotificationState(); } return changed; } BOOL LLVOAvatar::isFullyLoaded() const { return (mRenderUnloadedAvatar || mFullyLoaded); } bool LLVOAvatar::isTooComplex() const { bool too_complex; bool render_friend = (LLAvatarTracker::instance().isBuddy(getID()) && gSavedSettings.getBOOL("AlwaysRenderFriends")); if (isSelf() || render_friend || mVisuallyMuteSetting == AV_ALWAYS_RENDER) { too_complex = false; } else { // Determine if visually muted or not static LLCachedControl<U32> max_render_cost(gSavedSettings, "RenderAvatarMaxComplexity", 0U); static LLCachedControl<F32> max_attachment_area(gSavedSettings, "RenderAutoMuteSurfaceAreaLimit", 1000.0f); // If the user has chosen unlimited max complexity, we also disregard max attachment area // so that unlimited will completely disable the overly complex impostor rendering // yes, this leaves them vulnerable to griefing objects... their choice too_complex = ( max_render_cost > 0 && ( mVisualComplexity > max_render_cost || (max_attachment_area > 0.0f && mAttachmentSurfaceArea > max_attachment_area) )); } return too_complex; } //----------------------------------------------------------------------------- // findMotion() //----------------------------------------------------------------------------- LLMotion* LLVOAvatar::findMotion(const LLUUID& id) const { return mMotionController.findMotion(id); } // This is a semi-deprecated debugging tool - meshes will not show as // colorized if using deferred rendering. void LLVOAvatar::debugColorizeSubMeshes(U32 i, const LLColor4& color) { if (gSavedSettings.getBOOL("DebugAvatarCompositeBaked")) { avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[i].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[i].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setColor(color); } } } } //----------------------------------------------------------------------------- // updateMeshTextures() // Uses the current TE values to set the meshes' and layersets' textures. //----------------------------------------------------------------------------- // virtual void LLVOAvatar::updateMeshTextures() { static S32 update_counter = 0; mBakedTextureDebugText.clear(); // if user has never specified a texture, assign the default for (U32 i=0; i < getNumTEs(); i++) { const LLViewerTexture* te_image = getImage(i, 0); if(!te_image || te_image->getID().isNull() || (te_image->getID() == IMG_DEFAULT)) { // IMG_DEFAULT_AVATAR = a special texture that's never rendered. const LLUUID& image_id = (i == TEX_HAIR ? IMG_DEFAULT : IMG_DEFAULT_AVATAR); setImage(i, LLViewerTextureManager::getFetchedTexture(image_id), 0); } } const BOOL other_culled = !isSelf() && mCulled; LLLoadedCallbackEntry::source_callback_list_t* src_callback_list = NULL ; BOOL paused = FALSE; if(!isSelf()) { src_callback_list = &mCallbackTextureList ; paused = !isVisible(); } std::vector<BOOL> is_layer_baked; is_layer_baked.resize(mBakedTextureDatas.size(), false); std::vector<BOOL> use_lkg_baked_layer; // lkg = "last known good" use_lkg_baked_layer.resize(mBakedTextureDatas.size(), false); mBakedTextureDebugText += llformat("%06d\n",update_counter++); mBakedTextureDebugText += "indx layerset linvld ltda ilb ulkg ltid\n"; for (U32 i=0; i < mBakedTextureDatas.size(); i++) { is_layer_baked[i] = isTextureDefined(mBakedTextureDatas[i].mTextureIndex); LLViewerTexLayerSet* layerset = NULL; bool layerset_invalid = false; if (!other_culled) { // When an avatar is changing clothes and not in Appearance mode, // use the last-known good baked texture until it finishes the first // render of the new layerset. layerset = getTexLayerSet(i); layerset_invalid = layerset && ( !layerset->getViewerComposite()->isInitialized() || !layerset->isLocalTextureDataAvailable() ); use_lkg_baked_layer[i] = (!is_layer_baked[i] && (mBakedTextureDatas[i].mLastTextureID != IMG_DEFAULT_AVATAR) && layerset_invalid); if (use_lkg_baked_layer[i]) { layerset->setUpdatesEnabled(TRUE); } } else { use_lkg_baked_layer[i] = (!is_layer_baked[i] && mBakedTextureDatas[i].mLastTextureID != IMG_DEFAULT_AVATAR); } std::string last_id_string; if (mBakedTextureDatas[i].mLastTextureID == IMG_DEFAULT_AVATAR) last_id_string = "A"; else if (mBakedTextureDatas[i].mLastTextureID == IMG_DEFAULT) last_id_string = "D"; else if (mBakedTextureDatas[i].mLastTextureID == IMG_INVISIBLE) last_id_string = "I"; else last_id_string = "*"; bool is_ltda = layerset && layerset->getViewerComposite()->isInitialized() && layerset->isLocalTextureDataAvailable(); mBakedTextureDebugText += llformat("%4d %4s %4d %4d %4d %4d %4s\n", i, (layerset?"*":"0"), layerset_invalid, is_ltda, is_layer_baked[i], use_lkg_baked_layer[i], last_id_string.c_str()); } for (U32 i=0; i < mBakedTextureDatas.size(); i++) { debugColorizeSubMeshes(i, LLColor4::white); LLViewerTexLayerSet* layerset = getTexLayerSet(i); if (use_lkg_baked_layer[i] && !isUsingLocalAppearance() ) { LLViewerFetchedTexture* baked_img = LLViewerTextureManager::getFetchedTexture(mBakedTextureDatas[i].mLastTextureID); mBakedTextureDatas[i].mIsUsed = TRUE; debugColorizeSubMeshes(i,LLColor4::red); avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[i].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[i].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setTexture( baked_img ); } } } else if (!isUsingLocalAppearance() && is_layer_baked[i]) { LLViewerFetchedTexture* baked_img = LLViewerTextureManager::staticCastToFetchedTexture( getImage( mBakedTextureDatas[i].mTextureIndex, 0 ), TRUE) ; if( baked_img->getID() == mBakedTextureDatas[i].mLastTextureID ) { // Even though the file may not be finished loading, // we'll consider it loaded and use it (rather than // doing compositing). useBakedTexture( baked_img->getID() ); mLoadedCallbacksPaused |= !isVisible(); checkTextureLoading(); } else { mBakedTextureDatas[i].mIsLoaded = FALSE; if ( (baked_img->getID() != IMG_INVISIBLE) && ((i == BAKED_HEAD) || (i == BAKED_UPPER) || (i == BAKED_LOWER)) ) { baked_img->setLoadedCallback(onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ), src_callback_list, paused); } baked_img->setLoadedCallback(onBakedTextureLoaded, SWITCH_TO_BAKED_DISCARD, FALSE, FALSE, new LLUUID( mID ), src_callback_list, paused ); // this could add paused texture callbacks mLoadedCallbacksPaused |= paused; checkTextureLoading(); } } else if (layerset && isUsingLocalAppearance()) { debugColorizeSubMeshes(i,LLColor4::yellow ); layerset->createComposite(); layerset->setUpdatesEnabled( TRUE ); mBakedTextureDatas[i].mIsUsed = FALSE; avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[i].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[i].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setLayerSet( layerset ); } } } else { debugColorizeSubMeshes(i,LLColor4::blue); } } // set texture and color of hair manually if we are not using a baked image. // This can happen while loading hair for yourself, or for clients that did not // bake a hair texture. Still needed for yourself after 1.22 is depricated. if (!is_layer_baked[BAKED_HAIR]) { const LLColor4 color = mTexHairColor ? mTexHairColor->getColor() : LLColor4(1,1,1,1); LLViewerTexture* hair_img = getImage( TEX_HAIR, 0 ); avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[BAKED_HAIR].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[BAKED_HAIR].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setColor( color ); mesh->setTexture( hair_img ); } } } for (LLAvatarAppearanceDictionary::BakedTextures::const_iterator baked_iter = LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().begin(); baked_iter != LLAvatarAppearanceDictionary::getInstance()->getBakedTextures().end(); ++baked_iter) { const EBakedTextureIndex baked_index = baked_iter->first; const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = baked_iter->second; for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin(); local_tex_iter != baked_dict->mLocalTextures.end(); ++local_tex_iter) { const ETextureIndex texture_index = *local_tex_iter; const BOOL is_baked_ready = (is_layer_baked[baked_index] && mBakedTextureDatas[baked_index].mIsLoaded) || other_culled; if (isSelf()) { setBakedReady(texture_index, is_baked_ready); } } } // removeMissingBakedTextures() will call back into this rountine if something is removed, and can blow up the stack static bool call_remove_missing = true; if (call_remove_missing) { call_remove_missing = false; removeMissingBakedTextures(); // May call back into this function if anything is removed call_remove_missing = true; } } // virtual //----------------------------------------------------------------------------- // setLocalTexture() //----------------------------------------------------------------------------- void LLVOAvatar::setLocalTexture( ETextureIndex type, LLViewerTexture* in_tex, BOOL baked_version_ready, U32 index ) { // invalid for anyone but self llassert(0); } //virtual void LLVOAvatar::setBakedReady(LLAvatarAppearanceDefines::ETextureIndex type, BOOL baked_version_exists, U32 index) { // invalid for anyone but self llassert(0); } void LLVOAvatar::addChat(const LLChat& chat) { std::deque<LLChat>::iterator chat_iter; mChats.push_back(chat); S32 chat_length = 0; for( chat_iter = mChats.begin(); chat_iter != mChats.end(); ++chat_iter) { chat_length += chat_iter->mText.size(); } // remove any excess chat chat_iter = mChats.begin(); while ((chat_length > MAX_BUBBLE_CHAT_LENGTH || mChats.size() > MAX_BUBBLE_CHAT_UTTERANCES) && chat_iter != mChats.end()) { chat_length -= chat_iter->mText.size(); mChats.pop_front(); chat_iter = mChats.begin(); } mChatTimer.reset(); } void LLVOAvatar::clearChat() { mChats.clear(); } void LLVOAvatar::applyMorphMask(U8* tex_data, S32 width, S32 height, S32 num_components, LLAvatarAppearanceDefines::EBakedTextureIndex index) { if (index >= BAKED_NUM_INDICES) { LL_WARNS() << "invalid baked texture index passed to applyMorphMask" << LL_ENDL; return; } for (morph_list_t::const_iterator iter = mBakedTextureDatas[index].mMaskedMorphs.begin(); iter != mBakedTextureDatas[index].mMaskedMorphs.end(); ++iter) { const LLMaskedMorph* maskedMorph = (*iter); LLPolyMorphTarget* morph_target = dynamic_cast<LLPolyMorphTarget*>(maskedMorph->mMorphTarget); if (morph_target) { morph_target->applyMask(tex_data, width, height, num_components, maskedMorph->mInvert); } } } // returns TRUE if morph masks are present and not valid for a given baked texture, FALSE otherwise BOOL LLVOAvatar::morphMaskNeedsUpdate(LLAvatarAppearanceDefines::EBakedTextureIndex index) { if (index >= BAKED_NUM_INDICES) { return FALSE; } if (!mBakedTextureDatas[index].mMaskedMorphs.empty()) { if (isSelf()) { LLViewerTexLayerSet *layer_set = getTexLayerSet(index); if (layer_set) { return !layer_set->isMorphValid(); } } else { return FALSE; } } return FALSE; } //----------------------------------------------------------------------------- // releaseComponentTextures() // release any component texture UUIDs for which we have a baked texture // ! BACKWARDS COMPATIBILITY ! // This is only called for non-self avatars, it can be taken out once component // textures aren't communicated by non-self avatars. //----------------------------------------------------------------------------- void LLVOAvatar::releaseComponentTextures() { // ! BACKWARDS COMPATIBILITY ! // Detect if the baked hair texture actually wasn't sent, and if so set to default if (isTextureDefined(TEX_HAIR_BAKED) && getImage(TEX_HAIR_BAKED,0)->getID() == getImage(TEX_SKIRT_BAKED,0)->getID()) { if (getImage(TEX_HAIR_BAKED,0)->getID() != IMG_INVISIBLE) { // Regression case of messaging system. Expected 21 textures, received 20. last texture is not valid so set to default setTETexture(TEX_HAIR_BAKED, IMG_DEFAULT_AVATAR); } } for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++) { const LLAvatarAppearanceDictionary::BakedEntry * bakedDicEntry = LLAvatarAppearanceDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index); // skip if this is a skirt and av is not wearing one, or if we don't have a baked texture UUID if (!isTextureDefined(bakedDicEntry->mTextureIndex) && ( (baked_index != BAKED_SKIRT) || isWearingWearableType(LLWearableType::WT_SKIRT) )) { continue; } for (U8 texture = 0; texture < bakedDicEntry->mLocalTextures.size(); texture++) { const U8 te = (ETextureIndex)bakedDicEntry->mLocalTextures[texture]; setTETexture(te, IMG_DEFAULT_AVATAR); } } } void LLVOAvatar::dumpAvatarTEs( const std::string& context ) const { LL_DEBUGS("Avatar") << avString() << (isSelf() ? "Self: " : "Other: ") << context << LL_ENDL; for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin(); iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end(); ++iter) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second; // TODO: MULTI-WEARABLE: handle multiple textures for self const LLViewerTexture* te_image = getImage(iter->first,0); if( !te_image ) { LL_DEBUGS("Avatar") << avString() << " " << texture_dict->mName << ": null ptr" << LL_ENDL; } else if( te_image->getID().isNull() ) { LL_DEBUGS("Avatar") << avString() << " " << texture_dict->mName << ": null UUID" << LL_ENDL; } else if( te_image->getID() == IMG_DEFAULT ) { LL_DEBUGS("Avatar") << avString() << " " << texture_dict->mName << ": IMG_DEFAULT" << LL_ENDL; } else if( te_image->getID() == IMG_DEFAULT_AVATAR ) { LL_DEBUGS("Avatar") << avString() << " " << texture_dict->mName << ": IMG_DEFAULT_AVATAR" << LL_ENDL; } else { LL_DEBUGS("Avatar") << avString() << " " << texture_dict->mName << ": " << te_image->getID() << LL_ENDL; } } } //----------------------------------------------------------------------------- // clampAttachmentPositions() //----------------------------------------------------------------------------- void LLVOAvatar::clampAttachmentPositions() { if (isDead()) { return; } for (attachment_map_t::iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment) { attachment->clampObjectPosition(); } } } BOOL LLVOAvatar::hasHUDAttachment() const { for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment->getIsHUDAttachment() && attachment->getNumObjects() > 0) { return TRUE; } } return FALSE; } LLBBox LLVOAvatar::getHUDBBox() const { LLBBox bbox; for (attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* attachment = iter->second; if (attachment->getIsHUDAttachment()) { for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { const LLViewerObject* attached_object = (*attachment_iter); if (attached_object == NULL) { LL_WARNS() << "HUD attached object is NULL!" << LL_ENDL; continue; } // initialize bounding box to contain identity orientation and center point for attached object bbox.addPointLocal(attached_object->getPosition()); // add rotated bounding box for attached object bbox.addBBoxAgent(attached_object->getBoundingBoxAgent()); LLViewerObject::const_child_list_t& child_list = attached_object->getChildren(); for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin(); iter != child_list.end(); ++iter) { const LLViewerObject* child_objectp = *iter; bbox.addBBoxAgent(child_objectp->getBoundingBoxAgent()); } } } } return bbox; } //----------------------------------------------------------------------------- // onFirstTEMessageReceived() //----------------------------------------------------------------------------- void LLVOAvatar::onFirstTEMessageReceived() { LL_DEBUGS("Avatar") << avString() << LL_ENDL; if( !mFirstTEMessageReceived ) { mFirstTEMessageReceived = TRUE; LLLoadedCallbackEntry::source_callback_list_t* src_callback_list = NULL ; BOOL paused = FALSE ; if(!isSelf()) { src_callback_list = &mCallbackTextureList ; paused = !isVisible(); } for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { const BOOL layer_baked = isTextureDefined(mBakedTextureDatas[i].mTextureIndex); // Use any baked textures that we have even if they haven't downloaded yet. // (That is, don't do a transition from unbaked to baked.) if (layer_baked) { LLViewerFetchedTexture* image = LLViewerTextureManager::staticCastToFetchedTexture(getImage( mBakedTextureDatas[i].mTextureIndex, 0 ), TRUE) ; mBakedTextureDatas[i].mLastTextureID = image->getID(); // If we have more than one texture for the other baked layers, we'll want to call this for them too. if ( (image->getID() != IMG_INVISIBLE) && ((i == BAKED_HEAD) || (i == BAKED_UPPER) || (i == BAKED_LOWER)) ) { image->setLoadedCallback( onBakedTextureMasksLoaded, MORPH_MASK_REQUESTED_DISCARD, TRUE, TRUE, new LLTextureMaskData( mID ), src_callback_list, paused); } LL_DEBUGS("Avatar") << avString() << "layer_baked, setting onInitialBakedTextureLoaded as callback" << LL_ENDL; image->setLoadedCallback( onInitialBakedTextureLoaded, MAX_DISCARD_LEVEL, FALSE, FALSE, new LLUUID( mID ), src_callback_list, paused ); // this could add paused texture callbacks mLoadedCallbacksPaused |= paused; } } mMeshTexturesDirty = TRUE; gPipeline.markGLRebuild(this); } } //----------------------------------------------------------------------------- // bool visualParamWeightsAreDefault() //----------------------------------------------------------------------------- bool LLVOAvatar::visualParamWeightsAreDefault() { bool rtn = true; bool is_wearing_skirt = isWearingWearableType(LLWearableType::WT_SKIRT); for (LLVisualParam *param = getFirstVisualParam(); param; param = getNextVisualParam()) { if (param->isTweakable()) { LLViewerVisualParam* vparam = dynamic_cast<LLViewerVisualParam*>(param); llassert(vparam); bool is_skirt_param = vparam && LLWearableType::WT_SKIRT == vparam->getWearableType(); if (param->getWeight() != param->getDefaultWeight() && // we have to not care whether skirt weights are default, if we're not actually wearing a skirt (is_wearing_skirt || !is_skirt_param)) { //LL_INFOS() << "param '" << param->getName() << "'=" << param->getWeight() << " which differs from default=" << param->getDefaultWeight() << LL_ENDL; rtn = false; break; } } } //LL_INFOS() << "params are default ? " << int(rtn) << LL_ENDL; return rtn; } void dump_visual_param(apr_file_t* file, LLVisualParam* viewer_param, F32 value) { std::string type_string = "unknown"; if (dynamic_cast<LLTexLayerParamAlpha*>(viewer_param)) type_string = "param_alpha"; if (dynamic_cast<LLTexLayerParamColor*>(viewer_param)) type_string = "param_color"; if (dynamic_cast<LLDriverParam*>(viewer_param)) type_string = "param_driver"; if (dynamic_cast<LLPolyMorphTarget*>(viewer_param)) type_string = "param_morph"; if (dynamic_cast<LLPolySkeletalDistortion*>(viewer_param)) type_string = "param_skeleton"; S32 wtype = -1; LLViewerVisualParam *vparam = dynamic_cast<LLViewerVisualParam*>(viewer_param); if (vparam) { wtype = vparam->getWearableType(); } S32 u8_value = F32_to_U8(value,viewer_param->getMinWeight(),viewer_param->getMaxWeight()); apr_file_printf(file, "\t\t<param id=\"%d\" name=\"%s\" display=\"%s\" value=\"%.3f\" u8=\"%d\" type=\"%s\" wearable=\"%s\" group=\"%d\"/>\n", viewer_param->getID(), viewer_param->getName().c_str(), viewer_param->getDisplayName().c_str(), value, u8_value, type_string.c_str(), LLWearableType::getTypeName(LLWearableType::EType(wtype)).c_str(), viewer_param->getGroup()); } void LLVOAvatar::dumpAppearanceMsgParams( const std::string& dump_prefix, const LLAppearanceMessageContents& contents) { std::string outfilename = get_sequential_numbered_file_name(dump_prefix,".xml"); const std::vector<F32>& params_for_dump = contents.mParamWeights; const LLTEContents& tec = contents.mTEContents; LLAPRFile outfile; std::string fullpath = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,outfilename); outfile.open(fullpath, LL_APR_WB ); apr_file_t* file = outfile.getFileHandle(); if (!file) { return; } else { LL_DEBUGS("Avatar") << "dumping appearance message to " << fullpath << LL_ENDL; } apr_file_printf(file, "<header>\n"); apr_file_printf(file, "\t\t<cof_version %i />\n", contents.mCOFVersion); apr_file_printf(file, "\t\t<appearance_version %i />\n", contents.mAppearanceVersion); apr_file_printf(file, "</header>\n"); apr_file_printf(file, "\n<params>\n"); LLVisualParam* param = getFirstVisualParam(); for (S32 i = 0; i < params_for_dump.size(); i++) { while( param && ((param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE) && (param->getGroup() != VISUAL_PARAM_GROUP_TRANSMIT_NOT_TWEAKABLE)) ) // should not be any of group VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT { param = getNextVisualParam(); } LLViewerVisualParam* viewer_param = (LLViewerVisualParam*)param; F32 value = params_for_dump[i]; dump_visual_param(file, viewer_param, value); param = getNextVisualParam(); } apr_file_printf(file, "</params>\n"); apr_file_printf(file, "\n<textures>\n"); for (U32 i = 0; i < tec.face_count; i++) { std::string uuid_str; ((LLUUID*)tec.image_data)[i].toString(uuid_str); apr_file_printf( file, "\t\t<texture te=\"%i\" uuid=\"%s\"/>\n", i, uuid_str.c_str()); } apr_file_printf(file, "</textures>\n"); } void LLVOAvatar::parseAppearanceMessage(LLMessageSystem* mesgsys, LLAppearanceMessageContents& contents) { parseTEMessage(mesgsys, _PREHASH_ObjectData, -1, contents.mTEContents); // Parse the AppearanceData field, if any. if (mesgsys->has(_PREHASH_AppearanceData)) { U8 av_u8; mesgsys->getU8Fast(_PREHASH_AppearanceData, _PREHASH_AppearanceVersion, av_u8, 0); contents.mAppearanceVersion = av_u8; //LL_DEBUGS("Avatar") << "appversion set by AppearanceData field: " << contents.mAppearanceVersion << LL_ENDL; mesgsys->getS32Fast(_PREHASH_AppearanceData, _PREHASH_CofVersion, contents.mCOFVersion, 0); // For future use: //mesgsys->getU32Fast(_PREHASH_AppearanceData, _PREHASH_Flags, appearance_flags, 0); } // Parse the AppearanceData field, if any. contents.mHoverOffsetWasSet = false; if (mesgsys->has(_PREHASH_AppearanceHover)) { LLVector3 hover; mesgsys->getVector3Fast(_PREHASH_AppearanceHover, _PREHASH_HoverHeight, hover); //LL_DEBUGS("Avatar") << avString() << " hover received " << hover.mV[ VX ] << "," << hover.mV[ VY ] << "," << hover.mV[ VZ ] << LL_ENDL; contents.mHoverOffset = hover; contents.mHoverOffsetWasSet = true; } // Parse visual params, if any. S32 num_blocks = mesgsys->getNumberOfBlocksFast(_PREHASH_VisualParam); bool drop_visual_params_debug = gSavedSettings.getBOOL("BlockSomeAvatarAppearanceVisualParams") && (ll_rand(2) == 0); // pretend that ~12% of AvatarAppearance messages arrived without a VisualParam block, for testing if( num_blocks > 1 && !drop_visual_params_debug) { //LL_DEBUGS("Avatar") << avString() << " handle visual params, num_blocks " << num_blocks << LL_ENDL; LLVisualParam* param = getFirstVisualParam(); llassert(param); // if this ever fires, we should do the same as when num_blocks<=1 if (!param) { LL_WARNS() << "No visual params!" << LL_ENDL; } else { for( S32 i = 0; i < num_blocks; i++ ) { while( param && ((param->getGroup() != VISUAL_PARAM_GROUP_TWEAKABLE) && (param->getGroup() != VISUAL_PARAM_GROUP_TRANSMIT_NOT_TWEAKABLE)) ) // should not be any of group VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT { param = getNextVisualParam(); } if( !param ) { // more visual params supplied than expected - just process what we know about break; } U8 value; mesgsys->getU8Fast(_PREHASH_VisualParam, _PREHASH_ParamValue, value, i); F32 newWeight = U8_to_F32(value, param->getMinWeight(), param->getMaxWeight()); contents.mParamWeights.push_back(newWeight); contents.mParams.push_back(param); param = getNextVisualParam(); } } const S32 expected_tweakable_count = getVisualParamCountInGroup(VISUAL_PARAM_GROUP_TWEAKABLE) + getVisualParamCountInGroup(VISUAL_PARAM_GROUP_TRANSMIT_NOT_TWEAKABLE); // don't worry about VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT if (num_blocks != expected_tweakable_count) { LL_DEBUGS("Avatar") << "Number of params in AvatarAppearance msg (" << num_blocks << ") does not match number of tweakable params in avatar xml file (" << expected_tweakable_count << "). Processing what we can. object: " << getID() << LL_ENDL; } } else { if (drop_visual_params_debug) { LL_INFOS() << "Debug-faked lack of parameters on AvatarAppearance for object: " << getID() << LL_ENDL; } else { LL_DEBUGS("Avatar") << "AvatarAppearance msg received without any parameters, object: " << getID() << LL_ENDL; } } LLVisualParam* appearance_version_param = getVisualParam(11000); if (appearance_version_param) { std::vector<LLVisualParam*>::iterator it = std::find(contents.mParams.begin(), contents.mParams.end(),appearance_version_param); if (it != contents.mParams.end()) { S32 index = it - contents.mParams.begin(); contents.mParamAppearanceVersion = ll_round(contents.mParamWeights[index]); //LL_DEBUGS("Avatar") << "appversion req by appearance_version param: " << contents.mParamAppearanceVersion << LL_ENDL; } } } bool resolve_appearance_version(const LLAppearanceMessageContents& contents, S32& appearance_version) { appearance_version = -1; if ((contents.mAppearanceVersion) >= 0 && (contents.mParamAppearanceVersion >= 0) && (contents.mAppearanceVersion != contents.mParamAppearanceVersion)) { LL_WARNS() << "inconsistent appearance_version settings - field: " << contents.mAppearanceVersion << ", param: " << contents.mParamAppearanceVersion << LL_ENDL; return false; } if (contents.mParamAppearanceVersion >= 0) // use visual param if available. { appearance_version = contents.mParamAppearanceVersion; } else if (contents.mAppearanceVersion > 0) { appearance_version = contents.mAppearanceVersion; } else // still not set, go with 1. { appearance_version = 1; } //LL_DEBUGS("Avatar") << "appearance version info - field " << contents.mAppearanceVersion // << " param: " << contents.mParamAppearanceVersion // << " final: " << appearance_version << LL_ENDL; return true; } //----------------------------------------------------------------------------- // processAvatarAppearance() //----------------------------------------------------------------------------- void LLVOAvatar::processAvatarAppearance( LLMessageSystem* mesgsys ) { LL_DEBUGS("Avatar") << "starts" << LL_ENDL; bool enable_verbose_dumps = gSavedSettings.getBOOL("DebugAvatarAppearanceMessage"); std::string dump_prefix = getFullname() + "_" + (isSelf()?"s":"o") + "_"; if (gSavedSettings.getBOOL("BlockAvatarAppearanceMessages")) { LL_WARNS() << "Blocking AvatarAppearance message" << LL_ENDL; return; } mLastAppearanceMessageTimer.reset(); LLPointer<LLAppearanceMessageContents> contents(new LLAppearanceMessageContents); parseAppearanceMessage(mesgsys, *contents); if (enable_verbose_dumps) { dumpAppearanceMsgParams(dump_prefix + "appearance_msg", *contents); } S32 appearance_version; if (!resolve_appearance_version(*contents, appearance_version)) { LL_WARNS() << "bad appearance version info, discarding" << LL_ENDL; return; } llassert(appearance_version > 0); if (appearance_version > 1) { LL_WARNS() << "unsupported appearance version " << appearance_version << ", discarding appearance message" << LL_ENDL; return; } S32 thisAppearanceVersion(contents->mCOFVersion); if (isSelf()) { // In the past this was considered to be the canonical COF version, // that is no longer the case. The canonical version is maintained // by the AIS code and should match the COF version there. Even so, // we must prevent rolling this one backwards backwards or processing // stale versions. S32 aisCOFVersion(LLAppearanceMgr::instance().getCOFVersion()); LL_DEBUGS("Avatar") << "handling self appearance message #" << thisAppearanceVersion << " (highest seen #" << mLastUpdateReceivedCOFVersion << ") (AISCOF=#" << aisCOFVersion << ")" << LL_ENDL; if (mLastUpdateReceivedCOFVersion >= thisAppearanceVersion) { LL_WARNS("Avatar") << "Stale appearance received #" << thisAppearanceVersion << " attempt to roll back from #" << mLastUpdateReceivedCOFVersion << "... dropping." << LL_ENDL; return; } if (isEditingAppearance()) { LL_DEBUGS("Avatar") << "Editing appearance. Dropping appearance update." << LL_ENDL; return; } } // SUNSHINE CLEANUP - is this case OK now? S32 num_params = contents->mParamWeights.size(); if (num_params <= 1) { // In this case, we have no reliable basis for knowing // appearance version, which may cause us to look for baked // textures in the wrong place and flag them as missing // assets. LL_DEBUGS("Avatar") << "ignoring appearance message due to lack of params" << LL_ENDL; return; } // No backsies zone - if we get here, the message should be valid and usable, will be processed. // Note: // RequestAgentUpdateAppearanceResponder::onRequestRequested() // assumes that cof version is only updated with server-bake // appearance messages. LL_INFOS("Avatar") << "Processing appearance message version " << thisAppearanceVersion << LL_ENDL; // Note: // locally the COF is maintained via LLInventoryModel::accountForUpdate // which is called from various places. This should match the simhost's // idea of what the COF version is. AIS however maintains its own version // of the COF that should be considered canonical. mLastUpdateReceivedCOFVersion = thisAppearanceVersion; mLastProcessedAppearance = contents; bool slam_params = false; applyParsedAppearanceMessage(*contents, slam_params); } void LLVOAvatar::applyParsedAppearanceMessage(LLAppearanceMessageContents& contents, bool slam_params) { S32 num_params = contents.mParamWeights.size(); ESex old_sex = getSex(); if (applyParsedTEMessage(contents.mTEContents) > 0 && isChanged(TEXTURE)) { updateVisualComplexity(); } // prevent the overwriting of valid baked textures with invalid baked textures for (U8 baked_index = 0; baked_index < mBakedTextureDatas.size(); baked_index++) { if (!isTextureDefined(mBakedTextureDatas[baked_index].mTextureIndex) && mBakedTextureDatas[baked_index].mLastTextureID != IMG_DEFAULT && baked_index != BAKED_SKIRT) { LL_DEBUGS("Avatar") << avString() << " baked_index " << (S32) baked_index << " using mLastTextureID " << mBakedTextureDatas[baked_index].mLastTextureID << LL_ENDL; setTEImage(mBakedTextureDatas[baked_index].mTextureIndex, LLViewerTextureManager::getFetchedTexture(mBakedTextureDatas[baked_index].mLastTextureID, FTT_DEFAULT, TRUE, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)); } else { LL_DEBUGS("Avatar") << avString() << " baked_index " << (S32) baked_index << " using texture id " << getTE(mBakedTextureDatas[baked_index].mTextureIndex)->getID() << LL_ENDL; } } // runway - was // if (!is_first_appearance_message ) // which means it would be called on second appearance message - probably wrong. BOOL is_first_appearance_message = !mFirstAppearanceMessageReceived; mFirstAppearanceMessageReceived = TRUE; //LL_DEBUGS("Avatar") << avString() << "processAvatarAppearance start " << mID // << " first? " << is_first_appearance_message << " self? " << isSelf() << LL_ENDL; if (is_first_appearance_message ) { onFirstTEMessageReceived(); } setCompositeUpdatesEnabled( FALSE ); gPipeline.markGLRebuild(this); // Apply visual params if( num_params > 1) { //LL_DEBUGS("Avatar") << avString() << " handle visual params, num_params " << num_params << LL_ENDL; BOOL params_changed = FALSE; BOOL interp_params = FALSE; S32 params_changed_count = 0; for( S32 i = 0; i < num_params; i++ ) { LLVisualParam* param = contents.mParams[i]; F32 newWeight = contents.mParamWeights[i]; if (slam_params || is_first_appearance_message || (param->getWeight() != newWeight)) { params_changed = TRUE; params_changed_count++; if(is_first_appearance_message || slam_params) { //LL_DEBUGS("Avatar") << "param slam " << i << " " << newWeight << LL_ENDL; param->setWeight(newWeight); } else { interp_params = TRUE; param->setAnimationTarget(newWeight); } } } const S32 expected_tweakable_count = getVisualParamCountInGroup(VISUAL_PARAM_GROUP_TWEAKABLE) + getVisualParamCountInGroup(VISUAL_PARAM_GROUP_TRANSMIT_NOT_TWEAKABLE); // don't worry about VISUAL_PARAM_GROUP_TWEAKABLE_NO_TRANSMIT if (num_params != expected_tweakable_count) { LL_DEBUGS("Avatar") << "Number of params in AvatarAppearance msg (" << num_params << ") does not match number of tweakable params in avatar xml file (" << expected_tweakable_count << "). Processing what we can. object: " << getID() << LL_ENDL; } LL_DEBUGS("Avatar") << "Changed " << params_changed_count << " params" << LL_ENDL; if (params_changed) { if (interp_params) { startAppearanceAnimation(); } updateVisualParams(); ESex new_sex = getSex(); if( old_sex != new_sex ) { updateSexDependentLayerSets(); } } llassert( getSex() == ((getVisualParamWeight( "male" ) > 0.5f) ? SEX_MALE : SEX_FEMALE) ); } else { // AvatarAppearance message arrived without visual params LL_DEBUGS("Avatar") << avString() << "no visual params" << LL_ENDL; const F32 LOADING_TIMEOUT_SECONDS = 60.f; // this isn't really a problem if we already have a non-default shape if (visualParamWeightsAreDefault() && mRuthTimer.getElapsedTimeF32() > LOADING_TIMEOUT_SECONDS) { // re-request appearance, hoping that it comes back with a shape next time LL_INFOS() << "Re-requesting AvatarAppearance for object: " << getID() << LL_ENDL; LLAvatarPropertiesProcessor::getInstance()->sendAvatarTexturesRequest(getID()); mRuthTimer.reset(); } else { LL_INFOS() << "That's okay, we already have a non-default shape for object: " << getID() << LL_ENDL; // we don't really care. } } if (contents.mHoverOffsetWasSet && !isSelf()) { // Got an update for some other avatar // Ignore updates for self, because we have a more authoritative value in the preferences. setHoverOffset(contents.mHoverOffset); LL_DEBUGS("Avatar") << avString() << "setting hover to " << contents.mHoverOffset[2] << LL_ENDL; } if (!contents.mHoverOffsetWasSet && !isSelf()) { // If we don't get a value at all, we are presumably in a // region that does not support hover height. LL_WARNS() << avString() << "zeroing hover because not defined in appearance message" << LL_ENDL; setHoverOffset(LLVector3(0.0, 0.0, 0.0)); } setCompositeUpdatesEnabled( TRUE ); // If all of the avatars are completely baked, release the global image caches to conserve memory. LLVOAvatar::cullAvatarsByPixelArea(); if (isSelf()) { mUseLocalAppearance = false; } updateMeshTextures(); } // static void LLVOAvatar::getAnimLabels( std::vector<std::string>* labels ) { S32 i; labels->reserve(gUserAnimStatesCount); for( i = 0; i < gUserAnimStatesCount; i++ ) { labels->push_back( LLAnimStateLabels::getStateLabel( gUserAnimStates[i].mName ) ); } // Special case to trigger away (AFK) state labels->push_back( "Away From Keyboard" ); } // static void LLVOAvatar::getAnimNames( std::vector<std::string>* names ) { S32 i; names->reserve(gUserAnimStatesCount); for( i = 0; i < gUserAnimStatesCount; i++ ) { names->push_back( std::string(gUserAnimStates[i].mName) ); } // Special case to trigger away (AFK) state names->push_back( "enter_away_from_keyboard_state" ); } // static void LLVOAvatar::onBakedTextureMasksLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata ) { if (!userdata) return; //LL_INFOS() << "onBakedTextureMasksLoaded: " << src_vi->getID() << LL_ENDL; const LLUUID id = src_vi->getID(); LLTextureMaskData* maskData = (LLTextureMaskData*) userdata; LLVOAvatar* self = (LLVOAvatar*) gObjectList.findObject( maskData->mAvatarID ); // if discard level is 2 less than last discard level we processed, or we hit 0, // then generate morph masks if(self && success && (discard_level < maskData->mLastDiscardLevel - 2 || discard_level == 0)) { if(aux_src && aux_src->getComponents() == 1) { if (!aux_src->getData()) { LL_ERRS() << "No auxiliary source (morph mask) data for image id " << id << LL_ENDL; return; } U32 gl_name; LLImageGL::generateTextures(1, &gl_name ); stop_glerror(); gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, gl_name); stop_glerror(); LLImageGL::setManualImage( GL_TEXTURE_2D, 0, GL_ALPHA8, aux_src->getWidth(), aux_src->getHeight(), GL_ALPHA, GL_UNSIGNED_BYTE, aux_src->getData()); stop_glerror(); gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR); /* if( id == head_baked->getID() ) if (self->mBakedTextureDatas[BAKED_HEAD].mTexLayerSet) //LL_INFOS() << "onBakedTextureMasksLoaded for head " << id << " discard = " << discard_level << LL_ENDL; self->mBakedTextureDatas[BAKED_HEAD].mTexLayerSet->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1); maskData->mLastDiscardLevel = discard_level; */ BOOL found_texture_id = false; for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin(); iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end(); ++iter) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second; if (texture_dict->mIsUsedByBakedTexture) { const ETextureIndex texture_index = iter->first; const LLViewerTexture *baked_img = self->getImage(texture_index, 0); if (baked_img && id == baked_img->getID()) { const EBakedTextureIndex baked_index = texture_dict->mBakedTextureIndex; self->applyMorphMask(aux_src->getData(), aux_src->getWidth(), aux_src->getHeight(), 1, baked_index); maskData->mLastDiscardLevel = discard_level; if (self->mBakedTextureDatas[baked_index].mMaskTexName) { LLImageGL::deleteTextures(1, &(self->mBakedTextureDatas[baked_index].mMaskTexName)); } self->mBakedTextureDatas[baked_index].mMaskTexName = gl_name; found_texture_id = true; break; } } } if (!found_texture_id) { LL_INFOS() << "unexpected image id: " << id << LL_ENDL; } self->dirtyMesh(); } else { // this can happen when someone uses an old baked texture possibly provided by // viewer-side baked texture caching LL_WARNS() << "Masks loaded callback but NO aux source, id " << id << LL_ENDL; } } if (final || !success) { delete maskData; } } // static void LLVOAvatar::onInitialBakedTextureLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata ) { LLUUID *avatar_idp = (LLUUID *)userdata; LLVOAvatar *selfp = (LLVOAvatar *)gObjectList.findObject(*avatar_idp); if (selfp) { //LL_DEBUGS("Avatar") << selfp->avString() << "discard_level " << discard_level << " success " << success << " final " << final << LL_ENDL; } if (!success && selfp) { selfp->removeMissingBakedTextures(); } if (final || !success ) { delete avatar_idp; } } // Static void LLVOAvatar::onBakedTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata) { //LL_DEBUGS("Avatar") << "onBakedTextureLoaded: " << src_vi->getID() << LL_ENDL; LLUUID id = src_vi->getID(); LLUUID *avatar_idp = (LLUUID *)userdata; LLVOAvatar *selfp = (LLVOAvatar *)gObjectList.findObject(*avatar_idp); if (selfp) { //LL_DEBUGS("Avatar") << selfp->avString() << "discard_level " << discard_level << " success " << success << " final " << final << " id " << src_vi->getID() << LL_ENDL; } if (selfp && !success) { selfp->removeMissingBakedTextures(); } if( final || !success ) { delete avatar_idp; } if( selfp && success && final ) { selfp->useBakedTexture( id ); } } // Called when baked texture is loaded and also when we start up with a baked texture void LLVOAvatar::useBakedTexture( const LLUUID& id ) { for (U32 i = 0; i < mBakedTextureDatas.size(); i++) { LLViewerTexture* image_baked = getImage( mBakedTextureDatas[i].mTextureIndex, 0 ); if (id == image_baked->getID()) { //LL_DEBUGS("Avatar") << avString() << " i " << i << " id " << id << LL_ENDL; mBakedTextureDatas[i].mIsLoaded = true; mBakedTextureDatas[i].mLastTextureID = id; mBakedTextureDatas[i].mIsUsed = true; if (isUsingLocalAppearance()) { LL_INFOS() << "not changing to baked texture while isUsingLocalAppearance" << LL_ENDL; } else { debugColorizeSubMeshes(i,LLColor4::green); avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[i].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[i].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setTexture( image_baked ); } } } const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = LLAvatarAppearanceDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)i); for (texture_vec_t::const_iterator local_tex_iter = baked_dict->mLocalTextures.begin(); local_tex_iter != baked_dict->mLocalTextures.end(); ++local_tex_iter) { if (isSelf()) setBakedReady(*local_tex_iter, TRUE); } // ! BACKWARDS COMPATIBILITY ! // Workaround for viewing avatars from old viewers that haven't baked hair textures. // This is paired with similar code in updateMeshTextures that sets hair mesh color. if (i == BAKED_HAIR) { avatar_joint_mesh_list_t::iterator iter = mBakedTextureDatas[i].mJointMeshes.begin(); avatar_joint_mesh_list_t::iterator end = mBakedTextureDatas[i].mJointMeshes.end(); for (; iter != end; ++iter) { LLAvatarJointMesh* mesh = (*iter); if (mesh) { mesh->setColor( LLColor4::white ); } } } } } dirtyMesh(); } std::string get_sequential_numbered_file_name(const std::string& prefix, const std::string& suffix) { typedef std::map<std::string,S32> file_num_type; static file_num_type file_nums; file_num_type::iterator it = file_nums.find(prefix); S32 num = 0; if (it != file_nums.end()) { num = it->second; } file_nums[prefix] = num+1; std::string outfilename = prefix + " " + llformat("%04d",num) + ".xml"; std::replace(outfilename.begin(),outfilename.end(),' ','_'); return outfilename; } void dump_sequential_xml(const std::string outprefix, const LLSD& content) { std::string outfilename = get_sequential_numbered_file_name(outprefix,".xml"); std::string fullpath = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,outfilename); llofstream ofs(fullpath.c_str(), std::ios_base::out); ofs << LLSDOStreamer<LLSDXMLFormatter>(content, LLSDFormatter::OPTIONS_PRETTY); LL_DEBUGS("Avatar") << "results saved to: " << fullpath << LL_ENDL; } void LLVOAvatar::getSortedJointNames(S32 joint_type, std::vector<std::string>& result) const { result.clear(); if (joint_type==0) { avatar_joint_list_t::const_iterator iter = mSkeleton.begin(); avatar_joint_list_t::const_iterator end = mSkeleton.end(); for (; iter != end; ++iter) { LLJoint* pJoint = (*iter); result.push_back(pJoint->getName()); } } else if (joint_type==1) { for (S32 i = 0; i < mNumCollisionVolumes; i++) { LLAvatarJointCollisionVolume* pJoint = &mCollisionVolumes[i]; result.push_back(pJoint->getName()); } } else if (joint_type==2) { for (LLVOAvatar::attachment_map_t::const_iterator iter = mAttachmentPoints.begin(); iter != mAttachmentPoints.end(); ++iter) { LLViewerJointAttachment* pJoint = iter->second; if (!pJoint) continue; result.push_back(pJoint->getName()); } } std::sort(result.begin(), result.end()); } void LLVOAvatar::dumpArchetypeXML(const std::string& prefix, bool group_by_wearables ) { std::string outprefix(prefix); if (outprefix.empty()) { outprefix = getFullname() + (isSelf()?"_s":"_o"); } if (outprefix.empty()) { outprefix = std::string("new_archetype"); } std::string outfilename = get_sequential_numbered_file_name(outprefix,".xml"); LLAPRFile outfile; std::string fullpath = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,outfilename); if (APR_SUCCESS == outfile.open(fullpath, LL_APR_WB )) { apr_file_t* file = outfile.getFileHandle(); LL_INFOS() << "xmlfile write handle obtained : " << fullpath << LL_ENDL; apr_file_printf( file, "<?xml version=\"1.0\" encoding=\"US-ASCII\" standalone=\"yes\"?>\n" ); apr_file_printf( file, "<linden_genepool version=\"1.0\">\n" ); apr_file_printf( file, "\n\t<archetype name=\"???\">\n" ); if (group_by_wearables) { for (S32 type = LLWearableType::WT_SHAPE; type < LLWearableType::WT_COUNT; type++) { const std::string& wearable_name = LLWearableType::getTypeName((LLWearableType::EType)type); apr_file_printf( file, "\n\t\t<!-- wearable: %s -->\n", wearable_name.c_str() ); for (LLVisualParam* param = getFirstVisualParam(); param; param = getNextVisualParam()) { LLViewerVisualParam* viewer_param = (LLViewerVisualParam*)param; if( (viewer_param->getWearableType() == type) && (viewer_param->isTweakable() ) ) { dump_visual_param(file, viewer_param, viewer_param->getWeight()); } } for (U8 te = 0; te < TEX_NUM_INDICES; te++) { if (LLAvatarAppearanceDictionary::getTEWearableType((ETextureIndex)te) == type) { // MULTIPLE_WEARABLES: extend to multiple wearables? LLViewerTexture* te_image = getImage((ETextureIndex)te, 0); if( te_image ) { std::string uuid_str; te_image->getID().toString( uuid_str ); apr_file_printf( file, "\t\t<texture te=\"%i\" uuid=\"%s\"/>\n", te, uuid_str.c_str()); } } } } } else { // Just dump all params sequentially. for (LLVisualParam* param = getFirstVisualParam(); param; param = getNextVisualParam()) { LLViewerVisualParam* viewer_param = (LLViewerVisualParam*)param; dump_visual_param(file, viewer_param, viewer_param->getWeight()); } for (U8 te = 0; te < TEX_NUM_INDICES; te++) { // MULTIPLE_WEARABLES: extend to multiple wearables? LLViewerTexture* te_image = getImage((ETextureIndex)te, 0); if( te_image ) { std::string uuid_str; te_image->getID().toString( uuid_str ); apr_file_printf( file, "\t\t<texture te=\"%i\" uuid=\"%s\"/>\n", te, uuid_str.c_str()); } } } // Root joint const LLVector3& pos = mRoot->getPosition(); const LLVector3& scale = mRoot->getScale(); apr_file_printf( file, "\t\t<root name=\"%s\" position=\"%f %f %f\" scale=\"%f %f %f\"/>\n", mRoot->getName().c_str(), pos[0], pos[1], pos[2], scale[0], scale[1], scale[2]); // Bones std::vector<std::string> bone_names, cv_names, attach_names, all_names; getSortedJointNames(0, bone_names); getSortedJointNames(1, cv_names); getSortedJointNames(2, attach_names); all_names.insert(all_names.end(), bone_names.begin(), bone_names.end()); all_names.insert(all_names.end(), cv_names.begin(), cv_names.end()); all_names.insert(all_names.end(), attach_names.begin(), attach_names.end()); for (std::vector<std::string>::iterator name_iter = bone_names.begin(); name_iter != bone_names.end(); ++name_iter) { LLJoint *pJoint = getJoint(*name_iter); const LLVector3& pos = pJoint->getPosition(); const LLVector3& scale = pJoint->getScale(); apr_file_printf( file, "\t\t<bone name=\"%s\" position=\"%f %f %f\" scale=\"%f %f %f\"/>\n", pJoint->getName().c_str(), pos[0], pos[1], pos[2], scale[0], scale[1], scale[2]); } // Collision volumes for (std::vector<std::string>::iterator name_iter = cv_names.begin(); name_iter != cv_names.end(); ++name_iter) { LLJoint *pJoint = getJoint(*name_iter); const LLVector3& pos = pJoint->getPosition(); const LLVector3& scale = pJoint->getScale(); apr_file_printf( file, "\t\t<collision_volume name=\"%s\" position=\"%f %f %f\" scale=\"%f %f %f\"/>\n", pJoint->getName().c_str(), pos[0], pos[1], pos[2], scale[0], scale[1], scale[2]); } // Attachment joints for (std::vector<std::string>::iterator name_iter = attach_names.begin(); name_iter != attach_names.end(); ++name_iter) { LLJoint *pJoint = getJoint(*name_iter); if (!pJoint) continue; const LLVector3& pos = pJoint->getPosition(); const LLVector3& scale = pJoint->getScale(); apr_file_printf( file, "\t\t<attachment_point name=\"%s\" position=\"%f %f %f\" scale=\"%f %f %f\"/>\n", pJoint->getName().c_str(), pos[0], pos[1], pos[2], scale[0], scale[1], scale[2]); } // Joint pos overrides for (std::vector<std::string>::iterator name_iter = all_names.begin(); name_iter != all_names.end(); ++name_iter) { LLJoint *pJoint = getJoint(*name_iter); LLVector3 pos; LLUUID mesh_id; if (pJoint && pJoint->hasAttachmentPosOverride(pos,mesh_id)) { S32 num_pos_overrides; std::set<LLVector3> distinct_pos_overrides; pJoint->getAllAttachmentPosOverrides(num_pos_overrides, distinct_pos_overrides); apr_file_printf( file, "\t\t<joint_offset name=\"%s\" position=\"%f %f %f\" mesh_id=\"%s\" count=\"%d\" distinct=\"%d\"/>\n", pJoint->getName().c_str(), pos[0], pos[1], pos[2], mesh_id.asString().c_str(), num_pos_overrides, (S32) distinct_pos_overrides.size()); } } // Joint scale overrides for (std::vector<std::string>::iterator name_iter = all_names.begin(); name_iter != all_names.end(); ++name_iter) { LLJoint *pJoint = getJoint(*name_iter); LLVector3 scale; LLUUID mesh_id; if (pJoint && pJoint->hasAttachmentScaleOverride(scale,mesh_id)) { S32 num_scale_overrides; std::set<LLVector3> distinct_scale_overrides; pJoint->getAllAttachmentPosOverrides(num_scale_overrides, distinct_scale_overrides); apr_file_printf( file, "\t\t<joint_scale name=\"%s\" scale=\"%f %f %f\" mesh_id=\"%s\" count=\"%d\" distinct=\"%d\"/>\n", pJoint->getName().c_str(), scale[0], scale[1], scale[2], mesh_id.asString().c_str(), num_scale_overrides, (S32) distinct_scale_overrides.size()); } } F32 pelvis_fixup; LLUUID mesh_id; if (hasPelvisFixup(pelvis_fixup, mesh_id)) { apr_file_printf( file, "\t\t<pelvis_fixup z=\"%f\" mesh_id=\"%s\"/>\n", pelvis_fixup, mesh_id.asString().c_str()); } apr_file_printf( file, "\t</archetype>\n" ); apr_file_printf( file, "\n</linden_genepool>\n" ); bool ultra_verbose = false; if (isSelf() && ultra_verbose) { // show the cloned params inside the wearables as well. gAgentAvatarp->dumpWearableInfo(outfile); } LLSD args; args["PATH"] = fullpath; LLNotificationsUtil::add("AppearanceToXMLSaved", args); } else { LLNotificationsUtil::add("AppearanceToXMLFailed"); } // File will close when handle goes out of scope } void LLVOAvatar::setVisibilityRank(U32 rank) { if (mDrawable.isNull() || mDrawable->isDead()) { // do nothing return; } mVisibilityRank = rank; } // Assumes LLVOAvatar::sInstances has already been sorted. S32 LLVOAvatar::getUnbakedPixelAreaRank() { S32 rank = 1; for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; if (inst == this) { return rank; } else if (!inst->isDead() && !inst->isFullyBaked()) { rank++; } } llassert(0); return 0; } struct CompareScreenAreaGreater { BOOL operator()(const LLCharacter* const& lhs, const LLCharacter* const& rhs) { return lhs->getPixelArea() > rhs->getPixelArea(); } }; // static void LLVOAvatar::cullAvatarsByPixelArea() { std::sort(LLCharacter::sInstances.begin(), LLCharacter::sInstances.end(), CompareScreenAreaGreater()); // Update the avatars that have changed status U32 rank = 2; //1 is reserved for self. for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* inst = (LLVOAvatar*) *iter; BOOL culled; if (inst->isSelf() || inst->isFullyBaked()) { culled = FALSE; } else { culled = TRUE; } if (inst->mCulled != culled) { inst->mCulled = culled; LL_DEBUGS() << "avatar " << inst->getID() << (culled ? " start culled" : " start not culled" ) << LL_ENDL; inst->updateMeshTextures(); } if (inst->isSelf()) { inst->setVisibilityRank(1); } else if (inst->mDrawable.notNull() && inst->mDrawable->isVisible()) { inst->setVisibilityRank(rank++); } } // runway - this doesn't really detect gray/grey state. S32 grey_avatars = 0; if (!LLVOAvatar::areAllNearbyInstancesBaked(grey_avatars)) { if (gFrameTimeSeconds != sUnbakedUpdateTime) // only update once per frame { sUnbakedUpdateTime = gFrameTimeSeconds; sUnbakedTime += gFrameIntervalSeconds.value(); } if (grey_avatars > 0) { if (gFrameTimeSeconds != sGreyUpdateTime) // only update once per frame { sGreyUpdateTime = gFrameTimeSeconds; sGreyTime += gFrameIntervalSeconds.value(); } } } } void LLVOAvatar::startAppearanceAnimation() { if(!mAppearanceAnimating) { mAppearanceAnimating = TRUE; mAppearanceMorphTimer.reset(); mLastAppearanceBlendTime = 0.f; } } // virtual void LLVOAvatar::removeMissingBakedTextures() { } //virtual void LLVOAvatar::updateRegion(LLViewerRegion *regionp) { LLViewerObject::updateRegion(regionp); } std::string LLVOAvatar::getFullname() const { std::string name; LLNameValue* first = getNVPair("FirstName"); LLNameValue* last = getNVPair("LastName"); if (first && last) { name = LLCacheName::buildFullName( first->getString(), last->getString() ); } return name; } LLHost LLVOAvatar::getObjectHost() const { LLViewerRegion* region = getRegion(); if (region && !isDead()) { return region->getHost(); } else { return LLHost(); } } //static void LLVOAvatar::updateFreezeCounter(S32 counter) { if(counter) { sFreezeCounter = counter; } else if(sFreezeCounter > 0) { sFreezeCounter--; } else { sFreezeCounter = 0; } } BOOL LLVOAvatar::updateLOD() { if (isImpostor() && 0 != mDrawable->getNumFaces() && mDrawable->getFace(0)->hasGeometry()) { return TRUE; } BOOL res = updateJointLODs(); LLFace* facep = mDrawable->getFace(0); if (!facep || !facep->getVertexBuffer()) { dirtyMesh(2); } if (mDirtyMesh >= 2 || mDrawable->isState(LLDrawable::REBUILD_GEOMETRY)) { //LOD changed or new mesh created, allocate new vertex buffer if needed updateMeshData(); mDirtyMesh = 0; mNeedsSkin = TRUE; mDrawable->clearState(LLDrawable::REBUILD_GEOMETRY); } updateVisibility(); return res; } void LLVOAvatar::updateLODRiggedAttachments( void ) { updateLOD(); rebuildRiggedAttachments(); } U32 LLVOAvatar::getPartitionType() const { // Avatars merely exist as drawables in the bridge partition return LLViewerRegion::PARTITION_BRIDGE; } //static void LLVOAvatar::updateImpostors() { LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD; LLCharacter::sAllowInstancesChange = FALSE; for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { LLVOAvatar* avatar = (LLVOAvatar*) *iter; if (!avatar->isDead() && avatar->isVisible() && ( (avatar->isImpostor() || LLVOAvatar::AV_DO_NOT_RENDER == avatar->getVisualMuteSettings()) && avatar->needsImpostorUpdate()) ) { avatar->calcMutedAVColor(); gPipeline.generateImpostor(avatar); } } LLCharacter::sAllowInstancesChange = TRUE; } BOOL LLVOAvatar::isImpostor() { return sUseImpostors && (isVisuallyMuted() || (mUpdatePeriod >= IMPOSTOR_PERIOD)) ? TRUE : FALSE; } BOOL LLVOAvatar::shouldImpostor(const U32 rank_factor) const { return (!isSelf() && sUseImpostors && mVisibilityRank > (sMaxNonImpostors * rank_factor)); } BOOL LLVOAvatar::needsImpostorUpdate() const { return mNeedsImpostorUpdate; } const LLVector3& LLVOAvatar::getImpostorOffset() const { return mImpostorOffset; } const LLVector2& LLVOAvatar::getImpostorDim() const { return mImpostorDim; } void LLVOAvatar::setImpostorDim(const LLVector2& dim) { mImpostorDim = dim; } void LLVOAvatar::cacheImpostorValues() { getImpostorValues(mImpostorExtents, mImpostorAngle, mImpostorDistance); } void LLVOAvatar::getImpostorValues(LLVector4a* extents, LLVector3& angle, F32& distance) const { const LLVector4a* ext = mDrawable->getSpatialExtents(); extents[0] = ext[0]; extents[1] = ext[1]; LLVector3 at = LLViewerCamera::getInstance()->getOrigin()-(getRenderPosition()+mImpostorOffset); distance = at.normalize(); F32 da = 1.f - (at*LLViewerCamera::getInstance()->getAtAxis()); angle.mV[0] = LLViewerCamera::getInstance()->getYaw()*da; angle.mV[1] = LLViewerCamera::getInstance()->getPitch()*da; angle.mV[2] = da; } // static const U32 LLVOAvatar::IMPOSTORS_OFF = 66; /* Must equal the maximum allowed the RenderAvatarMaxNonImpostors * slider in panel_preferences_graphics1.xml */ // static void LLVOAvatar::updateImpostorRendering(U32 newMaxNonImpostorsValue) { U32 oldmax = sMaxNonImpostors; bool oldflg = sUseImpostors; if (IMPOSTORS_OFF <= newMaxNonImpostorsValue) { sMaxNonImpostors = 0; } else { sMaxNonImpostors = newMaxNonImpostorsValue; } // the sUseImpostors flag depends on whether or not sMaxNonImpostors is set to the no-limit value (0) sUseImpostors = (0 != sMaxNonImpostors); if ( oldflg != sUseImpostors ) { LL_DEBUGS("AvatarRender") << "was " << (oldflg ? "use" : "don't use" ) << " impostors (max " << oldmax << "); " << "now " << (sUseImpostors ? "use" : "don't use" ) << " impostors (max " << sMaxNonImpostors << "); " << LL_ENDL; } } void LLVOAvatar::idleUpdateRenderComplexity() { // Render Complexity calculateUpdateRenderComplexity(); // Update mVisualComplexity if needed if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_AVATAR_DRAW_INFO)) { std::string info_line; F32 red_level; F32 green_level; LLColor4 info_color; LLFontGL::StyleFlags info_style; if ( !mText ) { initHudText(); mText->setFadeDistance(20.0, 5.0); // limit clutter in large crowds } else { mText->clearString(); // clear debug text } /* * NOTE: the logic for whether or not each of the values below * controls muting MUST match that in the isVisuallyMuted and isTooComplex methods. */ static LLCachedControl<U32> max_render_cost(gSavedSettings, "RenderAvatarMaxComplexity", 0); info_line = llformat("%d Complexity", mVisualComplexity); if (max_render_cost != 0) // zero means don't care, so don't bother coloring based on this { green_level = 1.f-llclamp(((F32) mVisualComplexity-(F32)max_render_cost)/(F32)max_render_cost, 0.f, 1.f); red_level = llmin((F32) mVisualComplexity/(F32)max_render_cost, 1.f); info_color.set(red_level, green_level, 0.0, 1.0); info_style = ( mVisualComplexity > max_render_cost ? LLFontGL::BOLD : LLFontGL::NORMAL ); } else { info_color.set(LLColor4::grey); info_style = LLFontGL::NORMAL; } mText->addLine(info_line, info_color, info_style); // Visual rank info_line = llformat("%d rank", mVisibilityRank); // Use grey for imposters, white for normal rendering or no impostors info_color.set(isImpostor() ? LLColor4::grey : LLColor4::white); info_style = LLFontGL::NORMAL; mText->addLine(info_line, info_color, info_style); // Attachment Surface Area static LLCachedControl<F32> max_attachment_area(gSavedSettings, "RenderAutoMuteSurfaceAreaLimit", 1000.0f); info_line = llformat("%.0f m^2", mAttachmentSurfaceArea); if (max_render_cost != 0 && max_attachment_area != 0) // zero means don't care, so don't bother coloring based on this { green_level = 1.f-llclamp((mAttachmentSurfaceArea-max_attachment_area)/max_attachment_area, 0.f, 1.f); red_level = llmin(mAttachmentSurfaceArea/max_attachment_area, 1.f); info_color.set(red_level, green_level, 0.0, 1.0); info_style = ( mAttachmentSurfaceArea > max_attachment_area ? LLFontGL::BOLD : LLFontGL::NORMAL ); } else { info_color.set(LLColor4::grey); info_style = LLFontGL::NORMAL; } mText->addLine(info_line, info_color, info_style); updateText(); // corrects position } } void LLVOAvatar::addAttachmentArea(F32 delta_area) { mAttachmentSurfaceArea += delta_area; } void LLVOAvatar::subtractAttachmentArea(F32 delta_area) { mAttachmentSurfaceArea = delta_area > mAttachmentSurfaceArea ? 0.0 : mAttachmentSurfaceArea - delta_area; } void LLVOAvatar::updateVisualComplexity() { LL_DEBUGS("AvatarRender") << "avatar " << getID() << " appearance changed" << LL_ENDL; // Set the cache time to in the past so it's updated ASAP mVisualComplexityStale = true; } // Calculations for mVisualComplexity value void LLVOAvatar::calculateUpdateRenderComplexity() { /***************************************************************** * This calculation should not be modified by third party viewers, * since it is used to limit rendering and should be uniform for * everyone. If you have suggested improvements, submit them to * the official viewer for consideration. *****************************************************************/ static const U32 COMPLEXITY_BODY_PART_COST = 200; static LLCachedControl<F32> max_complexity_setting(gSavedSettings,"MaxAttachmentComplexity"); F32 max_attachment_complexity = max_complexity_setting; max_attachment_complexity = llmax(max_attachment_complexity, DEFAULT_MAX_ATTACHMENT_COMPLEXITY); // Diagnostic list of all textures on our avatar static std::set<LLUUID> all_textures; if (mVisualComplexityStale) { U32 cost = VISUAL_COMPLEXITY_UNKNOWN; LLVOVolume::texture_cost_t textures; hud_complexity_list_t hud_complexity_list; for (U8 baked_index = 0; baked_index < BAKED_NUM_INDICES; baked_index++) { const LLAvatarAppearanceDictionary::BakedEntry *baked_dict = LLAvatarAppearanceDictionary::getInstance()->getBakedTexture((EBakedTextureIndex)baked_index); ETextureIndex tex_index = baked_dict->mTextureIndex; if ((tex_index != TEX_SKIRT_BAKED) || (isWearingWearableType(LLWearableType::WT_SKIRT))) { if (isTextureVisible(tex_index)) { cost +=COMPLEXITY_BODY_PART_COST; } } } LL_DEBUGS("ARCdetail") << "Avatar body parts complexity: " << cost << LL_ENDL; for (attachment_map_t::const_iterator attachment_point = mAttachmentPoints.begin(); attachment_point != mAttachmentPoints.end(); ++attachment_point) { LLViewerJointAttachment* attachment = attachment_point->second; for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin(); attachment_iter != attachment->mAttachedObjects.end(); ++attachment_iter) { const LLViewerObject* attached_object = (*attachment_iter); if (attached_object && !attached_object->isHUDAttachment()) { textures.clear(); const LLDrawable* drawable = attached_object->mDrawable; if (drawable) { const LLVOVolume* volume = drawable->getVOVolume(); if (volume) { F32 attachment_total_cost = 0; F32 attachment_volume_cost = 0; F32 attachment_texture_cost = 0; F32 attachment_children_cost = 0; attachment_volume_cost += volume->getRenderCost(textures); const_child_list_t children = volume->getChildren(); for (const_child_list_t::const_iterator child_iter = children.begin(); child_iter != children.end(); ++child_iter) { LLViewerObject* child_obj = *child_iter; LLVOVolume *child = dynamic_cast<LLVOVolume*>( child_obj ); if (child) { attachment_children_cost += child->getRenderCost(textures); } } for (LLVOVolume::texture_cost_t::iterator volume_texture = textures.begin(); volume_texture != textures.end(); ++volume_texture) { // add the cost of each individual texture in the linkset attachment_texture_cost += volume_texture->second; } attachment_total_cost = attachment_volume_cost + attachment_texture_cost + attachment_children_cost; LL_DEBUGS("ARCdetail") << "Attachment costs " << attached_object->getAttachmentItemID() << " total: " << attachment_total_cost << ", volume: " << attachment_volume_cost << ", textures: " << attachment_texture_cost << ", " << volume->numChildren() << " children: " << attachment_children_cost << LL_ENDL; // Limit attachment complexity to avoid signed integer flipping of the wearer's ACI cost += (U32)llclamp(attachment_total_cost, MIN_ATTACHMENT_COMPLEXITY, max_attachment_complexity); } } } if (isSelf() && attached_object && attached_object->isHUDAttachment() && !attached_object->isTempAttachment() && attached_object->mDrawable) { textures.clear(); const LLVOVolume* volume = attached_object->mDrawable->getVOVolume(); if (volume) { LLHUDComplexity hud_object_complexity; hud_object_complexity.objectName = attached_object->getAttachmentItemName(); hud_object_complexity.objectId = attached_object->getAttachmentItemID(); std::string joint_name; gAgentAvatarp->getAttachedPointName(attached_object->getAttachmentItemID(), joint_name); hud_object_complexity.jointName = joint_name; // get cost and individual textures hud_object_complexity.objectsCost += volume->getRenderCost(textures); hud_object_complexity.objectsCount++; LLViewerObject::const_child_list_t& child_list = attached_object->getChildren(); for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin(); iter != child_list.end(); ++iter) { LLViewerObject* childp = *iter; const LLVOVolume* chld_volume = dynamic_cast<LLVOVolume*>(childp); if (chld_volume) { // get cost and individual textures hud_object_complexity.objectsCost += chld_volume->getRenderCost(textures); hud_object_complexity.objectsCount++; } } hud_object_complexity.texturesCount += textures.size(); for (LLVOVolume::texture_cost_t::iterator volume_texture = textures.begin(); volume_texture != textures.end(); ++volume_texture) { // add the cost of each individual texture (ignores duplicates) hud_object_complexity.texturesCost += volume_texture->second; LLViewerFetchedTexture *tex = LLViewerTextureManager::getFetchedTexture(volume_texture->first); if (tex) { // Note: Texture memory might be incorect since texture might be still loading. hud_object_complexity.texturesMemoryTotal += tex->getTextureMemory(); if (tex->getOriginalHeight() * tex->getOriginalWidth() >= HUD_OVERSIZED_TEXTURE_DATA_SIZE) { hud_object_complexity.largeTexturesCount++; } } } hud_complexity_list.push_back(hud_object_complexity); } } } } // Diagnostic output to identify all avatar-related textures. // Does not affect rendering cost calculation. // Could be wrapped in a debug option if output becomes problematic. if (isSelf()) { // print any attachment textures we didn't already know about. for (LLVOVolume::texture_cost_t::iterator it = textures.begin(); it != textures.end(); ++it) { LLUUID image_id = it->first; if( ! (image_id.isNull() || image_id == IMG_DEFAULT || image_id == IMG_DEFAULT_AVATAR) && (all_textures.find(image_id) == all_textures.end())) { // attachment texture not previously seen. LL_DEBUGS("ARCdetail") << "attachment_texture: " << image_id.asString() << LL_ENDL; all_textures.insert(image_id); } } // print any avatar textures we didn't already know about for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin(); iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end(); ++iter) { const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second; // TODO: MULTI-WEARABLE: handle multiple textures for self const LLViewerTexture* te_image = getImage(iter->first,0); if (!te_image) continue; LLUUID image_id = te_image->getID(); if( image_id.isNull() || image_id == IMG_DEFAULT || image_id == IMG_DEFAULT_AVATAR) continue; if (all_textures.find(image_id) == all_textures.end()) { LL_DEBUGS("ARCdetail") << "local_texture: " << texture_dict->mName << ": " << image_id << LL_ENDL; all_textures.insert(image_id); } } } if ( cost != mVisualComplexity ) { LL_DEBUGS("AvatarRender") << "Avatar "<< getID() << " complexity updated was " << mVisualComplexity << " now " << cost << " reported " << mReportedVisualComplexity << LL_ENDL; } else { LL_DEBUGS("AvatarRender") << "Avatar "<< getID() << " complexity updated no change " << mVisualComplexity << " reported " << mReportedVisualComplexity << LL_ENDL; } mVisualComplexity = cost; mVisualComplexityStale = false; static LLCachedControl<U32> show_my_complexity_changes(gSavedSettings, "ShowMyComplexityChanges", 20); if (isSelf() && show_my_complexity_changes) { // Avatar complexity LLAvatarRenderNotifier::getInstance()->updateNotificationAgent(mVisualComplexity); // HUD complexity LLHUDRenderNotifier::getInstance()->updateNotificationHUD(hud_complexity_list); } } } void LLVOAvatar::setVisualMuteSettings(VisualMuteSettings set) { mVisuallyMuteSetting = set; mNeedsImpostorUpdate = TRUE; LLRenderMuteList::getInstance()->saveVisualMuteSetting(getID(), S32(set)); } void LLVOAvatar::calcMutedAVColor() { LLColor4 new_color(mMutedAVColor); std::string change_msg; LLUUID av_id(getID()); if (getVisualMuteSettings() == AV_DO_NOT_RENDER) { // explicitly not-rendered avatars are light grey new_color = LLColor4::grey3; change_msg = " not rendered: color is grey3"; } else if (LLMuteList::getInstance()->isMuted(av_id)) // the user blocked them { // blocked avatars are dark grey new_color = LLColor4::grey4; change_msg = " blocked: color is grey4"; } else if ( mMutedAVColor == LLColor4::white || mMutedAVColor == LLColor4::grey3 || mMutedAVColor == LLColor4::grey4 ) { // select a color based on the first byte of the agents uuid so any muted agent is always the same color F32 color_value = (F32) (av_id.mData[0]); F32 spectrum = (color_value / 256.0); // spectrum is between 0 and 1.f // Array of colors. These are arranged so only one RGB color changes between each step, // and it loops back to red so there is an even distribution. It is not a heat map const S32 NUM_SPECTRUM_COLORS = 7; static LLColor4 * spectrum_color[NUM_SPECTRUM_COLORS] = { &LLColor4::red, &LLColor4::magenta, &LLColor4::blue, &LLColor4::cyan, &LLColor4::green, &LLColor4::yellow, &LLColor4::red }; spectrum = spectrum * (NUM_SPECTRUM_COLORS - 1); // Scale to range of number of colors S32 spectrum_index_1 = floor(spectrum); // Desired color will be after this index S32 spectrum_index_2 = spectrum_index_1 + 1; // and before this index (inclusive) F32 fractBetween = spectrum - (F32)(spectrum_index_1); // distance between the two indexes (0-1) new_color = lerp(*spectrum_color[spectrum_index_1], *spectrum_color[spectrum_index_2], fractBetween); new_color.normalize(); new_color *= 0.28f; // Tone it down change_msg = " over limit color "; } if (mMutedAVColor != new_color) { LL_DEBUGS("AvatarRender") << "avatar "<< av_id << change_msg << std::setprecision(3) << new_color << LL_ENDL; mMutedAVColor = new_color; } } // static BOOL LLVOAvatar::isIndexLocalTexture(ETextureIndex index) { return (index < 0 || index >= TEX_NUM_INDICES) ? false : LLAvatarAppearanceDictionary::getInstance()->getTexture(index)->mIsLocalTexture; } // static BOOL LLVOAvatar::isIndexBakedTexture(ETextureIndex index) { return (index < 0 || index >= TEX_NUM_INDICES) ? false : LLAvatarAppearanceDictionary::getInstance()->getTexture(index)->mIsBakedTexture; } const std::string LLVOAvatar::getBakedStatusForPrintout() const { std::string line; for (LLAvatarAppearanceDictionary::Textures::const_iterator iter = LLAvatarAppearanceDictionary::getInstance()->getTextures().begin(); iter != LLAvatarAppearanceDictionary::getInstance()->getTextures().end(); ++iter) { const ETextureIndex index = iter->first; const LLAvatarAppearanceDictionary::TextureEntry *texture_dict = iter->second; if (texture_dict->mIsBakedTexture) { line += texture_dict->mName; if (isTextureDefined(index)) { line += "_baked"; } line += " "; } } return line; } //virtual S32 LLVOAvatar::getTexImageSize() const { return TEX_IMAGE_SIZE_OTHER; } //----------------------------------------------------------------------------- // Utility functions //----------------------------------------------------------------------------- F32 calc_bouncy_animation(F32 x) { return -(cosf(x * F_PI * 2.5f - F_PI_BY_TWO))*(0.4f + x * -0.1f) + x * 1.3f; } //virtual BOOL LLVOAvatar::isTextureDefined(LLAvatarAppearanceDefines::ETextureIndex te, U32 index ) const { if (isIndexLocalTexture(te)) { return FALSE; } if( !getImage( te, index ) ) { LL_WARNS() << "getImage( " << te << ", " << index << " ) returned 0" << LL_ENDL; return FALSE; } return (getImage(te, index)->getID() != IMG_DEFAULT_AVATAR && getImage(te, index)->getID() != IMG_DEFAULT); } //virtual BOOL LLVOAvatar::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, U32 index) const { if (isIndexLocalTexture(type)) { return isTextureDefined(type, index); } else { // baked textures can use TE images directly return ((isTextureDefined(type) || isSelf()) && (getTEImage(type)->getID() != IMG_INVISIBLE || LLDrawPoolAlpha::sShowDebugAlpha)); } } //virtual BOOL LLVOAvatar::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, LLViewerWearable *wearable) const { // non-self avatars don't have wearables return FALSE; }