Rave & Leap: cleanup and move over to new hand/finger structures

interface/src/Avatar.cpp

@@ -821,10 +821,13 @@ void Avatar::updateHandMovementAndTouching(float deltaTime, bool enableHandMovem
         }
         
         // If there's a leap-interaction hand visible, use that as the endpoint
-        if (getHand().getHandPositions().size() > 0) {
+        for (size_t i = 0; i < getHand().getPalms().size(); ++i) {
-            _skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position =
+            PalmData& palm = getHand().getPalms()[i];
-                getHand().leapPositionToWorldPosition(getHand().getHandPositions()[0]);
+            if (palm.isActive()) {
+                _skeleton.joint[ AVATAR_JOINT_RIGHT_FINGERTIPS ].position = palm.getPosition();
+            }
         }
+        
     }//if (_isMine)
     
     //constrain right arm length and re-adjust elbow position as it bends

interface/src/Hand.cpp

@@ -55,15 +55,23 @@ void Hand::calculateGeometry() {
     _basePosition = head.getPosition() + head.getOrientation() * offset;
     _baseOrientation = head.getOrientation();
 
-    int numLeapBalls = _fingerTips.size();
+    _leapBalls.clear();
-    _leapBalls.resize(numLeapBalls);
+    for (size_t i = 0; i < getNumPalms(); ++i) {
-    
+        PalmData& palm = getPalms()[i];
-    for (int i = 0; i < _fingerTips.size(); ++i) {
+        if (palm.isActive()) {
-        _leapBalls[i].rotation = _baseOrientation;
+            for (size_t f = 0; f < palm.getNumFingers(); ++f) {
-        _leapBalls[i].position = leapPositionToWorldPosition(_fingerTips[i]);
+                FingerData& finger = palm.getFingers()[f];
-        _leapBalls[i].radius         = 0.01;
+                if (finger.isActive()) {
-        _leapBalls[i].touchForce     = 0.0;
+                    _leapBalls.resize(_leapBalls.size() + 1);
-        _leapBalls[i].isCollidable   = true;
+                    HandBall& ball = _leapBalls.back();
+                    ball.rotation = _baseOrientation;
+                    ball.position = finger.getTipPosition();
+                    ball.radius         = 0.01;
+                    ball.touchForce     = 0.0;
+                    ball.isCollidable   = true;
+                }
+            }
+        }
     }
 }
 
@@ -134,21 +142,28 @@ void Hand::renderHandSpheres() {
     }
     
     // Draw the finger root cones
-    if (_fingerTips.size() == _fingerRoots.size()) {
+    for (size_t i = 0; i < getNumPalms(); ++i) {
-        for (size_t i = 0; i < _fingerTips.size(); ++i) {
+        PalmData& palm = getPalms()[i];
-            glColor4f(_ballColor.r, _ballColor.g, _ballColor.b, 0.5);
+        if (palm.isActive()) {
-            glm::vec3 tip = leapPositionToWorldPosition(_fingerTips[i]);
+            for (size_t f = 0; f < palm.getNumFingers(); ++f) {
-            glm::vec3 root = leapPositionToWorldPosition(_fingerRoots[i]);
+                FingerData& finger = palm.getFingers()[f];
-            Avatar::renderJointConnectingCone(root, tip, 0.001, 0.003);
+                if (finger.isActive()) {
+                    glColor4f(_ballColor.r, _ballColor.g, _ballColor.b, 0.5);
+                    glm::vec3 tip = finger.getTipPosition();
+                    glm::vec3 root = finger.getRootPosition();
+                    Avatar::renderJointConnectingCone(root, tip, 0.001, 0.003);
+                }
+            }
         }
     }
 
     // Draw the palms
-    if (_handPositions.size() == _handNormals.size()) {
+    for (size_t i = 0; i < getNumPalms(); ++i) {
-        for (size_t i = 0; i < _handPositions.size(); ++i) {
+        PalmData& palm = getPalms()[i];
+        if (palm.isActive()) {
             glColor4f(_ballColor.r, _ballColor.g, _ballColor.b, 0.25);
-            glm::vec3 tip = leapPositionToWorldPosition(_handPositions[i]);
+            glm::vec3 tip = palm.getPosition();
-            glm::vec3 root = leapPositionToWorldPosition(_handPositions[i] + (_handNormals[i] * 2.0f));
+            glm::vec3 root = palm.getPosition() + palm.getNormal() * 0.002f;
             Avatar::renderJointConnectingCone(root, tip, 0.05, 0.03);
         }
     }
@@ -158,14 +173,39 @@ void Hand::renderHandSpheres() {
 
 void Hand::setLeapFingers(const std::vector<glm::vec3>& fingerTips,
                           const std::vector<glm::vec3>& fingerRoots) {
-    _fingerTips = fingerTips;
+    // TODO: add id-checking here to increase finger stability
-    _fingerRoots = fingerRoots;
+    
+    size_t fingerIndex = 0;
+    for (size_t i = 0; i < getNumPalms(); ++i) {
+        PalmData& palm = getPalms()[i];
+        for (size_t f = 0; f < palm.getNumFingers(); ++f) {
+            FingerData& finger = palm.getFingers()[f];
+            if (fingerIndex < fingerTips.size()) {
+                finger.setActive(true);
+                finger.setRawTipPosition(fingerTips[fingerIndex]);
+                finger.setRawRootPosition(fingerRoots[fingerIndex]);
+                fingerIndex++;
+            }
+            else {
+                finger.setActive(false);
+            }
+        }
+    }
 }
 
 void Hand::setLeapHands(const std::vector<glm::vec3>& handPositions,
                           const std::vector<glm::vec3>& handNormals) {
-    _handPositions = handPositions;
+    for (size_t i = 0; i < getNumPalms(); ++i) {
-    _handNormals = handNormals;
+        PalmData& palm = getPalms()[i];
+        if (i < handPositions.size()) {
+            palm.setActive(true);
+            palm.setRawPosition(handPositions[i]);
+            palm.setRawNormal(handNormals[i]);
+        }
+        else {
+            palm.setActive(false);
+        }
+    }
 }
 
 
@@ -182,33 +222,41 @@ void Hand::updateFingerParticles(float deltaTime) {
         
         static float t = 0.0f;
         t += deltaTime;
-                
-        for ( int f = 0; f< _fingerTips.size(); f ++ ) {
-            
-            if (_fingerParticleEmitter[f] != -1) {
-                    
-                glm::vec3 particleEmitterPosition = leapPositionToWorldPosition(_fingerTips[f]);
-                       
-                // this aspect is still being designed....
-                       
-                glm::vec3 tilt = glm::vec3
-                (
-                    30.0f * sinf( t * 0.55f ),
-                    0.0f,
-                    30.0f * cosf( t * 0.75f )
-                );
-                
-                glm::quat particleEmitterRotation = glm::quat(glm::radians(tilt));
 
-                _particleSystem.setEmitterPosition(_fingerParticleEmitter[0], particleEmitterPosition);
+        int fingerIndex = 0;
-                _particleSystem.setEmitterRotation(_fingerParticleEmitter[0], particleEmitterRotation);
+        for (size_t i = 0; i < getNumPalms(); ++i) {
-                
+            PalmData& palm = getPalms()[i];
-                float radius = 0.005f;
+            if (palm.isActive()) {
-                glm::vec4 color(1.0f, 0.6f, 0.0f, 0.5f);
+                for (size_t f = 0; f < palm.getNumFingers(); ++f) {
-                glm::vec3 velocity(0.0f, 0.005f, 0.0f);
+                    FingerData& finger = palm.getFingers()[f];
-                float lifespan = 0.3f;
+                    if (finger.isActive()) {
-                _particleSystem.emitParticlesNow(_fingerParticleEmitter[0], 1, radius, color, velocity, lifespan); 
+                        if (_fingerParticleEmitter[fingerIndex] != -1) {
-            }  
+                            
+                            glm::vec3 particleEmitterPosition = finger.getTipPosition();
+                            
+                            // this aspect is still being designed....
+                            
+                            glm::vec3 tilt = glm::vec3
+                            (
+                             30.0f * sinf( t * 0.55f ),
+                             0.0f,
+                             30.0f * cosf( t * 0.75f )
+                             );
+                            
+                            glm::quat particleEmitterRotation = glm::quat(glm::radians(tilt));
+                            
+                            _particleSystem.setEmitterPosition(_fingerParticleEmitter[0], particleEmitterPosition);
+                            _particleSystem.setEmitterRotation(_fingerParticleEmitter[0], particleEmitterRotation);
+                            
+                            float radius = 0.005f;
+                            glm::vec4 color(1.0f, 0.6f, 0.0f, 0.5f);
+                            glm::vec3 velocity(0.0f, 0.005f, 0.0f);
+                            float lifespan = 0.3f;
+                            _particleSystem.emitParticlesNow(_fingerParticleEmitter[0], 1, radius, color, velocity, lifespan);
+                        }
+                    }
+                }
+            }
         }
         
         _particleSystem.setUpDirection(glm::vec3(0.0f, 1.0f, 0.0f));  

libraries/avatars/src/AvatarData.cpp

@@ -127,36 +127,22 @@ int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
     *destinationBuffer++ = bitItems;
     
     // leap hand data
-    // In order to make the hand data version-robust, hand data packing is just a series of vec3's,
+    std::vector<glm::vec3> fingerVectors;
-    // with conventions. If a client doesn't know the conventions, they can just get the vec3's
+    _handData->encodeRemoteData(fingerVectors);
-    // and render them as balls, or ignore them, without crashing or disrupting anyone.
-    // Current convention:
-    //    Zero or more fingetTip positions, followed by the same number of fingerRoot positions
-    
-    const std::vector<glm::vec3>& fingerTips = _handData->getFingerTips();
-    const std::vector<glm::vec3>& fingerRoots = _handData->getFingerRoots();
-    size_t numFingerVectors = fingerTips.size() + fingerRoots.size();
-    if (numFingerVectors > 255)
-        numFingerVectors = 0; // safety. We shouldn't ever get over 255, so consider that invalid.
 
     /////////////////////////////////
     // Temporarily disable Leap finger sending, as it's causing a crash whenever someone's got a Leap connected
-    numFingerVectors = 0;
+    fingerVectors.clear();
     /////////////////////////////////
-    
+    if (fingerVectors.size() > 255)
-    *destinationBuffer++ = (unsigned char)numFingerVectors;
+        fingerVectors.clear(); // safety. We shouldn't ever get over 255, so consider that invalid.
-    
+
-    if (numFingerVectors > 0) {
+    *destinationBuffer++ = (unsigned char)fingerVectors.size();
-        for (size_t i = 0; i < fingerTips.size(); ++i) {
+
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerTips[i].x, 4);
+    for (size_t i = 0; i < fingerVectors.size(); ++i) {
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerTips[i].y, 4);
+        destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerVectors[i].x, 4);
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerTips[i].z, 4);
+        destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerVectors[i].y, 4);
-        }
+        destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerVectors[i].z, 4);
-        for (size_t i = 0; i < fingerRoots.size(); ++i) {
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerRoots[i].x, 4);
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerRoots[i].y, 4);
-            destinationBuffer += packFloatScalarToSignedTwoByteFixed(destinationBuffer, fingerRoots[i].z, 4);
-        }
     }
     
     // skeleton joints
@@ -263,25 +249,16 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
     // leap hand data
     if (sourceBuffer - startPosition < numBytes)    // safety check
     {
-        std::vector<glm::vec3> fingerTips;
-        std::vector<glm::vec3> fingerRoots;
         unsigned int numFingerVectors = *sourceBuffer++;
-        unsigned int numFingerTips = numFingerVectors / 2;
+        if (numFingerVectors > 0) {
-        unsigned int numFingerRoots = numFingerVectors - numFingerTips;
+            std::vector<glm::vec3> fingerVectors(numFingerVectors);
-        fingerTips.resize(numFingerTips);
+            for (size_t i = 0; i < numFingerVectors; ++i) {
-        fingerRoots.resize(numFingerRoots);
+                sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerVectors[i].x), 4);
-        for (size_t i = 0; i < numFingerTips; ++i) {
+                sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerVectors[i].y), 4);
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerTips[i].x), 4);
+                sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerVectors[i].z), 4);
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerTips[i].y), 4);
+            }
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerTips[i].z), 4);
+            _handData->decodeRemoteData(fingerVectors);
         }
-        for (size_t i = 0; i < numFingerRoots; ++i) {
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerRoots[i].x), 4);
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerRoots[i].y), 4);
-            sourceBuffer += unpackFloatScalarFromSignedTwoByteFixed((int16_t*) sourceBuffer, &(fingerRoots[i].z), 4);
-        }
-        _handData->setFingerTips(fingerTips);
-        _handData->setFingerRoots(fingerRoots);
     }
     
     // skeleton joints

libraries/avatars/src/HandData.cpp

@@ -35,3 +35,46 @@ _owningPalmData(owningPalmData),
 _owningHandData(owningHandData)
 {
 }
+
+void HandData::encodeRemoteData(std::vector<glm::vec3>& fingerVectors) {
+    fingerVectors.clear();
+    for (size_t i = 0; i < getNumPalms(); ++i) {
+        PalmData& palm = getPalms()[i];
+        fingerVectors.push_back(palm.getRawPosition());
+        fingerVectors.push_back(palm.getRawNormal());
+        for (size_t f = 0; f < palm.getNumFingers(); ++f) {
+            FingerData& finger = palm.getFingers()[f];
+            if (finger.isActive()) {
+                fingerVectors.push_back(finger.getTipRawPosition());
+                fingerVectors.push_back(finger.getRootRawPosition());
+            }
+            else {
+                fingerVectors.push_back(glm::vec3(0,0,0));
+                fingerVectors.push_back(glm::vec3(0,0,0));
+            }
+        }
+    }
+}
+
+void HandData::decodeRemoteData(const std::vector<glm::vec3>& fingerVectors) {
+    size_t vectorIndex = 0;
+    for (size_t i = 0; i < getNumPalms(); ++i) {
+        PalmData& palm = getPalms()[i];
+        // If a palm is active, there will be
+        //  1 vector for its position
+        //  1 vector for normal
+        // 10 vectors for fingers (5 tip/root pairs)
+        bool palmActive = fingerVectors.size() >= i * 12;
+        palm.setActive(palmActive);
+        if (palmActive) {
+            palm.setRawPosition(fingerVectors[vectorIndex++]);
+            palm.setRawNormal(fingerVectors[vectorIndex++]);
+            for (size_t f = 0; f < NUM_FINGERS_PER_HAND; ++f) {
+                FingerData& finger = palm.getFingers()[i];
+                finger.setRawTipPosition(fingerVectors[vectorIndex++]);
+                finger.setRawRootPosition(fingerVectors[vectorIndex++]);
+            }
+        }
+    }
+}
+

libraries/avatars/src/HandData.h

@@ -27,14 +27,6 @@ public:
     
     // These methods return the positions in Leap-relative space.
     // To convert to world coordinates, use Hand::leapPositionToWorldPosition.
-    const std::vector<glm::vec3>& getFingerTips() const { return _fingerTips; }
-    const std::vector<glm::vec3>& getFingerRoots() const { return _fingerRoots; }
-    const std::vector<glm::vec3>& getHandPositions() const { return _handPositions; }
-    const std::vector<glm::vec3>& getHandNormals() const { return _handNormals; }
-    void setFingerTips(const std::vector<glm::vec3>& fingerTips) { _fingerTips = fingerTips; }
-    void setFingerRoots(const std::vector<glm::vec3>& fingerRoots) { _fingerRoots = fingerRoots; }
-    void setHandPositions(const std::vector<glm::vec3>& handPositons) { _handPositions = handPositons; }
-    void setHandNormals(const std::vector<glm::vec3>& handNormals) { _handNormals = handNormals; }
     
     // position conversion
     glm::vec3 leapPositionToWorldPosition(const glm::vec3& leapPosition) {
@@ -45,12 +37,15 @@ public:
         return glm::normalize(_baseOrientation * leapDirection);
     }
 
+    std::vector<PalmData>& getPalms()    { return _palms; }
+    size_t                 getNumPalms() { return _palms.size(); }
+
+    // Use these for sending and receiving hand data
+    void encodeRemoteData(std::vector<glm::vec3>& fingerVectors);
+    void decodeRemoteData(const std::vector<glm::vec3>& fingerVectors);
+    
     friend class AvatarData;
 protected:
-    std::vector<glm::vec3> _fingerTips;
-    std::vector<glm::vec3> _fingerRoots;
-    std::vector<glm::vec3> _handPositions;
-    std::vector<glm::vec3> _handNormals;
     glm::vec3              _basePosition;      // Hands are placed relative to this
     glm::quat              _baseOrientation;   // Hands are placed relative to this
     AvatarData* _owningAvatarData;
@@ -64,6 +59,17 @@ private:
 class FingerData {
 public:
     FingerData(PalmData* owningPalmData, HandData* owningHandData);
+
+    glm::vec3        getTipPosition()     const { return _owningHandData->leapPositionToWorldPosition(_tipRawPosition); }
+    glm::vec3        getRootPosition()    const { return _owningHandData->leapPositionToWorldPosition(_rootRawPosition); }
+    const glm::vec3& getTipRawPosition()  const { return _tipRawPosition; }
+    const glm::vec3& getRootRawPosition() const { return _rootRawPosition; }
+    bool             isActive()           const { return _isActive; }
+
+    void setActive(bool active)                   { _isActive = active; }
+    void setRawTipPosition(const glm::vec3& pos)  { _tipRawPosition = pos; }
+    void setRawRootPosition(const glm::vec3& pos) { _rootRawPosition = pos; }
+
 private:
     glm::vec3 _tipRawPosition;
     glm::vec3 _rootRawPosition;
@@ -75,10 +81,19 @@ private:
 class PalmData {
 public:
     PalmData(HandData* owningHandData);
-    glm::vec3 getPosition() const { return _owningHandData->leapPositionToWorldPosition(_rawPosition); }
+    glm::vec3 getPosition()           const { return _owningHandData->leapPositionToWorldPosition(_rawPosition); }
-    glm::vec3 getNormal()   const { return _owningHandData->leapDirectionToWorldDirection(_rawNormal); }
+    glm::vec3 getNormal()             const { return _owningHandData->leapDirectionToWorldDirection(_rawNormal); }
     const glm::vec3& getRawPosition() const { return _rawPosition; }
     const glm::vec3& getRawNormal()   const { return _rawNormal; }
+    bool             isActive()       const { return _isActive; }
+
+    std::vector<FingerData>& getFingers()    { return _fingers; }
+    size_t                   getNumFingers() { return _fingers.size(); }
+
+    void setActive(bool active)                { _isActive = active; }
+    void setRawPosition(const glm::vec3& pos)  { _rawPosition = pos; }
+    void setRawNormal(const glm::vec3& normal) { _rawNormal = normal; }
+
 private:
     std::vector<FingerData> _fingers;
     glm::vec3 _rawPosition;

libraries/shared/src/PacketHeaders.cpp

@@ -15,7 +15,7 @@
 PACKET_VERSION versionForPacketType(PACKET_TYPE type) {
     switch (type) {
         case PACKET_TYPE_HEAD_DATA:
-            return 1;
+            return 2;
             break;
         default:
             return 0;