Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fed6bb2c8a6b1fd1c2e3734501d88b423edd8b80
SingularityViewer/indra/newview/llagent.h
Beeks 1fe07cfcd7 Fixes, foxes, faxes, and "oh fucks." 
Link and unlink buttons are now in the build menu. To facilitate this, some minor elements were adjusted, and the edit boxes were re-aligned. Emerald's layout was pretty sloppy anyway.
More fiddling with the windlight menu, and more dead ends.

Expect at least one more update before night's end to implement the features coming in from the merge.

Signed-off-by: Beeks <HgDelirium@gmail.com>
2010-09-02 03:19:13 -04:00

1037 lines
38 KiB
C++
Raw Blame History

/**
* @file llagent.h
* @brief LLAgent class header file
*
* $LicenseInfo:firstyear=2000&license=viewergpl$
*
* Copyright (c) 2000-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLAGENT_H
#define LL_LLAGENT_H
#include <set>
#include "indra_constants.h"
#include "llmath.h"
#include "llcontrol.h"
#include "llcoordframe.h"
#include "llevent.h"
#include "llagentaccess.h"
#include "llagentconstants.h"
#include "llanimationstates.h"
#include "lldbstrings.h"
#include "llhudeffectlookat.h"
#include "llhudeffectpointat.h"
#include "llmemory.h"
#include "llstring.h"
#include "lluuid.h"
#include "m3math.h"
#include "m4math.h"
#include "llquaternion.h"
#include "lltimer.h"
#include "v3dmath.h"
#include "v3math.h"
#include "v4color.h"
#include "v4math.h"
//#include "vmath.h"
#include "stdenums.h"
#include "llwearable.h"
#include "llcharacter.h"
#include "llinventory.h"
#include "llviewerinventory.h"
#include "llagentdata.h"
// Ventrella
#include "llfollowcam.h"
// end Ventrella
const U8 AGENT_STATE_TYPING = 0x04; // Typing indication
const U8 AGENT_STATE_EDITING = 0x10; // Set when agent has objects selected
const BOOL ANIMATE = TRUE;
typedef enum e_camera_modes
{
CAMERA_MODE_THIRD_PERSON,
CAMERA_MODE_MOUSELOOK,
CAMERA_MODE_CUSTOMIZE_AVATAR,
CAMERA_MODE_FOLLOW
} ECameraMode;
typedef enum e_camera_position
{
CAMERA_POSITION_SELF, /** Camera positioned at our position */
CAMERA_POSITION_OBJECT /** Camera positioned at observed object's position */
} ECameraPosition;
typedef enum e_anim_request
{
ANIM_REQUEST_START,
ANIM_REQUEST_STOP
} EAnimRequest;
class LLChat;
class LLVOAvatar;
class LLViewerRegion;
class LLMotion;
class LLToolset;
class LLMessageSystem;
class LLPermissions;
class LLHost;
class LLFriendObserver;
class LLPickInfo;
struct LLGroupData
{
LLUUID mID;
LLUUID mInsigniaID;
U64 mPowers;
BOOL mAcceptNotices;
BOOL mListInProfile;
S32 mContribution;
std::string mName;
};
inline bool operator==(const LLGroupData &a, const LLGroupData &b)
{
return (a.mID == b.mID);
}
// forward declarations
//
class LLAgent : public LLObservable
{
LOG_CLASS(LLAgent);
public:
// When the agent hasn't typed anything for this duration, it leaves the
// typing state (for both chat and IM).
static const F32 TYPING_TIMEOUT_SECS;
LLAgent();
~LLAgent();
void init();
void cleanup();
//
// MANIPULATORS
//
// TODO: Put all non-const functions here.
// Called whenever the agent moves. Puts camera back in default position,
// deselects items, etc.
void resetView(BOOL reset_camera = TRUE, BOOL change_camera = FALSE);
// Called on camera movement, to allow the camera to be unlocked from the
// default position behind the avatar.
void unlockView();
void onAppFocusGained();
void sendMessage(); // Send message to this agent's region.
void sendReliableMessage();
LLVector3d calcCameraPositionTargetGlobal(BOOL *hit_limit = NULL); // Calculate the camera position target
LLVector3d calcFocusPositionTargetGlobal();
LLVector3d calcThirdPersonFocusOffset();
// target for this mode
LLVector3d getCameraPositionGlobal() const;
const LLVector3 &getCameraPositionAgent() const;
F32 calcCameraFOVZoomFactor();
F32 getCameraMinOffGround(); // minimum height off ground for this mode, meters
void endAnimationUpdateUI();
void setKey(const S32 direction, S32 &key); // sets key to +1 for +direction, -1 for -direction
void handleScrollWheel(S32 clicks); // mousewheel driven zoom
void setAvatarObject(LLVOAvatar *avatar);
// rendering state bitmask helpers
void startTyping();
void stopTyping();
void setRenderState(U8 newstate);
void clearRenderState(U8 clearstate);
U8 getRenderState();
// Set the home data
void setRegion(LLViewerRegion *regionp);
LLViewerRegion *getRegion() const;
const LLHost& getRegionHost() const;
std::string getSLURL() const;
void updateAgentPosition(const F32 dt, const F32 yaw, const S32 mouse_x, const S32 mouse_y); // call once per frame to update position, angles radians
void updateLookAt(const S32 mouse_x, const S32 mouse_y);
void updateCamera(); // call once per frame to update camera location/orientation
void resetCamera(); // slam camera into its default position
void setupSitCamera();
void setCameraCollidePlane(const LLVector4 &plane) { mCameraCollidePlane = plane; }
void changeCameraToDefault();
void changeCameraToMouselook(BOOL animate = TRUE);
void changeCameraToThirdPerson(BOOL animate = TRUE);
void changeCameraToCustomizeAvatar(BOOL avatar_animate = TRUE, BOOL camera_animate = TRUE); // trigger transition animation
// Ventrella
void changeCameraToFollow(BOOL animate = TRUE);
//end Ventrella
void setFocusGlobal(const LLPickInfo& pick);
void setFocusGlobal(const LLVector3d &focus, const LLUUID &object_id = LLUUID::null);
void setFocusOnAvatar(BOOL focus, BOOL animate);
void setCameraPosAndFocusGlobal(const LLVector3d& pos, const LLVector3d& focus, const LLUUID &object_id);
void setSitCamera(const LLUUID &object_id, const LLVector3 &camera_pos = LLVector3::zero, const LLVector3 &camera_focus = LLVector3::zero);
void clearFocusObject();
void setFocusObject(LLViewerObject* object);
void setObjectTracking(BOOL track) { mTrackFocusObject = track; }
// void setLookingAtAvatar(BOOL looking);
void heardChat(const LLUUID& id);
void lookAtLastChat();
void lookAtObject(LLUUID avatar_id, ECameraPosition camera_pos);
F32 getTypingTime() { return mTypingTimer.getElapsedTimeF32(); }
void setAFK();
void clearAFK();
BOOL getAFK() const;
void setAlwaysRun() { mbAlwaysRun = true; }
void clearAlwaysRun() { mbAlwaysRun = false; }
void setRunning() { mbRunning = true; }
void clearRunning() { mbRunning = false; }
void setBusy();
void clearBusy();
BOOL getBusy() const;
void setAdminOverride(BOOL b);
void setGodLevel(U8 god_level);
void setFirstLogin(BOOL b) { mFirstLogin = b; }
void setGenderChosen(BOOL b) { mGenderChosen = b; }
// update internal datastructures and update the server with the
// new contribution level. Returns true if the group id was found
// and contribution could be set.
BOOL setGroupContribution(const LLUUID& group_id, S32 contribution);
BOOL setUserGroupFlags(const LLUUID& group_id, BOOL accept_notices, BOOL list_in_profile);
void setHideGroupTitle(BOOL hide) { mHideGroupTitle = hide; }
//
// ACCESSORS
//
// TODO: Put all read functions here, make them const
const LLUUID& getID() const { return gAgentID; }
const LLUUID& getSessionID() const { return gAgentSessionID; }
const LLUUID& getSecureSessionID() const { return mSecureSessionID; }
// Note: NEVER send this value in the clear or over any weakly
// encrypted channel (such as simple XOR masking). If you are unsure
// ask Aaron or MarkL.
BOOL isGodlike() const;
U8 getGodLevel() const;
// note: this is a prime candidate for pulling out into a Maturity class
// rather than just expose the preference setting, we're going to actually
// expose what the client code cares about -- what the user should see
// based on a combination of the is* and prefers* flags, combined with God bit.
bool wantsPGOnly() const;
bool canAccessMature() const;
bool canAccessAdult() const;
bool canAccessMaturityInRegion( U64 region_handle ) const;
bool canAccessMaturityAtGlobal( LLVector3d pos_global ) const;
bool prefersPG() const;
bool prefersMature() const;
bool prefersAdult() const;
bool isTeen() const;
bool isMature() const;
bool isAdult() const;
void setTeen(bool teen);
void setMaturity(char text);
static int convertTextToMaturity(char text);
bool sendMaturityPreferenceToServer(int preferredMaturity);
const LLAgentAccess& getAgentAccess();
// This function can go away after the AO transition (see llstartup.cpp)
void setAOTransition();
BOOL isGroupTitleHidden() const { return mHideGroupTitle; }
BOOL isGroupMember() const { return !mGroupID.isNull(); } // This is only used for building titles!
const LLUUID &getGroupID() const { return mGroupID; }
ECameraMode getCameraMode() const { return mCameraMode; }
BOOL getFocusOnAvatar() const { return mFocusOnAvatar; }
LLPointer<LLViewerObject>& getFocusObject() { return mFocusObject; }
F32 getFocusObjectDist() const { return mFocusObjectDist; }
BOOL inPrelude();
BOOL canManageEstate() const;
BOOL getAdminOverride() const;
LLUUID getLastChatter() const { return mLastChatterID; }
bool getAlwaysRun() const { return mbAlwaysRun; }
bool getRunning() const { return mbRunning; }
const LLUUID& getInventoryRootID() const { return mInventoryRootID; }
void buildFullname(std::string &name) const;
void buildFullnameAndTitle(std::string &name) const;
// Check against all groups in the entire agent group list.
BOOL isInGroup(const LLUUID& group_id) const;
BOOL hasPowerInGroup(const LLUUID& group_id, U64 power) const;
// Check for power in just the active group.
BOOL hasPowerInActiveGroup(const U64 power) const;
U64 getPowerInGroup(const LLUUID& group_id) const;
// Get group information by group_id. if not in group, data is
// left unchanged and method returns FALSE. otherwise, values are
// copied and returns TRUE.
BOOL getGroupData(const LLUUID& group_id, LLGroupData& data) const;
// Get just the agent's contribution to the given group.
S32 getGroupContribution(const LLUUID& group_id) const;
// return TRUE if the database reported this login as the first
// for this particular user.
BOOL isFirstLogin() const { return mFirstLogin; }
// On the very first login, gender isn't chosen until the user clicks
// in a dialog. We don't render the avatar until they choose.
BOOL isGenderChosen() const { return mGenderChosen; }
// utility to build a location string
void buildLocationString(std::string& str);
LLQuaternion getHeadRotation();
LLVOAvatar *getAvatarObject() const { return mAvatarObject; }
BOOL needsRenderAvatar(); // TRUE when camera mode is such that your own avatar should draw
// Not const because timers can't be accessed in const-fashion.
BOOL needsRenderHead();
BOOL cameraThirdPerson() const { return (mCameraMode == CAMERA_MODE_THIRD_PERSON && mLastCameraMode == CAMERA_MODE_THIRD_PERSON); }
BOOL cameraMouselook() const { return (mCameraMode == CAMERA_MODE_MOUSELOOK && mLastCameraMode == CAMERA_MODE_MOUSELOOK); }
BOOL cameraCustomizeAvatar() const { return (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR /*&& !mCameraAnimating*/); }
BOOL cameraFollow() const { return (mCameraMode == CAMERA_MODE_FOLLOW && mLastCameraMode == CAMERA_MODE_FOLLOW); }
LLVector3 getPosAgentFromGlobal(const LLVector3d &pos_global) const;
LLVector3d getPosGlobalFromAgent(const LLVector3 &pos_agent) const;
// Get the data members
const LLVector3& getAtAxis() const { return mFrameAgent.getAtAxis(); } // direction avatar is looking, not camera
const LLVector3& getUpAxis() const { return mFrameAgent.getUpAxis(); } // direction avatar is looking, not camera
const LLVector3& getLeftAxis() const { return mFrameAgent.getLeftAxis(); } // direction avatar is looking, not camera
LLCoordFrame getFrameAgent() const { return mFrameAgent; }
LLVector3 getVelocity() const;
F32 getVelocityZ() const { return getVelocity().mV[VZ]; } // a hack
const LLVector3d &getPositionGlobal() const;
const LLVector3 &getPositionAgent();
S32 getRegionsVisited() const;
F64 getDistanceTraveled() const;
const LLVector3d &getFocusGlobal() const { return mFocusGlobal; }
const LLVector3d &getFocusTargetGlobal() const { return mFocusTargetGlobal; }
BOOL getJump() const { return mbJump; }
BOOL getAutoPilot() const { return mAutoPilot; }
LLVector3d getAutoPilotTargetGlobal() const { return mAutoPilotTargetGlobal; }
LLQuaternion getQuat() const; // returns the quat that represents the rotation
// of the agent in the absolute frame
// BOOL getLookingAtAvatar() const;
void getName(std::string& name);
const LLColor4 &getEffectColor();
void setEffectColor(const LLColor4 &color);
// OGPX : Moving capabilities off region to agent service means they end up in LLAgent
// but, long term, this needs to be refactored into generalized Capabilities class
// since we want more flexibility in gathering up where services come from.
// Segmenting into region and agent domain caps might not make sense. Some implementations
// might want to provide caps that are not on the region or the agent domain. This is
// unsettled enough for now that we'll leave it as is.
void setCapability(const std::string& name, const std::string& url);
std::string getCapability(const std::string& name) const ;
//
// UTILITIES
//
// Set the physics data
void slamLookAt(const LLVector3 &look_at);
void setPositionAgent(const LLVector3 &center);
void resetAxes();
void resetAxes(const LLVector3 &look_at); // makes reasonable left and up
// Move the avatar's frame
void rotate(F32 angle, const LLVector3 &axis);
void rotate(F32 angle, F32 x, F32 y, F32 z);
void rotate(const LLMatrix3 &matrix);
void rotate(const LLQuaternion &quaternion);
void pitch(F32 angle);
void roll(F32 angle);
void yaw(F32 angle);
LLVector3 getReferenceUpVector();
F32 clampPitchToLimits(F32 angle);
void setThirdPersonHeadOffset(LLVector3 offset) { mThirdPersonHeadOffset = offset; }
// Flight management
BOOL getFlying() const { return mControlFlags & AGENT_CONTROL_FLY; }
void setFlying(BOOL fly);
void toggleFlying();
static BOOL getPhantom();
static void setPhantom(BOOL phantom);
static void togglePhantom();
static BOOL isTPosed() { return mForceTPose; }
static void setTPosed(BOOL TPose) { mForceTPose = TPose; }
static void toggleTPosed();
// Does this parcel allow you to fly?
BOOL canFly();
// Animation functions
void stopCurrentAnimations();
void requestStopMotion( LLMotion* motion );
void onAnimStop(const LLUUID& id);
void sendAnimationRequests(LLDynamicArray<LLUUID> &anim_ids, EAnimRequest request);
void sendAnimationRequest(const LLUUID &anim_id, EAnimRequest request);
LLVector3 calcFocusOffset(LLViewerObject *object, LLVector3 pos_agent, S32 x, S32 y);
BOOL calcCameraMinDistance(F32 &obj_min_distance);
void startCameraAnimation();
void stopCameraAnimation();
void cameraZoomIn(const F32 factor); // zoom in by fraction of current distance
void cameraOrbitAround(const F32 radians); // rotate camera CCW radians about build focus point
void cameraOrbitOver(const F32 radians); // rotate camera forward radians over build focus point
void cameraOrbitIn(const F32 meters); // move camera in toward build focus point
F32 getCameraZoomFraction(); // get camera zoom as fraction of minimum and maximum zoom
void setCameraZoomFraction(F32 fraction); // set camera zoom as fraction of minimum and maximum zoom
void cameraPanIn(const F32 meters);
void cameraPanLeft(const F32 meters);
void cameraPanUp(const F32 meters);
void updateFocusOffset();
void validateFocusObject();
void setUsingFollowCam( bool using_follow_cam);
F32 calcCustomizeAvatarUIOffset( const LLVector3d& camera_pos_global );
// marks current location as start, sends information to servers
void setStartPosition(U32 location_id);
// Movement from user input. All set the appropriate animation flags.
// All turn off autopilot and make sure the camera is behind the avatar.
// direction is either positive, zero, or negative
void moveAt(S32 direction, bool reset_view = true);
void moveAtNudge(S32 direction);
void moveLeft(S32 direction);
void moveLeftNudge(S32 direction);
void moveUp(S32 direction);
void moveYaw(F32 mag, bool reset_view = true);
void movePitch(S32 direction);
void setOrbitLeftKey(F32 mag) { mOrbitLeftKey = mag; }
void setOrbitRightKey(F32 mag) { mOrbitRightKey = mag; }
void setOrbitUpKey(F32 mag) { mOrbitUpKey = mag; }
void setOrbitDownKey(F32 mag) { mOrbitDownKey = mag; }
void setOrbitInKey(F32 mag) { mOrbitInKey = mag; }
void setOrbitOutKey(F32 mag) { mOrbitOutKey = mag; }
void setPanLeftKey(F32 mag) { mPanLeftKey = mag; }
void setPanRightKey(F32 mag) { mPanRightKey = mag; }
void setPanUpKey(F32 mag) { mPanUpKey = mag; }
void setPanDownKey(F32 mag) { mPanDownKey = mag; }
void setPanInKey(F32 mag) { mPanInKey = mag; }
void setPanOutKey(F32 mag) { mPanOutKey = mag; }
U32 getControlFlags();
void setControlFlags(U32 mask); // performs bitwise mControlFlags |= mask
void clearControlFlags(U32 mask); // performs bitwise mControlFlags &= ~mask
BOOL controlFlagsDirty() const;
void enableControlFlagReset();
void resetControlFlags();
void propagate(const F32 dt); // BUG: should roll into updateAgentPosition
void startAutoPilotGlobal(const LLVector3d &pos_global, const std::string& behavior_name = std::string(), const LLQuaternion *target_rotation = NULL,
void (*finish_callback)(BOOL, void *) = NULL, void *callback_data = NULL, F32 stop_distance = 0.f, F32 rotation_threshold = 0.03f);
void startFollowPilot(const LLUUID &leader_id);
void stopAutoPilot(BOOL user_cancel = FALSE);
void setAutoPilotGlobal(const LLVector3d &pos_global);
void autoPilot(F32 *delta_yaw); // autopilot walking action, angles in radians
void renderAutoPilotTarget();
//
// teportation methods
//
// go to a named location home
void teleportRequest(
const U64& region_handle,
const LLVector3& pos_local,
bool look_at_from_camera = false);
// teleport to a landmark
void teleportViaLandmark(const LLUUID& landmark_id);
// go home
void teleportHome() { teleportViaLandmark(LLUUID::null); }
// to an invited location
void teleportViaLure(const LLUUID& lure_id, BOOL godlike);
// to a global location - this will probably need to be
// deprecated.
void teleportViaLocation(const LLVector3d& pos_global);
// to a global location, preserving camera rotation
void teleportViaLocationLookAt(const LLVector3d& pos_global);
// cancel the teleport, may or may not be allowed by server
void teleportCancel();
void setTargetVelocity(const LLVector3 &vel);
const LLVector3 &getTargetVelocity() const;
const std::string getTeleportSourceSLURL() const { return mTeleportSourceSLURL; }
// OGPX : setTeleportSourceURL() is only used in agent domain case,
// so also made function name go from SLURL->URL for OGPX.
// This is what gets chatted into text chat when a teleport successfully completes.
void setTeleportSourceURL(const std::string agentdTeleportURL){ mTeleportSourceSLURL = agentdTeleportURL;};
// Setting the ability for this avatar to proxy for another avatar.
//static void processAddModifyAbility(LLMessageSystem* msg, void**);
//static void processGrantedProxies(LLMessageSystem* msg, void**);
//static void processRemoveModifyAbility(LLMessageSystem* msg, void**);
//BOOL isProxyFor(const LLUUID& agent_id);// *FIX should be const
static void processAgentDataUpdate(LLMessageSystem *msg, void **);
static void processAgentGroupDataUpdate(LLMessageSystem *msg, void **);
static void processAgentDropGroup(LLMessageSystem *msg, void **);
static void processScriptControlChange(LLMessageSystem *msg, void **);
static void processAgentCachedTextureResponse(LLMessageSystem *mesgsys, void **user_data);
//static void processControlTake(LLMessageSystem *msg, void **);
//static void processControlRelease(LLMessageSystem *msg, void **);
// This method checks to see if this agent can modify an object
// based on the permissions and the agent's proxy status.
BOOL isGrantedProxy(const LLPermissions& perm);
BOOL allowOperation(PermissionBit op,
const LLPermissions& perm,
U64 group_proxy_power = 0,
U8 god_minimum = GOD_MAINTENANCE);
friend std::ostream& operator<<(std::ostream &s, const LLAgent &sphere);
void initOriginGlobal(const LLVector3d &origin_global); // Only to be used in ONE place! - djs 08/07/02
BOOL leftButtonGrabbed() const { return ( (!cameraMouselook() && mControlsTakenCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
||(cameraMouselook() && mControlsTakenCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)
||(!cameraMouselook() && mControlsTakenPassedOnCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
||(cameraMouselook() && mControlsTakenPassedOnCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)); }
BOOL rotateGrabbed() const { return ( (mControlsTakenCount[CONTROL_YAW_POS_INDEX] > 0)
||(mControlsTakenCount[CONTROL_YAW_NEG_INDEX] > 0)); }
BOOL forwardGrabbed() const { return ( (mControlsTakenCount[CONTROL_AT_POS_INDEX] > 0)); }
BOOL backwardGrabbed() const { return ( (mControlsTakenCount[CONTROL_AT_NEG_INDEX] > 0)); }
BOOL upGrabbed() const { return ( (mControlsTakenCount[CONTROL_UP_POS_INDEX] > 0)); }
BOOL downGrabbed() const { return ( (mControlsTakenCount[CONTROL_UP_NEG_INDEX] > 0)); }
// True iff a script has taken over a control.
BOOL anyControlGrabbed() const;
BOOL isControlGrabbed(S32 control_index) const;
// Send message to simulator to force grabbed controls to be
// released, in case of a poorly written script.
void forceReleaseControls();
BOOL sitCameraEnabled() { return mSitCameraEnabled; }
F32 getCurrentCameraBuildOffset() { return (F32)mCameraFocusOffset.length(); }
// look at behavior
BOOL setLookAt(ELookAtType target_type, LLViewerObject *object = NULL, LLVector3 position = LLVector3::zero);
ELookAtType getLookAtType();
// point at behavior
BOOL setPointAt(EPointAtType target_type, LLViewerObject *object = NULL, LLVector3 position = LLVector3::zero);
EPointAtType getPointAtType();
void setHomePosRegion( const U64& region_handle, const LLVector3& pos_region );
BOOL getHomePosGlobal( LLVector3d* pos_global );
void setCameraAnimating( BOOL b ) { mCameraAnimating = b; }
BOOL getCameraAnimating( ) { return mCameraAnimating; }
void setAnimationDuration( F32 seconds ) { mAnimationDuration = seconds; }
F32 getNearChatRadius() { return mNearChatRadius; }
enum EDoubleTapRunMode
{
DOUBLETAP_NONE,
DOUBLETAP_FORWARD,
DOUBLETAP_BACKWARD,
DOUBLETAP_SLIDELEFT,
DOUBLETAP_SLIDERIGHT
};
enum ETeleportState
{
TELEPORT_NONE = 0, // No teleport in progress
TELEPORT_START = 1, // Transition to REQUESTED. Viewer has sent a TeleportRequest to the source simulator
TELEPORT_REQUESTED = 2, // Waiting for source simulator to respond
TELEPORT_MOVING = 3, // Viewer has received destination location from source simulator
TELEPORT_START_ARRIVAL = 4, // Transition to ARRIVING. Viewer has received avatar update, etc., from destination simulator
TELEPORT_ARRIVING = 5, // Make the user wait while content "pre-caches"
TELEPORT_LOCAL = 6, // Teleporting in-sim without showing the progress screen
TELEPORT_PLACE_AVATAR = 7 // OGPX : Separate agent domain TP using place_avatar from legacy
};
ETeleportState getTeleportState() const { return mTeleportState; }
void setTeleportState( ETeleportState state );
const std::string& getTeleportMessage() const { return mTeleportMessage; }
void setTeleportMessage(const std::string& message)
{
mTeleportMessage = message;
}
// trigger random fidget animations
void fidget();
void requestEnterGodMode();
void requestLeaveGodMode();
void sendAgentSetAppearance();
void sendAgentDataUpdateRequest();
// Ventrella
LLFollowCam mFollowCam;
// end Ventrella
//--------------------------------------------------------------------
// Wearables
//--------------------------------------------------------------------
void setWearable( LLInventoryItem* new_item, LLWearable* wearable );
static bool onSetWearableDialog( const LLSD& notification, const LLSD& response, LLWearable* wearable );
void setWearableFinal( LLInventoryItem* new_item, LLWearable* new_wearable );
void setWearableOutfit( const LLInventoryItem::item_array_t& items, const LLDynamicArray< LLWearable* >& wearables, BOOL remove );
void queryWearableCache();
BOOL isWearableModifiable(EWearableType type);
BOOL isWearableCopyable(EWearableType type);
BOOL needsReplacement(EWearableType wearableType, S32 remove);
U32 getWearablePermMask(EWearableType type);
LLInventoryItem* getWearableInventoryItem(EWearableType type);
LLWearable* getWearable( EWearableType type ) { return (type < WT_COUNT) ? mWearableEntry[ type ].mWearable : NULL; }
BOOL isWearingItem( const LLUUID& item_id );
LLWearable* getWearableFromWearableItem( const LLUUID& item_id );
const LLUUID& getWearableItem( EWearableType type ) { return (type < WT_COUNT) ? mWearableEntry[ type ].mItemID : LLUUID::null; }
static EWearableType getTEWearableType( S32 te );
static LLUUID getDefaultTEImageID( S32 te );
void copyWearableToInventory( EWearableType type );
void makeNewOutfit(
const std::string& new_folder_name,
const LLDynamicArray<S32>& wearables_to_include,
const LLDynamicArray<S32>& attachments_to_include,
BOOL rename_clothing);
void makeNewOutfitDone(S32 index);
void removeWearable( EWearableType type );
static bool onRemoveWearableDialog(const LLSD& notification, const LLSD& response );
void removeWearableFinal( EWearableType type );
void sendAgentWearablesUpdate();
/**
* @brief Only public because of addWearableToAgentInventoryCallback.
*
* NOTE: Do not call this method unless you are the inventory callback.
* NOTE: This can suffer from race conditions when working on the
* same values for index.
* @param index The index in mWearableEntry.
* @param item_id The inventory item id of the new wearable to wear.
* @param wearable The actual wearable data.
*/
void addWearabletoAgentInventoryDone(
S32 index,
const LLUUID& item_id,
LLWearable* wearable);
void saveWearableAs( EWearableType type, const std::string& new_name, BOOL save_in_lost_and_found );
void saveWearable( EWearableType type, BOOL send_update = TRUE );
void saveAllWearables();
void revertWearable( EWearableType type );
void revertAllWearables();
void setWearableName( const LLUUID& item_id, const std::string& new_name );
void createStandardWearables(BOOL female);
void createStandardWearablesDone(S32 index);
void createStandardWearablesAllDone();
BOOL areWearablesLoaded() { return mWearablesLoaded; }
void sendWalkRun(bool running);
void observeFriends();
void friendsChanged();
// statics
static void stopFidget();
static void processAgentInitialWearablesUpdate(LLMessageSystem* mesgsys, void** user_data);
static void userRemoveWearable( void* userdata ); // userdata is EWearableType
static void userRemoveAllClothes( void* userdata ); // userdata is NULL
static void userRemoveAllClothesStep2(BOOL proceed, void* userdata ); // userdata is NULL
static void userRemoveAllAttachments( void* userdata); // userdata is NULL
static BOOL selfHasWearable( void* userdata ); // userdata is EWearableType
//debug methods
static void clearVisualParams(void *);
// whether look-at reset after teleport
bool getTeleportKeepsLookAt() { return mbTeleportKeepsLookAt; }
// stuff to do for any sort of teleport. Returns true if the
// teleport can proceed.
bool teleportCore(bool is_local = false); //OGPX : now public method so agent domain TP can call
protected:
// helper function to prematurely age chat when agent is moving
void ageChat();
// internal wearable functions
void sendAgentWearablesRequest();
static void onInitialWearableAssetArrived(LLWearable* wearable, void* userdata);
void recoverMissingWearable(EWearableType type);
void recoverMissingWearableDone();
void addWearableToAgentInventory(LLPointer<LLInventoryCallback> cb,
LLWearable* wearable, const LLUUID& category_id = LLUUID::null,
BOOL notify = TRUE);
public:
// TODO: Make these private!
LLUUID mSecureSessionID; // secure token for this login session
F32 mDrawDistance;
U64 mGroupPowers;
BOOL mHideGroupTitle;
std::string mGroupTitle; // honorific, like "Sir"
std::string mGroupName;
LLUUID mGroupID;
//LLUUID mGroupInsigniaID;
LLUUID mInventoryRootID;
LLUUID mMapID;
F64 mMapOriginX; // Global x coord of mMapID's bottom left corner.
F64 mMapOriginY; // Global y coord of mMapID's bottom left corner.
S32 mMapWidth; // Width of map in meters
S32 mMapHeight; // Height of map in meters
std::string mMOTD; // message of the day
LLPointer<LLHUDEffectLookAt> mLookAt;
LLPointer<LLHUDEffectPointAt> mPointAt;
LLDynamicArray<LLGroupData> mGroups;
F32 mHUDTargetZoom; // target zoom level for HUD objects (used when editing)
F32 mHUDCurZoom; // current animated zoom level for HUD objects
BOOL mInitialized;
// <edit>
static BOOL lure_show;
static std::string lure_name;
static LLVector3d lure_posglobal;
static U16 lure_global_x;
static U16 lure_global_y;
static int lure_x;
static int lure_y;
static int lure_z;
static std::string lure_maturity;
static LLVector3 exlStartMeasurePoint;
static LLVector3 exlEndMeasurePoint;
// </edit>
S32 mNumPendingQueries;
S32* mActiveCacheQueries;
BOOL mForceMouselook;
static void parseTeleportMessages(const std::string& xml_filename);
//we should really define ERROR and PROGRESS enums here
//but I don't really feel like doing that, so I am just going
//to expose the mappings....yup
static std::map<std::string, std::string> sTeleportErrorMessages;
static std::map<std::string, std::string> sTeleportProgressMessages;
LLFrameTimer mDoubleTapRunTimer;
EDoubleTapRunMode mDoubleTapRunMode;
// <edit>
static void showLureDestination(const std::string fromname, const int global_x, const int global_y, const int x, const int y, const int z, const std::string maturity);
static void onFoundLureDestination();
// </edit>
private:
static BOOL exlPhantom;
static BOOL mForceTPose;
bool mbTeleportKeepsLookAt; // try to keep look-at after teleport is complete
bool mbAlwaysRun; // should the avatar run by default rather than walk
bool mbRunning; // is the avatar trying to run right now
LLAgentAccess mAgentAccess;
ETeleportState mTeleportState;
std::string mTeleportMessage;
S32 mControlsTakenCount[TOTAL_CONTROLS];
S32 mControlsTakenPassedOnCount[TOTAL_CONTROLS];
LLViewerRegion *mRegionp;
LLVector3d mAgentOriginGlobal; // Origin of agent coords from global coords
mutable LLVector3d mPositionGlobal;
std::string mTeleportSourceSLURL; // SLURL where last TP began.
std::set<U64> mRegionsVisited; // stat - what distinct regions has the avatar been to?
F64 mDistanceTraveled; // stat - how far has the avatar moved?
LLVector3d mLastPositionGlobal; // Used to calculate travel distance
LLPointer<LLVOAvatar> mAvatarObject; // NULL until avatar object sent down from simulator
U8 mRenderState; // Current behavior state of agent
LLFrameTimer mTypingTimer;
ECameraMode mCameraMode; // target mode after transition animation is done
ECameraMode mLastCameraMode;
BOOL mViewsPushed; // keep track of whether or not we have pushed views.
BOOL mCustomAnim ; //current animation is ANIM_AGENT_CUSTOMIZE ?
BOOL mShowAvatar; // should we render the avatar?
BOOL mCameraAnimating; // camera is transitioning from one mode to another
LLVector3d mAnimationCameraStartGlobal; // camera start position, global coords
LLVector3d mAnimationFocusStartGlobal; // camera focus point, global coords
LLFrameTimer mAnimationTimer; // seconds that transition animation has been active
F32 mAnimationDuration; // seconds
F32 mCameraFOVZoomFactor; // amount of fov zoom applied to camera when zeroing in on an object
F32 mCameraCurrentFOVZoomFactor; // interpolated fov zoom
F32 mCameraFOVDefault; // default field of view that is basis for FOV zoom effect
LLVector3d mCameraFocusOffset; // offset from focus point in build mode
LLVector3d mCameraFocusOffsetTarget; // target towards which we are lerping the camera's focus offset
LLVector3 mCameraOffsetDefault; // default third-person camera offset
LLVector4 mCameraCollidePlane; // colliding plane for camera
F32 mCurrentCameraDistance; // current camera offset from avatar
F32 mTargetCameraDistance; // target camera offset from avatar
F32 mCameraZoomFraction; // mousewheel driven fraction of zoom
LLVector3 mCameraLag; // third person camera lag
LLVector3 mThirdPersonHeadOffset; // head offset for third person camera position
LLVector3 mCameraPositionAgent; // camera position in agent coordinates
LLVector3 mCameraVirtualPositionAgent; // camera virtual position (target) before performing FOV zoom
BOOL mSitCameraEnabled; // use provided camera information when sitting?
LLVector3 mSitCameraPos; // root relative camera pos when sitting
LLVector3 mSitCameraFocus; // root relative camera target when sitting
LLVector3d mCameraSmoothingLastPositionGlobal;
LLVector3d mCameraSmoothingLastPositionAgent;
BOOL mCameraSmoothingStop;
LLVector3 mCameraUpVector; // camera's up direction in world coordinates (determines the 'roll' of the view)
LLPointer<LLViewerObject> mSitCameraReferenceObject; // object to which camera is related when sitting
BOOL mFocusOnAvatar;
LLVector3d mFocusGlobal;
LLVector3d mFocusTargetGlobal;
LLPointer<LLViewerObject> mFocusObject;
F32 mFocusObjectDist;
LLVector3 mFocusObjectOffset;
F32 mFocusDotRadius; // meters
BOOL mTrackFocusObject;
F32 mUIOffset;
LLCoordFrame mFrameAgent; // Agent position and view, agent-region coordinates
BOOL mIsBusy;
S32 mAtKey; // Either 1, 0, or -1... indicates that movement-key is pressed
S32 mWalkKey; // like AtKey, but causes less forward thrust
S32 mLeftKey;
S32 mUpKey;
F32 mYawKey;
S32 mPitchKey;
F32 mOrbitLeftKey;
F32 mOrbitRightKey;
F32 mOrbitUpKey;
F32 mOrbitDownKey;
F32 mOrbitInKey;
F32 mOrbitOutKey;
F32 mPanUpKey;
F32 mPanDownKey;
F32 mPanLeftKey;
F32 mPanRightKey;
F32 mPanInKey;
F32 mPanOutKey;
U32 mControlFlags; // replacement for the mFooKey's
BOOL mbFlagsDirty;
BOOL mbFlagsNeedReset; // HACK for preventing incorrect flags sent when crossing region boundaries
BOOL mbJump;
BOOL mAutoPilot;
BOOL mAutoPilotFlyOnStop;
LLVector3d mAutoPilotTargetGlobal;
F32 mAutoPilotStopDistance;
BOOL mAutoPilotUseRotation;
LLVector3 mAutoPilotTargetFacing;
F32 mAutoPilotTargetDist;
S32 mAutoPilotNoProgressFrameCount;
F32 mAutoPilotRotationThreshold;
std::string mAutoPilotBehaviorName;
void (*mAutoPilotFinishedCallback)(BOOL, void *);
void* mAutoPilotCallbackData;
LLUUID mLeaderID;
std::set<LLUUID> mProxyForAgents;
//
typedef std::map<std::string, std::string> CapabilityMap; //OGPX TODO: refactor Caps to their own class
CapabilityMap mCapabilities; // for caps that we have on the agent domain.
LLColor4 mEffectColor;
BOOL mHaveHomePosition;
U64 mHomeRegionHandle;
LLVector3 mHomePosRegion;
LLFrameTimer mChatTimer;
LLUUID mLastChatterID;
F32 mNearChatRadius;
LLFrameTimer mFidgetTimer;
LLFrameTimer mFocusObjectFadeTimer;
F32 mNextFidgetTime;
S32 mCurrentFidget;
BOOL mFirstLogin;
BOOL mGenderChosen;
//--------------------------------------------------------------------
// Wearables
//--------------------------------------------------------------------
struct LLWearableEntry
{
LLWearableEntry() : mItemID( LLUUID::null ), mWearable( NULL ) {}
LLUUID mItemID; // ID of the inventory item in the agent's inventory.
LLWearable* mWearable;
};
LLWearableEntry mWearableEntry[ WT_COUNT ];
U32 mAgentWearablesUpdateSerialNum;
BOOL mWearablesLoaded;
S32 mTextureCacheQueryID;
U32 mAppearanceSerialNum;
LLAnimPauseRequest mPauseRequest;
class createStandardWearablesAllDoneCallback : public LLRefCount
{
protected:
~createStandardWearablesAllDoneCallback();
};
class sendAgentWearablesUpdateCallback : public LLRefCount
{
protected:
~sendAgentWearablesUpdateCallback();
};
class addWearableToAgentInventoryCallback : public LLInventoryCallback
{
public:
enum {
CALL_NONE = 0,
CALL_UPDATE = 1,
CALL_RECOVERDONE = 2,
CALL_CREATESTANDARDDONE = 4,
CALL_MAKENEWOUTFITDONE = 8
} EType;
/**
* @brief Construct a callback for dealing with the wearables.
*
* Would like to pass the agent in here, but we can't safely
* count on it being around later. Just use gAgent directly.
* @param cb callback to execute on completion (??? unused ???)
* @param index Index for the wearable in the agent
* @param wearable The wearable data.
* @param todo Bitmask of actions to take on completion.
*/
addWearableToAgentInventoryCallback(
LLPointer<LLRefCount> cb,
S32 index,
LLWearable* wearable,
U32 todo = CALL_NONE);
virtual void fire(const LLUUID& inv_item);
private:
S32 mIndex;
LLWearable* mWearable;
U32 mTodo;
LLPointer<LLRefCount> mCB;
};
LLFriendObserver* mFriendObserver;
};
extern LLAgent gAgent;
// <edit>
extern LLUUID gReSitTargetID;
extern LLVector3 gReSitOffset;
// </edit>
#endif
Reference in New Issue View Git Blame Copy Permalink