Merge remote-tracking branch 'upstream/master' into nodelist-container

interface/src/Application.cpp

@@ -1114,7 +1114,7 @@ void Application::mouseMoveEvent(QMouseEvent* event) {
                 return;
             }
             if (_isHoverVoxel) {
-                _myAvatar.orbit(glm::vec3(_hoverVoxel.x, _hoverVoxel.y, _hoverVoxel.z) * (float)TREE_SCALE, deltaX, deltaY);
+                _myAvatar.orbit(getMouseVoxelWorldCoordinates(_hoverVoxel), deltaX, deltaY);
                 return;
             }
         }
@@ -1340,8 +1340,9 @@ void Application::timer() {
     // ask the node list to check in with the domain server
     NodeList::getInstance()->sendDomainServerCheckIn();
 
-    // give the MyAvatar object position to the Profile so it can propagate to the data-server
+    // give the MyAvatar object position, orientation to the Profile so it can propagate to the data-server
     _profile.updatePosition(_myAvatar.getPosition());
+    _profile.updateOrientation(_myAvatar.getOrientation());
 }
 
 static glm::vec3 getFaceVector(BoxFace face) {
@@ -1605,10 +1606,9 @@ void Application::makeVoxel(glm::vec3 position,
                         isDestructive);
    }
 
-const glm::vec3 Application::getMouseVoxelWorldCoordinates(const VoxelDetail _mouseVoxel) {
+glm::vec3 Application::getMouseVoxelWorldCoordinates(const VoxelDetail& mouseVoxel) {
-    return glm::vec3((_mouseVoxel.x + _mouseVoxel.s / 2.f) * TREE_SCALE,
+    return glm::vec3((mouseVoxel.x + mouseVoxel.s / 2.f) * TREE_SCALE, (mouseVoxel.y + mouseVoxel.s / 2.f) * TREE_SCALE,
-                     (_mouseVoxel.y + _mouseVoxel.s / 2.f) * TREE_SCALE,
+        (mouseVoxel.z + mouseVoxel.s / 2.f) * TREE_SCALE);
-                     (_mouseVoxel.z + _mouseVoxel.s / 2.f) * TREE_SCALE);
 }
 
 const float NUDGE_PRECISION_MIN = 1 / pow(2.0, 12.0);
@@ -2045,9 +2045,12 @@ void Application::updateAvatars(float deltaTime, glm::vec3 mouseRayOrigin, glm::
     for (vector<Avatar*>::iterator fade = _avatarFades.begin(); fade != _avatarFades.end(); fade++) {
         Avatar* avatar = *fade;
         const float SHRINK_RATE = 0.9f;
-        avatar->setNewScale(avatar->getNewScale() * SHRINK_RATE);
+        
-        const float MINIMUM_SCALE = 0.001f;
+        avatar->setTargetScale(avatar->getScale() * SHRINK_RATE);
-        if (avatar->getNewScale() < MINIMUM_SCALE) {
+        
+        const float MIN_FADE_SCALE = 0.001;
+        
+        if (avatar->getTargetScale() < MIN_FADE_SCALE) {
             delete avatar;
             _avatarFades.erase(fade--);
 

interface/src/Application.h

@@ -142,7 +142,7 @@ public:
 
     void removeVoxel(glm::vec3 position, float scale);
 
-    const glm::vec3 getMouseVoxelWorldCoordinates(const VoxelDetail _mouseVoxel);
+    glm::vec3 getMouseVoxelWorldCoordinates(const VoxelDetail& mouseVoxel);
 
     QGLWidget* getGLWidget() { return _glWidget; }
     MyAvatar* getAvatar() { return &_myAvatar; }

interface/src/DataServerClient.cpp

@@ -174,25 +174,35 @@ void DataServerClient::processSendFromDataServer(unsigned char* packetData, int
                         }
                     }
                 }
-            } else if (keyList[i] == DataServerKey::Domain && keyList[i + 1] == DataServerKey::Position
+            } else if (keyList[i] == DataServerKey::Domain && keyList[i + 1] == DataServerKey::Position &&
-                       && valueList[i] != " " && valueList[i + 1] != " ") {
+                    keyList[i + 2] == DataServerKey::Orientation && valueList[i] != " " &&
+                    valueList[i + 1] != " " && valueList[i + 2] != " ") {
                 
                 QStringList coordinateItems = valueList[i + 1].split(',');
+                QStringList orientationItems = valueList[i + 2].split(',');
                 
-                if (coordinateItems.size() == 3) {
+                if (coordinateItems.size() == 3 && orientationItems.size() == 3) {
                     
                     // send a node kill request, indicating to other clients that they should play the "disappeared" effect
                     NodeList::getInstance()->sendKillNode(&NODE_TYPE_AVATAR_MIXER, 1);
                     
                     qDebug() << "Changing domain to" << valueList[i].toLocal8Bit().constData() <<
-                        "and position to" << valueList[i + 1].toLocal8Bit().constData() <<
+                        ", position to" << valueList[i + 1].toLocal8Bit().constData() <<
+                        ", and orientation to" << valueList[i + 2].toLocal8Bit().constData() <<
                         "to go to" << userString << "\n";
                     
                     NodeList::getInstance()->setDomainHostname(valueList[i]);
                     
-                    glm::vec3 newPosition(coordinateItems[0].toFloat(),
+                    // orient the user to face the target
-                                          coordinateItems[1].toFloat(),
+                    glm::quat newOrientation = glm::quat(glm::radians(glm::vec3(orientationItems[0].toFloat(),
-                                          coordinateItems[2].toFloat());
+                        orientationItems[1].toFloat(), orientationItems[2].toFloat()))) *
+                            glm::angleAxis(180.0f, 0.0f, 1.0f, 0.0f);
+                    Application::getInstance()->getAvatar()->setOrientation(newOrientation);
+                    
+                    // move the user a couple units away
+                    const float DISTANCE_TO_USER = 2.0f;
+                    glm::vec3 newPosition = glm::vec3(coordinateItems[0].toFloat(), coordinateItems[1].toFloat(),
+                        coordinateItems[2].toFloat()) - newOrientation * IDENTITY_FRONT * DISTANCE_TO_USER;
                     Application::getInstance()->getAvatar()->setPosition(newPosition);
                 }
                 

interface/src/DataServerClient.h

@@ -41,6 +41,7 @@ namespace DataServerKey {
     const QString FaceMeshURL = "mesh";
     const QString SkeletonURL = "skeleton";
     const QString Position = "position";
+    const QString Orientation = "orientation";
     const QString UUID = "uuid";
 }
 

interface/src/Menu.cpp

@@ -891,7 +891,7 @@ void Menu::editPreferences() {
         _maxVoxelPacketsPerSecond = maxVoxelsPPS->value();
         
         applicationInstance->getAvatar()->setLeanScale(leanScale->value());
-        applicationInstance->getAvatar()->setNewScale(avatarScale->value());
+        applicationInstance->getAvatar()->setClampedTargetScale(avatarScale->value());
         
         _audioJitterBufferSamples = audioJitterBufferSamples->value();
         
@@ -999,8 +999,9 @@ void Menu::goToUser() {
     int dialogReturn = userDialog.exec();
     if (dialogReturn == QDialog::Accepted && !userDialog.textValue().isEmpty()) {
         // there's a username entered by the user, make a request to the data-server
-        DataServerClient::getValuesForKeysAndUserString((QStringList() << DataServerKey::Domain << DataServerKey::Position),
+        DataServerClient::getValuesForKeysAndUserString(
-                                                        userDialog.textValue());
+            QStringList() << DataServerKey::Domain << DataServerKey::Position << DataServerKey::Orientation,
+            userDialog.textValue());
     }
     
     sendFakeEnterEvent();

interface/src/avatar/Avatar.cpp

@@ -418,30 +418,30 @@ void Avatar::goHome() {
 }
 
 void Avatar::increaseSize() {
-    if ((1.f + SCALING_RATIO) * _newScale < MAX_SCALE) {
+    if ((1.f + SCALING_RATIO) * _targetScale < MAX_AVATAR_SCALE) {
-        _newScale *= (1.f + SCALING_RATIO);
+        _targetScale *= (1.f + SCALING_RATIO);
-        qDebug("Changed scale to %f\n", _newScale);
+        qDebug("Changed scale to %f\n", _targetScale);
     }
 }
 
 void Avatar::decreaseSize() {
-    if (MIN_SCALE < (1.f - SCALING_RATIO) * _newScale) {
+    if (MIN_AVATAR_SCALE < (1.f - SCALING_RATIO) * _targetScale) {
-        _newScale *= (1.f - SCALING_RATIO);
+        _targetScale *= (1.f - SCALING_RATIO);
-        qDebug("Changed scale to %f\n", _newScale);
+        qDebug("Changed scale to %f\n", _targetScale);
     }
 }
 
 void Avatar::resetSize() {
-    _newScale = 1.0f;
+    _targetScale = 1.0f;
-    qDebug("Reseted scale to %f\n", _newScale);
+    qDebug("Reseted scale to %f\n", _targetScale);
 }
 
 void Avatar::setScale(const float scale) {
     _scale = scale;
 
-    if (_newScale * (1.f - RESCALING_TOLERANCE) < _scale &&
+    if (_targetScale * (1.f - RESCALING_TOLERANCE) < _scale &&
-            _scale < _newScale * (1.f + RESCALING_TOLERANCE)) {
+            _scale < _targetScale * (1.f + RESCALING_TOLERANCE)) {
-        _scale = _newScale;
+        _scale = _targetScale;
     }
     
     _skeleton.setScale(_scale);

interface/src/avatar/MyAvatar.cpp

@@ -502,7 +502,7 @@ void MyAvatar::saveData(QSettings* settings) {
     settings->setValue("pupilDilation", _head.getPupilDilation());
     
     settings->setValue("leanScale", _leanScale);
-    settings->setValue("scale", _newScale);
+    settings->setValue("scale", _targetScale);
     
     settings->endGroup();
 }
@@ -525,7 +525,7 @@ void MyAvatar::loadData(QSettings* settings) {
     
     _leanScale = loadSetting(settings, "leanScale", 0.05f);
     
-    _newScale = loadSetting(settings, "scale", 1.0f);
+    _targetScale = loadSetting(settings, "scale", 1.0f);
     setScale(_scale);
     Application::getInstance()->getCamera()->setScale(_scale);
     

interface/src/avatar/Profile.cpp

@@ -18,6 +18,7 @@ Profile::Profile(const QString &username) :
     _uuid(),
     _lastDomain(),
     _lastPosition(0.0, 0.0, 0.0),
+    _lastOrientationSend(0),
  	_faceModelURL()
 {
     if (!_username.isEmpty()) {
@@ -69,6 +70,10 @@ void Profile::updateDomain(const QString& domain) {
     }
 }
 
+static QByteArray createByteArray(const glm::vec3& vector) {
+    return QByteArray::number(vector.x) + ',' + QByteArray::number(vector.y) + ',' + QByteArray::number(vector.z);
+}
+
 void Profile::updatePosition(const glm::vec3 position) {
     if (_lastPosition != position) {
         
@@ -90,12 +95,29 @@ void Profile::updatePosition(const glm::vec3 position) {
                 gettimeofday(&lastPositionSend, NULL);
                 
                 // send the changed position to the data-server
-                QString positionString = QString("%1,%2,%3").arg(position.x).arg(position.y).arg(position.z);
+                DataServerClient::putValueForKey(DataServerKey::Position, createByteArray(position).constData());
-                DataServerClient::putValueForKey(DataServerKey::Position, positionString.toLocal8Bit().constData());
             }
     }
 }
 
+void Profile::updateOrientation(const glm::quat& orientation) {
+    glm::vec3 eulerAngles = safeEulerAngles(orientation);
+    if (_lastOrientation == eulerAngles) {
+        return;
+    }
+    const uint64_t DATA_SERVER_ORIENTATION_UPDATE_INTERVAL_USECS = 5 * 1000 * 1000;
+    const float DATA_SERVER_ORIENTATION_CHANGE_THRESHOLD_DEGREES = 5.0f;
+    
+    uint64_t now = usecTimestampNow();
+    if (now - _lastOrientationSend >= DATA_SERVER_ORIENTATION_UPDATE_INTERVAL_USECS &&
+            glm::distance(_lastOrientation, eulerAngles) >= DATA_SERVER_ORIENTATION_CHANGE_THRESHOLD_DEGREES) {
+        DataServerClient::putValueForKey(DataServerKey::Orientation, createByteArray(eulerAngles).constData());
+        
+        _lastOrientation = eulerAngles;
+        _lastOrientationSend = now;
+    }
+}
+
 void Profile::saveData(QSettings* settings) {
     settings->beginGroup("Profile");
     

interface/src/avatar/Profile.h

@@ -9,11 +9,14 @@
 #ifndef __hifi__Profile__
 #define __hifi__Profile__
 
+#include <stdint.h>
+
 #include <QtCore/QString>
 #include <QtCore/QUrl>
 #include <QtCore/QUuid>
 
 #include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
 
 class Profile {
 public:
@@ -34,6 +37,7 @@ public:
     
     void updateDomain(const QString& domain);
     void updatePosition(const glm::vec3 position);
+    void updateOrientation(const glm::quat& orientation);
     
     QString getLastDomain() const  { return _lastDomain; }
     const glm::vec3& getLastPosition() const { return _lastPosition; }
@@ -45,6 +49,8 @@ private:
     QUuid _uuid;
     QString _lastDomain;
     glm::vec3 _lastPosition;
+    glm::vec3 _lastOrientation;
+    uint64_t _lastOrientationSend;
     QUrl _faceModelURL;
     QUrl _skeletonModelURL;
 };

interface/src/renderer/GeometryCache.cpp

@@ -251,18 +251,16 @@ QSharedPointer<NetworkGeometry> GeometryCache::getGeometry(const QUrl& url) {
 }
 
 NetworkGeometry::NetworkGeometry(const QUrl& url) :
+    _modelRequest(url),
     _modelReply(NULL),
-    _mappingReply(NULL)
+    _mappingReply(NULL),
+    _attempts(0)
 {
     if (!url.isValid()) {
         return;
     }
-    QNetworkRequest modelRequest(url);
+    _modelRequest.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
-    modelRequest.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
+    makeModelRequest();
-    _modelReply = Application::getInstance()->getNetworkAccessManager()->get(modelRequest);
-    
-    connect(_modelReply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(maybeReadModelWithMapping()));
-    connect(_modelReply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(handleModelReplyError()));
     
     QUrl mappingURL = url;
     QString path = url.path();
@@ -312,12 +310,30 @@ glm::vec4 NetworkGeometry::computeAverageColor() const {
     return (totalTriangles == 0) ? glm::vec4(1.0f, 1.0f, 1.0f, 1.0f) : totalColor / totalTriangles;
 }
 
+void NetworkGeometry::makeModelRequest() {
+    _modelReply = Application::getInstance()->getNetworkAccessManager()->get(_modelRequest);
+    
+    connect(_modelReply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(maybeReadModelWithMapping()));
+    connect(_modelReply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(handleModelReplyError()));
+}
+
 void NetworkGeometry::handleModelReplyError() {
-    qDebug() << _modelReply->errorString() << "\n";
+    QDebug debug = qDebug() << _modelReply->errorString();
     
     _modelReply->disconnect(this);
     _modelReply->deleteLater();
     _modelReply = NULL;
+    
+    // retry with increasing delays
+    const int MAX_ATTEMPTS = 8;
+    const int BASE_DELAY_MS = 1000;
+    if (++_attempts < MAX_ATTEMPTS) {
+        QTimer::singleShot(BASE_DELAY_MS * (int)pow(2.0, _attempts), this, SLOT(makeModelRequest()));
+        debug << " -- retrying...\n";    
+        
+    } else {
+        debug << "\n";
+    }
 }
 
 void NetworkGeometry::handleMappingReplyError() {

interface/src/renderer/GeometryCache.h

@@ -10,6 +10,7 @@
 #define __interface__GeometryCache__
 
 #include <QHash>
+#include <QNetworkRequest>
 #include <QObject>
 #include <QSharedPointer>
 #include <QWeakPointer>
@@ -67,15 +68,18 @@ public:
 
 private slots:
     
+    void makeModelRequest();
     void handleModelReplyError();    
     void handleMappingReplyError();
     void maybeReadModelWithMapping();
     
 private:
     
+    QNetworkRequest _modelRequest;
     QNetworkReply* _modelReply;
     QNetworkReply* _mappingReply;
     
+    int _attempts;
     FBXGeometry _geometry;
     QVector<NetworkMesh> _meshes;
 };

interface/src/renderer/TextureCache.cpp

@@ -252,16 +252,17 @@ Texture::~Texture() {
     glDeleteTextures(1, &_id);
 }
 
-NetworkTexture::NetworkTexture(const QUrl& url, bool normalMap) : _reply(NULL), _averageColor(1.0f, 1.0f, 1.0f, 1.0f) {
+NetworkTexture::NetworkTexture(const QUrl& url, bool normalMap) :
+    _request(url),
+    _reply(NULL),
+    _attempts(0),
+    _averageColor(1.0f, 1.0f, 1.0f, 1.0f) {
+    
     if (!url.isValid()) {
         return;
     }
-    QNetworkRequest request(url);
+    _request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
-    request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
+    makeRequest();
-    _reply = Application::getInstance()->getNetworkAccessManager()->get(request);
-    
-    connect(_reply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(handleDownloadProgress(qint64,qint64)));
-    connect(_reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(handleReplyError()));
     
     // default to white/blue
     glBindTexture(GL_TEXTURE_2D, getID());
@@ -279,6 +280,13 @@ void NetworkTexture::imageLoaded(const QImage& image) {
     // nothing by default
 }
 
+void NetworkTexture::makeRequest() {
+    _reply = Application::getInstance()->getNetworkAccessManager()->get(_request);
+    
+    connect(_reply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(handleDownloadProgress(qint64,qint64)));
+    connect(_reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(handleReplyError()));
+}
+
 void NetworkTexture::handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal) {
     if (bytesReceived < bytesTotal && !_reply->isFinished()) {
         return;
@@ -314,11 +322,22 @@ void NetworkTexture::handleDownloadProgress(qint64 bytesReceived, qint64 bytesTo
 }
 
 void NetworkTexture::handleReplyError() {
-    qDebug() << _reply->errorString() << "\n";
+    QDebug debug = qDebug() << _reply->errorString();
     
     _reply->disconnect(this);
     _reply->deleteLater();
     _reply = NULL;
+    
+    // retry with increasing delays
+    const int MAX_ATTEMPTS = 8;
+    const int BASE_DELAY_MS = 1000;
+    if (++_attempts < MAX_ATTEMPTS) {
+        QTimer::singleShot(BASE_DELAY_MS * (int)pow(2.0, _attempts), this, SLOT(makeRequest()));
+        debug << " -- retrying...\n";    
+        
+    } else {
+        debug << "\n";
+    }
 }
 
 DilatableNetworkTexture::DilatableNetworkTexture(const QUrl& url, bool normalMap) :

interface/src/renderer/TextureCache.h

@@ -12,6 +12,7 @@
 #include <QHash>
 #include <QImage>
 #include <QMap>
+#include <QNetworkRequest>
 #include <QObject>
 #include <QSharedPointer>
 #include <QWeakPointer>
@@ -126,12 +127,15 @@ protected:
     
 private slots:
     
+    void makeRequest();
     void handleDownloadProgress(qint64 bytesReceived, qint64 bytesTotal);
     void handleReplyError();    
-    
+
 private:
-    
+
+    QNetworkRequest _request;
     QNetworkReply* _reply;
+    int _attempts;
     glm::vec4 _averageColor;
 };
 

libraries/audio/src/PositionalAudioRingBuffer.cpp

@@ -20,7 +20,8 @@ PositionalAudioRingBuffer::PositionalAudioRingBuffer(PositionalAudioRingBuffer::
     _position(0.0f, 0.0f, 0.0f),
     _orientation(0.0f, 0.0f, 0.0f, 0.0f),
     _willBeAddedToMix(false),
-    _shouldLoopbackForNode(false)
+    _shouldLoopbackForNode(false),
+    _shouldOutputStarveDebug(true)
 {
     
 }
@@ -57,11 +58,19 @@ int PositionalAudioRingBuffer::parsePositionalData(unsigned char* sourceBuffer,
 
 bool PositionalAudioRingBuffer::shouldBeAddedToMix(int numJitterBufferSamples) {
     if (!isNotStarvedOrHasMinimumSamples(NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL + numJitterBufferSamples)) {
-        qDebug() << "Starved and do not have minimum samples to start. Buffer held back.\n";
+        if (_shouldOutputStarveDebug) {
+            qDebug() << "Starved and do not have minimum samples to start. Buffer held back.\n";
+            _shouldOutputStarveDebug = false;
+        }
+        
         return false;
     } else if (samplesAvailable() < NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL) {
         qDebug() << "Do not have number of samples needed for interval. Buffer starved.\n";
         _isStarved = true;
+        
+        // reset our _shouldOutputStarveDebug to true so the next is printed
+        _shouldOutputStarveDebug = true;
+        
         return false;
     } else {
         // good buffer, add this to the mix

libraries/audio/src/PositionalAudioRingBuffer.h

@@ -49,6 +49,7 @@ protected:
     glm::quat _orientation;
     bool _willBeAddedToMix;
     bool _shouldLoopbackForNode;
+    bool _shouldOutputStarveDebug;
 };
 
 #endif /* defined(__hifi__PositionalAudioRingBuffer__) */

libraries/avatars/src/AvatarData.cpp

@@ -193,7 +193,7 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
     sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_bodyRoll);
 
     // Body scale
-    sourceBuffer += unpackFloatRatioFromTwoByte(sourceBuffer, _newScale);
+    sourceBuffer += unpackFloatRatioFromTwoByte(sourceBuffer, _targetScale);
 
     // Head rotation (NOTE: This needs to become a quaternion to save two bytes)
     float headYaw, headPitch, headRoll;
@@ -287,12 +287,10 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
     return sourceBuffer - startPosition;
 }
 
-void AvatarData::setNewScale(float newScale) {
+void AvatarData::setClampedTargetScale(float targetScale) {
-    if (newScale > MAX_SCALE) {
+    
-        newScale = MAX_SCALE;
+    targetScale =  glm::clamp(targetScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);
-    } else if (newScale < MIN_SCALE) {
+    
-        newScale = MIN_SCALE;
+    _targetScale = targetScale;
-    }
+    qDebug() << "Changed scale to " << _targetScale << "\n";
-    _newScale = newScale;
-    qDebug() << "Changed scale to " << _newScale << "\n";
 }

libraries/avatars/src/AvatarData.h

@@ -32,8 +32,8 @@ const int HAND_STATE_START_BIT = 2; // 3rd and 4th bits
 const int IS_FACESHIFT_CONNECTED = 4; // 5th bit
 const int IS_CHAT_CIRCLING_ENABLED = 5;
 
-static const float MAX_SCALE = 1000.f;
+static const float MAX_AVATAR_SCALE = 1000.f;
-static const float MIN_SCALE = .005f;
+static const float MIN_AVATAR_SCALE = .005f;
 
 const float MAX_AUDIO_LOUDNESS = 1000.0; // close enough for mouth animation
 
@@ -82,8 +82,9 @@ public:
     void setBodyRoll(float bodyRoll) { _bodyRoll = bodyRoll; }
     
     //  Scale
-    float getNewScale() const { return _newScale; }
+    float getTargetScale() const { return _targetScale; }
-    void setNewScale(float);
+    void setTargetScale(float targetScale) { _targetScale = targetScale; }
+    void setClampedTargetScale(float targetScale);
     
     //  Hand State
     void setHandState(char s) { _handState = s; }
@@ -130,7 +131,7 @@ protected:
     float _bodyRoll;
 
     // Body scale
-    float _newScale;
+    float _targetScale;
 
     //  Hand state (are we grabbing something or not)
     char _handState;

libraries/metavoxels/src/MetavoxelData.cpp

@@ -301,8 +301,8 @@ void MetavoxelNode::clearChildren(const AttributePointer& attribute) {
 }
 
 int MetavoxelPath::operator[](int index) const {
-    return _array.at(index * BITS_PER_ELEMENT) | (_array.at(index * BITS_PER_ELEMENT + 1) << 1) |
+    return (int)_array.at(index * BITS_PER_ELEMENT) | ((int)_array.at(index * BITS_PER_ELEMENT + 1) << 1) |
-        (_array.at(index * BITS_PER_ELEMENT + 2) << 2);
+        ((int)_array.at(index * BITS_PER_ELEMENT + 2) << 2);
 }
 
 MetavoxelPath& MetavoxelPath::operator+=(int element) {

libraries/voxels/src/VoxelTreeElement.h

@@ -92,4 +92,4 @@ protected:
 };
 
 
-#endif /* defined(__hifi__VoxelTreeElement__) */
+#endif /* defined(__hifi__VoxelTreeElement__) */