Merge remote-tracking branch 'upstream/master' into render_cursor

examples/dialTone.js

@@ -14,10 +14,10 @@ var connectSound = SoundCache.getSound("file://" + Paths.resources + "sounds/sho
 
 // setup the options needed for that sound
 var connectSoundOptions = {
-  localOnly: true
+    localOnly: true
 }
 
 // play the sound locally once we get the first audio packet from a mixer
 Audio.receivedFirstPacket.connect(function(){
-  Audio.playSound(connectSound, connectSoundOptions);
+    Audio.playSound(connectSound, connectSoundOptions);
 });

interface/src/avatar/Avatar.cpp

@@ -304,6 +304,7 @@ bool Avatar::addToScene(AvatarSharedPointer self, std::shared_ptr<render::Scene>
 void Avatar::removeFromScene(AvatarSharedPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
     pendingChanges.removeItem(_renderItemID);
     _skeletonModel.removeFromScene(scene, pendingChanges);
+    getHead()->getFaceModel().removeFromScene(scene, pendingChanges);
 }
 
 void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {

interface/src/avatar/AvatarManager.cpp

@@ -55,7 +55,7 @@ AvatarManager::AvatarManager(QObject* parent) :
     _avatarFades() {
     // register a meta type for the weak pointer we'll use for the owning avatar mixer for each avatar
     qRegisterMetaType<QWeakPointer<Node> >("NodeWeakPointer");
-    _myAvatar = std::shared_ptr<MyAvatar>(new MyAvatar());
+    _myAvatar = std::make_shared<MyAvatar>();
 }
 
 void AvatarManager::init() {
@@ -97,9 +97,9 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     // simulate avatars
     AvatarHash::iterator avatarIterator = _avatarHash.begin();
     while (avatarIterator != _avatarHash.end()) {
-        Avatar* avatar = reinterpret_cast<Avatar*>(avatarIterator.value().get());
+        auto avatar = std::dynamic_pointer_cast<Avatar>(avatarIterator.value());
         
-        if (avatar == _myAvatar.get() || !avatar->isInitialized()) {
+        if (avatar == _myAvatar || !avatar->isInitialized()) {
             // DO NOT update _myAvatar!  Its update has already been done earlier in the main loop.
             // DO NOT update or fade out uninitialized Avatars
             ++avatarIterator;
@@ -121,26 +121,30 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
     
     const float SHRINK_RATE = 0.9f;
     const float MIN_FADE_SCALE = 0.001f;
-
+    
+    render::ScenePointer scene = Application::getInstance()->getMain3DScene();
+    render::PendingChanges pendingChanges;
     while (fadingIterator != _avatarFades.end()) {
-        Avatar* avatar = static_cast<Avatar*>(fadingIterator->get());
+        auto avatar = std::static_pointer_cast<Avatar>(*fadingIterator);
         avatar->setTargetScale(avatar->getScale() * SHRINK_RATE, true);
         if (avatar->getTargetScale() < MIN_FADE_SCALE) {
+            avatar->removeFromScene(*fadingIterator, scene, pendingChanges);
             fadingIterator = _avatarFades.erase(fadingIterator);
         } else {
             avatar->simulate(deltaTime);
             ++fadingIterator;
         }
     }
+    scene->enqueuePendingChanges(pendingChanges);
 }
 
 AvatarSharedPointer AvatarManager::newSharedAvatar() {
-    return AvatarSharedPointer(new Avatar());
+    return AvatarSharedPointer(std::make_shared<Avatar>());
 }
 
 // virtual 
 AvatarSharedPointer AvatarManager::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
-    std::shared_ptr<Avatar> avatar = std::dynamic_pointer_cast<Avatar>(AvatarHashMap::addAvatar(sessionUUID, mixerWeakPointer));
+    auto avatar = std::dynamic_pointer_cast<Avatar>(AvatarHashMap::addAvatar(sessionUUID, mixerWeakPointer));
     render::ScenePointer scene = Application::getInstance()->getMain3DScene();
     render::PendingChanges pendingChanges;
     avatar->addToScene(avatar, scene, pendingChanges);    
@@ -171,10 +175,6 @@ void AvatarManager::removeAvatar(const QUuid& sessionUUID) {
             _avatarFades.push_back(avatarIterator.value());
             _avatarHash.erase(avatarIterator);
         }
-        render::ScenePointer scene = Application::getInstance()->getMain3DScene();
-        render::PendingChanges pendingChanges;
-        avatar->removeFromScene(avatar, scene, pendingChanges);
-        scene->enqueuePendingChanges(pendingChanges);
     }
 }
 
@@ -182,12 +182,12 @@ void AvatarManager::clearOtherAvatars() {
     // clear any avatars that came from an avatar-mixer
     AvatarHash::iterator avatarIterator =  _avatarHash.begin();
     while (avatarIterator != _avatarHash.end()) {
-        Avatar* avatar = reinterpret_cast<Avatar*>(avatarIterator.value().get());
-        if (avatar == _myAvatar.get() || !avatar->isInitialized()) {
+        auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
+        if (avatar == _myAvatar || !avatar->isInitialized()) {
             // don't remove myAvatar or uninitialized avatars from the list
             ++avatarIterator;
         } else {
-            removeAvatarMotionState(avatar);
+            removeAvatarMotionState(avatar.get());
             _avatarFades.push_back(avatarIterator.value());
             avatarIterator = _avatarHash.erase(avatarIterator);
         }
@@ -250,7 +250,7 @@ void AvatarManager::handleCollisionEvents(CollisionEvents& collisionEvents) {
 void AvatarManager::updateAvatarPhysicsShape(const QUuid& id) {
     AvatarHash::iterator avatarItr = _avatarHash.find(id);
     if (avatarItr != _avatarHash.end()) {
-        Avatar* avatar = static_cast<Avatar*>(avatarItr.value().get());
+        auto avatar = std::static_pointer_cast<Avatar>(avatarItr.value());
         AvatarMotionState* motionState = avatar->_motionState;
         if (motionState) {
             motionState->addDirtyFlags(EntityItem::DIRTY_SHAPE);
@@ -259,7 +259,7 @@ void AvatarManager::updateAvatarPhysicsShape(const QUuid& id) {
             avatar->computeShapeInfo(shapeInfo);
             btCollisionShape* shape = ObjectMotionState::getShapeManager()->getShape(shapeInfo);
             if (shape) {
-                AvatarMotionState* motionState = new AvatarMotionState(avatar, shape);
+                AvatarMotionState* motionState = new AvatarMotionState(avatar.get(), shape);
                 avatar->_motionState = motionState;
                 _motionStatesToAdd.insert(motionState);
                 _avatarMotionStates.insert(motionState);

libraries/networking/src/AddressManager.cpp

@@ -35,6 +35,7 @@ AddressManager::AddressManager() :
     _positionGetter(NULL),
     _orientationGetter(NULL)
 {
+
 }
 
 bool AddressManager::isConnected() {
@@ -217,7 +218,7 @@ void AddressManager::goToAddressFromObject(const QVariantMap& dataObject, const
                 const QString DOMAIN_NETWORK_PORT_KEY = "network_port";
                 const QString DOMAIN_ICE_SERVER_ADDRESS_KEY = "ice_server_address";
 
-                DependencyManager::get<NodeList>()->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::HandleAddress);
+               DependencyManager::get<NodeList>()->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::HandleAddress);
 
                 const QString DOMAIN_ID_KEY = "id";
                 QString domainIDString = domainObject[DOMAIN_ID_KEY].toString();
@@ -415,6 +416,9 @@ bool AddressManager::handleViewpoint(const QString& viewpointString, bool should
                               positionRegex.cap(2).toFloat(),
                               positionRegex.cap(3).toFloat());
 
+        // we're about to jump positions - store the current address in our history
+        addCurrentAddressToHistory();
+
         if (!isNaN(newPosition.x) && !isNaN(newPosition.y) && !isNaN(newPosition.z)) {
             glm::quat newOrientation;
 
@@ -467,6 +471,10 @@ bool AddressManager::handleUsername(const QString& lookupString) {
 
 void AddressManager::setHost(const QString& host) {
     if (host != _host) {
+
+        // if the host is being changed we should store current address in the history
+        addCurrentAddressToHistory();
+
         _host = host;
         emit hostChanged(_host);
     }
@@ -474,7 +482,8 @@ void AddressManager::setHost(const QString& host) {
 
 
 void AddressManager::setDomainInfo(const QString& hostname, quint16 port) {
-    _host = hostname;
+    setHost(hostname);
+
     _rootPlaceID = QUuid();
 
     qCDebug(networking) << "Possible domain change required to connect to domain at" << hostname << "on" << port;
@@ -500,3 +509,22 @@ void AddressManager::copyAddress() {
 void AddressManager::copyPath() {
     QApplication::clipboard()->setText(currentPath());
 }
+
+void AddressManager::addCurrentAddressToHistory() {
+    if (_lastHistoryAppend == 0) {
+        // we don't store the first address on application load
+        // just update the last append time so the next is stored
+        _lastHistoryAppend = usecTimestampNow();
+    } else {
+        const quint64 DOUBLE_STORE_THRESHOLD_USECS = 500000;
+
+        // avoid double storing when the host changes and the viewpoint changes immediately after
+        if (usecTimestampNow() - _lastHistoryAppend > DOUBLE_STORE_THRESHOLD_USECS) {
+            // add the current address to the history
+            _history.append(currentAddress());
+
+            // change our last history append to now
+            _lastHistoryAppend = usecTimestampNow();
+        }
+    }
+}

libraries/networking/src/AddressManager.h

@@ -98,10 +98,15 @@ private:
     bool handleUsername(const QString& lookupString);
     bool handleDomainID(const QString& host);
 
+    void addCurrentAddressToHistory();
+
     QString _host;
     QUuid _rootPlaceID;
     PositionGetter _positionGetter;
     OrientationGetter _orientationGetter;
+
+    QList<QUrl> _history;
+    quint64 _lastHistoryAppend = 0;
 };
 
 #endif // hifi_AddressManager_h