15 #ifndef hifi_MyAvatar_h
16 #define hifi_MyAvatar_h
21 #include <glm/glm.hpp>
25 #include <AvatarConstants.h>
26 #include <avatars-renderer/Avatar.h>
27 #include <avatars-renderer/ScriptAvatar.h>
28 #include <controllers/Pose.h>
29 #include <controllers/Actions.h>
30 #include <EntityItem.h>
31 #include <HelperScriptEngine.h>
32 #include <ThreadSafeValueCache.h>
34 #include <SettingHandle.h>
36 #include <shared/Camera.h>
37 #include <ScriptValue.h>
39 #include "AtRestDetector.h"
40 #include "MyCharacterController.h"
41 #include "RingBufferHistory.h"
43 class AvatarActionHold;
46 class DetailedMotionState;
48 using ScriptEnginePointer = std::shared_ptr<ScriptEngine>;
67 enum LocomotionControlsMode {
73 enum LocomotionRelativeMovementMode {
74 MOVEMENT_HMD_RELATIVE = 0,
75 MOVEMENT_HAND_RELATIVE,
76 MOVEMENT_HAND_RELATIVE_LEVELED
79 enum eyeContactTarget {
85 enum AudioListenerMode {
91 Q_DECLARE_METATYPE(AudioListenerMode);
93 class MyAvatar :
public Avatar {
95 friend class AnimStats;
364 Q_PROPERTY(QVector3D qmlPosition READ getQmlPosition)
365 QVector3D getQmlPosition() {
auto p = getWorldPosition();
return QVector3D(p.x, p.y, p.z); }
367 Q_PROPERTY(glm::vec3 feetPosition READ getWorldFeetPosition WRITE goToFeetLocation)
368 Q_PROPERTY(
bool shouldRenderLocally READ getShouldRenderLocally WRITE setShouldRenderLocally)
369 Q_PROPERTY(glm::vec3 motorVelocity READ getScriptedMotorVelocity WRITE setScriptedMotorVelocity)
370 Q_PROPERTY(
float motorTimescale READ getScriptedMotorTimescale WRITE setScriptedMotorTimescale)
371 Q_PROPERTY(QString motorReferenceFrame READ getScriptedMotorFrame WRITE setScriptedMotorFrame)
372 Q_PROPERTY(QString motorMode READ getScriptedMotorMode WRITE setScriptedMotorMode)
373 Q_PROPERTY(QString collisionSoundURL READ getCollisionSoundURL WRITE setCollisionSoundURL)
374 Q_PROPERTY(AudioListenerMode audioListenerMode READ getAudioListenerMode WRITE setAudioListenerMode)
375 Q_PROPERTY(AudioListenerMode audioListenerModeHead READ getAudioListenerModeHead)
376 Q_PROPERTY(AudioListenerMode audioListenerModeCamera READ getAudioListenerModeCamera)
377 Q_PROPERTY(AudioListenerMode audioListenerModeCustom READ getAudioListenerModeCustom)
378 Q_PROPERTY(glm::vec3 customListenPosition READ getCustomListenPosition WRITE setCustomListenPosition)
379 Q_PROPERTY(glm::quat customListenOrientation READ getCustomListenOrientation WRITE setCustomListenOrientation)
380 Q_PROPERTY(
float rotationRecenterFilterLength READ getRotationRecenterFilterLength WRITE setRotationRecenterFilterLength)
381 Q_PROPERTY(
float rotationThreshold READ getRotationThreshold WRITE setRotationThreshold)
382 Q_PROPERTY(
bool enableStepResetRotation READ getEnableStepResetRotation WRITE setEnableStepResetRotation)
383 Q_PROPERTY(
bool enableDrawAverageFacing READ getEnableDrawAverageFacing WRITE setEnableDrawAverageFacing)
386 Q_PROPERTY(glm::vec3 leftHandPosition READ getLeftHandPosition)
387 Q_PROPERTY(glm::vec3 rightHandPosition READ getRightHandPosition)
388 Q_PROPERTY(glm::vec3 leftHandTipPosition READ getLeftHandTipPosition)
389 Q_PROPERTY(glm::vec3 rightHandTipPosition READ getRightHandTipPosition)
391 Q_PROPERTY(controller::Pose leftHandPose READ getLeftHandPose)
392 Q_PROPERTY(controller::Pose rightHandPose READ getRightHandPose)
393 Q_PROPERTY(controller::Pose leftHandTipPose READ getLeftHandTipPose)
394 Q_PROPERTY(controller::Pose rightHandTipPose READ getRightHandTipPose)
396 Q_PROPERTY(
float energy READ getEnergy WRITE setEnergy)
397 Q_PROPERTY(
bool isAway READ getIsAway WRITE setAway)
399 Q_PROPERTY(
bool centerOfGravityModelEnabled READ getCenterOfGravityModelEnabled WRITE setCenterOfGravityModelEnabled)
400 Q_PROPERTY(
bool hmdLeanRecenterEnabled READ getHMDLeanRecenterEnabled WRITE setHMDLeanRecenterEnabled)
401 Q_PROPERTY(
bool collisionsEnabled READ getCollisionsEnabled WRITE setCollisionsEnabled)
402 Q_PROPERTY(
bool otherAvatarsCollisionsEnabled READ getOtherAvatarsCollisionsEnabled WRITE setOtherAvatarsCollisionsEnabled)
403 Q_PROPERTY(
bool characterControllerEnabled READ getCharacterControllerEnabled WRITE setCharacterControllerEnabled)
404 Q_PROPERTY(
bool useAdvancedMovementControls READ useAdvancedMovementControls WRITE setUseAdvancedMovementControls)
405 Q_PROPERTY(
bool showPlayArea READ getShowPlayArea WRITE setShowPlayArea)
407 Q_PROPERTY(
float yawSpeed MEMBER _yawSpeed)
408 Q_PROPERTY(
float hmdYawSpeed MEMBER _hmdYawSpeed)
409 Q_PROPERTY(
float pitchSpeed MEMBER _pitchSpeed)
411 Q_PROPERTY(
bool hmdRollControlEnabled READ getHMDRollControlEnabled WRITE setHMDRollControlEnabled)
412 Q_PROPERTY(
float hmdRollControlDeadZone READ getHMDRollControlDeadZone WRITE setHMDRollControlDeadZone)
413 Q_PROPERTY(
float hmdRollControlRate READ getHMDRollControlRate WRITE setHMDRollControlRate)
415 Q_PROPERTY(
float userHeight READ getUserHeight WRITE setUserHeight)
416 Q_PROPERTY(
float userEyeHeight READ getUserEyeHeight)
418 Q_PROPERTY(QUuid SELF_ID READ getSelfID CONSTANT)
420 Q_PROPERTY(
float walkSpeed READ getWalkSpeed WRITE setWalkSpeed);
421 Q_PROPERTY(
float analogPlusWalkSpeed READ getAnalogPlusWalkSpeed WRITE setAnalogPlusWalkSpeed NOTIFY analogPlusWalkSpeedChanged);
422 Q_PROPERTY(
float analogPlusSprintSpeed READ getAnalogPlusSprintSpeed WRITE setAnalogPlusSprintSpeed NOTIFY analogPlusSprintSpeedChanged);
423 Q_PROPERTY(
float walkBackwardSpeed READ getWalkBackwardSpeed WRITE setWalkBackwardSpeed NOTIFY walkBackwardSpeedChanged);
424 Q_PROPERTY(
float sprintSpeed READ getSprintSpeed WRITE setSprintSpeed NOTIFY sprintSpeedChanged);
425 Q_PROPERTY(
bool isInSittingState READ getIsInSittingState WRITE setIsInSittingState);
426 Q_PROPERTY(MyAvatar::SitStandModelType userRecenterModel READ getUserRecenterModel WRITE setUserRecenterModel);
427 Q_PROPERTY(
bool isSitStandStateLocked READ getIsSitStandStateLocked WRITE setIsSitStandStateLocked);
428 Q_PROPERTY(
bool allowTeleporting READ getAllowTeleporting)
430 const QString DOMINANT_LEFT_HAND =
"left";
431 const QString DOMINANT_RIGHT_HAND =
"right";
432 const QString DEFAULT_HMD_AVATAR_ALIGNMENT_TYPE =
"head";
434 using Clock = std::chrono::system_clock;
435 using TimePoint = Clock::time_point;
437 const float DEFAULT_GEAR_1 = 0.2f;
438 const float DEFAULT_GEAR_2 = 0.4f;
439 const float DEFAULT_GEAR_3 = 0.8f;
440 const float DEFAULT_GEAR_4 = 0.9f;
441 const float DEFAULT_GEAR_5 = 1.0f;
443 const bool DEFAULT_STRAFE_ENABLED =
true;
554 enum SitStandModelType {
561 Q_ENUM(SitStandModelType)
564 enum class AllowAvatarStandingPreference : uint {
570 Q_ENUM(AllowAvatarStandingPreference)
573 enum class AllowAvatarLeaningPreference : uint {
579 Default = WhenUserIsStanding
581 Q_ENUM(AllowAvatarLeaningPreference)
583 static const std::array<QString, (uint)AllowAvatarStandingPreference::Count> allowAvatarStandingPreferenceStrings;
584 static const std::array<QString, (uint)AllowAvatarLeaningPreference::Count> allowAvatarLeaningPreferenceStrings;
586 explicit MyAvatar(QThread* thread);
589 void instantiableAvatar()
override {};
590 static void registerMetaTypes(ScriptEnginePointer engine);
591 void registerProperties(ScriptEnginePointer engine);
593 virtual void simulateAttachments(
float deltaTime)
override;
595 AudioListenerMode getAudioListenerModeHead()
const {
return FROM_HEAD; }
596 AudioListenerMode getAudioListenerModeCamera()
const {
return FROM_CAMERA; }
597 AudioListenerMode getAudioListenerModeCustom()
const {
return CUSTOM; }
599 void reset(
bool andRecenter =
false,
bool andReload =
true,
bool andHead =
true);
601 void setCollisionWithOtherAvatarsFlags()
override;
607 Q_INVOKABLE
void resetSensorsAndBody();
614 Q_INVOKABLE
void centerBody();
623 Q_INVOKABLE
void clearIKJointLimitHistory();
625 void update(
float deltaTime);
626 virtual void postUpdate(
float deltaTime,
const render::ScenePointer& scene)
override;
627 void preDisplaySide(
const RenderArgs* renderArgs);
629 const glm::mat4& getHMDSensorMatrix()
const {
return _hmdSensorMatrix; }
630 const glm::vec3& getHMDSensorPosition()
const {
return _hmdSensorPosition; }
631 const glm::quat& getHMDSensorOrientation()
const {
return _hmdSensorOrientation; }
638 Q_INVOKABLE
void setOrientationVar(
const QVariant& newOrientationVar);
645 Q_INVOKABLE QVariant getOrientationVar()
const;
648 glm::quat getOrientationOutbound()
const override;
653 void updateFromHMDSensorMatrix(
const glm::mat4& hmdSensorMatrix);
656 glm::vec2 computeHandAzimuth()
const;
659 void updateJointFromController(controller::Action poseKey, ThreadSafeValueCache<glm::mat4>& matrixCache);
664 void updateSensorToWorldMatrix();
666 void setRealWorldFieldOfView(
float realWorldFov) { _realWorldFieldOfView.set(realWorldFov); }
678 Q_INVOKABLE glm::vec3 getDefaultEyePosition()
const;
680 float getRealWorldFieldOfView() {
return _realWorldFieldOfView.get(); }
710 Q_INVOKABLE
void overrideAnimation(
const QString& url,
float fps,
bool loop,
float firstFrame,
float lastFrame);
732 Q_INVOKABLE
void overrideHandAnimation(
bool isLeft,
const QString& url,
float fps,
bool loop,
float firstFrame,
float lastFrame);
749 Q_INVOKABLE
void restoreAnimation();
766 Q_INVOKABLE
void restoreHandAnimation(
bool isLeft);
784 Q_INVOKABLE QStringList getAnimationRoles();
824 Q_INVOKABLE
void overrideRoleAnimation(
const QString& role,
const QString& url,
float fps,
bool loop,
float firstFrame,
float lastFrame);
839 Q_INVOKABLE
void restoreRoleAnimation(
const QString& role);
880 Q_INVOKABLE
ScriptValue addAnimationStateHandler(
const ScriptValue& handler,
const ScriptValue& propertiesList) {
return _skeletonModel->getRig().addAnimationStateHandler(handler, propertiesList); }
888 Q_INVOKABLE
void removeAnimationStateHandler(
const ScriptValue& handler) { _skeletonModel->getRig().removeAnimationStateHandler(handler); }
897 Q_INVOKABLE
bool getSnapTurn()
const {
return _useSnapTurn; }
904 Q_INVOKABLE
void setSnapTurn(
bool on) { _useSnapTurn = on; }
911 Q_INVOKABLE
int getControlScheme()
const {
return _controlSchemeIndex; }
918 Q_INVOKABLE
void setControlScheme(
int index) { _controlSchemeIndex = (index >= 0 && index <= 2) ? index : 0; }
927 Q_INVOKABLE
bool hoverWhenUnsupported()
const {
return _hoverWhenUnsupported; }
935 Q_INVOKABLE
void setHoverWhenUnsupported(
bool on) { _hoverWhenUnsupported = on; }
943 Q_INVOKABLE
void setDominantHand(
const QString& hand);
950 Q_INVOKABLE QString getDominantHand()
const;
957 Q_INVOKABLE
void setStrafeEnabled(
bool enabled);
964 Q_INVOKABLE
bool getStrafeEnabled()
const;
972 Q_INVOKABLE
void setHmdAvatarAlignmentType(
const QString& type);
980 Q_INVOKABLE QString getHmdAvatarAlignmentType()
const;
988 Q_INVOKABLE
void setCenterOfGravityModelEnabled(
bool value) { _centerOfGravityModelEnabled = value; }
996 Q_INVOKABLE
bool getCenterOfGravityModelEnabled()
const {
return _centerOfGravityModelEnabled; }
1006 Q_INVOKABLE
void setHMDLeanRecenterEnabled(
bool value) { _hmdLeanRecenterEnabled = value; }
1014 Q_INVOKABLE
bool getHMDLeanRecenterEnabled()
const {
return _hmdLeanRecenterEnabled; }
1023 Q_INVOKABLE
void requestEnableHandTouch();
1032 Q_INVOKABLE
void requestDisableHandTouch();
1041 Q_INVOKABLE
void disableHandTouchForID(
const QUuid& entityID);
1050 Q_INVOKABLE
void enableHandTouchForID(
const QUuid& entityID);
1052 bool useAdvancedMovementControls()
const {
return _useAdvancedMovementControls.get(); }
1053 void setUseAdvancedMovementControls(
bool useAdvancedMovementControls)
1054 { _useAdvancedMovementControls.set(useAdvancedMovementControls); }
1056 bool getAllowTeleporting() {
return _allowTeleportingSetting.get(); }
1057 void setAllowTeleporting(
bool allowTeleporting) { _allowTeleportingSetting.set(allowTeleporting); }
1059 bool getShowPlayArea()
const {
return _showPlayArea.get(); }
1060 void setShowPlayArea(
bool showPlayArea) { _showPlayArea.set(showPlayArea); }
1062 void setHMDRollControlEnabled(
bool value) { _hmdRollControlEnabled = value; }
1063 bool getHMDRollControlEnabled()
const {
return _hmdRollControlEnabled; }
1064 void setHMDRollControlDeadZone(
float value) { _hmdRollControlDeadZone = value; }
1065 float getHMDRollControlDeadZone()
const {
return _hmdRollControlDeadZone; }
1066 void setHMDRollControlRate(
float value) { _hmdRollControlRate = value; }
1067 float getHMDRollControlRate()
const {
return _hmdRollControlRate; }
1070 void resizeAvatarEntitySettingHandles(uint32_t maxIndex);
1072 void saveAvatarEntityDataToSettings();
1074 void loadAvatarEntityDataFromSettings();
1076 void saveAttachmentData(
const AttachmentData& attachment)
const;
1077 AttachmentData loadAttachmentData(
const QUrl& modelURL,
const QString& jointName = QString())
const;
1080 void clearDriveKeys();
1081 void setDriveKey(DriveKeys key,
float val);
1082 void setSprintMode(
bool sprint);
1083 float getDriveKey(DriveKeys key)
const;
1091 Q_INVOKABLE
float getRawDriveKey(DriveKeys key)
const;
1093 void relayDriveKeysToCharacterController();
1107 Q_INVOKABLE
void disableDriveKey(DriveKeys key);
1115 Q_INVOKABLE
void enableDriveKey(DriveKeys key);
1123 Q_INVOKABLE
bool isDriveKeyDisabled(DriveKeys key)
const;
1131 Q_INVOKABLE
void triggerVerticalRecenter();
1138 Q_INVOKABLE
void triggerHorizontalRecenter();
1144 Q_INVOKABLE
void triggerRotationRecenter();
1152 Q_INVOKABLE
bool isRecenteringHorizontally()
const;
1154 eyeContactTarget getEyeContactTarget();
1156 const MyHead* getMyHead()
const;
1165 Q_INVOKABLE glm::vec3 getHeadPosition()
const {
return getHead()->getPosition(); }
1172 Q_INVOKABLE
float getHeadFinalYaw()
const {
return getHead()->getFinalYaw(); }
1179 Q_INVOKABLE
float getHeadFinalRoll()
const {
return getHead()->getFinalRoll(); }
1186 Q_INVOKABLE
float getHeadFinalPitch()
const {
return getHead()->getFinalPitch(); }
1195 Q_INVOKABLE
float getHeadDeltaPitch()
const {
return getHead()->getDeltaPitch(); }
1205 Q_INVOKABLE glm::vec3 getEyePosition()
const {
return getHead()->getEyePosition(); }
1216 Q_INVOKABLE glm::vec3 getTargetAvatarPosition()
const {
return _targetAvatarPosition; }
1223 Q_INVOKABLE ScriptAvatarData* getTargetAvatar()
const;
1237 Q_INVOKABLE glm::vec3 getLeftHandPosition()
const;
1250 Q_INVOKABLE glm::vec3 getRightHandPosition()
const;
1259 Q_INVOKABLE glm::vec3 getLeftHandTipPosition()
const;
1268 Q_INVOKABLE glm::vec3 getRightHandTipPosition()
const;
1282 Q_INVOKABLE controller::Pose getLeftHandPose()
const;
1295 Q_INVOKABLE controller::Pose getRightHandPose()
const;
1307 Q_INVOKABLE controller::Pose getLeftHandTipPose()
const;
1319 Q_INVOKABLE controller::Pose getRightHandTipPose()
const;
1321 AvatarWeakPointer getLookAtTargetAvatar()
const {
return _lookAtTargetAvatar; }
1322 void updateLookAtTargetAvatar();
1323 void computeMyLookAtTarget(
const AvatarHash& hash);
1324 void snapOtherAvatarLookAtTargetsToMe(
const AvatarHash& hash);
1325 void clearLookAtTargetAvatar();
1327 virtual void setJointRotations(
const QVector<glm::quat>& jointRotations)
override;
1328 virtual void setJointData(
int index,
const glm::quat& rotation,
const glm::vec3& translation)
override;
1329 virtual void setJointRotation(
int index,
const glm::quat& rotation)
override;
1330 virtual void setJointTranslation(
int index,
const glm::vec3& translation)
override;
1331 virtual void clearJointData(
int index)
override;
1333 virtual void setJointData(
const QString& name,
const glm::quat& rotation,
const glm::vec3& translation)
override;
1334 virtual void setJointRotation(
const QString& name,
const glm::quat& rotation)
override;
1335 virtual void setJointTranslation(
const QString& name,
const glm::vec3& translation)
override;
1336 virtual void clearJointData(
const QString& name)
override;
1337 virtual void clearJointsData()
override;
1348 Q_INVOKABLE
bool pinJoint(
int index,
const glm::vec3& position,
const glm::quat& orientation);
1350 bool isJointPinned(
int index);
1359 Q_INVOKABLE
bool clearPinOnJoint(
int index);
1366 Q_INVOKABLE
float getIKErrorOnLastSolve()
const;
1374 Q_INVOKABLE
void useFullAvatarURL(
const QUrl& fullAvatarURL,
const QString& modelName = QString());
1383 Q_INVOKABLE QUrl getFullAvatarURLFromPreferences()
const {
return _fullAvatarURLFromPreferences; }
1392 Q_INVOKABLE QString getFullAvatarModelName()
const {
return _fullAvatarModelName; }
1394 void resetFullAvatarURL();
1396 MyCharacterController* getCharacterController() {
return &_characterController; }
1397 const MyCharacterController* getCharacterController()
const {
return &_characterController; }
1399 void updateMotors();
1400 void prepareForPhysicsSimulation();
1401 void nextAttitude(glm::vec3 position, glm::quat orientation);
1402 void harvestResultsFromPhysicsSimulation(
float deltaTime);
1404 const QString& getCollisionSoundURL() {
return _collisionSoundURL; }
1405 void setCollisionSoundURL(
const QString& url);
1407 SharedSoundPointer getCollisionSound();
1408 void setCollisionSound(SharedSoundPointer sound) { _collisionSound = sound; }
1410 void clearScriptableSettings();
1412 float getBoomLength()
const {
return _boomLength; }
1413 void setBoomLength(
float boomLength) { _boomLength = boomLength; }
1415 float getPitchSpeed()
const {
return _pitchSpeed; }
1416 void setPitchSpeed(
float speed) { _pitchSpeed = speed; }
1418 float getYawSpeed()
const {
return _yawSpeed; }
1419 void setYawSpeed(
float speed) { _yawSpeed = speed; }
1421 float getHMDYawSpeed()
const {
return _hmdYawSpeed; }
1422 void setHMDYawSpeed(
float speed) { _hmdYawSpeed = speed; }
1424 static const float ZOOM_MIN;
1425 static const float ZOOM_MAX;
1426 static const float ZOOM_DEFAULT;
1428 void destroyAnimGraph();
1430 AudioListenerMode getAudioListenerMode() {
return _audioListenerMode; }
1431 void setAudioListenerMode(AudioListenerMode audioListenerMode);
1432 glm::vec3 getCustomListenPosition() {
return _customListenPosition; }
1433 void setCustomListenPosition(glm::vec3 customListenPosition) { _customListenPosition = customListenPosition; }
1434 glm::quat getCustomListenOrientation() {
return _customListenOrientation; }
1435 void setCustomListenOrientation(glm::quat customListenOrientation) { _customListenOrientation = customListenOrientation; }
1437 virtual void rebuildCollisionShape()
override;
1439 const glm::vec2& getHipToHandController()
const {
return _hipToHandController; }
1440 void setHipToHandController(glm::vec2 currentHipToHandController) { _hipToHandController = currentHipToHandController; }
1441 const glm::vec2& getHeadControllerFacing()
const {
return _headControllerFacing; }
1442 void setHeadControllerFacing(glm::vec2 currentHeadControllerFacing) { _headControllerFacing = currentHeadControllerFacing; }
1443 const glm::vec2& getHeadControllerFacingMovingAverage()
const {
return _headControllerFacingMovingAverage; }
1444 void setHeadControllerFacingMovingAverage(glm::vec2 currentHeadControllerFacing) { _headControllerFacingMovingAverage = currentHeadControllerFacing; }
1445 float getCurrentStandingHeight()
const {
return _currentStandingHeight; }
1446 void setCurrentStandingHeight(
float newMode) { _currentStandingHeight = newMode; }
1447 const glm::quat getAverageHeadRotation()
const {
return _averageHeadRotation; }
1448 void setAverageHeadRotation(glm::quat rotation) { _averageHeadRotation = rotation; }
1449 bool getResetMode()
const {
return _resetMode; }
1450 void setResetMode(
bool hasBeenReset) { _resetMode = hasBeenReset; }
1452 void setControllerPoseInSensorFrame(controller::Action action,
const controller::Pose& pose);
1453 controller::Pose getControllerPoseInSensorFrame(controller::Action action)
const;
1454 controller::Pose getControllerPoseInWorldFrame(controller::Action action)
const;
1455 controller::Pose getControllerPoseInAvatarFrame(controller::Action action)
const;
1457 bool hasDriveInput()
const;
1464 Q_INVOKABLE QVariantList getAvatarEntitiesVariant();
1466 void removeWornAvatarEntity(
const EntityItemID& entityID);
1467 void clearWornAvatarEntities();
1468 bool hasAvatarEntities()
const;
1475 Q_INVOKABLE
bool isFlying();
1483 Q_INVOKABLE
bool isInAir();
1492 Q_INVOKABLE
void setFlyingEnabled(
bool enabled);
1501 Q_INVOKABLE
bool getFlyingEnabled();
1510 Q_INVOKABLE
void setFlyingDesktopPref(
bool enabled);
1519 Q_INVOKABLE
bool getFlyingDesktopPref();
1528 Q_INVOKABLE
void setFlyingHMDPref(
bool enabled);
1537 Q_INVOKABLE
bool getFlyingHMDPref();
1545 Q_INVOKABLE
void setMovementReference(
int enabled);
1553 Q_INVOKABLE
int getMovementReference();
1560 Q_INVOKABLE
void setDriveGear1(
float shiftPoint);
1567 Q_INVOKABLE
float getDriveGear1();
1574 Q_INVOKABLE
void setDriveGear2(
float shiftPoint);
1581 Q_INVOKABLE
float getDriveGear2();
1588 Q_INVOKABLE
void setDriveGear3(
float shiftPoint);
1595 Q_INVOKABLE
float getDriveGear3();
1602 Q_INVOKABLE
void setDriveGear4(
float shiftPoint);
1609 Q_INVOKABLE
float getDriveGear4();
1616 Q_INVOKABLE
void setDriveGear5(
float shiftPoint);
1623 Q_INVOKABLE
float getDriveGear5();
1625 void setControlSchemeIndex(
int index);
1627 int getControlSchemeIndex();
1635 Q_INVOKABLE
float getAvatarScale()
const;
1643 Q_INVOKABLE
void setAvatarScale(
float scale);
1654 Q_INVOKABLE
void setCollisionsEnabled(
bool enabled);
1662 Q_INVOKABLE
bool getCollisionsEnabled();
1670 Q_INVOKABLE
void setOtherAvatarsCollisionsEnabled(
bool enabled);
1677 Q_INVOKABLE
bool getOtherAvatarsCollisionsEnabled();
1686 Q_INVOKABLE QVariantMap getCollisionCapsule()
const;
1694 Q_INVOKABLE
void setCharacterControllerEnabled(
bool enabled);
1701 Q_INVOKABLE
bool getCharacterControllerEnabled();
1714 virtual glm::quat getAbsoluteJointRotationInObjectFrame(
int index)
const override;
1727 virtual glm::vec3 getAbsoluteJointTranslationInObjectFrame(
int index)
const override;
1730 glm::mat4 getCenterEyeCalibrationMat()
const;
1731 glm::mat4 getHeadCalibrationMat()
const;
1732 glm::mat4 getSpine2CalibrationMat()
const;
1733 glm::mat4 getHipsCalibrationMat()
const;
1734 glm::mat4 getLeftFootCalibrationMat()
const;
1735 glm::mat4 getRightFootCalibrationMat()
const;
1736 glm::mat4 getRightArmCalibrationMat()
const;
1737 glm::mat4 getLeftArmCalibrationMat()
const;
1738 glm::mat4 getLeftHandCalibrationMat()
const;
1739 glm::mat4 getRightHandCalibrationMat()
const;
1741 void addHoldAction(AvatarActionHold* holdAction);
1742 void removeHoldAction(AvatarActionHold* holdAction);
1743 void updateHoldActions(
const AnimPose& prePhysicsPose,
const AnimPose& postUpdatePose);
1748 glm::mat4 deriveBodyFromHMDSensor(
const bool forceFollowYPos =
false)
const;
1750 glm::mat4 getSpine2RotationRigSpace()
const;
1752 glm::vec3 computeCounterBalance();
1757 glm::mat4 deriveBodyUsingCgModel();
1767 Q_INVOKABLE
bool isUp(
const glm::vec3& direction) {
return glm::dot(direction, _worldUpDirection) > 0.0f; };
1777 Q_INVOKABLE
bool isDown(
const glm::vec3& direction) {
return glm::dot(direction, _worldUpDirection) < 0.0f; };
1779 void setUserHeight(
float value);
1780 float getUserHeight()
const;
1781 float getUserEyeHeight()
const;
1783 virtual SpatialParentTree* getParentTree()
const override;
1784 virtual glm::vec3 scaleForChildren()
const override {
return glm::vec3(getSensorToWorldScale()); }
1786 const QUuid& getSelfID()
const {
return AVATAR_SELF_ID; }
1788 void setIsInWalkingState(
bool isWalking);
1789 bool getIsInWalkingState()
const;
1790 void setIsInSittingState(
bool isSitting);
1791 bool getIsInSittingState()
const;
1792 void setUserRecenterModel(MyAvatar::SitStandModelType modelName);
1793 MyAvatar::SitStandModelType getUserRecenterModel()
const;
1794 void setIsSitStandStateLocked(
bool isLocked);
1795 bool getIsSitStandStateLocked()
const;
1796 void setAllowAvatarStandingPreference(
const AllowAvatarStandingPreference preference);
1797 AllowAvatarStandingPreference getAllowAvatarStandingPreference()
const;
1798 void setAllowAvatarLeaningPreference(
const AllowAvatarLeaningPreference preference);
1799 AllowAvatarLeaningPreference getAllowAvatarLeaningPreference()
const;
1800 void setWalkSpeed(
float value);
1801 float getWalkSpeed()
const;
1802 void setWalkBackwardSpeed(
float value);
1803 float getWalkBackwardSpeed()
const;
1804 void setSprintSpeed(
float value);
1805 float getSprintSpeed()
const;
1806 void setAnalogWalkSpeed(
float value);
1807 float getAnalogWalkSpeed()
const;
1808 void setAnalogSprintSpeed(
float value);
1809 float getAnalogSprintSpeed()
const;
1810 void setAnalogPlusWalkSpeed(
float value);
1811 float getAnalogPlusWalkSpeed()
const;
1812 void setAnalogPlusSprintSpeed(
float value);
1813 float getAnalogPlusSprintSpeed()
const;
1814 void setSitStandStateChange(
bool stateChanged);
1815 bool getSitStandStateChange()
const;
1816 void updateSitStandState(
float newHeightReading,
float dt);
1818 QVector<QString> getScriptUrls();
1820 bool isReadyForPhysics()
const;
1822 float computeStandingHeightMode(
const controller::Pose& head);
1823 glm::quat computeAverageHeadRotation(
const controller::Pose& head);
1825 virtual void setAttachmentData(
const QVector<AttachmentData>& attachmentData)
override;
1826 virtual QVector<AttachmentData> getAttachmentData()
const override;
1828 virtual QVariantList getAttachmentsVariant()
const override;
1829 virtual void setAttachmentsVariant(
const QVariantList& variant)
override;
1831 glm::vec3 getNextPosition() {
return _goToPending ? _goToPosition : getWorldPosition(); }
1832 void prepareAvatarEntityDataForReload();
1841 Q_INVOKABLE
void setHeadLookAt(
const glm::vec3& lookAtTarget);
1848 Q_INVOKABLE glm::vec3 getHeadLookAt() {
return _lookAtCameraTarget; }
1854 Q_INVOKABLE
void releaseHeadLookAtControl();
1863 Q_INVOKABLE
void setEyesLookAt(
const glm::vec3& lookAtTarget);
1870 Q_INVOKABLE glm::vec3 getEyesLookAt() {
return _eyesLookAtTarget.get(); }
1876 Q_INVOKABLE
void releaseEyesLookAtControl();
1886 Q_INVOKABLE
bool setPointAt(
const glm::vec3& pointAtTarget);
1888 glm::quat getLookAtRotation() {
return _lookAtYaw * _lookAtPitch; }
1917 Q_INVOKABLE
const QUuid grab(
const QUuid& targetID,
int parentJointIndex,
1918 glm::vec3 positionalOffset, glm::quat rotationalOffset);
1925 Q_INVOKABLE
void releaseGrab(
const QUuid& grabID);
1936 AvatarEntityMap getAvatarEntityData()
const override;
1938 AvatarEntityMap getAvatarEntityDataNonDefault()
const override;
1945 void setAvatarEntityData(
const AvatarEntityMap& avatarEntityData)
override;
1950 void updateAvatarEntity(
const QUuid& entityID,
const QByteArray& entityData)
override;
1952 void avatarEntityDataToJson(QJsonObject& root)
const override;
1954 void storeAvatarEntityDataPayload(
const QUuid& entityID,
const QByteArray& payload)
override;
1959 int sendAvatarDataPacket(
bool sendAll =
false)
override;
1961 void addAvatarHandsToFlow(
const std::shared_ptr<Avatar>& otherAvatar);
1976 Q_INVOKABLE
void useFlow(
bool isActive,
bool isCollidable,
const QVariantMap& physicsConfig = QVariantMap(),
const QVariantMap& collisionsConfig = QVariantMap());
1983 Q_INVOKABLE QVariantMap getFlowData();
1990 Q_INVOKABLE QVariantList getCollidingFlowJoints();
1998 Q_INVOKABLE
void beginSit(
const glm::vec3& position,
const glm::quat& rotation);
2006 Q_INVOKABLE
void endSit(
const glm::vec3& position,
const glm::quat& rotation);
2013 Q_INVOKABLE
bool isSeated() {
return _characterController.getSeated(); }
2015 int getOverrideJointCount()
const;
2016 bool getFlowActive()
const;
2017 bool getNetworkGraphActive()
const;
2019 void updateEyesLookAtPosition(
float deltaTime);
2023 void updateRigControllerParameters(Rig::ControllerParameters& params);
2026 virtual const QUrl& getSkeletonModelURL()
const override {
return _skeletonModelURL; }
2028 void debugDrawPose(controller::Action action,
const char* channelName,
float size);
2030 bool getIsJointOverridden(
int jointIndex)
const;
2031 glm::vec3 getLookAtPivotPoint();
2032 glm::vec3 getCameraEyesPosition(
float deltaTime);
2034 bool getHMDCrouchRecenterEnabled()
const;
2035 bool isAllowedToLean()
const;
2036 bool areFeetTracked()
const {
return _isBodyPartTracked._feet; };
2037 bool areHipsTracked()
const {
return _isBodyPartTracked._hips; };
2044 virtual void setSessionUUID(
const QUuid& sessionUUID)
override;
2057 void increaseSize();
2070 void decreaseSize();
2082 void animGraphLoaded();
2089 void setGravity(
float gravity);
2109 void goToFeetLocation(
const glm::vec3& newPosition,
bool hasOrientation =
false,
2110 const glm::quat& newOrientation = glm::quat(),
bool shouldFaceLocation =
false);
2122 void goToLocation(
const glm::vec3& newPosition,
2123 bool hasOrientation =
false,
const glm::quat& newOrientation = glm::quat(),
2124 bool shouldFaceLocation =
false,
bool withSafeLanding =
true);
2130 void goToLocation(
const QVariant& properties);
2137 void goToLocationAndEnableCollisions(
const glm::vec3& newPosition);
2145 bool safeLanding(
const glm::vec3& position);
2153 void restrictScaleFromDomainSettings(
const QJsonObject& domainSettingsObject);
2159 void clearScaleRestriction();
2170 void addThrust(glm::vec3 newThrust) { _thrust += newThrust; };
2179 glm::vec3 getThrust() {
return _thrust; };
2188 void setThrust(glm::vec3 newThrust) { _thrust = newThrust; }
2196 Q_INVOKABLE
void updateMotionBehaviorFromMenu();
2203 void setToggleHips(
bool followHead);
2212 void setEnableDebugDrawBaseOfSupport(
bool isEnabled);
2219 void setEnableDebugDrawDefaultPose(
bool isEnabled);
2227 void setEnableDebugDrawAnimPose(
bool isEnabled);
2236 void setDebugDrawAnimPoseName(QString poseName);
2243 void setEnableDebugDrawPosition(
bool isEnabled);
2250 void setEnableDebugDrawHandControllers(
bool isEnabled);
2257 void setEnableDebugDrawSensorToWorldMatrix(
bool isEnabled);
2264 void setEnableDebugDrawIKTargets(
bool isEnabled);
2271 void setEnableDebugDrawIKConstraints(
bool isEnabled);
2278 void setEnableDebugDrawIKChains(
bool isEnabled);
2285 void setEnableDebugDrawDetailedCollision(
bool isEnabled);
2292 bool getEnableMeshVisible()
const override;
2297 void clearAvatarEntity(
const QUuid& entityID,
bool requiresRemovalFromTree =
true)
override;
2309 virtual void setEnableMeshVisible(
bool isEnabled)
override;
2316 void setEnableInverseKinematics(
bool isEnabled);
2327 QUrl getAnimGraphOverrideUrl()
const;
2336 void setAnimGraphOverrideUrl(QUrl value);
2347 QUrl getAnimGraphUrl()
const;
2356 void setAnimGraphUrl(
const QUrl& url);
2364 glm::vec3 getPositionForAudio();
2372 glm::quat getOrientationForAudio();
2379 virtual void setModelScale(
float scale)
override;
2389 QStringList getTriggerReactions()
const;
2402 QStringList getBeginEndReactions()
const;
2411 bool triggerReaction(QString reactionName);
2421 bool beginReaction(QString reactionName);
2429 bool endReaction(QString reactionName);
2438 void audioListenerModeChanged();
2446 void analogPlusWalkSpeedChanged(
float value);
2454 void analogPlusSprintSpeedChanged(
float value);
2463 void sprintSpeedChanged(
float value);
2472 void walkBackwardSpeedChanged(
float value);
2479 void transformChanged();
2487 void newCollisionSoundURL(
const QUrl& url);
2499 void collisionWithEntity(
const Collision& collision);
2508 void collisionsEnabledChanged(
bool enabled);
2517 void otherAvatarsCollisionsEnabledChanged(
bool enabled);
2528 void animGraphUrlChanged(
const QUrl& url);
2536 void energyChanged(
float newEnergy);
2544 void positionGoneTo();
2551 void onLoadComplete();
2558 void onLoadFailed();
2585 void skeletonChanged();
2593 void dominantHandChanged(
const QString& hand);
2602 void hmdAvatarAlignmentTypeChanged(
const QString& type);
2611 void sensorToWorldScaleChanged(
float sensorToWorldScale);
2621 void attachmentsChanged();
2629 void scaleChanged();
2640 void shouldDisableHandTouchChanged(
bool shouldDisable);
2652 void disableHandTouchForIDChanged(
const QUuid& entityID,
bool disable);
2656 void updateCollisionCapsuleCache();
2659 void handleChangedAvatarEntityData();
2660 void handleCanRezAvatarEntitiesChanged(
bool canRezAvatarEntities);
2661 virtual void beParentOfChild(SpatiallyNestablePointer newChild)
const override;
2662 virtual void forgetChild(SpatiallyNestablePointer newChild)
const override;
2663 virtual void recalculateChildCauterization()
const override;
2666 bool updateStaleAvatarEntityBlobs()
const;
2668 bool requiresSafeLanding(
const glm::vec3& positionIn, glm::vec3& positionOut);
2670 virtual QByteArray toByteArrayStateful(AvatarDataDetail dataDetail,
bool dropFaceTracking)
override;
2672 void simulate(
float deltaTime,
bool inView)
override;
2673 void saveAvatarUrl();
2674 virtual void render(RenderArgs* renderArgs)
override;
2675 virtual bool shouldRenderHead(
const RenderArgs* renderArgs)
const override;
2676 void setShouldRenderLocally(
bool shouldRender) { _shouldRender = shouldRender; setEnableMeshVisible(shouldRender); }
2677 bool getShouldRenderLocally()
const {
return _shouldRender; }
2678 void setRotationRecenterFilterLength(
float length);
2679 float getRotationRecenterFilterLength()
const {
return _rotationRecenterFilterLength; }
2680 void setRotationThreshold(
float angleRadians);
2681 float getRotationThreshold()
const {
return _rotationThreshold; }
2682 void setEnableStepResetRotation(
bool stepReset) { _stepResetRotationEnabled = stepReset; }
2683 bool getEnableStepResetRotation()
const {
return _stepResetRotationEnabled; }
2684 void setEnableDrawAverageFacing(
bool drawAverage) { _drawAverageFacingEnabled = drawAverage; }
2685 bool getEnableDrawAverageFacing()
const {
return _drawAverageFacingEnabled; }
2686 virtual bool isMyAvatar()
const override {
return true; }
2687 virtual bool isMyAvatarURLProtected()
const override;
2688 virtual int parseDataFromBuffer(
const QByteArray& buffer)
override;
2689 virtual glm::vec3 getSkeletonPosition()
const override;
2690 int _skeletonModelChangeCount { 0 };
2693 void saveAvatarScale();
2695 glm::vec3 getScriptedMotorVelocity()
const {
return _scriptedMotorVelocity; }
2696 float getScriptedMotorTimescale()
const {
return _scriptedMotorTimescale; }
2697 QString getScriptedMotorFrame()
const;
2698 QString getScriptedMotorMode()
const;
2699 void setScriptedMotorVelocity(
const glm::vec3& velocity);
2700 void setScriptedMotorTimescale(
float timescale);
2701 void setScriptedMotorFrame(QString frame);
2702 void setScriptedMotorMode(QString mode);
2705 virtual void attach(
const QString& modelURL,
const QString& jointName = QString(),
2706 const glm::vec3& translation = glm::vec3(),
const glm::quat& rotation = glm::quat(),
2707 float scale = 1.0f,
bool isSoft =
false,
2708 bool allowDuplicates =
false,
bool useSaved =
true)
override;
2710 virtual void detachOne(
const QString& modelURL,
const QString& jointName = QString())
override;
2711 virtual void detachAll(
const QString& modelURL,
const QString& jointName = QString())
override;
2714 void attachmentDataToEntityProperties(
const AttachmentData& data,
EntityItemProperties& properties);
2716 bool findAvatarEntity(
const QString& modelURL,
const QString& jointName, QUuid& entityID);
2717 void addAvatarEntitiesToTree();
2720 void clearAvatarEntityInternal(
const QUuid& entityID)
override;
2722 bool cameraInsideHead(
const glm::vec3& cameraPosition)
const;
2724 void updateEyeContactTarget(
float deltaTime);
2730 Q_INVOKABLE
virtual void setSkeletonModelURL(
const QUrl& skeletonModelURL)
override;
2732 virtual void updatePalms()
override {}
2733 void lateUpdatePalms();
2734 void setSitDriveKeysStatus(
bool enabled);
2736 void clampTargetScaleToDomainLimits();
2737 void clampScaleChangeToDomainLimits(
float desiredScale);
2738 glm::mat4 computeCameraRelativeHandControllerMatrix(
const glm::mat4& controllerSensorMatrix)
const;
2740 std::array<float, MAX_DRIVE_KEYS> _driveKeys;
2741 std::bitset<MAX_DRIVE_KEYS> _disabledDriveKeys;
2743 bool _enableFlying {
false };
2744 bool _flyingPrefDesktop {
true };
2745 bool _flyingPrefHMD {
true };
2746 bool _wasPushing {
false };
2747 bool _isPushing {
false };
2748 bool _isBeingPushed {
false };
2749 bool _isBraking {
false };
2750 bool _isAway {
false };
2754 bool _feet {
false };
2755 bool _feetPreviousUpdate{
false };
2756 bool _hips{
false };
2757 bool _leftHand{
false };
2758 bool _rightHand{
false };
2759 bool _head{
false };
2760 } _isBodyPartTracked;
2762 float _boomLength { ZOOM_DEFAULT };
2766 float _driveGear1 { DEFAULT_GEAR_1 };
2767 float _driveGear2 { DEFAULT_GEAR_2 };
2768 float _driveGear3 { DEFAULT_GEAR_3 };
2769 float _driveGear4 { DEFAULT_GEAR_4 };
2770 float _driveGear5 { DEFAULT_GEAR_5 };
2771 int _controlSchemeIndex { CONTROLS_ANALOG };
2772 int _movementReference{ 0 };
2774 glm::vec3 _thrust { 0.0f };
2776 glm::vec3 _actionMotorVelocity;
2777 glm::vec3 _scriptedMotorVelocity;
2778 float _scriptedMotorTimescale;
2779 int _scriptedMotorFrame;
2780 int _scriptedMotorMode;
2781 quint32 _motionBehaviors;
2782 QString _collisionSoundURL;
2784 SharedSoundPointer _collisionSound;
2786 MyCharacterController _characterController;
2787 int32_t _previousCollisionMask { BULLET_COLLISION_MASK_MY_AVATAR };
2789 AvatarWeakPointer _lookAtTargetAvatar;
2790 glm::vec3 _targetAvatarPosition;
2791 bool _shouldRender {
true };
2792 float _oculusYawOffset;
2794 eyeContactTarget _eyeContactTarget;
2795 float _eyeContactTargetTimer { 0.0f };
2796 ThreadSafeValueCache<glm::vec3> _eyesLookAtTarget { glm::vec3() };
2797 bool _scriptControlsEyesLookAt{
false };
2798 float _scriptEyesControlTimer{ 0.0f };
2800 glm::vec3 _trackedHeadPosition;
2802 const float MAX_LOOK_AT_TIME_SCRIPT_CONTROL = 2.0f;
2803 glm::quat _lookAtPitch;
2804 glm::quat _lookAtYaw;
2805 float _lookAtYawSpeed { 0.0f };
2806 glm::vec3 _lookAtCameraTarget;
2807 glm::vec3 _lookAtScriptTarget;
2808 bool _headLookAtActive {
false };
2809 bool _shouldTurnToFaceCamera {
false };
2810 bool _scriptControlsHeadLookAt {
false };
2811 float _scriptHeadControlTimer { 0.0f };
2812 float _firstPersonSteadyHeadTimer { 0.0f };
2813 bool _pointAtActive {
false };
2814 bool _isPointTargetValid {
true };
2821 const float SMOOTH_TIME_ORIENTATION = 0.5f;
2824 float _smoothOrientationTimer;
2825 glm::quat _smoothOrientationInitial;
2826 glm::quat _smoothOrientationTarget;
2829 void updateOrientation(
float deltaTime);
2830 glm::vec3 calculateScaledDirection();
2831 float calculateGearedSpeed(
const float driveKey);
2832 glm::vec3 scaleMotorSpeed(
const glm::vec3 forward,
const glm::vec3 right);
2833 void updateActionMotor(
float deltaTime);
2834 void updatePosition(
float deltaTime);
2835 void updateViewBoom();
2836 void updateCollisionSound(
const glm::vec3& penetration,
float deltaTime,
float frequency);
2837 void initHeadBones();
2838 void initAnimGraph();
2839 void initFlowFromFST();
2840 void updateHeadLookAt(
float deltaTime);
2841 void resetHeadLookAt();
2842 void resetLookAtRotation(
const glm::vec3& avatarPosition,
const glm::quat& avatarOrientation);
2843 void resetPointAt();
2844 static glm::vec3 aimToBlendValues(
const glm::vec3& aimVector,
const glm::quat& frameOrientation);
2845 void centerBodyInternal(
const bool forceFollowYPos =
false);
2848 QUrl _fullAvatarURLFromPreferences;
2849 QString _fullAvatarModelName;
2850 ThreadSafeValueCache<QUrl> _currentAnimGraphUrl;
2851 ThreadSafeValueCache<QUrl> _prefOverrideAnimGraphUrl;
2852 QUrl _fstAnimGraphOverrideUrl;
2853 bool _useSnapTurn {
true };
2854 bool _hoverWhenUnsupported{
false };
2855 ThreadSafeValueCache<QString> _dominantHand { DOMINANT_RIGHT_HAND };
2856 ThreadSafeValueCache<QString> _hmdAvatarAlignmentType { DEFAULT_HMD_AVATAR_ALIGNMENT_TYPE };
2857 ThreadSafeValueCache<bool> _strafeEnabled{ DEFAULT_STRAFE_ENABLED };
2859 const float ROLL_CONTROL_DEAD_ZONE_DEFAULT = 8.0f;
2860 const float ROLL_CONTROL_RATE_DEFAULT = 114.0f;
2862 bool _hmdRollControlEnabled {
true };
2863 float _hmdRollControlDeadZone { ROLL_CONTROL_DEAD_ZONE_DEFAULT };
2864 float _hmdRollControlRate { ROLL_CONTROL_RATE_DEFAULT };
2865 std::atomic<bool> _hasScriptedBlendShapes {
false };
2866 std::atomic<float> _rotationRecenterFilterLength { 4.0f };
2867 std::atomic<float> _rotationThreshold { 0.5235f };
2868 std::atomic<bool> _stepResetRotationEnabled {
true };
2869 std::atomic<bool> _drawAverageFacingEnabled {
false };
2872 glm::mat4 _sensorToWorldMatrix { glm::mat4() };
2875 glm::mat4 _hmdSensorMatrix;
2876 glm::quat _hmdSensorOrientation;
2877 glm::vec3 _hmdSensorPosition;
2879 glm::vec2 _headControllerFacing;
2880 glm::vec2 _headControllerFacingMovingAverage { 0.0f, 0.0f };
2881 glm::quat _averageHeadRotation { 0.0f, 0.0f, 0.0f, 1.0f };
2883 glm::vec2 _hipToHandController { 0.0f, 1.0f };
2885 float _currentStandingHeight { 0.0f };
2886 bool _resetMode {
true };
2887 RingBufferHistory<int> _recentModeReadings;
2891 glm::mat4 _bodySensorMatrix;
2893 struct FollowHelper {
2896 CharacterController::FollowTimePerType _timeRemaining;
2899 void deactivate(CharacterController::FollowType type);
2900 void activate(CharacterController::FollowType type,
const bool snapFollow);
2901 bool isActive()
const;
2902 bool isActive(CharacterController::FollowType followType)
const;
2903 void decrementTimeRemaining(
float dt);
2904 bool shouldActivateRotation(
const MyAvatar& myAvatar,
const glm::mat4& desiredBodyMatrix,
const glm::mat4& currentBodyMatrix,
bool& shouldSnapOut)
const;
2905 bool shouldActivateVertical(
const MyAvatar& myAvatar,
const glm::mat4& desiredBodyMatrix,
const glm::mat4& currentBodyMatrix)
const;
2906 bool shouldActivateHorizontal(
const MyAvatar& myAvatar,
2907 const glm::mat4& desiredBodyMatrix,
2908 const glm::mat4& currentBodyMatrix,
2910 bool& goToWalkingStateOut)
const;
2911 void prePhysicsUpdate(MyAvatar& myAvatar,
const glm::mat4& bodySensorMatrix,
const glm::mat4& currentBodyMatrix,
bool hasDriveInput);
2912 glm::mat4 postPhysicsUpdate(MyAvatar& myAvatar,
const glm::mat4& currentBodyMatrix);
2913 bool getForceActivateRotation()
const;
2914 void setForceActivateRotation(
bool val);
2915 bool getForceActivateVertical()
const;
2916 void setForceActivateVertical(
bool val);
2917 bool getForceActivateHorizontal()
const;
2918 void setForceActivateHorizontal(
bool val);
2919 std::atomic<bool> _forceActivateRotation {
false };
2920 std::atomic<bool> _forceActivateVertical {
false };
2921 std::atomic<bool> _forceActivateHorizontal {
false };
2922 std::atomic<bool> _toggleHipsFollowing {
true };
2925 bool shouldActivateHorizontal_userSitting(
const MyAvatar& myAvatar,
2926 const glm::mat4& desiredBodyMatrix,
2927 const glm::mat4& currentBodyMatrix)
const;
2928 bool shouldActivateHorizontal_userStanding(
const MyAvatar& myAvatar,
2930 bool& goToWalkingStateOut)
const;
2933 FollowHelper _follow;
2935 bool isFollowActive(CharacterController::FollowType followType)
const;
2937 bool _goToPending {
false };
2938 bool _physicsSafetyPending {
false };
2939 bool _goToSafe {
true };
2940 bool _goToFeetAjustment {
false };
2941 glm::vec3 _goToPosition;
2942 glm::quat _goToOrientation;
2944 std::unordered_set<int> _headBoneSet;
2945 std::unordered_set<SpatiallyNestablePointer> _cauterizedChildrenOfHead;
2946 bool _prevShouldDrawHead;
2947 bool _rigEnabled {
true };
2949 bool _enableDebugDrawBaseOfSupport {
false };
2950 bool _enableDebugDrawDefaultPose {
false };
2951 bool _enableDebugDrawAnimPose {
false };
2952 bool _enableDebugDrawHandControllers {
false };
2953 bool _enableDebugDrawSensorToWorldMatrix {
false };
2954 bool _enableDebugDrawIKTargets {
false };
2955 bool _enableDebugDrawIKConstraints {
false };
2956 bool _enableDebugDrawIKChains {
false };
2957 bool _enableDebugDrawDetailedCollision {
false };
2959 ThreadSafeValueCache<QString> _debugDrawAnimPoseName;
2961 mutable bool _cauterizationNeedsUpdate {
false };
2963 AudioListenerMode _audioListenerMode;
2964 glm::vec3 _customListenPosition;
2965 glm::quat _customListenOrientation;
2967 AtRestDetector _leftHandAtRestDetector;
2968 AtRestDetector _rightHandAtRestDetector;
2971 std::map<controller::Action, controller::Pose> _controllerPoseMap;
2972 mutable std::mutex _controllerPoseMapMutex;
2973 mutable std::mutex _disableHandTouchMutex;
2975 bool _centerOfGravityModelEnabled {
true };
2976 bool _hmdLeanRecenterEnabled {
true };
2977 bool _hmdCrouchRecenterEnabled {
2980 bool _sprint {
false };
2982 AnimPose _prePhysicsRoomPose;
2983 std::mutex _holdActionsMutex;
2984 std::vector<AvatarActionHold*> _holdActions;
2986 float AVATAR_MOVEMENT_ENERGY_CONSTANT { 0.001f };
2987 float AUDIO_ENERGY_CONSTANT { 0.000001f };
2988 float MAX_AVATAR_MOVEMENT_PER_FRAME { 30.0f };
2989 float currentEnergy { 0.0f };
2990 float energyChargeRate { 0.003f };
2991 glm::vec3 priorVelocity;
2992 glm::vec3 lastPosition;
2993 float getAudioEnergy();
2994 float getAccelerationEnergy();
2996 void setEnergy(
float value);
2998 bool getIsAway()
const {
return _isAway; }
2999 void setAway(
bool value);
3000 void sendPacket(
const QUuid& entityID)
const override;
3002 std::mutex _pinnedJointsMutex;
3003 std::vector<int> _pinnedJoints;
3005 void updateChildCauterization(SpatiallyNestablePointer
object,
bool cauterize);
3008 ThreadSafeValueCache<float> _userHeight { DEFAULT_AVATAR_HEIGHT };
3009 float _averageUserHeightSensorSpace { _userHeight.get() };
3010 bool _sitStandStateChange {
false };
3013 ThreadSafeValueCache<float> _defaultWalkSpeed { DEFAULT_AVATAR_MAX_WALKING_SPEED };
3014 ThreadSafeValueCache<float> _defaultWalkBackwardSpeed { DEFAULT_AVATAR_MAX_WALKING_BACKWARD_SPEED };
3015 ThreadSafeValueCache<float> _defaultSprintSpeed { DEFAULT_AVATAR_MAX_SPRINT_SPEED };
3016 ThreadSafeValueCache<float> _analogWalkSpeed { ANALOG_AVATAR_MAX_WALKING_SPEED };
3017 ThreadSafeValueCache<float> _analogWalkBackwardSpeed { ANALOG_AVATAR_MAX_WALKING_BACKWARD_SPEED };
3018 ThreadSafeValueCache<float> _analogSprintSpeed { ANALOG_AVATAR_MAX_SPRINT_SPEED };
3019 ThreadSafeValueCache<float> _analogPlusWalkSpeed { ANALOG_PLUS_AVATAR_MAX_WALKING_SPEED };
3020 ThreadSafeValueCache<float> _analogPlusWalkBackwardSpeed { ANALOG_PLUS_AVATAR_MAX_WALKING_BACKWARD_SPEED };
3021 ThreadSafeValueCache<float> _analogPlusSprintSpeed { ANALOG_PLUS_AVATAR_MAX_SPRINT_SPEED };
3023 float _walkSpeedScalar { AVATAR_WALK_SPEED_SCALAR };
3024 bool _isInWalkingState {
false };
3025 ThreadSafeValueCache<bool> _isInSittingState {
false };
3026 ThreadSafeValueCache<MyAvatar::AllowAvatarStandingPreference> _allowAvatarStandingPreference{
3027 MyAvatar::AllowAvatarStandingPreference::Default
3029 ThreadSafeValueCache<MyAvatar::AllowAvatarLeaningPreference> _allowAvatarLeaningPreference{
3030 MyAvatar::AllowAvatarLeaningPreference::Default
3032 float _sitStandStateTimer { 0.0f };
3033 float _tippingPoint { _userHeight.get() };
3036 bool _shouldLoadScripts {
false };
3038 bool _haveReceivedHeightLimitsFromDomain {
false };
3039 int _disableHandTouchCount { 0 };
3040 bool _reloadAvatarEntityDataFromSettings {
true };
3042 TimePoint _nextTraitsSendWindow;
3072 std::vector<Setting::Handle<QUuid>> _avatarEntityIDSettings;
3073 std::vector<Setting::Handle<QByteArray>> _avatarEntityDataSettings;
3080 mutable AvatarEntityMap _cachedAvatarEntityBlobs;
3091 std::vector<EntityItemID> _entitiesToDelete;
3092 std::vector<EntityItemID> _entitiesToAdd;
3093 std::vector<EntityItemID> _entitiesToUpdate;
3098 std::vector<EntityItemID> _cachedAvatarEntityBlobsToDelete;
3099 std::vector<EntityItemID> _cachedAvatarEntityBlobsToAddOrUpdate;
3100 std::vector<EntityItemID> _cachedAvatarEntityBlobUpdatesToSkip;
3103 mutable std::set<EntityItemID> _staleCachedAvatarEntityBlobs;
3110 bool _needToSaveAvatarEntitySettings {
false };
3112 bool _reactionTriggers[NUM_AVATAR_TRIGGER_REACTIONS] {
false,
false };
3113 int _reactionEnabledRefCounts[NUM_AVATAR_BEGIN_END_REACTIONS] { 0, 0, 0 };
3115 mutable std::mutex _reactionLock;
3118 bool _endSitKeyPressComplete {
false };
3120 glm::vec3 _cameraEyesOffset;
3121 float _landingAfterJumpTime { 0.0f };
3123 QTimer _addAvatarEntitiesToTreeTimer;
3126 Q_DECLARE_METATYPE(MyAvatar::DriveKeys)
3129 bool audioListenModeFromScriptValue(
const ScriptValue&
object, AudioListenerMode& audioListenerMode);
3132 bool driveKeysFromScriptValue(
const ScriptValue&
object, MyAvatar::DriveKeys& driveKeys);
3134 bool isWearableEntity(
const EntityItemPointer& entity);
Abstract ID for editing model items. Used in EntityItem JS API.
Definition: EntityItemID.h:28
Definition: EntityItemProperties.h:106
Provides a wrapper around script engine that does not have ScriptManager.
Definition: HelperScriptEngine.h:31
Provides an engine-independent interface for a scripting engine.
Definition: ScriptEngine.h:93
[ScriptInterface] Provides an engine-independent interface for QScriptValue
Definition: ScriptValue.h:40
1.9.1