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

Merge pull request #94 from Ventrella/master

Browse source 
improved logic of avatar hand movement and also usingBodySprings
This commit is contained in:
ZappoMan 2013-04-19 15:18:46 -07:00
commit de209e9587
3 changed files with 147 additions and 194 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

206
interface/src/Head.cpp
View file

@ -33,7 +33,7 @@ float MouthWidthChoices[3] = {0.5, 0.77, 0.3};
float browWidth = 0.8; float browWidth = 0.8;
float browThickness = 0.16; float browThickness = 0.16;
bool usingBigSphereCollisionTest = false; bool usingBigSphereCollisionTest = true;
const float DECAY = 0.1; const float DECAY = 0.1;
const float THRUST_MAG = 10.0; const float THRUST_MAG = 10.0;
@ -47,9 +47,9 @@ unsigned int iris_texture_height = 256;
Head::Head(bool isMine) { Head::Head(bool isMine) {
_avatar.orientation.setToIdentity(); _orientation.setToIdentity();
_avatar.velocity = glm::vec3( 0.0, 0.0, 0.0 ); _velocity = glm::vec3( 0.0, 0.0, 0.0 );
_avatar.thrust = glm::vec3( 0.0, 0.0, 0.0 ); _thrust = glm::vec3( 0.0, 0.0, 0.0 );
_rotation = glm::quat( 0.0f, 0.0f, 0.0f, 0.0f ); _rotation = glm::quat( 0.0f, 0.0f, 0.0f, 0.0f );
_closestOtherAvatar = 0; _closestOtherAvatar = 0;
_bodyYaw = -90.0; _bodyYaw = -90.0;
@ -104,10 +104,8 @@ Head::Head(bool isMine) {
_lastLoudness = 0.0; _lastLoudness = 0.0;
_browAudioLift = 0.0; _browAudioLift = 0.0;
_noise = 0; _noise = 0;
_handBeingMoved = false;
_previousHandBeingMoved = false;
_movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 ); _movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 );
_usingSprings = false; _usingBodySprings = false;
_springForce = 6.0f; _springForce = 6.0f;
_springVelocityDecay = 16.0f; _springVelocityDecay = 16.0f;
@ -136,9 +134,9 @@ Head::Head(bool isMine) {
Head::Head(const Head &otherHead) { Head::Head(const Head &otherHead) {
_avatar.orientation.set( otherHead._avatar.orientation ); _orientation.set( otherHead._orientation );
_avatar.velocity = otherHead._avatar.velocity; _velocity = otherHead._velocity;
_avatar.thrust = otherHead._avatar.thrust; _thrust = otherHead._thrust;
_rotation = otherHead._rotation; _rotation = otherHead._rotation;
_closestOtherAvatar = otherHead._closestOtherAvatar; _closestOtherAvatar = otherHead._closestOtherAvatar;
_bodyYaw = otherHead._bodyYaw; _bodyYaw = otherHead._bodyYaw;
@ -316,7 +314,7 @@ void Head::simulate(float deltaTime) {
float distance = glm::length( v ); float distance = glm::length( v );
if ( distance < _avatar.maxArmLength ) { if ( distance < _maxArmLength ) {
if ( distance < closestDistance ) { if ( distance < closestDistance ) {
closestDistance = distance; closestDistance = distance;
_closestOtherAvatar = o; _closestOtherAvatar = o;
@ -338,60 +336,43 @@ void Head::simulate(float deltaTime) {
//------------------------ //------------------------
updateSkeleton(); updateSkeleton();
//------------------------------------------------------------------------ //------------------------------------------------------------
// reset hand and elbow position according to hand movement // reset hand and arm positions according to hand movement
//------------------------------------------------------------------------ //------------------------------------------------------------
if ( _handBeingMoved ){ if (_usingBodySprings) {
if (! _previousHandBeingMoved ){
initializeBodySprings();
_usingSprings = true;
//printLog( "just started moving hand\n" );
}
}
else {
if ( _previousHandBeingMoved ){
_usingSprings = false;
//printLog( "just stopped moving hand\n" );
}
}
if ( _handBeingMoved ) {
updateHandMovement(); updateHandMovement();
updateBodySprings( deltaTime ); updateBodySprings( deltaTime );
} }
_previousHandBeingMoved = _handBeingMoved;
_handBeingMoved = false;
if ( _isMine ) { // driving the avatar around should only apply is this is my avatar (as opposed to an avatar being driven remotely) if ( _isMine ) { // driving the avatar around should only apply if this is my avatar (as opposed to an avatar being driven remotely)
//------------------------------------------------- //-------------------------------------------------
// this handles the avatar being driven around... // this handles the avatar being driven around...
//------------------------------------------------- //-------------------------------------------------
_avatar.thrust = glm::vec3( 0.0, 0.0, 0.0 ); _thrust = glm::vec3( 0.0, 0.0, 0.0 );
if (_driveKeys[FWD]) { if (_driveKeys[FWD]) {
glm::vec3 front( _avatar.orientation.getFront().x, _avatar.orientation.getFront().y, _avatar.orientation.getFront().z ); glm::vec3 front( _orientation.getFront().x, _orientation.getFront().y, _orientation.getFront().z );
_avatar.thrust += front * THRUST_MAG; _thrust += front * THRUST_MAG;
} }
if (_driveKeys[BACK]) { if (_driveKeys[BACK]) {
glm::vec3 front( _avatar.orientation.getFront().x, _avatar.orientation.getFront().y, _avatar.orientation.getFront().z ); glm::vec3 front( _orientation.getFront().x, _orientation.getFront().y, _orientation.getFront().z );
_avatar.thrust -= front * THRUST_MAG; _thrust -= front * THRUST_MAG;
} }
if (_driveKeys[RIGHT]) { if (_driveKeys[RIGHT]) {
glm::vec3 right( _avatar.orientation.getRight().x, _avatar.orientation.getRight().y, _avatar.orientation.getRight().z ); glm::vec3 right( _orientation.getRight().x, _orientation.getRight().y, _orientation.getRight().z );
_avatar.thrust += right * THRUST_MAG; _thrust += right * THRUST_MAG;
} }
if (_driveKeys[LEFT]) { if (_driveKeys[LEFT]) {
glm::vec3 right( _avatar.orientation.getRight().x, _avatar.orientation.getRight().y, _avatar.orientation.getRight().z ); glm::vec3 right( _orientation.getRight().x, _orientation.getRight().y, _orientation.getRight().z );
_avatar.thrust -= right * THRUST_MAG; _thrust -= right * THRUST_MAG;
} }
if (_driveKeys[UP]) { if (_driveKeys[UP]) {
glm::vec3 up( _avatar.orientation.getUp().x, _avatar.orientation.getUp().y, _avatar.orientation.getUp().z ); glm::vec3 up( _orientation.getUp().x, _orientation.getUp().y, _orientation.getUp().z );
_avatar.thrust += up * THRUST_MAG; _thrust += up * THRUST_MAG;
} }
if (_driveKeys[DOWN]) { if (_driveKeys[DOWN]) {
glm::vec3 up( _avatar.orientation.getUp().x, _avatar.orientation.getUp().y, _avatar.orientation.getUp().z ); glm::vec3 up( _orientation.getUp().x, _orientation.getUp().y, _orientation.getUp().z );
_avatar.thrust -= up * THRUST_MAG; _thrust -= up * THRUST_MAG;
} }
if (_driveKeys[ROT_RIGHT]) { if (_driveKeys[ROT_RIGHT]) {
_bodyYawDelta -= YAW_MAG * deltaTime; _bodyYawDelta -= YAW_MAG * deltaTime;
@ -403,7 +384,7 @@ void Head::simulate(float deltaTime) {
//---------------------------------------------------------- //----------------------------------------------------------
float translationalSpeed = glm::length( _avatar.velocity ); float translationalSpeed = glm::length( _velocity );
float rotationalSpeed = fabs( _bodyYawDelta ); float rotationalSpeed = fabs( _bodyYawDelta );
if ( translationalSpeed + rotationalSpeed > 0.2 ) if ( translationalSpeed + rotationalSpeed > 0.2 )
{ {
@ -411,7 +392,7 @@ void Head::simulate(float deltaTime) {
} }
else else
{ {
_mode = AVATAR_MODE_COMMUNICATING; _mode = AVATAR_MODE_INTERACTING;
} }
//---------------------------------------------------------- //----------------------------------------------------------
@ -435,18 +416,18 @@ void Head::simulate(float deltaTime) {
//---------------------------------------------------------- //----------------------------------------------------------
// add thrust to velocity // add thrust to velocity
//---------------------------------------------------------- //----------------------------------------------------------
_avatar.velocity += glm::dvec3(_avatar.thrust * deltaTime); _velocity += glm::dvec3(_thrust * deltaTime);
//---------------------------------------------------------- //----------------------------------------------------------
// update position by velocity // update position by velocity
//---------------------------------------------------------- //----------------------------------------------------------
_bodyPosition += (glm::vec3)_avatar.velocity * deltaTime; _bodyPosition += (glm::vec3)_velocity * deltaTime;
//---------------------------------------------------------- //----------------------------------------------------------
// decay velocity // decay velocity
//---------------------------------------------------------- //----------------------------------------------------------
const float LIN_VEL_DECAY = 5.0; const float LIN_VEL_DECAY = 5.0;
_avatar.velocity *= ( 1.0 - LIN_VEL_DECAY * deltaTime ); _velocity *= ( 1.0 - LIN_VEL_DECAY * deltaTime );
if (!_noise) { if (!_noise) {
// Decay back toward center // Decay back toward center
@ -565,24 +546,36 @@ void Head::updateBigSphereCollisionTest( float deltaTime ) {
float amp = 1.0 - (distanceToBigSphereCenter / combinedRadius); float amp = 1.0 - (distanceToBigSphereCenter / combinedRadius);
glm::vec3 collisionForce = vectorFromJointToBigSphere * amp; glm::vec3 collisionForce = vectorFromJointToBigSphere * amp;
_bone[b].springyVelocity += collisionForce * 8.0f * deltaTime; _bone[b].springyVelocity += collisionForce * 8.0f * deltaTime;
_avatar.velocity += collisionForce * 18.0f * deltaTime; _velocity += collisionForce * 18.0f * deltaTime;
} }
} }
} }
if ( jointCollision ) { if ( jointCollision ) {
if (!_usingBodySprings) {
_usingBodySprings = true;
initializeBodySprings();
}
/*
else {
if (_usingSprings) {
_usingSprings = false;
}
}
*/
//---------------------------------------------------------- //----------------------------------------------------------
// add gravity to velocity // add gravity to velocity
//---------------------------------------------------------- //----------------------------------------------------------
_avatar.velocity += glm::dvec3( 0.0, -1.0, 0.0 ) * 0.05; _velocity += glm::dvec3( 0.0, -1.0, 0.0 ) * 0.05;
//---------------------------------------------------------- //----------------------------------------------------------
// ground collisions // ground collisions
//---------------------------------------------------------- //----------------------------------------------------------
if ( _bodyPosition.y < 0.0 ) { if ( _bodyPosition.y < 0.0 ) {
_bodyPosition.y = 0.0; _bodyPosition.y = 0.0;
if ( _avatar.velocity.y < 0.0 ) { if ( _velocity.y < 0.0 ) {
_avatar.velocity.y *= -0.7; _velocity.y *= -0.7;
} }
} }
} }
@ -648,7 +641,7 @@ void Head::render(int faceToFace) {
glPopMatrix(); glPopMatrix();
} }
if ( _usingSprings ) { if (_usingBodySprings) {
if ( _closestOtherAvatar != -1 ) { if ( _closestOtherAvatar != -1 ) {
glm::vec3 v1( _bone[ AVATAR_BONE_RIGHT_HAND ].position ); glm::vec3 v1( _bone[ AVATAR_BONE_RIGHT_HAND ].position );
@ -665,35 +658,6 @@ void Head::render(int faceToFace) {
} }
} }
//this has been moved to Utils.cpp
/*
void Head::renderOrientationDirections( glm::vec3 position, Orientation orientation, float size ) {
glm::vec3 pRight = position + orientation.right * size;
glm::vec3 pUp = position + orientation.up * size;
glm::vec3 pFront = position + orientation.front * size;
glColor3f( 1.0f, 0.0f, 0.0f );
glBegin( GL_LINE_STRIP );
glVertex3f( position.x, position.y, position.z );
glVertex3f( pRight.x, pRight.y, pRight.z );
glEnd();
glColor3f( 0.0f, 1.0f, 0.0f );
glBegin( GL_LINE_STRIP );
glVertex3f( position.x, position.y, position.z );
glVertex3f( pUp.x, pUp.y, pUp.z );
glEnd();
glColor3f( 0.0f, 0.0f, 1.0f );
glBegin( GL_LINE_STRIP );
glVertex3f( position.x, position.y, position.z );
glVertex3f( pFront.x, pFront.y, pFront.z );
glEnd();
}
*/
void Head::renderHead(int faceToFace) { void Head::renderHead(int faceToFace) {
@ -704,7 +668,7 @@ void Head::renderHead(int faceToFace) {
glPushMatrix(); glPushMatrix();
if (_usingSprings) { if (_usingBodySprings) {
glTranslatef glTranslatef
( (
_bone[ AVATAR_BONE_HEAD ].springyPosition.x, _bone[ AVATAR_BONE_HEAD ].springyPosition.x,
@ -862,10 +826,19 @@ void Head::renderHead(int faceToFace) {
} }
void Head::startHandMovement() {
void Head::setHandMovement( glm::vec3 handOffset ) { if (!_usingBodySprings) {
_handBeingMoved = true; initializeBodySprings();
_usingBodySprings = true;
}
}
void Head::stopHandMovement() {
_usingBodySprings = false;
}
void Head::setHandMovementValues( glm::vec3 handOffset ) {
_movedHandOffset = handOffset; _movedHandOffset = handOffset;
} }
@ -873,7 +846,6 @@ AvatarMode Head::getMode() {
return _mode; return _mode;
} }
void Head::initializeSkeleton() { void Head::initializeSkeleton() {
for (int b=0; b<NUM_AVATAR_BONES; b++) { for (int b=0; b<NUM_AVATAR_BONES; b++) {
@ -985,7 +957,7 @@ void Head::calculateBoneLengths() {
_bone[b].length = glm::length( _bone[b].defaultPosePosition ); _bone[b].length = glm::length( _bone[b].defaultPosePosition );
} }
_avatar.maxArmLength _maxArmLength
= _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].length = _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].length
+ _bone[ AVATAR_BONE_RIGHT_FOREARM ].length + _bone[ AVATAR_BONE_RIGHT_FOREARM ].length
+ _bone[ AVATAR_BONE_RIGHT_HAND ].length; + _bone[ AVATAR_BONE_RIGHT_HAND ].length;
@ -995,13 +967,13 @@ void Head::updateSkeleton() {
//---------------------------------- //----------------------------------
// rotate body... // rotate body...
//---------------------------------- //----------------------------------
_avatar.orientation.setToIdentity(); _orientation.setToIdentity();
_avatar.orientation.yaw( _bodyYaw ); _orientation.yaw( _bodyYaw );
//test! - make sure this does what expected: st rotation to be identity PLUS _bodyYaw //test! - make sure this does what expected: st rotation to be identity PLUS _bodyYaw
//_rotation = glm::angleAxis( _bodyYaw, _avatar.orientation.up ); //_rotation = glm::angleAxis( _bodyYaw, _orientation.up );
//glm::quat yaw_rotation = glm::angleAxis( _bodyYaw, _avatar.orientation.up ); //glm::quat yaw_rotation = glm::angleAxis( _bodyYaw, _orientation.up );
//------------------------------------------------------------------------ //------------------------------------------------------------------------
@ -1009,7 +981,7 @@ void Head::updateSkeleton() {
//------------------------------------------------------------------------ //------------------------------------------------------------------------
for (int b=0; b<NUM_AVATAR_BONES; b++) { for (int b=0; b<NUM_AVATAR_BONES; b++) {
if ( _bone[b].parent == AVATAR_BONE_NULL ) { if ( _bone[b].parent == AVATAR_BONE_NULL ) {
_bone[b].orientation.set( _avatar.orientation ); _bone[b].orientation.set( _orientation );
_bone[b].position = _bodyPosition; _bone[b].position = _bodyPosition;
} }
else { else {
@ -1087,27 +1059,27 @@ void Head::updateBodySprings( float deltaTime ) {
glm::vec3 Head::getHeadLookatDirection() { glm::vec3 Head::getHeadLookatDirection() {
return glm::vec3 return glm::vec3
( (
_avatar.orientation.getFront().x, _orientation.getFront().x,
_avatar.orientation.getFront().y, _orientation.getFront().y,
_avatar.orientation.getFront().z _orientation.getFront().z
); );
} }
glm::vec3 Head::getHeadLookatDirectionUp() { glm::vec3 Head::getHeadLookatDirectionUp() {
return glm::vec3 return glm::vec3
( (
_avatar.orientation.getUp().x, _orientation.getUp().x,
_avatar.orientation.getUp().y, _orientation.getUp().y,
_avatar.orientation.getUp().z _orientation.getUp().z
); );
} }
glm::vec3 Head::getHeadLookatDirectionRight() { glm::vec3 Head::getHeadLookatDirectionRight() {
return glm::vec3 return glm::vec3
( (
_avatar.orientation.getRight().x, _orientation.getRight().x,
_avatar.orientation.getRight().y, _orientation.getRight().y,
_avatar.orientation.getRight().z _orientation.getRight().z
); );
} }
@ -1126,14 +1098,14 @@ void Head::updateHandMovement() {
glm::vec3 transformedHandMovement; glm::vec3 transformedHandMovement;
transformedHandMovement transformedHandMovement
= _avatar.orientation.getRight() * _movedHandOffset.x = _orientation.getRight() * _movedHandOffset.x
+ _avatar.orientation.getUp() * -_movedHandOffset.y * 0.5f + _orientation.getUp() * -_movedHandOffset.y * 0.5f
+ _avatar.orientation.getFront() * -_movedHandOffset.y; + _orientation.getFront() * -_movedHandOffset.y;
_bone[ AVATAR_BONE_RIGHT_HAND ].position += transformedHandMovement; _bone[ AVATAR_BONE_RIGHT_HAND ].position += transformedHandMovement;
//if holding hands, add a pull to the hand... //if holding hands, add a pull to the hand...
if ( _usingSprings ) { if ( _usingBodySprings ) {
if ( _closestOtherAvatar != -1 ) { if ( _closestOtherAvatar != -1 ) {
if ( _triggeringAction ) { if ( _triggeringAction ) {
@ -1166,14 +1138,14 @@ void Head::updateHandMovement() {
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
// if right hand is being dragged beyond maximum arm length... // if right hand is being dragged beyond maximum arm length...
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
if ( distance > _avatar.maxArmLength ) { if ( distance > _maxArmLength ) {
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
// reset right hand to be constrained to maximum arm length // reset right hand to be constrained to maximum arm length
//------------------------------------------------------------------------------- //-------------------------------------------------------------------------------
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position; _bone[ AVATAR_BONE_RIGHT_HAND ].position = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
glm::vec3 armNormal = armVector / distance; glm::vec3 armNormal = armVector / distance;
armVector = armNormal * _avatar.maxArmLength; armVector = armNormal * _maxArmLength;
distance = _avatar.maxArmLength; distance = _maxArmLength;
glm::vec3 constrainedPosition = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position; glm::vec3 constrainedPosition = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
constrainedPosition += armVector; constrainedPosition += armVector;
_bone[ AVATAR_BONE_RIGHT_HAND ].position = constrainedPosition; _bone[ AVATAR_BONE_RIGHT_HAND ].position = constrainedPosition;
@ -1199,9 +1171,9 @@ void Head::updateHandMovement() {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
glm::vec3 newElbowPosition = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position; glm::vec3 newElbowPosition = _bone[ AVATAR_BONE_RIGHT_SHOULDER ].position;
newElbowPosition += armVector * ONE_HALF; newElbowPosition += armVector * ONE_HALF;
glm::vec3 perpendicular = glm::cross( _avatar.orientation.getFront(), armVector ); glm::vec3 perpendicular = glm::cross( _orientation.getFront(), armVector );
newElbowPosition += perpendicular * ( 1.0f - ( _avatar.maxArmLength / distance ) ) * ONE_HALF; newElbowPosition += perpendicular * ( 1.0f - ( _maxArmLength / distance ) ) * ONE_HALF;
_bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].position = newElbowPosition; _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].position = newElbowPosition;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -1225,7 +1197,7 @@ void Head::renderBody() {
// Render bone positions as spheres // Render bone positions as spheres
//----------------------------------------- //-----------------------------------------
for (int b=0; b<NUM_AVATAR_BONES; b++) { for (int b=0; b<NUM_AVATAR_BONES; b++) {
if ( _usingSprings ) { if ( _usingBodySprings ) {
glColor3fv( lightBlue ); glColor3fv( lightBlue );
glPushMatrix(); glPushMatrix();
glTranslatef( _bone[b].springyPosition.x, _bone[b].springyPosition.y, _bone[b].springyPosition.z ); glTranslatef( _bone[b].springyPosition.x, _bone[b].springyPosition.y, _bone[b].springyPosition.z );
@ -1244,7 +1216,7 @@ void Head::renderBody() {
//----------------------------------------------------- //-----------------------------------------------------
// Render lines connecting the bone positions // Render lines connecting the bone positions
//----------------------------------------------------- //-----------------------------------------------------
if ( _usingSprings ) { if ( _usingBodySprings ) {
glColor3f( 0.4f, 0.5f, 0.6f ); glColor3f( 0.4f, 0.5f, 0.6f );
glLineWidth(3.0); glLineWidth(3.0);
@ -1272,7 +1244,7 @@ void Head::renderBody() {
} }
if (( _usingSprings ) && ( _triggeringAction )) { if (( _usingBodySprings ) && ( _triggeringAction )) {
glColor4f( 1.0, 1.0, 0.5, 0.5 ); glColor4f( 1.0, 1.0, 0.5, 0.5 );
glPushMatrix(); glPushMatrix();
glTranslatef glTranslatef

29
interface/src/Head.h
View file

@ -40,7 +40,7 @@ enum AvatarMode
{ {
AVATAR_MODE_STANDING = 0, AVATAR_MODE_STANDING = 0,
AVATAR_MODE_WALKING, AVATAR_MODE_WALKING,
AVATAR_MODE_COMMUNICATING, AVATAR_MODE_INTERACTING,
NUM_AVATAR_MODES NUM_AVATAR_MODES
}; };
@ -91,14 +91,6 @@ struct AvatarBone
float radius; // used for detecting collisions for certain physical effects float radius; // used for detecting collisions for certain physical effects
}; };
struct Avatar
{
glm::dvec3 velocity;
glm::vec3 thrust;
float maxArmLength;
Orientation orientation;
};
class Head : public AvatarData { class Head : public AvatarData {
public: public:
Head(bool isMine); Head(bool isMine);
@ -149,7 +141,9 @@ class Head : public AvatarData {
void simulate(float); void simulate(float);
void setHandMovement( glm::vec3 movement ); void startHandMovement();
void stopHandMovement();
void setHandMovementValues( glm::vec3 movement );
void updateHandMovement(); void updateHandMovement();
float getLoudness() {return _loudness;}; float getLoudness() {return _loudness;};
@ -164,9 +158,9 @@ class Head : public AvatarData {
bool getDriveKeys(int key) { return _driveKeys[key]; }; bool getDriveKeys(int key) { return _driveKeys[key]; };
// Set/Get update the thrust that will move the avatar around // Set/Get update the thrust that will move the avatar around
void setThrust(glm::vec3 newThrust) { _avatar.thrust = newThrust; }; void setThrust(glm::vec3 newThrust) { _thrust = newThrust; };
void addThrust(glm::vec3 newThrust) { _avatar.thrust += newThrust; }; void addThrust(glm::vec3 newThrust) { _thrust += newThrust; };
glm::vec3 getThrust() { return _avatar.thrust; }; glm::vec3 getThrust() { return _thrust; };
// //
// Related to getting transmitter UDP data used to animate the avatar hand // Related to getting transmitter UDP data used to animate the avatar hand
@ -218,16 +212,17 @@ class Head : public AvatarData {
float _bodyYawDelta; float _bodyYawDelta;
float _closeEnoughToInteract; float _closeEnoughToInteract;
int _closestOtherAvatar; int _closestOtherAvatar;
bool _usingSprings; bool _usingBodySprings;
bool _handBeingMoved;
bool _previousHandBeingMoved;
glm::vec3 _movedHandOffset; glm::vec3 _movedHandOffset;
float _springVelocityDecay; float _springVelocityDecay;
float _springForce; float _springForce;
glm::quat _rotation; // the rotation of the avatar body as a whole glm::quat _rotation; // the rotation of the avatar body as a whole
AvatarBone _bone[ NUM_AVATAR_BONES ]; AvatarBone _bone[ NUM_AVATAR_BONES ];
AvatarMode _mode; AvatarMode _mode;
Avatar _avatar; glm::dvec3 _velocity;
glm::vec3 _thrust;
float _maxArmLength;
Orientation _orientation;
int _driveKeys[MAX_DRIVE_KEYS]; int _driveKeys[MAX_DRIVE_KEYS];
int _eyeContact; int _eyeContact;
eyeContactTargets _eyeContactTarget; eyeContactTargets _eyeContactTarget;

106
interface/src/main.cpp
View file

@ -177,7 +177,7 @@ int mousePressed = 0; // true if mouse has been pressed (clear when finished)
Menu menu; // main menu Menu menu; // main menu
int menuOn = 1; // Whether to show onscreen menu int menuOn = 1; // Whether to show onscreen menu
struct HandMovement struct HandController
{ {
bool enabled; bool enabled;
int startX; int startX;
@ -193,59 +193,61 @@ struct HandMovement
float envelope; float envelope;
}; };
HandMovement handMovement; HandController handController;
void initializeHandMovement() { void initializeHandController() {
handMovement.enabled = false; handController.enabled = false;
handMovement.startX = WIDTH / 2; handController.startX = WIDTH / 2;
handMovement.startY = HEIGHT / 2; handController.startY = HEIGHT / 2;
handMovement.x = 0; handController.x = 0;
handMovement.y = 0; handController.y = 0;
handMovement.lastX = 0; handController.lastX = 0;
handMovement.lastY = 0; handController.lastY = 0;
handMovement.velocityX = 0; handController.velocityX = 0;
handMovement.velocityY = 0; handController.velocityY = 0;
handMovement.rampUpRate = 0.05; handController.rampUpRate = 0.05;
handMovement.rampDownRate = 0.02; handController.rampDownRate = 0.02;
handMovement.envelope = 0.0f; handController.envelope = 0.0f;
} }
void updateHandMovement( int x, int y ) { void updateHandController( int x, int y ) {
handMovement.lastX = handMovement.x; handController.lastX = handController.x;
handMovement.lastY = handMovement.y; handController.lastY = handController.y;
handMovement.x = x; handController.x = x;
handMovement.y = y; handController.y = y;
handMovement.velocityX = handMovement.x - handMovement.lastX; handController.velocityX = handController.x - handController.lastX;
handMovement.velocityY = handMovement.y - handMovement.lastY; handController.velocityY = handController.y - handController.lastY;
if (( handMovement.velocityX != 0 ) if (( handController.velocityX != 0 )
|| ( handMovement.velocityY != 0 )) { || ( handController.velocityY != 0 )) {
handMovement.enabled = true; handController.enabled = true;
if ( handMovement.envelope < 1.0 ) { myAvatar.startHandMovement();
handMovement.envelope += handMovement.rampUpRate; if ( handController.envelope < 1.0 ) {
if ( handMovement.envelope >= 1.0 ) { handController.envelope += handController.rampUpRate;
handMovement.envelope = 1.0; if ( handController.envelope >= 1.0 ) {
handController.envelope = 1.0;
} }
} }
} }
if ( ! handMovement.enabled ) { if ( ! handController.enabled ) {
if ( handMovement.envelope > 0.0 ) { if ( handController.envelope > 0.0 ) {
handMovement.envelope -= handMovement.rampDownRate; handController.envelope -= handController.rampDownRate;
if ( handMovement.envelope <= 0.0 ) { if ( handController.envelope <= 0.0 ) {
handMovement.startX = WIDTH / 2; handController.startX = WIDTH / 2;
handMovement.startY = HEIGHT / 2; handController.startY = HEIGHT / 2;
handMovement.envelope = 0.0; handController.envelope = 0.0;
myAvatar.stopHandMovement();
} }
} }
} }
if ( handMovement.envelope > 0.0 ) { if ( handController.envelope > 0.0 ) {
float leftRight = ( ( handMovement.x - handMovement.startX ) / (float)WIDTH ) * handMovement.envelope; float leftRight = ( ( handController.x - handController.startX ) / (float)WIDTH ) * handController.envelope;
float downUp = ( ( handMovement.y - handMovement.startY ) / (float)HEIGHT ) * handMovement.envelope; float downUp = ( ( handController.y - handController.startY ) / (float)HEIGHT ) * handController.envelope;
float backFront = 0.0; float backFront = 0.0;
myAvatar.setHandMovement( glm::vec3( leftRight, downUp, backFront ) ); myAvatar.setHandMovementValues( glm::vec3( leftRight, downUp, backFront ) );
} }
} }
@ -378,7 +380,7 @@ void init(void)
voxels.setViewerHead(&myAvatar); voxels.setViewerHead(&myAvatar);
myAvatar.setRenderYaw(startYaw); myAvatar.setRenderYaw(startYaw);
initializeHandMovement(); initializeHandController();
headMouseX = WIDTH/2; headMouseX = WIDTH/2;
headMouseY = HEIGHT/2; headMouseY = HEIGHT/2;
@ -444,22 +446,6 @@ void reset_sensors()
} }
} }
/*
void updateAvatarHand(float deltaTime) {
// If mouse is being dragged, send current force to the hand controller
if (mousePressed == 1)
{
// NOTE--PER: Need to re-implement when ready for new avatar hand movements
const float MOUSE_HAND_FORCE = 1.5;
float dx = mouseX - mouseStartX;
float dy = mouseY - mouseStartY;
glm::vec3 vel(dx*MOUSE_HAND_FORCE, -dy*MOUSE_HAND_FORCE*(WIDTH/HEIGHT), 0);
//myAvatar.hand->addVelocity(vel*deltaTime);
}
}
*/
// //
// Using gyro data, update both view frustum and avatar head position // Using gyro data, update both view frustum and avatar head position
// //
@ -1416,7 +1402,7 @@ void idle(void) {
float deltaTime = 1.f/FPS; float deltaTime = 1.f/FPS;
// update behaviors for avatar hand movement // update behaviors for avatar hand movement
updateHandMovement( mouseX, mouseY ); updateHandController( mouseX, mouseY );
// when the mouse is being pressed, an 'action' is being // when the mouse is being pressed, an 'action' is being
// triggered in the avatar. The action is context-based. // triggered in the avatar. The action is context-based.
@ -1427,9 +1413,9 @@ void idle(void) {
myAvatar.setTriggeringAction( false ); myAvatar.setTriggeringAction( false );
} }
// walking triggers the handMovement to stop // walking triggers the handController to stop
if ( myAvatar.getMode() == AVATAR_MODE_WALKING ) { if ( myAvatar.getMode() == AVATAR_MODE_WALKING ) {
handMovement.enabled = false; handController.enabled = false;
} }
// //