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

Merge remote-tracking branch 'upstream/master' into avatar-from-mixer

Browse source
This commit is contained in:
Stephen Birarda 2013-04-22 17:56:19 -07:00
commit 8a3135a084
7 changed files with 175 additions and 188 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

243
interface/src/Head.cpp
View file

@ -35,9 +35,7 @@ float browThickness = 0.16;
bool usingBigSphereCollisionTest = true; bool usingBigSphereCollisionTest = true;
const float DECAY = 0.1;
const float THRUST_MAG = 10.0;
const float YAW_MAG = 300.0;
char iris_texture_file[] = "resources/images/green_eye.png"; char iris_texture_file[] = "resources/images/green_eye.png";
@ -115,8 +113,7 @@ Head::Head(bool isMine) {
_head.noise = 0; _head.noise = 0;
_movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 ); _movedHandOffset = glm::vec3( 0.0, 0.0, 0.0 );
_usingBodySprings = true; _usingBodySprings = true;
//_usingBodySprings = false;
_springForce = 6.0f; _springForce = 6.0f;
_springVelocityDecay = 16.0f; _springVelocityDecay = 16.0f;
_renderYaw = 0.0; _renderYaw = 0.0;
@ -152,7 +149,7 @@ Head::Head(const Head &otherAvatar) {
_bodyPitch = otherAvatar._bodyPitch; _bodyPitch = otherAvatar._bodyPitch;
_bodyRoll = otherAvatar._bodyRoll; _bodyRoll = otherAvatar._bodyRoll;
_bodyYawDelta = otherAvatar._bodyYawDelta; _bodyYawDelta = otherAvatar._bodyYawDelta;
_mousePressed = otherAvatar._mousePressed; _mousePressed = otherAvatar._mousePressed;
_mode = otherAvatar._mode; _mode = otherAvatar._mode;
_isMine = otherAvatar._isMine; _isMine = otherAvatar._isMine;
_renderYaw = otherAvatar._renderYaw; _renderYaw = otherAvatar._renderYaw;
@ -168,11 +165,7 @@ Head::Head(const Head &otherAvatar) {
_springForce = otherAvatar._springForce; _springForce = otherAvatar._springForce;
_springVelocityDecay = otherAvatar._springVelocityDecay; _springVelocityDecay = otherAvatar._springVelocityDecay;
_orientation.set( otherAvatar._orientation ); _orientation.set( otherAvatar._orientation );
//for (int o=0;o<NUM_OTHER_AVATARS; o++) {
// _DEBUG_otherAvatarListPosition[o] = otherAvatar._DEBUG_otherAvatarListPosition[o];
//}
_sphere = NULL; _sphere = NULL;
initializeSkeleton(); initializeSkeleton();
@ -312,7 +305,6 @@ void Head::setMousePressed( bool d ) {
} }
void Head::simulate(float deltaTime) { void Head::simulate(float deltaTime) {
//------------------------------------------------------------- //-------------------------------------------------------------
@ -386,7 +378,19 @@ void Head::simulate(float deltaTime) {
//-------------------------------------------------------------- //--------------------------------------------------------------
updateBigSphereCollisionTest(deltaTime); updateBigSphereCollisionTest(deltaTime);
} }
if ( AVATAR_GRAVITY ) {
if ( _bodyPosition.y > _bone[ AVATAR_BONE_RIGHT_FOOT ].radius * 2.0 ) {
_velocity += glm::dvec3( 0.0, -1.0, 0.0 ) * ( 6.0 * deltaTime );
}
else {
if ( _bodyPosition.y < _bone[ AVATAR_BONE_RIGHT_FOOT ].radius ) {
_bodyPosition.y = _bone[ AVATAR_BONE_RIGHT_FOOT ].radius;
_velocity.y = 0.0;
}
}
}
//------------------------ //------------------------
// update avatar skeleton // update avatar skeleton
//------------------------ //------------------------
@ -466,7 +470,6 @@ void Head::simulate(float deltaTime) {
//---------------------------------------------------------- //----------------------------------------------------------
// decay body yaw delta // decay body yaw delta
//---------------------------------------------------------- //----------------------------------------------------------
const float TEST_YAW_DECAY = 5.0;
_bodyYawDelta *= (1.0 - TEST_YAW_DECAY * deltaTime); _bodyYawDelta *= (1.0 - TEST_YAW_DECAY * deltaTime);
//---------------------------------------------------------- //----------------------------------------------------------
@ -482,7 +485,6 @@ void Head::simulate(float deltaTime) {
//---------------------------------------------------------- //----------------------------------------------------------
// decay velocity // decay velocity
//---------------------------------------------------------- //----------------------------------------------------------
const float LIN_VEL_DECAY = 5.0;
_velocity *= ( 1.0 - LIN_VEL_DECAY * deltaTime ); _velocity *= ( 1.0 - LIN_VEL_DECAY * deltaTime );
if (!_head.noise) { if (!_head.noise) {
@ -591,18 +593,22 @@ void Head::updateBigSphereCollisionTest( float deltaTime ) {
{ {
for (int b=0; b<NUM_AVATAR_BONES; b++) for (int b=0; b<NUM_AVATAR_BONES; b++)
{ {
glm::vec3 vectorFromJointToBigSphere(_bone[b].position - _TEST_bigSpherePosition); glm::vec3 vectorFromJointToBigSphereCenter(_bone[b].springyPosition - _TEST_bigSpherePosition);
float distanceToBigSphereCenter = glm::length(vectorFromJointToBigSphere); float distanceToBigSphereCenter = glm::length(vectorFromJointToBigSphereCenter);
float combinedRadius = _bone[b].radius + _TEST_bigSphereRadius; float combinedRadius = _bone[b].radius + _TEST_bigSphereRadius;
if ( distanceToBigSphereCenter < combinedRadius ) if ( distanceToBigSphereCenter < combinedRadius )
{ {
jointCollision = true; jointCollision = true;
if (distanceToBigSphereCenter > 0.0) if (distanceToBigSphereCenter > 0.0)
{ {
float amp = 1.0 - (distanceToBigSphereCenter / combinedRadius); glm::vec3 directionVector = vectorFromJointToBigSphereCenter / distanceToBigSphereCenter;
glm::vec3 collisionForce = vectorFromJointToBigSphere * amp;
_bone[b].springyVelocity += collisionForce * 8.0f * deltaTime; float penetration = 1.0 - (distanceToBigSphereCenter / combinedRadius);
_velocity += collisionForce * 18.0f * deltaTime; glm::vec3 collisionForce = vectorFromJointToBigSphereCenter * penetration;
_bone[b].springyVelocity += collisionForce * 30.0f * deltaTime;
_velocity += collisionForce * 100.0f * deltaTime;
_bone[b].springyPosition = _TEST_bigSpherePosition + directionVector * combinedRadius;
} }
} }
} }
@ -611,22 +617,7 @@ void Head::updateBigSphereCollisionTest( float deltaTime ) {
if (!_usingBodySprings) { if (!_usingBodySprings) {
_usingBodySprings = true; _usingBodySprings = true;
initializeBodySprings(); initializeBodySprings();
} }
//----------------------------------------------------------
// add gravity to velocity
//----------------------------------------------------------
_velocity += glm::dvec3( 0.0, -1.0, 0.0 ) * 0.05;
//----------------------------------------------------------
// ground collisions
//----------------------------------------------------------
if ( _bodyPosition.y < 0.0 ) {
_bodyPosition.y = 0.0;
if ( _velocity.y < 0.0 ) {
_velocity.y *= -0.7;
}
}
} }
} }
} }
@ -658,12 +649,7 @@ void Head::render(int faceToFace) {
glutSolidSphere( 1, 20, 20 ); glutSolidSphere( 1, 20, 20 );
glPopMatrix(); glPopMatrix();
} }
//---------------------------------------------------
// show avatar orientation
//---------------------------------------------------
renderOrientationDirections( _bone[ AVATAR_BONE_HEAD ].position, _bone[ AVATAR_BONE_HEAD ].orientation, 0.2f );
//--------------------------------------------------- //---------------------------------------------------
// render body // render body
//--------------------------------------------------- //---------------------------------------------------
@ -679,6 +665,7 @@ void Head::render(int faceToFace) {
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
if ( _isMine ) if ( _isMine )
{ {
/*
//--------------------------------------------------- //---------------------------------------------------
// render other avatars (DEBUG TEST) // render other avatars (DEBUG TEST)
//--------------------------------------------------- //---------------------------------------------------
@ -689,6 +676,7 @@ void Head::render(int faceToFace) {
glutSolidSphere( 1, 10, 10 ); glutSolidSphere( 1, 10, 10 );
glPopMatrix(); glPopMatrix();
} }
*/
if (_usingBodySprings) { if (_usingBodySprings) {
if ( _closestOtherAvatar != -1 ) { if ( _closestOtherAvatar != -1 ) {
@ -715,6 +703,11 @@ void Head::renderHead(int faceToFace) {
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
glEnable(GL_RESCALE_NORMAL); glEnable(GL_RESCALE_NORMAL);
//---------------------------------------------------
// show head orientation
//---------------------------------------------------
//renderOrientationDirections( _bone[ AVATAR_BONE_HEAD ].position, _bone[ AVATAR_BONE_HEAD ].orientation, 0.2f );
glPushMatrix(); glPushMatrix();
if (_usingBodySprings) { if (_usingBodySprings) {
@ -858,7 +851,6 @@ void Head::renderHead(int faceToFace) {
glPopMatrix(); glPopMatrix();
} }
void Head::startHandMovement() { void Head::startHandMovement() {
if (!_usingBodySprings) { if (!_usingBodySprings) {
@ -892,7 +884,7 @@ void Head::initializeSkeleton() {
_bone[b].pitch = 0.0; _bone[b].pitch = 0.0;
_bone[b].roll = 0.0; _bone[b].roll = 0.0;
_bone[b].length = 0.0; _bone[b].length = 0.0;
_bone[b].radius = 0.02; //default _bone[b].radius = 0.0;
_bone[b].springBodyTightness = 4.0; _bone[b].springBodyTightness = 4.0;
_bone[b].orientation.setToIdentity(); _bone[b].orientation.setToIdentity();
} }
@ -900,45 +892,25 @@ void Head::initializeSkeleton() {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// parental hierarchy // parental hierarchy
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
//----------------------------------------------------------------------------
// spine and head
//----------------------------------------------------------------------------
_bone[ AVATAR_BONE_PELVIS_SPINE ].parent = AVATAR_BONE_NULL; _bone[ AVATAR_BONE_PELVIS_SPINE ].parent = AVATAR_BONE_NULL;
_bone[ AVATAR_BONE_MID_SPINE ].parent = AVATAR_BONE_PELVIS_SPINE; _bone[ AVATAR_BONE_MID_SPINE ].parent = AVATAR_BONE_PELVIS_SPINE;
_bone[ AVATAR_BONE_CHEST_SPINE ].parent = AVATAR_BONE_MID_SPINE; _bone[ AVATAR_BONE_CHEST_SPINE ].parent = AVATAR_BONE_MID_SPINE;
_bone[ AVATAR_BONE_NECK ].parent = AVATAR_BONE_CHEST_SPINE; _bone[ AVATAR_BONE_NECK ].parent = AVATAR_BONE_CHEST_SPINE;
_bone[ AVATAR_BONE_HEAD ].parent = AVATAR_BONE_NECK; _bone[ AVATAR_BONE_HEAD ].parent = AVATAR_BONE_NECK;
//----------------------------------------------------------------------------
// left chest and arm
//----------------------------------------------------------------------------
_bone[ AVATAR_BONE_LEFT_CHEST ].parent = AVATAR_BONE_MID_SPINE; _bone[ AVATAR_BONE_LEFT_CHEST ].parent = AVATAR_BONE_MID_SPINE;
_bone[ AVATAR_BONE_LEFT_SHOULDER ].parent = AVATAR_BONE_LEFT_CHEST; _bone[ AVATAR_BONE_LEFT_SHOULDER ].parent = AVATAR_BONE_LEFT_CHEST;
_bone[ AVATAR_BONE_LEFT_UPPER_ARM ].parent = AVATAR_BONE_LEFT_SHOULDER; _bone[ AVATAR_BONE_LEFT_UPPER_ARM ].parent = AVATAR_BONE_LEFT_SHOULDER;
_bone[ AVATAR_BONE_LEFT_FOREARM ].parent = AVATAR_BONE_LEFT_UPPER_ARM; _bone[ AVATAR_BONE_LEFT_FOREARM ].parent = AVATAR_BONE_LEFT_UPPER_ARM;
_bone[ AVATAR_BONE_LEFT_HAND ].parent = AVATAR_BONE_LEFT_FOREARM; _bone[ AVATAR_BONE_LEFT_HAND ].parent = AVATAR_BONE_LEFT_FOREARM;
//----------------------------------------------------------------------------
// right chest and arm
//----------------------------------------------------------------------------
_bone[ AVATAR_BONE_RIGHT_CHEST ].parent = AVATAR_BONE_MID_SPINE; _bone[ AVATAR_BONE_RIGHT_CHEST ].parent = AVATAR_BONE_MID_SPINE;
_bone[ AVATAR_BONE_RIGHT_SHOULDER ].parent = AVATAR_BONE_RIGHT_CHEST; _bone[ AVATAR_BONE_RIGHT_SHOULDER ].parent = AVATAR_BONE_RIGHT_CHEST;
_bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].parent = AVATAR_BONE_RIGHT_SHOULDER; _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].parent = AVATAR_BONE_RIGHT_SHOULDER;
_bone[ AVATAR_BONE_RIGHT_FOREARM ].parent = AVATAR_BONE_RIGHT_UPPER_ARM; _bone[ AVATAR_BONE_RIGHT_FOREARM ].parent = AVATAR_BONE_RIGHT_UPPER_ARM;
_bone[ AVATAR_BONE_RIGHT_HAND ].parent = AVATAR_BONE_RIGHT_FOREARM; _bone[ AVATAR_BONE_RIGHT_HAND ].parent = AVATAR_BONE_RIGHT_FOREARM;
//----------------------------------------------------------------------------
// left pelvis and leg
//----------------------------------------------------------------------------
_bone[ AVATAR_BONE_LEFT_PELVIS ].parent = AVATAR_BONE_PELVIS_SPINE; _bone[ AVATAR_BONE_LEFT_PELVIS ].parent = AVATAR_BONE_PELVIS_SPINE;
_bone[ AVATAR_BONE_LEFT_THIGH ].parent = AVATAR_BONE_LEFT_PELVIS; _bone[ AVATAR_BONE_LEFT_THIGH ].parent = AVATAR_BONE_LEFT_PELVIS;
_bone[ AVATAR_BONE_LEFT_SHIN ].parent = AVATAR_BONE_LEFT_THIGH; _bone[ AVATAR_BONE_LEFT_SHIN ].parent = AVATAR_BONE_LEFT_THIGH;
_bone[ AVATAR_BONE_LEFT_FOOT ].parent = AVATAR_BONE_LEFT_SHIN; _bone[ AVATAR_BONE_LEFT_FOOT ].parent = AVATAR_BONE_LEFT_SHIN;
//----------------------------------------------------------------------------
// right pelvis and leg
//----------------------------------------------------------------------------
_bone[ AVATAR_BONE_RIGHT_PELVIS ].parent = AVATAR_BONE_PELVIS_SPINE; _bone[ AVATAR_BONE_RIGHT_PELVIS ].parent = AVATAR_BONE_PELVIS_SPINE;
_bone[ AVATAR_BONE_RIGHT_THIGH ].parent = AVATAR_BONE_RIGHT_PELVIS; _bone[ AVATAR_BONE_RIGHT_THIGH ].parent = AVATAR_BONE_RIGHT_PELVIS;
_bone[ AVATAR_BONE_RIGHT_SHIN ].parent = AVATAR_BONE_RIGHT_THIGH; _bone[ AVATAR_BONE_RIGHT_SHIN ].parent = AVATAR_BONE_RIGHT_THIGH;
@ -947,29 +919,54 @@ void Head::initializeSkeleton() {
//---------------------------------------------------------- //----------------------------------------------------------
// specify the default pose position // specify the default pose position
//---------------------------------------------------------- //----------------------------------------------------------
_bone[ AVATAR_BONE_PELVIS_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.3, 0.0 ); _bone[ AVATAR_BONE_PELVIS_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.3, 0.0 );
_bone[ AVATAR_BONE_MID_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.1, 0.0 ); _bone[ AVATAR_BONE_MID_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.1, 0.0 );
_bone[ AVATAR_BONE_CHEST_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.1, 0.0 ); _bone[ AVATAR_BONE_CHEST_SPINE ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 );
_bone[ AVATAR_BONE_NECK ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 ); _bone[ AVATAR_BONE_NECK ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 );
_bone[ AVATAR_BONE_HEAD ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 ); _bone[ AVATAR_BONE_HEAD ].defaultPosePosition = glm::vec3( 0.0, 0.06, 0.0 );
_bone[ AVATAR_BONE_LEFT_CHEST ].defaultPosePosition = glm::vec3( -0.06, 0.06, 0.0 ); _bone[ AVATAR_BONE_LEFT_CHEST ].defaultPosePosition = glm::vec3( -0.05, 0.05, 0.0 );
_bone[ AVATAR_BONE_LEFT_SHOULDER ].defaultPosePosition = glm::vec3( -0.03, 0.0, 0.0 ); _bone[ AVATAR_BONE_LEFT_SHOULDER ].defaultPosePosition = glm::vec3( -0.03, 0.0, 0.0 );
_bone[ AVATAR_BONE_LEFT_UPPER_ARM ].defaultPosePosition = glm::vec3( 0.0, -0.12, 0.0 ); _bone[ AVATAR_BONE_LEFT_UPPER_ARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 );
_bone[ AVATAR_BONE_LEFT_FOREARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 ); _bone[ AVATAR_BONE_LEFT_FOREARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 );
_bone[ AVATAR_BONE_LEFT_HAND ].defaultPosePosition = glm::vec3( 0.0, -0.05, 0.0 ); _bone[ AVATAR_BONE_LEFT_HAND ].defaultPosePosition = glm::vec3( 0.0, -0.05, 0.0 );
_bone[ AVATAR_BONE_RIGHT_CHEST ].defaultPosePosition = glm::vec3( 0.06, 0.06, 0.0 ); _bone[ AVATAR_BONE_RIGHT_CHEST ].defaultPosePosition = glm::vec3( 0.05, 0.05, 0.0 );
_bone[ AVATAR_BONE_RIGHT_SHOULDER ].defaultPosePosition = glm::vec3( 0.03, 0.0, 0.0 ); _bone[ AVATAR_BONE_RIGHT_SHOULDER ].defaultPosePosition = glm::vec3( 0.03, 0.0, 0.0 );
_bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].defaultPosePosition = glm::vec3( 0.0, -0.12, 0.0 ); _bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 );
_bone[ AVATAR_BONE_RIGHT_FOREARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 ); _bone[ AVATAR_BONE_RIGHT_FOREARM ].defaultPosePosition = glm::vec3( 0.0, -0.1, 0.0 );
_bone[ AVATAR_BONE_RIGHT_HAND ].defaultPosePosition = glm::vec3( 0.0, -0.05, 0.0 ); _bone[ AVATAR_BONE_RIGHT_HAND ].defaultPosePosition = glm::vec3( 0.0, -0.05, 0.0 );
_bone[ AVATAR_BONE_LEFT_PELVIS ].defaultPosePosition = glm::vec3( -0.05, 0.0, 0.0 ); _bone[ AVATAR_BONE_LEFT_PELVIS ].defaultPosePosition = glm::vec3( -0.05, 0.0, 0.0 );
_bone[ AVATAR_BONE_LEFT_THIGH ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 ); _bone[ AVATAR_BONE_LEFT_THIGH ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 );
_bone[ AVATAR_BONE_LEFT_SHIN ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 ); _bone[ AVATAR_BONE_LEFT_SHIN ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 );
_bone[ AVATAR_BONE_LEFT_FOOT ].defaultPosePosition = glm::vec3( 0.0, 0.0, 0.04 ); _bone[ AVATAR_BONE_LEFT_FOOT ].defaultPosePosition = glm::vec3( 0.0, 0.0, 0.04 );
_bone[ AVATAR_BONE_RIGHT_PELVIS ].defaultPosePosition = glm::vec3( 0.05, 0.0, 0.0 ); _bone[ AVATAR_BONE_RIGHT_PELVIS ].defaultPosePosition = glm::vec3( 0.05, 0.0, 0.0 );
_bone[ AVATAR_BONE_RIGHT_THIGH ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 ); _bone[ AVATAR_BONE_RIGHT_THIGH ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 );
_bone[ AVATAR_BONE_RIGHT_SHIN ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 ); _bone[ AVATAR_BONE_RIGHT_SHIN ].defaultPosePosition = glm::vec3( 0.0, -0.15, 0.0 );
_bone[ AVATAR_BONE_RIGHT_FOOT ].defaultPosePosition = glm::vec3( 0.0, 0.0, 0.04 ); _bone[ AVATAR_BONE_RIGHT_FOOT ].defaultPosePosition = glm::vec3( 0.0, 0.0, 0.04 );
_bone[ AVATAR_BONE_PELVIS_SPINE ].radius = 0.05;
_bone[ AVATAR_BONE_MID_SPINE ].radius = 0.06;
_bone[ AVATAR_BONE_CHEST_SPINE ].radius = 0.03;
_bone[ AVATAR_BONE_NECK ].radius = 0.02;
_bone[ AVATAR_BONE_HEAD ].radius = 0.02;
_bone[ AVATAR_BONE_LEFT_CHEST ].radius = 0.025;
_bone[ AVATAR_BONE_LEFT_SHOULDER ].radius = 0.02;
_bone[ AVATAR_BONE_LEFT_UPPER_ARM ].radius = 0.015;
_bone[ AVATAR_BONE_LEFT_FOREARM ].radius = 0.015;
_bone[ AVATAR_BONE_LEFT_HAND ].radius = 0.01;
_bone[ AVATAR_BONE_RIGHT_CHEST ].radius = 0.025;
_bone[ AVATAR_BONE_RIGHT_SHOULDER ].radius = 0.02;
_bone[ AVATAR_BONE_RIGHT_UPPER_ARM ].radius = 0.015;
_bone[ AVATAR_BONE_RIGHT_FOREARM ].radius = 0.015;
_bone[ AVATAR_BONE_RIGHT_HAND ].radius = 0.01;
_bone[ AVATAR_BONE_LEFT_PELVIS ].radius = 0.02;
_bone[ AVATAR_BONE_LEFT_THIGH ].radius = 0.02;
_bone[ AVATAR_BONE_LEFT_SHIN ].radius = 0.015;
_bone[ AVATAR_BONE_LEFT_FOOT ].radius = 0.02;
_bone[ AVATAR_BONE_RIGHT_PELVIS ].radius = 0.02;
_bone[ AVATAR_BONE_RIGHT_THIGH ].radius = 0.02;
_bone[ AVATAR_BONE_RIGHT_SHIN ].radius = 0.015;
_bone[ AVATAR_BONE_RIGHT_FOOT ].radius = 0.02;
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// calculate bone length // calculate bone length
@ -1111,16 +1108,16 @@ glm::vec3 Head::getHeadLookatDirectionRight() {
} }
glm::vec3 Head::getHeadPosition() { glm::vec3 Head::getHeadPosition() {
return glm::vec3
( if ( _usingBodySprings ) {
_bone[ AVATAR_BONE_HEAD ].position.x, return _bone[ AVATAR_BONE_HEAD ].springyPosition;
_bone[ AVATAR_BONE_HEAD ].position.y, }
_bone[ AVATAR_BONE_HEAD ].position.z
); return _bone[ AVATAR_BONE_HEAD ].position;
} }
glm::vec3 Head::getBonePosition( AvatarBones b ) { glm::vec3 Head::getBonePosition( AvatarBoneID b ) {
return _bone[b].position; return _bone[b].position;
} }
@ -1140,16 +1137,12 @@ void Head::updateHandMovement() {
if ( _usingBodySprings ) { if ( _usingBodySprings ) {
if ( _closestOtherAvatar != -1 ) { if ( _closestOtherAvatar != -1 ) {
if ( _mousePressed ) { if ( _mousePressed ) {
glm::vec3 handToHandVector( _otherAvatarHandPosition[ _closestOtherAvatar ]);
handToHandVector -= _bone[ AVATAR_BONE_RIGHT_HAND ].position;
/* //_bone[ AVATAR_BONE_RIGHT_HAND ].springyVelocity -= handPull;
glm::vec3 handShakePull( DEBUG_otherAvatarListPosition[ closestOtherAvatar ]);
handShakePull -= _bone[ AVATAR_BONE_RIGHT_HAND ].position;
handShakePull *= 1.0;
transformedHandMovement += handShakePull;
*/
_bone[ AVATAR_BONE_RIGHT_HAND ].position = _otherAvatarHandPosition[ _closestOtherAvatar ]; _bone[ AVATAR_BONE_RIGHT_HAND ].position = _otherAvatarHandPosition[ _closestOtherAvatar ];
} }
} }
@ -1230,30 +1223,23 @@ 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++) {
//renderBoneAsBlock( (AvatarBoneID)b);
/*
if ( _isMine ) //render bone orientation
{ renderOrientationDirections( _bone[b].springyPosition, _bone[b].orientation, _bone[b].radius * 2.0 );
printf( "my avatar: %d\n", _usingBodySprings );
}
else
{
printf( "other avatar: %d\n", _usingBodySprings );
}
*/
if ( _usingBodySprings ) { if ( _usingBodySprings ) {
glColor3fv( lightBlue ); glColor3fv( skinColor );
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 );
glutSolidSphere( _bone[b].radius, 10.0f, 5.0f ); glutSolidSphere( _bone[b].radius, 20.0f, 20.0f );
glPopMatrix(); glPopMatrix();
} }
else { else {
glColor3fv( skinColor ); glColor3fv( skinColor );
glPushMatrix(); glPushMatrix();
glTranslatef( _bone[b].position.x, _bone[b].position.y, _bone[b].position.z ); glTranslatef( _bone[b].position.x, _bone[b].position.y, _bone[b].position.z );
glutSolidSphere( _bone[b].radius, 10.0f, 5.0f ); glutSolidSphere( _bone[b].radius, 20.0f, 20.0f );
glPopMatrix(); glPopMatrix();
} }
} }
@ -1288,7 +1274,6 @@ else
} }
} }
if (( _usingBodySprings ) && ( _mousePressed )) { if (( _usingBodySprings ) && ( _mousePressed )) {
glColor4f( 1.0, 1.0, 0.5, 0.5 ); glColor4f( 1.0, 1.0, 0.5, 0.5 );
glPushMatrix(); glPushMatrix();
@ -1301,9 +1286,25 @@ else
glutSolidSphere( 0.03f, 10.0f, 5.0f ); glutSolidSphere( 0.03f, 10.0f, 5.0f );
glPopMatrix(); glPopMatrix();
} }
} }
void Head::renderBoneAsBlock( AvatarBoneID b ) {
glColor3fv( skinColor );
glPushMatrix();
glTranslatef( _bone[b].springyPosition.x, _bone[b].springyPosition.y, _bone[b].springyPosition.z );
glScalef( _bone[b].radius, _bone[b].length, _bone[b].radius );
glRotatef(_bone[b].yaw, 0, 1, 0 );
glRotatef(_bone[b].pitch, 1, 0, 0 );
glRotatef(_bone[b].roll, 0, 0, 1 );
glutSolidCube(1.0);
glPopMatrix();
}
void Head::SetNewHeadTarget(float pitch, float yaw) { void Head::SetNewHeadTarget(float pitch, float yaw) {
_head.pitchTarget = pitch; _head.pitchTarget = pitch;
_head.yawTarget = yaw; _head.yawTarget = yaw;

46
interface/src/Head.h
View file

@ -22,6 +22,13 @@
#include <glm/gtc/quaternion.hpp> #include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp> //looks like we might not need this #include <glm/gtx/quaternion.hpp> //looks like we might not need this
const bool AVATAR_GRAVITY = true;
const float DECAY = 0.1;
const float THRUST_MAG = 10.0;
const float YAW_MAG = 300.0;
const float TEST_YAW_DECAY = 5.0;
const float LIN_VEL_DECAY = 5.0;
enum eyeContactTargets {LEFT_EYE, RIGHT_EYE, MOUTH}; enum eyeContactTargets {LEFT_EYE, RIGHT_EYE, MOUTH};
#define FWD 0 #define FWD 0
@ -44,7 +51,7 @@ enum AvatarMode
NUM_AVATAR_MODES NUM_AVATAR_MODES
}; };
enum AvatarBones enum AvatarBoneID
{ {
AVATAR_BONE_NULL = -1, AVATAR_BONE_NULL = -1,
AVATAR_BONE_PELVIS_SPINE, // connects pelvis joint with torso joint (not supposed to be rotated) AVATAR_BONE_PELVIS_SPINE, // connects pelvis joint with torso joint (not supposed to be rotated)
@ -76,19 +83,19 @@ enum AvatarBones
struct AvatarBone struct AvatarBone
{ {
AvatarBones parent; // which bone is this bone connected to? AvatarBoneID parent; // which bone is this bone connected to?
glm::vec3 position; // the position at the "end" of the bone glm::vec3 position; // the position at the "end" of the bone
glm::vec3 defaultPosePosition; // the parent relative position when the avatar is in the "T-pose" glm::vec3 defaultPosePosition; // the parent relative position when the avatar is in the "T-pose"
glm::vec3 springyPosition; // used for special effects (a 'flexible' variant of position) glm::vec3 springyPosition; // used for special effects (a 'flexible' variant of position)
glm::dvec3 springyVelocity; // used for special effects ( the velocity of the springy position) glm::dvec3 springyVelocity; // used for special effects ( the velocity of the springy position)
float springBodyTightness; // how tightly the springy position tries to stay on the position float springBodyTightness; // how tightly the springy position tries to stay on the position
glm::quat rotation; // this will eventually replace yaw, pitch and roll (and maybe orientation) glm::quat rotation; // this will eventually replace yaw, pitch and roll (and maybe orientation)
float yaw; // the yaw Euler angle of the bone rotation off the parent float yaw; // the yaw Euler angle of the bone rotation off the parent
float pitch; // the pitch Euler angle of the bone rotation off the parent float pitch; // the pitch Euler angle of the bone rotation off the parent
float roll; // the roll Euler angle of the bone rotation off the parent float roll; // the roll Euler angle of the bone rotation off the parent
Orientation orientation; // three orthogonal normals determined by yaw, pitch, roll Orientation orientation; // three orthogonal normals determined by yaw, pitch, roll
float length; // the length of the bone float length; // the length of the bone
float radius; // used for detecting collisions for certain physical effects float radius; // used for detecting collisions for certain physical effects
}; };
struct AvatarHead struct AvatarHead
@ -168,19 +175,15 @@ class Head : public AvatarData {
glm::vec3 getHeadLookatDirectionUp(); glm::vec3 getHeadLookatDirectionUp();
glm::vec3 getHeadLookatDirectionRight(); glm::vec3 getHeadLookatDirectionRight();
glm::vec3 getHeadPosition(); glm::vec3 getHeadPosition();
glm::vec3 getBonePosition( AvatarBones b ); glm::vec3 getBonePosition( AvatarBoneID b );
AvatarMode getMode(); AvatarMode getMode();
void setMousePressed( bool pressed ); void setMousePressed( bool pressed );
void render(int faceToFace); void render(int faceToFace);
void renderBody(); void renderBody();
void renderHead( int faceToFace); void renderHead( int faceToFace);
void simulate(float); void simulate(float);
void startHandMovement(); void startHandMovement();
void stopHandMovement(); void stopHandMovement();
void setHandMovementValues( glm::vec3 movement ); void setHandMovementValues( glm::vec3 movement );
@ -217,7 +220,6 @@ class Head : public AvatarData {
glm::vec3 _otherAvatarHandPosition[ MAX_OTHER_AVATARS ]; glm::vec3 _otherAvatarHandPosition[ MAX_OTHER_AVATARS ];
bool _mousePressed; bool _mousePressed;
float _bodyYawDelta; float _bodyYawDelta;
//float _closeEnoughToInteract;
int _closestOtherAvatar; int _closestOtherAvatar;
bool _usingBodySprings; bool _usingBodySprings;
glm::vec3 _movedHandOffset; glm::vec3 _movedHandOffset;
@ -231,13 +233,11 @@ class Head : public AvatarData {
float _maxArmLength; float _maxArmLength;
Orientation _orientation; Orientation _orientation;
int _numOtherAvatarsInView; int _numOtherAvatarsInView;
int _driveKeys[MAX_DRIVE_KEYS]; int _driveKeys[MAX_DRIVE_KEYS];
GLUquadric* _sphere; GLUquadric* _sphere;
float _renderYaw; float _renderYaw;
float _renderPitch; // Pitch from view frustum when this is own head. float _renderPitch; // Pitch from view frustum when this is own head.
// //
// Related to getting transmitter UDP data used to animate the avatar hand // Related to getting transmitter UDP data used to animate the avatar hand
// //
@ -255,6 +255,8 @@ class Head : public AvatarData {
void calculateBoneLengths(); void calculateBoneLengths();
void updateBigSphereCollisionTest( float deltaTime ); void updateBigSphereCollisionTest( float deltaTime );
void readSensors(); void readSensors();
void renderBoneAsBlock( AvatarBoneID b );
}; };
#endif #endif

2
interface/src/VoxelSystem.cpp
View file

@ -465,7 +465,7 @@ bool VoxelSystem::falseColorizeInViewOperation(VoxelNode* node, bool down, void*
voxelBox.getSize().x); voxelBox.getSize().x);
// If the voxel is outside of the view frustum, then false color it red // If the voxel is outside of the view frustum, then false color it red
if (ViewFrustum::OUTSIDE == viewFrustum->pointInFrustum(voxelBox.getCorner())) { if (ViewFrustum::OUTSIDE == viewFrustum->boxInFrustum(voxelBox)) {
// Out of view voxels are colored RED // Out of view voxels are colored RED
unsigned char newR = 255; unsigned char newR = 255;
unsigned char newG = 0; unsigned char newG = 0;

38
interface/src/main.cpp
View file

@ -819,18 +819,16 @@ void display(void)
//-------------------------------------------------------- //--------------------------------------------------------
// camera settings // camera settings
//-------------------------------------------------------- //--------------------------------------------------------
myCamera.setTargetPosition( myAvatar.getBodyPosition() );
if ( displayHead ) { if ( displayHead ) {
//----------------------------------------------- //-----------------------------------------------
// set the camera to looking at my own face // set the camera to looking at my own face
//----------------------------------------------- //-----------------------------------------------
myCamera.setTargetPosition ( myAvatar.getBodyPosition() ); // XXXBHG - Shouldn't we use Head position here? myCamera.setTargetPosition ( myAvatar.getHeadPosition() );
myCamera.setYaw ( - myAvatar.getBodyYaw() ); myCamera.setYaw ( - myAvatar.getBodyYaw() );
myCamera.setPitch ( 0.0 ); myCamera.setPitch ( 0.0 );
myCamera.setRoll ( 0.0 ); myCamera.setRoll ( 0.0 );
myCamera.setUp ( 0.6 ); myCamera.setUp ( 0.0 );
myCamera.setDistance ( 0.3 ); myCamera.setDistance ( 0.2 );
myCamera.setTightness ( 100.0f ); myCamera.setTightness ( 100.0f );
myCamera.update ( 1.f/FPS ); myCamera.update ( 1.f/FPS );
} else { } else {
@ -839,12 +837,12 @@ void display(void)
//---------------------------------------------------- //----------------------------------------------------
myCamera.setTargetPosition ( myAvatar.getBodyPosition() ); myCamera.setTargetPosition ( myAvatar.getBodyPosition() );
myCamera.setYaw ( 180.0 - myAvatar.getBodyYaw() ); myCamera.setYaw ( 180.0 - myAvatar.getBodyYaw() );
myCamera.setPitch ( 0.0 ); // temporarily, this must be 0.0 or else bad juju myCamera.setPitch ( 0.0 ); // temporarily, this must be 0.0 or else bad juju
myCamera.setRoll ( 0.0 ); myCamera.setRoll ( 0.0 );
myCamera.setUp ( 0.45); myCamera.setUp ( 0.45 );
myCamera.setDistance ( 1.0 ); myCamera.setDistance ( 1.0 );
myCamera.setTightness ( 10.0f ); myCamera.setTightness ( 8.0f );
myCamera.update ( 1.f/FPS ); myCamera.update ( 1.f/FPS);
} }
// Note: whichCamera is used to pick between the normal camera myCamera for our // Note: whichCamera is used to pick between the normal camera myCamera for our
@ -907,14 +905,12 @@ void display(void)
float sphereRadius = 0.25f; float sphereRadius = 0.25f;
glColor3f(1,0,0); glColor3f(1,0,0);
glPushMatrix(); glPushMatrix();
//glTranslatef( 0.0f, sphereRadius, 0.0f );
glutSolidSphere( sphereRadius, 15, 15 ); glutSolidSphere( sphereRadius, 15, 15 );
glPopMatrix(); glPopMatrix();
//draw a grid gound plane.... //draw a grid gound plane....
drawGroundPlaneGrid( 5.0f, 9 ); drawGroundPlaneGrid( 5.0f, 9 );
// Draw cloud of dots // Draw cloud of dots
if (!displayHead) cloud.render(); if (!displayHead) cloud.render();
@ -934,12 +930,7 @@ void display(void)
agent++) { agent++) {
if (agent->getLinkedData() != NULL && agent->getType() == AGENT_TYPE_AVATAR) { if (agent->getLinkedData() != NULL && agent->getType() == AGENT_TYPE_AVATAR) {
Head *avatar = (Head *)agent->getLinkedData(); Head *avatar = (Head *)agent->getLinkedData();
//glPushMatrix();
//printf( "rendering remote avatar\n" );
avatar->render(0); avatar->render(0);
//glPopMatrix();
} }
} }
@ -1509,7 +1500,7 @@ void idle(void) {
// //
// Sample hardware, update view frustum if needed, Lsend avatar data to mixer/agents // Sample hardware, update view frustum if needed, Lsend avatar data to mixer/agents
// //
updateAvatar( 1.f/FPS ); updateAvatar(deltaTime);
//loop through all the other avatars and simulate them. //loop through all the other avatars and simulate them.
AgentList * agentList = AgentList::getInstance(); AgentList * agentList = AgentList::getInstance();
@ -1518,14 +1509,9 @@ void idle(void) {
if (agent->getLinkedData() != NULL) if (agent->getLinkedData() != NULL)
{ {
Head *avatar = (Head *)agent->getLinkedData(); Head *avatar = (Head *)agent->getLinkedData();
//printf( "simulating remote avatar\n" );
avatar->simulate(deltaTime); avatar->simulate(deltaTime);
} }
} }
//updateAvatarHand(1.f/FPS);
field.simulate (deltaTime); field.simulate (deltaTime);
myAvatar.simulate(deltaTime); myAvatar.simulate(deltaTime);

26
libraries/voxels/src/ViewFrustum.cpp
View file

@ -192,16 +192,16 @@ int ViewFrustum::sphereInFrustum(const glm::vec3& center, float radius) const {
int ViewFrustum::boxInFrustum(const AABox& box) const { int ViewFrustum::boxInFrustum(const AABox& box) const {
printf("ViewFrustum::boxInFrustum() box.corner=%f,%f,%f x=%f\n", //printf("ViewFrustum::boxInFrustum() box.corner=%f,%f,%f x=%f\n",
box.getCorner().x,box.getCorner().y,box.getCorner().z,box.getSize().x); // box.getCorner().x,box.getCorner().y,box.getCorner().z,box.getSize().x);
int result = INSIDE; int result = INSIDE;
for(int i=0; i < 6; i++) { for(int i=0; i < 6; i++) {
printf("plane[%d] -- point(%f,%f,%f) normal(%f,%f,%f) d=%f \n",i, //printf("plane[%d] -- point(%f,%f,%f) normal(%f,%f,%f) d=%f \n",i,
_planes[i].getPoint().x, _planes[i].getPoint().y, _planes[i].getPoint().z, // _planes[i].getPoint().x, _planes[i].getPoint().y, _planes[i].getPoint().z,
_planes[i].getNormal().x, _planes[i].getNormal().y, _planes[i].getNormal().z, // _planes[i].getNormal().x, _planes[i].getNormal().y, _planes[i].getNormal().z,
_planes[i].getDCoefficient() // _planes[i].getDCoefficient()
); //);
glm::vec3 normal = _planes[i].getNormal(); glm::vec3 normal = _planes[i].getNormal();
glm::vec3 boxVertexP = box.getVertexP(normal); glm::vec3 boxVertexP = box.getVertexP(normal);
@ -210,13 +210,11 @@ int ViewFrustum::boxInFrustum(const AABox& box) const {
glm::vec3 boxVertexN = box.getVertexN(normal); glm::vec3 boxVertexN = box.getVertexN(normal);
float planeToBoxVertexNDistance = _planes[i].distance(boxVertexN); float planeToBoxVertexNDistance = _planes[i].distance(boxVertexN);
//printf("plane[%d] normal=(%f,%f,%f) bVertexP=(%f,%f,%f) planeToBoxVertexPDistance=%f boxVertexN=(%f,%f,%f) planeToBoxVertexNDistance=%f\n",i,
// normal.x,normal.y,normal.z,
printf("plane[%d] normal=(%f,%f,%f) bVertexP=(%f,%f,%f) planeToBoxVertexPDistance=%f boxVertexN=(%f,%f,%f) planeToBoxVertexNDistance=%f\n",i, // boxVertexP.x,boxVertexP.y,boxVertexP.z,planeToBoxVertexPDistance,
normal.x,normal.y,normal.z, // boxVertexN.x,boxVertexN.y,boxVertexN.z,planeToBoxVertexNDistance
boxVertexP.x,boxVertexP.y,boxVertexP.z,planeToBoxVertexPDistance, // );
boxVertexN.x,boxVertexN.y,boxVertexN.z,planeToBoxVertexNDistance
);
if (planeToBoxVertexPDistance < 0) { if (planeToBoxVertexPDistance < 0) {
return OUTSIDE; return OUTSIDE;

2
libraries/voxels/src/VoxelTree.cpp
View file

@ -392,7 +392,7 @@ unsigned char * VoxelTree::loadBitstreamBuffer(unsigned char *& bitstreamBuffer,
bool childIsClose = true; // for now, assume we're close enough bool childIsClose = true; // for now, assume we're close enough
bool childInView = !viewFrustumCulling || bool childInView = !viewFrustumCulling ||
(ViewFrustum::OUTSIDE != viewFrustum.pointInFrustum(childBox.getCorner())); (ViewFrustum::OUTSIDE != viewFrustum.boxInFrustum(childBox));
/// XXXBHG - debug code, switch this to true, and we'll send everything but include false coloring /// XXXBHG - debug code, switch this to true, and we'll send everything but include false coloring
// on voxels based on whether or not they match these rules. // on voxels based on whether or not they match these rules.

6
voxel-server/src/main.cpp
View file

@ -49,7 +49,7 @@ VoxelTree randomTree;
bool wantColorRandomizer = false; bool wantColorRandomizer = false;
bool debugViewFrustum = false; bool debugViewFrustum = false;
bool viewFrustumCulling = false; // for now bool viewFrustumCulling = true; // for now
void addSphere(VoxelTree * tree,bool random, bool wantColorRandomizer) { void addSphere(VoxelTree * tree,bool random, bool wantColorRandomizer) {
float r = random ? randFloatInRange(0.05,0.1) : 0.25; float r = random ? randFloatInRange(0.05,0.1) : 0.25;
@ -276,8 +276,8 @@ int main(int argc, const char * argv[])
::debugViewFrustum = cmdOptionExists(argc, argv, DEBUG_VIEW_FRUSTUM); ::debugViewFrustum = cmdOptionExists(argc, argv, DEBUG_VIEW_FRUSTUM);
printf("debugViewFrustum=%s\n", (::debugViewFrustum ? "yes" : "no")); printf("debugViewFrustum=%s\n", (::debugViewFrustum ? "yes" : "no"));
const char* VIEW_FRUSTUM_CULLING = "--ViewFrustumCulling"; const char* NO_VIEW_FRUSTUM_CULLING = "--NoViewFrustumCulling";
::viewFrustumCulling = cmdOptionExists(argc, argv, VIEW_FRUSTUM_CULLING); ::viewFrustumCulling = !cmdOptionExists(argc, argv, NO_VIEW_FRUSTUM_CULLING);
printf("viewFrustumCulling=%s\n", (::viewFrustumCulling ? "yes" : "no")); printf("viewFrustumCulling=%s\n", (::viewFrustumCulling ? "yes" : "no"));
const char* WANT_COLOR_RANDOMIZER = "--WantColorRandomizer"; const char* WANT_COLOR_RANDOMIZER = "--WantColorRandomizer";