Mirrors/overte-JulianGro
3
0
Fork 0
mirror of https://github.com/JulianGro/overte.git synced 2025-04-25 17:14:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of https://github.com/worklist/hifi into voxel_animation

Browse source
This commit is contained in:
ZappoMan 2013-05-21 12:47:46 -07:00
commit 9f23f846a9
10 changed files with 248 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
interface/src/Application.cpp
View file

@ -298,8 +298,9 @@ void Application::paintGL() {
_myCamera.setDistance (0.0f);
_myCamera.setTightness (100.0f);
_myCamera.setTargetPosition(_myAvatar.getHeadPosition());
_myCamera.setTargetRotation(_myAvatar.getBodyYaw() + _myAvatar.getHeadYaw(),
-_myAvatar.getHeadPitch(), _myAvatar.getHeadRoll());
_myCamera.setTargetRotation(_myAvatar.getBodyYaw() + _myAvatar.getHead().getYaw(),
-_myAvatar.getHead().getPitch(),
_myAvatar.getHead().getRoll());
} else if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
_myCamera.setTightness (100.0f);
@ -1363,29 +1364,13 @@ void Application::updateAvatar(float deltaTime) {
_headMouseY = max(_headMouseY, 0);
_headMouseY = min(_headMouseY, _glWidget->height());
// Update head and body pitch and yaw based on measured gyro rates
if (_gyroLook->isChecked()) {
// Render Yaw
/* NOTE: PER - Leave here until I get back and can modify to couple gyros to head pitch, yaw
float renderYawSpring = fabs(_headMouseX - _glWidget->width() / 2.f) / (_glWidget->width() / 2.f);
const float RENDER_YAW_MULTIPLY = 4.f;
_myAvatar.setRenderYaw((1.f - renderYawSpring * deltaTime) * _myAvatar.getRenderYaw() +
renderYawSpring * deltaTime * -_myAvatar.getHeadYaw() * RENDER_YAW_MULTIPLY);
// Render Pitch
float renderPitchSpring = fabs(_headMouseY - _glWidget->height() / 2.f) / (_glWidget->height() / 2.f);
const float RENDER_PITCH_MULTIPLY = 4.f;
_myAvatar.setRenderPitch((1.f - renderPitchSpring * deltaTime) * _myAvatar.getRenderPitch() +
renderPitchSpring * deltaTime * -_myAvatar.getHeadPitch() * RENDER_PITCH_MULTIPLY);
*/
}
if (OculusManager::isConnected()) {
float yaw, pitch, roll;
OculusManager::getEulerAngles(yaw, pitch, roll);
_myAvatar.setHeadYaw(-yaw);
_myAvatar.setHeadPitch(pitch);
_myAvatar.setHeadRoll(roll);
_myAvatar.getHead().setYaw(-yaw);
_myAvatar.getHead().setPitch(pitch);
_myAvatar.getHead().setRoll(roll);
}
// Get audio loudness data from audio input device

181
interface/src/Avatar.cpp
View file

@ -59,58 +59,66 @@ bool usingBigSphereCollisionTest = true;
float chatMessageScale = 0.0015;
float chatMessageHeight = 0.45;
Avatar::Avatar(bool isMine) {
_orientation.setToIdentity();
Avatar::Avatar(bool isMine) :
_isMine(isMine),
_TEST_bigSphereRadius(0.4f),
_TEST_bigSpherePosition(5.0f, _TEST_bigSphereRadius, 5.0f),
_mousePressed(false),
_bodyPitchDelta(0.0f),
_bodyYawDelta(0.0f),
_bodyRollDelta(0.0f),
_movedHandOffset(0.0f, 0.0f, 0.0f),
_rotation(0.0f, 0.0f, 0.0f, 0.0f),
_mode(AVATAR_MODE_STANDING),
_handHoldingPosition(0.0f, 0.0f, 0.0f),
_velocity(0.0f, 0.0f, 0.0f),
_thrust(0.0f, 0.0f, 0.0f),
_speed(0.0f),
_maxArmLength(0.0f),
_orientation(),
_transmitterIsFirstData(true),
_transmitterHz(0.0f),
_transmitterPackets(0),
_transmitterInitialReading(0.0f, 0.0f, 0.0f),
_isTransmitterV2Connected(false),
_pelvisStandingHeight(0.0f),
_displayingHead(true),
_distanceToNearestAvatar(std::numeric_limits<float>::max()),
_gravity(0.0f, -1.0f, 0.0f),
_mouseRayOrigin(0.0f, 0.0f, 0.0f),
_mouseRayDirection(0.0f, 0.0f, 0.0f),
_cameraPosition(0.0f, 0.0f, 0.0f),
_interactingOther(NULL),
_cumulativeMouseYaw(0.0f),
_isMouseTurningRight(false)
{
_velocity = glm::vec3(0.0f, 0.0f, 0.0f);
_thrust = glm::vec3(0.0f, 0.0f, 0.0f);
_rotation = glm::quat(0.0f, 0.0f, 0.0f, 0.0f);
_bodyYaw = -90.0;
_bodyPitch = 0.0;
_bodyRoll = 0.0;
_bodyPitchDelta = 0.0;
_bodyYawDelta = 0.0;
_bodyRollDelta = 0.0;
_mousePressed = false;
_mode = AVATAR_MODE_STANDING;
_isMine = isMine;
_maxArmLength = 0.0;
_transmitterHz = 0.0;
_transmitterPackets = 0;
_transmitterIsFirstData = true;
_transmitterInitialReading = glm::vec3(0.f, 0.f, 0.f);
_isTransmitterV2Connected = false;
_speed = 0.0;
_pelvisStandingHeight = 0.0f;
_displayingHead = true;
_TEST_bigSphereRadius = 0.4f;
_TEST_bigSpherePosition = glm::vec3(5.0f, _TEST_bigSphereRadius, 5.0f);
_mouseRayOrigin = glm::vec3(0.0f, 0.0f, 0.0f);
_mouseRayDirection = glm::vec3(0.0f, 0.0f, 0.0f);
_cameraPosition = glm::vec3(0.0f, 0.0f, 0.0f);
_interactingOther = NULL;
// give the pointer to our head to inherited _headData variable from AvatarData
_headData = &_head;
for (int i = 0; i < MAX_DRIVE_KEYS; i++) _driveKeys[i] = false;
_movedHandOffset = glm::vec3(0.0f, 0.0f, 0.0f);
_handHoldingPosition = glm::vec3(0.0f, 0.0f, 0.0f);
_distanceToNearestAvatar = std::numeric_limits<float>::max();
_gravity = glm::vec3(0.0f, -1.0f, 0.0f);
_cumulativeMouseYaw = 0.f;
_isMouseTurningRight = false;
for (int i = 0; i < MAX_DRIVE_KEYS; i++) {
_driveKeys[i] = false;
}
initializeSkeleton();
_avatarTouch.setReachableRadius(PERIPERSONAL_RADIUS);
if (BALLS_ON) { _balls = new Balls(100); }
else { _balls = NULL; }
if (BALLS_ON) {
_balls = new Balls(100);
} else {
_balls = NULL;
}
}
Avatar::~Avatar() {
_headData = NULL;
delete _balls;
}
void Avatar::reset() {
_headPitch = _headYaw = _headRoll = 0;
_head.leanForward = _head.leanSideways = 0;
_head.reset();
}
// Update avatar head rotation with sensor data
@ -124,23 +132,16 @@ void Avatar::updateHeadFromGyros(float deltaTime, SerialInterface* serialInterfa
measuredRollRate = serialInterface->getLastRollRate();
// Update avatar head position based on measured gyro rates
const float MAX_YAW = 85;
const float MIN_YAW = -85;
const float MAX_ROLL = 50;
const float MIN_ROLL = -50;
addHeadPitch(measuredPitchRate * deltaTime);
addHeadYaw(measuredYawRate * deltaTime);
addHeadRoll(measuredRollRate * deltaTime);
setHeadYaw(glm::clamp(getHeadYaw(), MIN_YAW, MAX_YAW));
setHeadRoll(glm::clamp(getHeadRoll(), MIN_ROLL, MAX_ROLL));
_head.addPitch(measuredPitchRate * deltaTime);
_head.addYaw(measuredYawRate * deltaTime);
_head.addRoll(measuredRollRate * deltaTime);
// Update head lean distance based on accelerometer data
const float LEAN_SENSITIVITY = 0.15;
const float LEAN_MAX = 0.45;
const float LEAN_AVERAGING = 10.0;
glm::vec3 headRotationRates(getHeadPitch(), getHeadYaw(), getHeadRoll());
glm::vec3 headRotationRates(_head.getPitch(), _head.getYaw(), _head.getRoll());
float headRateMax = 50.f;
@ -149,35 +150,19 @@ void Avatar::updateHeadFromGyros(float deltaTime, SerialInterface* serialInterfa
* (1.f - fminf(glm::length(headRotationRates), headRateMax) / headRateMax);
leaning.y = 0.f;
if (glm::length(leaning) < LEAN_MAX) {
_head.leanForward = _head.leanForward * (1.f - LEAN_AVERAGING * deltaTime) +
(LEAN_AVERAGING * deltaTime) * leaning.z * LEAN_SENSITIVITY;
_head.leanSideways = _head.leanSideways * (1.f - LEAN_AVERAGING * deltaTime) +
(LEAN_AVERAGING * deltaTime) * leaning.x * LEAN_SENSITIVITY;
_head.setLeanForward(_head.getLeanForward() * (1.f - LEAN_AVERAGING * deltaTime) +
(LEAN_AVERAGING * deltaTime) * leaning.z * LEAN_SENSITIVITY);
_head.setLeanSideways(_head.getLeanSideways() * (1.f - LEAN_AVERAGING * deltaTime) +
(LEAN_AVERAGING * deltaTime) * leaning.x * LEAN_SENSITIVITY);
}
setHeadLeanSideways(_head.leanSideways);
setHeadLeanForward(_head.leanForward);
}
float Avatar::getAbsoluteHeadYaw() const {
return _bodyYaw + _headYaw;
return _bodyYaw + _head.getYaw();
}
float Avatar::getAbsoluteHeadPitch() const {
return _bodyPitch + _headPitch;
}
void Avatar::addLean(float x, float z) {
//Add lean as impulse
_head.leanSideways += x;
_head.leanForward += z;
}
void Avatar::setLeanForward(float dist){
_head.leanForward = dist;
}
void Avatar::setLeanSideways(float dist){
_head.leanSideways = dist;
return _bodyPitch + _head.getPitch();
}
void Avatar::setMousePressed(bool mousePressed) {
@ -221,7 +206,7 @@ void Avatar::updateFromMouse(int mouseX, int mouseY, int screenWidth, int scree
if (fabs(mouseLocationY) > MOUSE_MOVE_RADIUS) {
float mousePitchAdd = (fabs(mouseLocationY) - MOUSE_MOVE_RADIUS) / (0.5f - MOUSE_MOVE_RADIUS) * MOUSE_PITCH_SPEED;
bool downPitching = (mouseLocationY > 0.f);
setHeadPitch(getHeadPitch() + (downPitching ? mousePitchAdd : -mousePitchAdd));
_head.setPitch(_head.getPitch() + (downPitching ? mousePitchAdd : -mousePitchAdd));
}
}
@ -354,20 +339,15 @@ void Avatar::simulate(float deltaTime) {
// Decay HeadPitch as a function of acceleration, so that you look straight ahead when
// you start moving, but don't do this with an HMD like the Oculus.
if (!OculusManager::isConnected()) {
setHeadPitch(getHeadPitch() * (1.f - acceleration * ACCELERATION_PITCH_DECAY * deltaTime));
_head.setPitch(_head.getPitch() * (1.f - acceleration * ACCELERATION_PITCH_DECAY * deltaTime));
}
// Get head position data from network for other people
if (!_isMine) {
_head.leanSideways = getHeadLeanSideways();
_head.leanForward = getHeadLeanForward();
}
//apply the head lean values to the springy position...
if (fabs(_head.leanSideways + _head.leanForward) > 0.0f) {
if (fabs(_head.getLeanSideways() + _head.getLeanForward()) > 0.0f) {
glm::vec3 headLean =
_orientation.getRight() * _head.leanSideways +
_orientation.getFront() * _head.leanForward;
_orientation.getRight() * _head.getLeanSideways() +
_orientation.getFront() * _head.getLeanForward();
// this is not a long-term solution, but it works ok for initial purposes of making the avatar lean
_joint[ AVATAR_JOINT_TORSO ].springyPosition += headLean * 0.1f;
@ -389,26 +369,21 @@ void Avatar::simulate(float deltaTime) {
}
// update head state
_head.setPositionRotationAndScale(
_joint[ AVATAR_JOINT_HEAD_BASE ].springyPosition,
glm::vec3(_headYaw, _headPitch, _headRoll),
_joint[ AVATAR_JOINT_HEAD_BASE ].radius
);
_head.setPositionAndScale(_joint[AVATAR_JOINT_HEAD_BASE].springyPosition, _joint[AVATAR_JOINT_HEAD_BASE].radius);
setLookatPosition(glm::vec3(0.0f, 0.0f, 0.0f)); //default lookat position is 0,0,0
_head.setLookAtPosition(glm::vec3(0.0f, 0.0f, 0.0f)); //default lookat position is 0,0,0
if (_interactingOther) {
_head.setLooking(true);
if (_isMine) {
setLookatPosition(_interactingOther->getSpringyHeadPosition());
_head.setLookAtPosition(_interactingOther->getSpringyHeadPosition());
}
} else {
_head.setLooking(false);
}
_head.setBodyYaw(_bodyYaw);
_head.setLookatPosition(_lookatPosition);
_head.setAudioLoudness(_audioLoudness);
_head.setSkinColor(glm::vec3(skinColor[0], skinColor[1], skinColor[2]));
_head.simulate(deltaTime, _isMine);
@ -1334,27 +1309,21 @@ void Avatar::setHeadFromGyros(glm::vec3* eulerAngles, glm::vec3* angularVelocity
// absolute eulerAngles passed.
//
//
float const MAX_YAW = 90.f;
float const MIN_YAW = -90.f;
float const MAX_PITCH = 85.f;
float const MIN_PITCH = -85.f;
float const MAX_ROLL = 90.f;
float const MIN_ROLL = -90.f;
if (deltaTime == 0.f) {
// On first sample, set head to absolute position
setHeadYaw(eulerAngles->x);
setHeadPitch(eulerAngles->y);
setHeadRoll(eulerAngles->z);
_head.setYaw(eulerAngles->x);
_head.setPitch(eulerAngles->y);
_head.setRoll(eulerAngles->z);
} else {
glm::vec3 angles(getHeadYaw(), getHeadPitch(), getHeadRoll());
glm::vec3 angles(_head.getYaw(), _head.getPitch(), _head.getRoll());
// Increment by detected velocity
angles += (*angularVelocity) * deltaTime;
// Smooth to slowly follow absolute values
angles = ((1.f - deltaTime / smoothingTime) * angles) + (deltaTime / smoothingTime) * (*eulerAngles);
setHeadYaw(fmin(fmax(angles.x, MIN_YAW), MAX_YAW));
setHeadPitch(fmin(fmax(angles.y, MIN_PITCH), MAX_PITCH));
setHeadRoll(fmin(fmax(angles.z, MIN_ROLL), MAX_ROLL));
_head.setYaw(angles.x);
_head.setPitch(angles.y);
_head.setRoll(angles.z);
//printLog("Y/P/R: %3.1f, %3.1f, %3.1f\n", angles.x, angles.y, angles.z);
}
}

9
interface/src/Avatar.h
View file

@ -77,6 +77,7 @@ enum AvatarJointID
class Avatar : public AvatarData {
public:
Avatar(bool isMine);
~Avatar();
void reset();
void updateHeadFromGyros(float frametime, SerialInterface * serialInterface, glm::vec3 * gravity);
@ -92,9 +93,6 @@ public:
float getAbsoluteHeadYaw() const;
float getAbsoluteHeadPitch() const;
void setLeanForward(float dist);
void setLeanSideways(float dist);
void addLean(float x, float z);
glm::vec3 getApproximateEyePosition();
const glm::vec3& getHeadPosition() const ; // get the position of the avatar's rigid body head
const glm::vec3& getSpringyHeadPosition() const ; // get the springy position of the avatar's head
@ -106,6 +104,7 @@ public:
float getHeight() const { return _height; }
AvatarMode getMode() const { return _mode; }
Head getHead() const { return _head; }
void setMousePressed(bool pressed);
void render(bool lookingInMirror, glm::vec3 cameraPosition);
@ -163,8 +162,8 @@ private:
Head _head;
bool _isMine;
glm::vec3 _TEST_bigSpherePosition;
float _TEST_bigSphereRadius;
glm::vec3 _TEST_bigSpherePosition;
bool _mousePressed;
float _bodyPitchDelta;
float _bodyYawDelta;
@ -180,8 +179,6 @@ private:
float _maxArmLength;
Orientation _orientation;
int _driveKeys[MAX_DRIVE_KEYS];
float _renderYaw;
float _renderPitch; // Pitch from view frustum when this is own head
bool _transmitterIsFirstData;
timeval _transmitterTimeLastReceived;
timeval _transmitterTimer;

6
interface/src/Environment.cpp
View file

@ -21,7 +21,6 @@ void Environment::init() {
}
void Environment::renderAtmosphere(Camera& camera) {
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(getAtmosphereCenter().x, getAtmosphereCenter().y, getAtmosphereCenter().z);
@ -72,10 +71,7 @@ void Environment::renderAtmosphere(Camera& camera) {
program->release();
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPopMatrix();
}
ProgramObject* Environment::createSkyProgram(const char* from, int* locations) {

30
interface/src/Head.cpp
View file

@ -39,16 +39,10 @@ vector<unsigned char> irisTexture;
Head::Head() :
yawRate(0.0f),
noise(0.0f),
leanForward(0.0f),
leanSideways(0.0f),
_audioLoudness(0.0f),
_skinColor(0.0f, 0.0f, 0.0f),
_position(0.0f, 0.0f, 0.0f),
_rotation(0.0f, 0.0f, 0.0f),
_lookatPosition(0.0f, 0.0f, 0.0f),
_yaw(0.0f),
_pitch(0.0f),
_roll(0.0f),
_eyeballPitch(),
_eyeballYaw(),
_interBrowDistance(0.75f),
@ -77,12 +71,9 @@ Head::Head() :
}
void Head::setPositionRotationAndScale(glm::vec3 p, glm::vec3 r, float s) {
_position = p;
_scale = s;
_yaw = r.x;
_pitch = r.y;
_roll = r.z;
void Head::setPositionAndScale(glm::vec3 position, float scale) {
_position = position;
_scale = scale;
}
void Head::setNewTarget(float pitch, float yaw) {
@ -90,6 +81,11 @@ void Head::setNewTarget(float pitch, float yaw) {
_yawTarget = yaw;
}
void Head::reset() {
_yaw = _pitch = _roll = 0.0f;
_leanForward = _leanSideways = 0.0f;
}
void Head::simulate(float deltaTime, bool isMine) {
//generate orientation directions based on Euler angles...
@ -122,8 +118,8 @@ void Head::simulate(float deltaTime, bool isMine) {
_roll *= 1.f - (HEAD_MOTION_DECAY * deltaTime);
}
leanForward *= (1.f - HEAD_MOTION_DECAY * 30 * deltaTime);
leanSideways *= (1.f - HEAD_MOTION_DECAY * 30 * deltaTime);
_leanForward *= (1.f - HEAD_MOTION_DECAY * 30 * deltaTime);
_leanSideways *= (1.f - HEAD_MOTION_DECAY * 30 * deltaTime);
// Update where the avatar's eyes are
//
@ -230,7 +226,7 @@ void Head::setLooking(bool looking) {
_lookingAtSomething = looking;
glm::vec3 averageEyePosition = _leftEyePosition + (_rightEyePosition - _leftEyePosition ) * ONE_HALF;
glm::vec3 targetLookatAxis = glm::normalize(_lookatPosition - averageEyePosition);
glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - averageEyePosition);
float dot = glm::dot(targetLookatAxis, _orientation.getFront());
if (dot < MINIMUM_EYE_ROTATION) {
@ -376,7 +372,7 @@ void Head::renderEyeBalls() {
if (_lookingAtSomething) {
//rotate the eyeball to aim towards the lookat position
glm::vec3 targetLookatAxis = glm::normalize(_lookatPosition - _leftEyePosition); // the lookat direction
glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _leftEyePosition); // the lookat direction
glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);
glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
@ -420,7 +416,7 @@ void Head::renderEyeBalls() {
if (_lookingAtSomething) {
//rotate the eyeball to aim towards the lookat position
glm::vec3 targetLookatAxis = glm::normalize(_lookatPosition - _rightEyePosition);
glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _rightEyePosition);
glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);
glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);

12
interface/src/Head.h
View file

@ -23,18 +23,18 @@ enum eyeContactTargets
MOUTH
};
class Head {
class Head : public HeadData {
public:
Head();
void reset();
void simulate(float deltaTime, bool isMine);
void render(bool lookingInMirror);
void setLooking(bool looking);
void setPositionRotationAndScale(glm::vec3 position, glm::vec3 rotation, float scale);
void setPositionAndScale(glm::vec3 position, float scale);
void setNewTarget(float, float);
void setLookatPosition (glm::vec3 lookatPosition ) { _lookatPosition = lookatPosition; }
void setGravity (glm::vec3 gravity ) { _gravity = gravity; }
void setSkinColor (glm::vec3 skinColor ) { _skinColor = skinColor; }
void setBodyYaw (float bodyYaw ) { _bodyYaw = bodyYaw; }
@ -50,8 +50,6 @@ public:
//some public members (left-over from pulling Head out of Avatar - I may see about privatizing these later).
float yawRate;
float noise;
float leanForward;
float leanSideways;
private:
@ -60,12 +58,8 @@ private:
glm::vec3 _skinColor;
glm::vec3 _position;
glm::vec3 _rotation;
glm::vec3 _lookatPosition;
glm::vec3 _leftEyePosition;
glm::vec3 _rightEyePosition;
float _yaw;
float _pitch;
float _roll;
float _eyeballPitch[2];
float _eyeballYaw [2];
float _eyebrowPitch[2];

79
libraries/avatars/src/AvatarData.cpp
View file

@ -3,7 +3,7 @@
// hifi
//
// Created by Stephen Birarda on 4/9/13.
//
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include <cstdio>
@ -35,15 +35,9 @@ int unpackFloatAngleFromTwoByte(uint16_t* byteAnglePointer, float* destinationPo
AvatarData::AvatarData() :
_handPosition(0,0,0),
_lookatPosition(0,0,0),
_bodyYaw(-90.0),
_bodyPitch(0.0),
_bodyRoll(0.0),
_headYaw(0),
_headPitch(0),
_headRoll(0),
_headLeanSideways(0),
_headLeanForward(0),
_audioLoudness(0),
_handState(0),
_cameraPosition(0,0,0),
@ -57,10 +51,15 @@ AvatarData::AvatarData() :
_keyState(NO_KEY_DOWN),
_wantResIn(false),
_wantColor(true),
_wantDelta(false)
_wantDelta(false),
_headData(NULL)
{
}
AvatarData::~AvatarData() {
delete _headData;
}
int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
unsigned char* bufferStart = destinationBuffer;
@ -68,6 +67,11 @@ int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
// that can pack any type given the number of bytes
// and return the number of bytes to push the pointer
// lazily allocate memory for HeadData in case we're not an Avatar instance
if (!_headData) {
_headData = new HeadData();
}
// Body world position
memcpy(destinationBuffer, &_position, sizeof(float) * 3);
destinationBuffer += sizeof(float) * 3;
@ -78,23 +82,23 @@ int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _bodyRoll);
// Head rotation (NOTE: This needs to become a quaternion to save two bytes)
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headYaw);
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headPitch);
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headRoll);
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->_yaw);
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->_pitch);
destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _headData->_roll);
// Head lean X,Z (head lateral and fwd/back motion relative to torso)
memcpy(destinationBuffer, &_headLeanSideways, sizeof(float));
destinationBuffer += sizeof(float);
memcpy(destinationBuffer, &_headLeanForward, sizeof(float));
destinationBuffer += sizeof(float);
memcpy(destinationBuffer, &_headData->_leanSideways, sizeof(_headData->_leanSideways));
destinationBuffer += sizeof(_headData->_leanSideways);
memcpy(destinationBuffer, &_headData->_leanForward, sizeof(_headData->_leanForward));
destinationBuffer += sizeof(_headData->_leanForward);
// Hand Position
memcpy(destinationBuffer, &_handPosition, sizeof(float) * 3);
destinationBuffer += sizeof(float) * 3;
// Lookat Position
memcpy(destinationBuffer, &_lookatPosition, sizeof(_lookatPosition));
destinationBuffer += sizeof(_lookatPosition);
memcpy(destinationBuffer, &_headData->_lookAtPosition, sizeof(_headData->_lookAtPosition));
destinationBuffer += sizeof(_headData->_lookAtPosition);
// Hand State (0 = not grabbing, 1 = grabbing)
memcpy(destinationBuffer, &_handState, sizeof(char));
@ -144,7 +148,10 @@ int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
// called on the other agents - assigns it to my views of the others
int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
//printf("AvatarData::parseData()\n");
// lazily allocate memory for HeadData in case we're not an Avatar instance
if (!_headData) {
_headData = new HeadData();
}
// increment to push past the packet header
sourceBuffer += sizeof(PACKET_HEADER_HEAD_DATA);
@ -159,28 +166,33 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
sourceBuffer += sizeof(float) * 3;
// Body rotation (NOTE: This needs to become a quaternion to save two bytes)
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_bodyYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_bodyPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_bodyRoll);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyRoll);
// Head rotation (NOTE: This needs to become a quaternion to save two bytes)
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_headYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_headPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t *)sourceBuffer, &_headRoll);
float headYaw, headPitch, headRoll;
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headYaw);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headPitch);
sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &headRoll);
_headData->setYaw(headYaw);
_headData->setPitch(headPitch);
_headData->setRoll(headRoll);
// Head position relative to pelvis
memcpy(&_headLeanSideways, sourceBuffer, sizeof(float));
sourceBuffer += sizeof(float);
memcpy(&_headLeanForward, sourceBuffer, sizeof(float));
memcpy(&_headData->_leanSideways, sourceBuffer, sizeof(_headData->_leanSideways));
sourceBuffer += sizeof(float);
memcpy(&_headData->_leanForward, sourceBuffer, sizeof(_headData->_leanForward));
sourceBuffer += sizeof(_headData->_leanForward);
// Hand Position
memcpy(&_handPosition, sourceBuffer, sizeof(float) * 3);
sourceBuffer += sizeof(float) * 3;
// Lookat Position
memcpy(&_lookatPosition, sourceBuffer, sizeof(_lookatPosition));
sourceBuffer += sizeof(_lookatPosition);
memcpy(&_headData->_lookAtPosition, sourceBuffer, sizeof(_headData->_lookAtPosition));
sourceBuffer += sizeof(_headData->_lookAtPosition);
// Hand State
memcpy(&_handState, sourceBuffer, sizeof(char));
@ -224,11 +236,4 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
_wantDelta = oneAtBit(wantItems,WANT_DELTA_AT_BIT);
return sourceBuffer - startPosition;
}
void AvatarData::setHeadPitch(float p) {
// Set head pitch and apply limits
const float MAX_PITCH = 60;
const float MIN_PITCH = -60;
_headPitch = glm::clamp(p, MIN_PITCH, MAX_PITCH);
}
}

35
libraries/avatars/src/AvatarData.h
View file

@ -3,7 +3,7 @@
// hifi
//
// Created by Stephen Birarda on 4/9/13.
//
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __hifi__AvatarData__
@ -14,6 +14,7 @@
#include <glm/glm.hpp>
#include <AgentData.h>
#include "HeadData.h"
const int WANT_RESIN_AT_BIT = 0;
const int WANT_COLOR_AT_BIT = 1;
@ -29,12 +30,12 @@ enum KeyState
class AvatarData : public AgentData {
public:
AvatarData();
~AvatarData();
const glm::vec3& getPosition() const { return _position; }
void setPosition (const glm::vec3 position ) { _position = position; }
void setHandPosition (const glm::vec3 handPosition ) { _handPosition = handPosition; }
void setLookatPosition(const glm::vec3 lookatPosition) { _lookatPosition = lookatPosition; }
int getBroadcastData(unsigned char* destinationBuffer);
int parseData(unsigned char* sourceBuffer, int numBytes);
@ -46,23 +47,6 @@ public:
void setBodyPitch(float bodyPitch) { _bodyPitch = bodyPitch; }
float getBodyRoll() const {return _bodyRoll; }
void setBodyRoll(float bodyRoll) { _bodyRoll = bodyRoll; }
// Head Rotation
void setHeadPitch(float p);
void setHeadYaw(float y) {_headYaw = y; }
void setHeadRoll(float r) {_headRoll = r; };
float getHeadPitch() const { return _headPitch; };
float getHeadYaw() const { return _headYaw; };
float getHeadRoll() const { return _headRoll; };
void addHeadPitch(float p) { setHeadPitch(_headPitch - p); }
void addHeadYaw(float y){_headYaw -= y; }
void addHeadRoll(float r){_headRoll += r; }
// Head vector deflection from pelvix in X,Z
void setHeadLeanSideways(float s) {_headLeanSideways = s; };
float getHeadLeanSideways() const { return _headLeanSideways; };
void setHeadLeanForward(float f) {_headLeanForward = f; };
float getHeadLeanForward() const { return _headLeanForward; };
// Hand State
void setHandState(char s) { _handState = s; };
@ -108,6 +92,8 @@ public:
void setWantColor(bool wantColor) { _wantColor = wantColor; }
void setWantDelta(bool wantDelta) { _wantDelta = wantDelta; }
void setHeadData(HeadData* headData) { _headData = headData; }
protected:
// privatize the copy constructor and assignment operator so they cannot be called
AvatarData(const AvatarData&);
@ -115,20 +101,11 @@ protected:
glm::vec3 _position;
glm::vec3 _handPosition;
glm::vec3 _lookatPosition;
// Body rotation
float _bodyYaw;
float _bodyPitch;
float _bodyRoll;
// Head rotation (relative to body)
float _headYaw;
float _headPitch;
float _headRoll;
float _headLeanSideways;
float _headLeanForward;
// Audio loudness (used to drive facial animation)
float _audioLoudness;
@ -158,6 +135,8 @@ protected:
bool _wantResIn;
bool _wantColor;
bool _wantDelta;
HeadData* _headData;
};
#endif /* defined(__hifi__AvatarData__) */

38
libraries/avatars/src/HeadData.cpp Normal file
View file

@ -0,0 +1,38 @@
//
// HeadData.cpp
// hifi
//
// Created by Stephen Birarda on 5/20/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#include "HeadData.h"
HeadData::HeadData() :
_yaw(0.0f),
_pitch(0.0f),
_roll(0.0f),
_lookAtPosition(0.0f, 0.0f, 0.0f),
_leanSideways(0.0f),
_leanForward(0.0f)
{
}
void HeadData::addYaw(float yaw) {
setYaw(_yaw + yaw);
}
void HeadData::addPitch(float pitch) {
setPitch(_pitch + pitch);
}
void HeadData::addRoll(float roll) {
setRoll(_roll + roll);
}
void HeadData::addLean(float sideways, float forwards) {
// Add lean as impulse
_leanSideways += sideways;
_leanForward += forwards;
}

60
libraries/avatars/src/HeadData.h Normal file
View file

@ -0,0 +1,60 @@
//
// HeadData.h
// hifi
//
// Created by Stephen Birarda on 5/20/13.
// Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
//
#ifndef __hifi__HeadData__
#define __hifi__HeadData__
#include <iostream>
#include <glm/glm.hpp>
const float MIN_HEAD_YAW = -85;
const float MAX_HEAD_YAW = 85;
const float MIN_HEAD_PITCH = -60;
const float MAX_HEAD_PITCH = 60;
const float MIN_HEAD_ROLL = -50;
const float MAX_HEAD_ROLL = 50;
class HeadData {
public:
HeadData();
float getLeanSideways() const { return _leanSideways; }
void setLeanSideways(float leanSideways) { _leanSideways = leanSideways; }
float getLeanForward() const { return _leanForward; }
void setLeanForward(float leanForward) { _leanForward = leanForward; }
float getYaw() const { return _yaw; }
void setYaw(float yaw) { _yaw = glm::clamp(yaw, MIN_HEAD_YAW, MAX_HEAD_YAW); }
float getPitch() const { return _pitch; }
void setPitch(float pitch) { _pitch = glm::clamp(pitch, MIN_HEAD_PITCH, MAX_HEAD_PITCH); }
float getRoll() const { return _roll; }
void setRoll(float roll) { _roll = glm::clamp(roll, MIN_HEAD_ROLL, MAX_HEAD_ROLL); }
void addYaw(float yaw);
void addPitch(float pitch);
void addRoll(float roll);
void addLean(float sideways, float forwards);
const glm::vec3& getLookAtPosition() const { return _lookAtPosition; }
void setLookAtPosition(const glm::vec3& lookAtPosition) { _lookAtPosition = lookAtPosition; }
friend class AvatarData;
protected:
float _yaw;
float _pitch;
float _roll;
glm::vec3 _lookAtPosition;
float _leanSideways;
float _leanForward;
};
#endif /* defined(__hifi__HeadData__) */