Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-08-07 16:41:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add MyAvatar drive keys capture capability

Browse source
This commit is contained in:
Atlante45 2017-03-15 13:49:50 -07:00
parent 21c5e7b0b2
commit 7517f224a8
3 changed files with 37 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
interface/src/Application.cpp
View file

@ -4383,16 +4383,16 @@ void Application::update(float deltaTime) {
myAvatar->clearDriveKeys(); myAvatar->clearDriveKeys();
if (_myCamera.getMode() != CAMERA_MODE_INDEPENDENT) { if (_myCamera.getMode() != CAMERA_MODE_INDEPENDENT) {
if (!_controllerScriptingInterface->areActionsCaptured()) { if (!_controllerScriptingInterface->areActionsCaptured()) {
myAvatar->setDriveKeys(TRANSLATE_Z, -1.0f * userInputMapper->getActionState(controller::Action::TRANSLATE_Z)); myAvatar->setDriveKey(TRANSLATE_Z, -1.0f * userInputMapper->getActionState(controller::Action::TRANSLATE_Z));
myAvatar->setDriveKeys(TRANSLATE_Y, userInputMapper->getActionState(controller::Action::TRANSLATE_Y)); myAvatar->setDriveKey(TRANSLATE_Y, userInputMapper->getActionState(controller::Action::TRANSLATE_Y));
myAvatar->setDriveKeys(TRANSLATE_X, userInputMapper->getActionState(controller::Action::TRANSLATE_X)); myAvatar->setDriveKey(TRANSLATE_X, userInputMapper->getActionState(controller::Action::TRANSLATE_X));
if (deltaTime > FLT_EPSILON) { if (deltaTime > FLT_EPSILON) {
myAvatar->setDriveKeys(PITCH, -1.0f * userInputMapper->getActionState(controller::Action::PITCH)); myAvatar->setDriveKey(PITCH, -1.0f * userInputMapper->getActionState(controller::Action::PITCH));
myAvatar->setDriveKeys(YAW, -1.0f * userInputMapper->getActionState(controller::Action::YAW)); myAvatar->setDriveKey(YAW, -1.0f * userInputMapper->getActionState(controller::Action::YAW));
myAvatar->setDriveKeys(STEP_YAW, -1.0f * userInputMapper->getActionState(controller::Action::STEP_YAW)); myAvatar->setDriveKey(STEP_YAW, -1.0f * userInputMapper->getActionState(controller::Action::STEP_YAW));
} }
} }
myAvatar->setDriveKeys(ZOOM, userInputMapper->getActionState(controller::Action::TRANSLATE_CAMERA_Z)); myAvatar->setDriveKey(ZOOM, userInputMapper->getActionState(controller::Action::TRANSLATE_CAMERA_Z));
} }
controller::Pose leftHandPose = userInputMapper->getPoseState(controller::Action::LEFT_HAND); controller::Pose leftHandPose = userInputMapper->getPoseState(controller::Action::LEFT_HAND);

34
interface/src/avatar/MyAvatar.cpp
View file

@ -119,9 +119,7 @@ MyAvatar::MyAvatar(RigPointer rig) :
using namespace recording; using namespace recording;
_skeletonModel->flagAsCauterized(); _skeletonModel->flagAsCauterized();
for (int i = 0; i < MAX_DRIVE_KEYS; i++) { clearDriveKeys();
_driveKeys[i] = 0.0f;
}
// Necessary to select the correct slot // Necessary to select the correct slot
using SlotType = void(MyAvatar::*)(const glm::vec3&, bool, const glm::quat&, bool); using SlotType = void(MyAvatar::*)(const glm::vec3&, bool, const glm::quat&, bool);
@ -462,7 +460,7 @@ void MyAvatar::simulate(float deltaTime) {
// When there are no step values, we zero out the last step pulse. // When there are no step values, we zero out the last step pulse.
// This allows a user to do faster snapping by tapping a control // This allows a user to do faster snapping by tapping a control
for (int i = STEP_TRANSLATE_X; !stepAction && i <= STEP_YAW; ++i) { for (int i = STEP_TRANSLATE_X; !stepAction && i <= STEP_YAW; ++i) {
if (_driveKeys[i] != 0.0f) { if (getDriveKey(i) != 0.0f) {
stepAction = true; stepAction = true;
} }
} }
@ -1655,7 +1653,7 @@ bool MyAvatar::shouldRenderHead(const RenderArgs* renderArgs) const {
void MyAvatar::updateOrientation(float deltaTime) { void MyAvatar::updateOrientation(float deltaTime) {
// Smoothly rotate body with arrow keys // Smoothly rotate body with arrow keys
float targetSpeed = _driveKeys[YAW] * _yawSpeed; float targetSpeed = getDriveKey(YAW) * _yawSpeed;
if (targetSpeed != 0.0f) { if (targetSpeed != 0.0f) {
const float ROTATION_RAMP_TIMESCALE = 0.1f; const float ROTATION_RAMP_TIMESCALE = 0.1f;
float blend = deltaTime / ROTATION_RAMP_TIMESCALE; float blend = deltaTime / ROTATION_RAMP_TIMESCALE;
@ -1684,8 +1682,8 @@ void MyAvatar::updateOrientation(float deltaTime) {
// Comfort Mode: If you press any of the left/right rotation drive keys or input, you'll // Comfort Mode: If you press any of the left/right rotation drive keys or input, you'll
// get an instantaneous 15 degree turn. If you keep holding the key down you'll get another // get an instantaneous 15 degree turn. If you keep holding the key down you'll get another
// snap turn every half second. // snap turn every half second.
if (_driveKeys[STEP_YAW] != 0.0f) { if (getDriveKey(STEP_YAW) != 0.0f) {
totalBodyYaw += _driveKeys[STEP_YAW]; totalBodyYaw += getDriveKey(STEP_YAW);
} }
// use head/HMD orientation to turn while flying // use head/HMD orientation to turn while flying
@ -1722,7 +1720,7 @@ void MyAvatar::updateOrientation(float deltaTime) {
// update body orientation by movement inputs // update body orientation by movement inputs
setOrientation(getOrientation() * glm::quat(glm::radians(glm::vec3(0.0f, totalBodyYaw, 0.0f)))); setOrientation(getOrientation() * glm::quat(glm::radians(glm::vec3(0.0f, totalBodyYaw, 0.0f))));
getHead()->setBasePitch(getHead()->getBasePitch() + _driveKeys[PITCH] * _pitchSpeed * deltaTime); getHead()->setBasePitch(getHead()->getBasePitch() + getDriveKey(PITCH) * _pitchSpeed * deltaTime);
if (qApp->isHMDMode()) { if (qApp->isHMDMode()) {
glm::quat orientation = glm::quat_cast(getSensorToWorldMatrix()) * getHMDSensorOrientation(); glm::quat orientation = glm::quat_cast(getSensorToWorldMatrix()) * getHMDSensorOrientation();
@ -1756,14 +1754,14 @@ void MyAvatar::updateActionMotor(float deltaTime) {
} }
// compute action input // compute action input
glm::vec3 front = (_driveKeys[TRANSLATE_Z]) * IDENTITY_FRONT; glm::vec3 front = (getDriveKey(TRANSLATE_Z)) * IDENTITY_FRONT;
glm::vec3 right = (_driveKeys[TRANSLATE_X]) * IDENTITY_RIGHT; glm::vec3 right = (getDriveKey(TRANSLATE_X)) * IDENTITY_RIGHT;
glm::vec3 direction = front + right; glm::vec3 direction = front + right;
CharacterController::State state = _characterController.getState(); CharacterController::State state = _characterController.getState();
if (state == CharacterController::State::Hover) { if (state == CharacterController::State::Hover) {
// we're flying --> support vertical motion // we're flying --> support vertical motion
glm::vec3 up = (_driveKeys[TRANSLATE_Y]) * IDENTITY_UP; glm::vec3 up = (getDriveKey(TRANSLATE_Y)) * IDENTITY_UP;
direction += up; direction += up;
} }
@ -1802,7 +1800,7 @@ void MyAvatar::updateActionMotor(float deltaTime) {
_actionMotorVelocity = MAX_WALKING_SPEED * direction; _actionMotorVelocity = MAX_WALKING_SPEED * direction;
} }
float boomChange = _driveKeys[ZOOM]; float boomChange = getDriveKey(ZOOM);
_boomLength += 2.0f * _boomLength * boomChange + boomChange * boomChange; _boomLength += 2.0f * _boomLength * boomChange + boomChange * boomChange;
_boomLength = glm::clamp<float>(_boomLength, ZOOM_MIN, ZOOM_MAX); _boomLength = glm::clamp<float>(_boomLength, ZOOM_MIN, ZOOM_MAX);
} }
@ -1833,11 +1831,11 @@ void MyAvatar::updatePosition(float deltaTime) {
} }
// capture the head rotation, in sensor space, when the user first indicates they would like to move/fly. // capture the head rotation, in sensor space, when the user first indicates they would like to move/fly.
if (!_hoverReferenceCameraFacingIsCaptured && (fabs(_driveKeys[TRANSLATE_Z]) > 0.1f || fabs(_driveKeys[TRANSLATE_X]) > 0.1f)) { if (!_hoverReferenceCameraFacingIsCaptured && (fabs(getDriveKey(TRANSLATE_Z)) > 0.1f || fabs(getDriveKey(TRANSLATE_X)) > 0.1f)) {
_hoverReferenceCameraFacingIsCaptured = true; _hoverReferenceCameraFacingIsCaptured = true;
// transform the camera facing vector into sensor space. // transform the camera facing vector into sensor space.
_hoverReferenceCameraFacing = transformVectorFast(glm::inverse(_sensorToWorldMatrix), getHead()->getCameraOrientation() * Vectors::UNIT_Z); _hoverReferenceCameraFacing = transformVectorFast(glm::inverse(_sensorToWorldMatrix), getHead()->getCameraOrientation() * Vectors::UNIT_Z);
} else if (_hoverReferenceCameraFacingIsCaptured && (fabs(_driveKeys[TRANSLATE_Z]) <= 0.1f && fabs(_driveKeys[TRANSLATE_X]) <= 0.1f)) { } else if (_hoverReferenceCameraFacingIsCaptured && (fabs(getDriveKey(TRANSLATE_Z)) <= 0.1f && fabs(getDriveKey(TRANSLATE_X)) <= 0.1f)) {
_hoverReferenceCameraFacingIsCaptured = false; _hoverReferenceCameraFacingIsCaptured = false;
} }
} }
@ -2094,12 +2092,12 @@ bool MyAvatar::getCharacterControllerEnabled() {
void MyAvatar::clearDriveKeys() { void MyAvatar::clearDriveKeys() {
for (int i = 0; i < MAX_DRIVE_KEYS; ++i) { for (int i = 0; i < MAX_DRIVE_KEYS; ++i) {
_driveKeys[i] = 0.0f; setDriveKey(i, 0.0f);
} }
} }
void MyAvatar::relayDriveKeysToCharacterController() { void MyAvatar::relayDriveKeysToCharacterController() {
if (_driveKeys[TRANSLATE_Y] > 0.0f) { if (getDriveKey(TRANSLATE_Y) > 0.0f) {
_characterController.jump(); _characterController.jump();
} }
} }
@ -2382,7 +2380,7 @@ bool MyAvatar::didTeleport() {
} }
bool MyAvatar::hasDriveInput() const { bool MyAvatar::hasDriveInput() const {
return fabsf(_driveKeys[TRANSLATE_X]) > 0.0f || fabsf(_driveKeys[TRANSLATE_Y]) > 0.0f || fabsf(_driveKeys[TRANSLATE_Z]) > 0.0f; return fabsf(getDriveKey(TRANSLATE_X)) > 0.0f || fabsf(getDriveKey(TRANSLATE_Y)) > 0.0f || fabsf(getDriveKey(TRANSLATE_Z)) > 0.0f;
} }
void MyAvatar::setAway(bool value) { void MyAvatar::setAway(bool value) {
@ -2498,7 +2496,7 @@ bool MyAvatar::pinJoint(int index, const glm::vec3& position, const glm::quat& o
return false; return false;
} }
setPosition(position); slamPosition(position);
setOrientation(orientation); setOrientation(orientation);
_rig->setMaxHipsOffsetLength(0.05f); _rig->setMaxHipsOffsetLength(0.05f);

17
interface/src/avatar/MyAvatar.h
View file

@ -12,6 +12,8 @@
#ifndef hifi_MyAvatar_h #ifndef hifi_MyAvatar_h
#define hifi_MyAvatar_h #define hifi_MyAvatar_h
#include <bitset>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include <SettingHandle.h> #include <SettingHandle.h>
@ -87,6 +89,8 @@ class MyAvatar : public Avatar {
Q_PROPERTY(bool hmdLeanRecenterEnabled READ getHMDLeanRecenterEnabled WRITE setHMDLeanRecenterEnabled) Q_PROPERTY(bool hmdLeanRecenterEnabled READ getHMDLeanRecenterEnabled WRITE setHMDLeanRecenterEnabled)
Q_PROPERTY(bool characterControllerEnabled READ getCharacterControllerEnabled WRITE setCharacterControllerEnabled) Q_PROPERTY(bool characterControllerEnabled READ getCharacterControllerEnabled WRITE setCharacterControllerEnabled)
Q_ENUMS(DriveKeys)
public: public:
explicit MyAvatar(RigPointer rig); explicit MyAvatar(RigPointer rig);
~MyAvatar(); ~MyAvatar();
@ -180,9 +184,15 @@ public:
// Set what driving keys are being pressed to control thrust levels // Set what driving keys are being pressed to control thrust levels
void clearDriveKeys(); void clearDriveKeys();
void setDriveKeys(int key, float val) { _driveKeys[key] = val; }; void setDriveKey(int key, float val) { _driveKeys[key] = val; };
float getDriveKey(int key) const { return isDriveKeyCaptured(key) ? 0.0f : _driveKeys[key]; };
Q_INVOKABLE float getRawDriveKey(int key) const { return _driveKeys[key]; };
void relayDriveKeysToCharacterController(); void relayDriveKeysToCharacterController();
Q_INVOKABLE void captureDriveKey(int key) { _capturedDriveKeys.set(key); }
Q_INVOKABLE void releaseDriveKey(int key) { _capturedDriveKeys.reset(key); }
Q_INVOKABLE bool isDriveKeyCaptured(int key) const { return _capturedDriveKeys.test(key); }
eyeContactTarget getEyeContactTarget(); eyeContactTarget getEyeContactTarget();
Q_INVOKABLE glm::vec3 getTrackedHeadPosition() const { return _trackedHeadPosition; } Q_INVOKABLE glm::vec3 getTrackedHeadPosition() const { return _trackedHeadPosition; }
@ -352,7 +362,6 @@ private:
virtual bool shouldRenderHead(const RenderArgs* renderArgs) const override; virtual bool shouldRenderHead(const RenderArgs* renderArgs) const override;
void setShouldRenderLocally(bool shouldRender) { _shouldRender = shouldRender; setEnableMeshVisible(shouldRender); } void setShouldRenderLocally(bool shouldRender) { _shouldRender = shouldRender; setEnableMeshVisible(shouldRender); }
bool getShouldRenderLocally() const { return _shouldRender; } bool getShouldRenderLocally() const { return _shouldRender; }
bool getDriveKeys(int key) { return _driveKeys[key] != 0.0f; };
bool isMyAvatar() const override { return true; } bool isMyAvatar() const override { return true; }
virtual int parseDataFromBuffer(const QByteArray& buffer) override; virtual int parseDataFromBuffer(const QByteArray& buffer) override;
virtual glm::vec3 getSkeletonPosition() const override; virtual glm::vec3 getSkeletonPosition() const override;
@ -388,7 +397,9 @@ private:
void clampScaleChangeToDomainLimits(float desiredScale); void clampScaleChangeToDomainLimits(float desiredScale);
glm::mat4 computeCameraRelativeHandControllerMatrix(const glm::mat4& controllerSensorMatrix) const; glm::mat4 computeCameraRelativeHandControllerMatrix(const glm::mat4& controllerSensorMatrix) const;
float _driveKeys[MAX_DRIVE_KEYS]; std::array<float, MAX_DRIVE_KEYS> _driveKeys;
std::bitset<MAX_DRIVE_KEYS> _capturedDriveKeys;
bool _wasPushing; bool _wasPushing;
bool _isPushing; bool _isPushing;
bool _isBeingPushed; bool _isBeingPushed;