//static void LLFloaterAO::onClickStandAdd(void* user_data) { LLFloaterAO* floater = (LLFloaterAO*)user_data; LLUUID id = LLUUID(floater->mStandsCombo->getValue()); std::list<LLUUID>::iterator itr = std::find(LLAO::mStandOverrides.begin(),LLAO::mStandOverrides.end(),id); LLVOAvatar* avatarp = gAgent.getAvatarObject(); if(id.notNull() && itr == LLAO::mStandOverrides.end()) { //back is always last played avatarp->stopMotion(LLAO::mStandOverrides.back()); avatarp->startMotion(id); LLAO::mStandOverrides.push_back(id); floater->refresh(); LLAO::mTimer->reset(); } onCommitAnim(NULL,user_data); }
void LLWearable::setParamsToDefaults() { LLVOAvatar* avatar = gAgent.getAvatarObject(); llassert( avatar ); if( !avatar ) { return; } mVisualParamMap.clear(); for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() ) { if( (((LLViewerVisualParam*)param)->getWearableType() == mType ) && (param->isTweakable()) ) { mVisualParamMap[param->getID()] = param->getDefaultWeight(); } } }
//----------------------------------------------------------------------------- // validateEaseOut() //----------------------------------------------------------------------------- BOOL LLFloaterAnimPreview::validateEaseOut(LLUICtrl* spin, void* data) { LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data; if (!previewp->getEnabled()) return FALSE; LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar(); LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(previewp->mMotionID); if (!motionp->getLoop()) { F32 new_ease_out = llclamp((F32)previewp->childGetValue("ease_out_time").asReal(), 0.f, motionp->getDuration() - motionp->getEaseInDuration()); previewp->childSetValue("ease_out_time", LLSD(new_ease_out)); } return TRUE; }
// Does not copy mAssetID. // Definition version is current: removes obsolete enties and creates default values for new ones. void LLWearable::copyDataFrom( LLWearable* src ) { LLVOAvatar* avatar = gAgent.getAvatarObject(); llassert( avatar ); if( !avatar ) { return; } mDefinitionVersion = LLWearable::sCurrentDefinitionVersion; mName = src->mName; mDescription = src->mDescription; mPermissions = src->mPermissions; mSaleInfo = src->mSaleInfo; mType = src->mType; // Deep copy of mVisualParamMap (copies only those params that are current, filling in defaults where needed) for( LLViewerVisualParam* param = (LLViewerVisualParam*) avatar->getFirstVisualParam(); param; param = (LLViewerVisualParam*) avatar->getNextVisualParam() ) { if( (param->getWearableType() == mType) && (param->isTweakable() ) ) { S32 id = param->getID(); F32 weight = get_if_there(src->mVisualParamMap, id, param->getDefaultWeight() ); if(id == 507) avatar->setActualBoobGrav(weight); mVisualParamMap[id] = weight; } } // Deep copy of mTEMap (copies only those tes that are current, filling in defaults where needed) for( S32 te = 0; te < TEX_NUM_INDICES; te++ ) { if( LLVOAvatar::getTEWearableType((ETextureIndex) te ) == mType ) { const LLUUID& image_id = get_if_there(src->mTEMap, te, LLVOAvatar::getDefaultTEImageID((ETextureIndex) te ) ); mTEMap[te] = image_id; } } }
//----------------------------------------------------------------------------- // onBtnPlay() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::onBtnPlay(void* user_data) { LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data; if (!previewp->getEnabled()) return; if (previewp->mMotionID.notNull()) { LLVOAvatar* avatarp; if (previewp->mInWorld) { if (!gAgent.getAvatarObject()) { return; } avatarp = gAgent.getAvatarObject(); } else { if (!previewp->mAnimPreview) { return; } avatarp = previewp->mAnimPreview->getDummyAvatar(); } if(!avatarp->isMotionActive(previewp->mMotionID)) { previewp->resetMotion(); previewp->mPauseRequest = NULL; } else { if (avatarp->areAnimationsPaused()) { previewp->mPauseRequest = NULL; } else { previewp->mPauseRequest = avatarp->requestPause(); } } } }
void LLVisualParamHint::preRender(BOOL clear_depth) { LLVOAvatar* avatarp = gAgent.getAvatarObject(); mLastParamWeight = avatarp->getVisualParamWeight(mVisualParam); avatarp->setVisualParamWeight(mVisualParam, mVisualParamWeight); avatarp->setVisualParamWeight("Blink_Left", 0.f); avatarp->setVisualParamWeight("Blink_Right", 0.f); avatarp->updateComposites(); avatarp->updateVisualParams(); avatarp->updateGeometry(avatarp->mDrawable); avatarp->updateLOD(); LLDynamicTexture::preRender(clear_depth); }
void LLWearable::pullCrossWearableValues() { // scan through all of the avatar's visual parameters LLVOAvatar* avatar = gAgent.getAvatarObject(); for (LLViewerVisualParam* param = (LLViewerVisualParam*) avatar->getFirstVisualParam(); param; param = (LLViewerVisualParam*) avatar->getNextVisualParam()) { if( param ) { LLDriverParam *driver_param = dynamic_cast<LLDriverParam*>(param); if(driver_param) { // parameter is a driver parameter, have it update its driver_param->updateCrossDrivenParams(getType()); } } } }
// Updates asset from the user's avatar void LLWearable::readFromAvatar() { LLVOAvatar* avatar = gAgent.getAvatarObject(); llassert( avatar ); if( !avatar ) { return; } mDefinitionVersion = LLWearable::sCurrentDefinitionVersion; mVisualParamMap.clear(); for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() ) { if( (((LLViewerVisualParam*)param)->getWearableType() == mType) && (param->isTweakable() ) ) { //pretty sure is right if(param->getID() == 507) avatar->setActualBoobGrav(param->getWeight()); mVisualParamMap[param->getID()] = param->getWeight(); } } mTEMap.clear(); for( S32 te = 0; te < TEX_NUM_INDICES; te++ ) { if( LLVOAvatar::getTEWearableType((ETextureIndex) te ) == mType ) { LLViewerImage* image = avatar->getTEImage( te ); if( image ) { mTEMap[te] = image->getID(); } } } //if( gFloaterCustomize ) //{ // mDescription = gFloaterCustomize->getWearableDescription( mType ); //} }
void LLPanelContents::getState(LLViewerObject *objectp ) { if( !objectp ) { childSetEnabled("button new script",FALSE); return; } LLUUID group_id; // used for SL-23488 LLSelectMgr::getInstance()->selectGetGroup(group_id); // sets group_id as a side effect SL-23488 // BUG? Check for all objects being editable? BOOL editable = gAgent.isGodlike() || (objectp->permModify() && ( objectp->permYouOwner() || ( !group_id.isNull() && gAgent.isInGroup(group_id) ))); // solves SL-23488 BOOL all_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME ); // [RLVa:KB] - Checked: 2010-04-01 (RLVa-1.2.0c) | Modified: RLVa-1.0.5a if ( (rlv_handler_t::isEnabled()) && (editable) ) { // Don't allow creation of new scripts if it's non-detachable if (objectp->isAttachment()) editable = !gRlvAttachmentLocks.isLockedAttachment(objectp->getRootEdit()); // Don't allow creation of new scripts if we're @unsit=n or @sittp=n restricted and we're sitting on the selection if ( (editable) && ((gRlvHandler.hasBehaviour(RLV_BHVR_UNSIT)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SITTP))) ) { // Only check the first (non-)root object because nothing else would result in enabling the button (see below) LLViewerObject* pObj = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject(TRUE); LLVOAvatar* pAvatar = gAgent.getAvatarObject(); editable = (pObj) && (pAvatar) && ((!pAvatar->mIsSitting) || (pAvatar->getRoot() != pObj->getRootEdit())); } } // [/RLVa:KB] // Edit script button - ok if object is editable and there's an unambiguous destination for the object. childSetEnabled("button new script", editable && all_volume && ((LLSelectMgr::getInstance()->getSelection()->getRootObjectCount() == 1) || (LLSelectMgr::getInstance()->getSelection()->getObjectCount() == 1))); }
// virtual void LLPreviewAnim::onClose(bool app_quitting) { const LLInventoryItem *item = getItem(); if(item) { gAgent.getAvatarObject()->stopMotion(item->getAssetUUID()); gAgent.sendAnimationRequest(item->getAssetUUID(), ANIM_REQUEST_STOP); LLVOAvatar* avatar = gAgent.getAvatarObject(); LLMotion* motion = avatar->findMotion(item->getAssetUUID()); if (motion) { // *TODO: minor memory leak here, user data is never deleted (Use real callbacks) motion->setDeactivateCallback(NULL, (void *)NULL); } } }
void LLFloaterAvatarTextures::refresh() { LLVOAvatar *avatarp = find_avatar(mID); if (avatarp) { std::string fullname; if (gCacheName->getFullName(avatarp->getID(), fullname)) { setTitle(mTitle + ": " + fullname); } for (U32 i=0; i < TEX_NUM_INDICES; i++) { update_texture_ctrl(avatarp, mTextures[i], ETextureIndex(i)); } } else { setTitle(mTitle + ": INVALID AVATAR (" + mID.asString() + ")"); } }
//----------------------------------------------------------------------------- // initialize() //----------------------------------------------------------------------------- void LLMorphView::initialize() { mCameraPitch = 0.f; mCameraYaw = 0.f; mCameraDist = -1.f; LLVOAvatar *avatarp = gAgent.getAvatarObject(); if (!avatarp || avatarp->isDead()) { gAgent.changeCameraToDefault(); return; } avatarp->stopMotion( ANIM_AGENT_BODY_NOISE ); avatarp->mSpecialRenderMode = 3; // set up camera for close look at avatar mOldCameraNearClip = LLViewerCamera::getInstance()->getNear(); LLViewerCamera::getInstance()->setNear(MORPH_NEAR_CLIP); }
//----------------------------------------------------------------------------- // onBtnPlay() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::onBtnPlay() { if (!getEnabled()) return; if (mMotionID.notNull() && mAnimPreview) { LLVOAvatar* avatarp = mAnimPreview->getPreviewAvatar(); if (!avatarp->isMotionActive(mMotionID)) { resetMotion(); mPauseRequest = NULL; } else if (avatarp->areAnimationsPaused()) { mPauseRequest = NULL; } } }
void LLFloaterTopObjects::lookAtAvatar() { LLScrollListCtrl* list = getChild<LLScrollListCtrl>("objects_list"); if (!list) return; LLScrollListItem* first_selected = list->getFirstSelected(); if (!first_selected) return; LLUUID taskid = first_selected->getUUID(); LLVOAvatar* voavatar = gObjectList.findAvatar(taskid); if(voavatar) { gAgentCamera.setFocusOnAvatar(FALSE, FALSE); gAgentCamera.changeCameraToThirdPerson(); gAgentCamera.setFocusGlobal(voavatar->getPositionGlobal(),taskid); gAgentCamera.setCameraPosAndFocusGlobal(voavatar->getPositionGlobal() + LLVector3d(3.5,1.35,0.75) * voavatar->getRotation(), voavatar->getPositionGlobal(), taskid ); } }
void LLDrawPoolAvatar::renderShadow(S32 pass) { LLFastTimer t(FTM_SHADOW_AVATAR); if (mDrawFace.empty()) { return; } const LLFace *facep = mDrawFace[0]; if (!facep->getDrawable()) { return; } LLVOAvatar *avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get(); if (avatarp->isDead() || avatarp->mIsDummy || avatarp->mDrawable.isNull()) { return; } BOOL impostor = avatarp->isImpostor(); if (impostor) { return; } if (pass == 0) { avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE); } else { renderRigged(avatarp, RIGGED_SIMPLE); renderRigged(avatarp, RIGGED_ALPHA); renderRigged(avatarp, RIGGED_FULLBRIGHT); renderRigged(avatarp, RIGGED_FULLBRIGHT_SHINY); renderRigged(avatarp, RIGGED_SHINY); renderRigged(avatarp, RIGGED_FULLBRIGHT_ALPHA); } }
//----------------------------------------------------------------------------- // onSliderMove() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::onSliderMove(LLUICtrl* ctrl, void*user_data) { LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)user_data; if (!previewp->getEnabled()) return; LLVOAvatar* avatarp; if (previewp->mInWorld) { if (!gAgent.getAvatarObject()) { return; } avatarp = gAgent.getAvatarObject(); } else { if (!previewp->mAnimPreview) { return; } avatarp = previewp->mAnimPreview->getDummyAvatar(); } F32 slider_value = (F32)previewp->childGetValue("playback_slider").asReal(); LLUUID base_id = previewp->mIDList[previewp->childGetValue("preview_base_anim").asString()]; LLMotion* motionp = avatarp->findMotion(previewp->mMotionID); F32 duration = motionp->getDuration();// + motionp->getEaseOutDuration(); F32 delta_time = duration * slider_value; avatarp->deactivateAllMotions(); avatarp->startMotion(base_id, delta_time + BASE_ANIM_TIME_OFFSET); avatarp->startMotion(previewp->mMotionID, delta_time); previewp->mPauseRequest = avatarp->requestPause(); previewp->refresh(); }
//----------------------------------------------------------------------------- // onCommitBaseAnim() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::onCommitBaseAnim(LLUICtrl* ctrl, void* data) { LLFloaterAnimPreview* previewp = (LLFloaterAnimPreview*)data; if (!previewp->getEnabled()) return; if (previewp->mAnimPreview) { LLVOAvatar* avatarp = previewp->mAnimPreview->getDummyAvatar(); BOOL paused = avatarp->areAnimationsPaused(); // stop all other possible base motions avatarp->stopMotion(ANIM_AGENT_STAND, TRUE); avatarp->stopMotion(ANIM_AGENT_WALK, TRUE); avatarp->stopMotion(ANIM_AGENT_SIT, TRUE); avatarp->stopMotion(ANIM_AGENT_HOVER, TRUE); previewp->resetMotion(); if (!paused) { previewp->mPauseRequest = NULL; } } }
bool PanelRadar::isKickable(const LLUUID& agent_id) { if (agent_id.notNull()) { LLViewerObject* av_obj = gObjectList.findObject(agent_id); if (av_obj != NULL && av_obj->isAvatar()) { LLVOAvatar* avatar = (LLVOAvatar*)av_obj; LLViewerRegion* region = avatar->getRegion(); if (region) { const LLVector3& pos = avatar->getPositionRegion(); if (region->isOwnedSelf(pos) || region->canManageEstate()) { return true; } const LLVector3d& pos_global = avatar->getPositionGlobal(); if (LLWorld::getInstance()->positionRegionValidGlobal(pos_global)) { LLParcel* parcel = LLViewerParcelMgr::getInstance()->selectParcelAt(pos_global)->getParcel(); LLViewerParcelMgr::getInstance()->deselectLand(); if (parcel) { if (region->isOwnedGroup(pos) && (LLViewerParcelMgr::getInstance()->isParcelOwnedByAgent(parcel,GP_LAND_ADMIN) || LLViewerParcelMgr::getInstance()->isParcelOwnedByAgent(parcel,GP_LAND_MANAGE_BANNED))) { return true; } } } } } } return false; }
void LLFloaterHUD::find() // Scanner activated by Scan button { if(mHalt) return; // this basically checks if the scan has been toggled on or off otherwise llvoavatar calls the scan on avatar activity mListNames->deleteAllItems(); //Clear the list std::vector< LLCharacter* >::iterator avatar_it; for(avatar_it = LLCharacter::sInstances.begin(); avatar_it != LLCharacter::sInstances.end(); ++avatar_it) { LLVOAvatar* avatarp = (LLVOAvatar*)*avatar_it; if (avatarp->isDead() || avatarp->isSelf()) //Dont show the user! { continue; } if (dist_vec(avatarp->getPositionAgent(), gAgent.getPositionAgent()) <= SCAN_MAX_RADIUS) //Scanner radius set in indra constants. { // Pull in that avatar data! std::string name = avatarp->getFullname(); LLVector3d position = gAgent.getPosGlobalFromAgent(avatarp->getCharacterPosition()); LLUUID avid = avatarp->getID(); // Work out distance relative to user! LLVector3d mypos = gAgent.getPositionGlobal(); LLVector3d delta = position - mypos; F32 distance = (F32)delta.magVec(); //Build the list LLSD element; element["id"] = avid; element["columns"][LIST_AVATAR_NAME]["column"] = "name"; element["columns"][LIST_AVATAR_NAME]["value"] = name; element["columns"][LIST_DISTANCE]["column"] = "distance"; element["columns"][LIST_DISTANCE]["value"] = distance; mListNames->addElement(element); mListNames->sortByColumn("distance", TRUE); mListNames->setCallbackUserData(this); } } return; }
LLVector3d LLAvatarTracker::getGlobalPos() { if(!mTrackedAgentValid || !mTrackingData) return LLVector3d(); LLVector3d global_pos; LLVOAvatar* avatarp = gObjectList.findAvatar(mTrackingData->mAvatarID); if(avatarp && !avatarp->isDead()) { global_pos = avatarp->getPositionGlobal(); // HACK - for making the tracker point above the avatar's head // rather than its groin global_pos.mdV[VZ] += 0.7f * avatarp->mBodySize.mV[VZ]; mTrackingData->mGlobalPositionEstimate = global_pos; } else { global_pos = mTrackingData->mGlobalPositionEstimate; } return global_pos; }
// Updates asset from the user's avatar void LLWearable::readFromAvatar() { LLVOAvatar* avatar = gAgent.getAvatarObject(); llassert( avatar ); if( !avatar ) { return; } mDefinitionVersion = LLWearable::sCurrentDefinitionVersion; mVisualParamMap.clear(); for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() ) { if( (((LLViewerVisualParam*)param)->getWearableType() == mType) && (param->getGroup() == VISUAL_PARAM_GROUP_TWEAKABLE ) ) { mVisualParamMap[param->getID()] = param->getWeight(); } } mTEMap.clear(); for( S32 te = 0; te < LLVOAvatar::TEX_NUM_ENTRIES; te++ ) { if( LLVOAvatar::getTEWearableType( te ) == mType ) { LLViewerImage* image = avatar->getTEImage( te ); if( image ) { mTEMap[te] = image->getID(); } } } //if( gFloaterCustomize ) //{ // mDescription = gFloaterCustomize->getWearableDescription( mType ); //} }
void LLAvatarTracker::getDegreesAndDist(F32& rot, F64& horiz_dist, F64& vert_dist) { if(!mTrackingData) return; LLVector3d global_pos; LLVOAvatar* avatarp = gObjectList.findAvatar(mTrackingData->mAvatarID); if(avatarp && !avatarp->isDead()) { global_pos = avatarp->getPositionGlobal(); mTrackingData->mGlobalPositionEstimate = global_pos; } else { global_pos = mTrackingData->mGlobalPositionEstimate; } LLVector3d to_vec = global_pos - gAgent.getPositionGlobal(); horiz_dist = sqrt(to_vec.mdV[VX] * to_vec.mdV[VX] + to_vec.mdV[VY] * to_vec.mdV[VY]); vert_dist = to_vec.mdV[VZ]; rot = F32(RAD_TO_DEG * atan2(to_vec.mdV[VY], to_vec.mdV[VX])); }
// Updates the user's avatar's appearance, replacing this wearables' parameters and textures with default values. // static void LLWearable::removeFromAvatar( EWearableType type, BOOL set_by_user ) { LLVOAvatar* avatar = gAgent.getAvatarObject(); llassert( avatar ); if( !avatar ) { return; } // You can't just remove body parts. if( (type == WT_SHAPE) || (type == WT_SKIN) || (type == WT_HAIR) || (type == WT_EYES) ) { return; } // Pull params for( LLVisualParam* param = avatar->getFirstVisualParam(); param; param = avatar->getNextVisualParam() ) { if (((LLViewerVisualParam*)param)->getWearableType() == type && param->isTweakable()) { S32 param_id = param->getID(); avatar->setVisualParamWeight( param_id, param->getDefaultWeight(), set_by_user ); } } // Pull textures LLViewerImage* image = gImageList.getImage( IMG_DEFAULT_AVATAR ); for( S32 te = 0; te < TEX_NUM_INDICES; te++ ) { if( LLVOAvatar::getTEWearableType((ETextureIndex) te ) == type ) { avatar->setLocTexTE( te, image, set_by_user ); } } if( gFloaterCustomize ) { gFloaterCustomize->setWearable(type, NULL, PERM_ALL, TRUE); } avatar->updateVisualParams(); avatar->updateMeshTextures(); // if( set_by_user ) // { // gAgent.sendAgentSetAppearance(); // } }
void LLLocalSpeakerMgr::updateSpeakerList() { // pull speakers from voice channel LLSpeakerMgr::updateSpeakerList(); if (gDisconnected)//the world is cleared. { return ; } // pick up non-voice speakers in chat range std::vector<LLUUID> avatar_ids; std::vector<LLVector3d> positions; LLWorld::getInstance()->getAvatars(&avatar_ids, &positions, gAgent.getPositionGlobal(), CHAT_NORMAL_RADIUS); for(U32 i=0; i<avatar_ids.size(); i++) { setSpeaker(avatar_ids[i]); } // check if text only speakers have moved out of chat range for (speaker_map_t::iterator speaker_it = mSpeakers.begin(); speaker_it != mSpeakers.end(); ++speaker_it) { LLUUID speaker_id = speaker_it->first; LLSpeaker* speakerp = speaker_it->second; if (speakerp->mStatus == LLSpeaker::STATUS_TEXT_ONLY) { LLVOAvatar* avatarp = (LLVOAvatar*)gObjectList.findObject(speaker_id); if (!avatarp || dist_vec(avatarp->getPositionAgent(), gAgent.getPositionAgent()) > CHAT_NORMAL_RADIUS) { speakerp->mStatus = LLSpeaker::STATUS_NOT_IN_CHANNEL; speakerp->mDotColor = INACTIVE_COLOR; speakerp->mActivityTimer.resetWithExpiry(SPEAKER_TIMEOUT); } } } }
//static void PanelRadar::onClickTeleport(void* user_data) { PanelRadar* self = (PanelRadar*)user_data; LLScrollListItem *item = self->mRadarList->getFirstSelected(); if (item) { LLUUID agent_id = item->getUUID(); std::string agent_name = self->getSelectedName(agent_id); if (!agent_name.empty()) { LLViewerObject *av_obj = gObjectList.findObject(agent_id); if (av_obj != NULL && av_obj->isAvatar()) { LLVOAvatar* avatarp = (LLVOAvatar*)av_obj; if (avatarp != NULL) { LLVector3d pos = avatarp->getPositionGlobal(); gAgent.teleportViaLocation(pos); } } } } }
static void send_eject(const LLUUID& avatar_id, bool ban) { LLMessageSystem* msg = gMessageSystem; LLVOAvatar* avatarp = gObjectList.findAvatar(avatar_id); if (avatarp && avatarp->getRegion()) { U32 flags = 0x0; if (ban) { // eject and add to ban list flags |= 0x1; } msg->newMessage("EjectUser"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgent.getID()); msg->addUUID("SessionID", gAgent.getSessionID()); msg->nextBlock("Data"); msg->addUUID("TargetID", avatar_id); msg->addU32("Flags", flags); msg->sendReliable( avatarp->getRegion()->getHost()); } }
void LLFloaterAvatarTextures::refresh() { // <FS:Ansariel> Enable for regular user //if (gAgent.isGodlike()) { LLVOAvatar *avatarp = find_avatar(mID); if (avatarp) { LLAvatarName av_name; if (LLAvatarNameCache::get(avatarp->getID(), &av_name)) { setTitle(mTitle + ": " + av_name.getCompleteName()); } for (U32 i=0; i < TEX_NUM_INDICES; i++) { update_texture_ctrl(avatarp, mTextures[i], ETextureIndex(i)); } } else { setTitle(mTitle + ": " + getString("InvalidAvatar") + " (" + mID.asString() + ")"); } } }
static void send_freeze(const LLUUID& avatar_id, bool freeze) { U32 flags = 0x0; if (!freeze) { // unfreeze flags |= 0x1; } LLMessageSystem* msg = gMessageSystem; LLVOAvatar* avatarp = gObjectList.findAvatar(avatar_id); if (avatarp && avatarp->getRegion()) { msg->newMessage("FreezeUser"); msg->nextBlock("AgentData"); msg->addUUID("AgentID", gAgent.getID()); msg->addUUID("SessionID", gAgent.getSessionID()); msg->nextBlock("Data"); msg->addUUID("TargetID", avatar_id); msg->addU32("Flags", flags); msg->sendReliable( avatarp->getRegion()->getHost()); } }
//----------------------------------------------------------------------------- // resetMotion() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::resetMotion() { LLVOAvatar* avatarp; if (mInWorld) { avatarp = gAgent.getAvatarObject(); } else { avatarp = mAnimPreview->getDummyAvatar(); } if (!avatarp) { return; } BOOL paused = avatarp->areAnimationsPaused(); // *TODO: Fix awful casting hack LLKeyframeMotion* motionp = (LLKeyframeMotion*)avatarp->findMotion(mMotionID); // Set emotion std::string emote = childGetValue("emote_combo").asString(); motionp->setEmote(mIDList[emote]); LLUUID base_id = mIDList[childGetValue("preview_base_anim").asString()]; avatarp->deactivateAllMotions(); avatarp->startMotion(base_id, BASE_ANIM_TIME_OFFSET); avatarp->startMotion(mMotionID, 0.0f); childSetValue("playback_slider", 0.0f); // Set pose std::string handpose = childGetValue("hand_pose_combo").asString(); avatarp->startMotion( ANIM_AGENT_HAND_MOTION, 0.0f ); motionp->setHandPose(LLHandMotion::getHandPose(handpose)); if (paused) { mPauseRequest = avatarp->requestPause(); } else { mPauseRequest = NULL; } }
//----------------------------------------------------------------------------- // onSliderMove() //----------------------------------------------------------------------------- void LLFloaterAnimPreview::onSliderMove() { if (!getEnabled()) return; if (mAnimPreview) { LLVOAvatar* avatarp = mAnimPreview->getPreviewAvatar(); F32 slider_value = (F32)getChild<LLUICtrl>("playback_slider")->getValue().asReal(); LLUUID base_id = mIDList[getChild<LLUICtrl>("preview_base_anim")->getValue().asString()]; LLMotion* motionp = avatarp->findMotion(mMotionID); F32 duration = motionp->getDuration();// + motionp->getEaseOutDuration(); F32 delta_time = duration * slider_value; avatarp->deactivateAllMotions(); avatarp->startMotion(base_id, delta_time + BASE_ANIM_TIME_OFFSET); avatarp->startMotion(mMotionID, delta_time); mPauseRequest = avatarp->requestPause(); refresh(); } }