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

assignment-client/src/Agent.h

@@ -36,4 +36,4 @@ private:
     std::vector<AudioInjector*> _audioInjectors;
 };
 
-#endif /* defined(__hifi__Operative__) */
+#endif /* defined(__hifi__Agent__) */

assignment-client/src/audio/AudioMixer.cpp

@@ -163,7 +163,7 @@ void AudioMixer::run() {
             
             const int PHASE_DELAY_AT_90 = 20;
             
-            if (node->getType() == NODE_TYPE_AGENT && node->getActiveSocket()) {
+            if (node->getType() == NODE_TYPE_AGENT && node->getActiveSocket() && node->getLinkedData()) {
                 AvatarAudioRingBuffer* nodeRingBuffer = (AvatarAudioRingBuffer*) node->getLinkedData();
                 
                 // zero out the client mix for this node
@@ -171,7 +171,8 @@ void AudioMixer::run() {
                 
                 // loop through all other nodes that have sufficient audio to mix
                 for (NodeList::iterator otherNode = nodeList->begin(); otherNode != nodeList->end(); otherNode++) {
-                    if (((PositionalAudioRingBuffer*) otherNode->getLinkedData())->willBeAddedToMix()
+                    if (otherNode->getLinkedData()
+                        && ((PositionalAudioRingBuffer*) otherNode->getLinkedData())->willBeAddedToMix()
                         && (otherNode != node || (otherNode == node && nodeRingBuffer->shouldLoopbackForNode()))) {
                         PositionalAudioRingBuffer* otherNodeBuffer = (PositionalAudioRingBuffer*) otherNode->getLinkedData();
                         // based on our listen mode we will do this mixing...
@@ -339,7 +340,7 @@ void AudioMixer::run() {
                 }
                 
                 memcpy(clientPacket + numBytesPacketHeader, clientSamples, sizeof(clientSamples));
-                nodeList->getNodeSocket()->send(node->getPublicSocket(), clientPacket, sizeof(clientPacket));
+                nodeList->getNodeSocket()->send(node->getActiveSocket(), clientPacket, sizeof(clientPacket));
             }
         }
         

domain-server/src/DomainServer.cpp

@@ -46,15 +46,13 @@ int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
     const struct mg_request_info* ri = mg_get_request_info(connection);
     
     const char RESPONSE_200[] = "HTTP/1.0 200 OK\r\n\r\n";
+    const char RESPONSE_400[] = "HTTP/1.0 400 Bad Request\r\n\r\n";
     
-    if (strcmp(ri->uri, "/assignment") == 0 && strcmp(ri->request_method, "POST") == 0) {
+    const char URI_ASSIGNMENT[] = "/assignment";
-        // return a 200
+    const char URI_NODE[] = "/node";
-        mg_printf(connection, "%s", RESPONSE_200);
-        // upload the file
-        mg_upload(connection, "/tmp");
     
-        return 1;
+    if (strcmp(ri->request_method, "GET") == 0) {
-    } else if (strcmp(ri->uri, "/assignments.json") == 0) {
+        if (strcmp(ri->uri, "/assignments.json") == 0) {
             // user is asking for json list of assignments
             
             // start with a 200 response
@@ -120,6 +118,50 @@ int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
             
             // we've processed this request
             return 1;
+        }
+        
+        // not processed, pass to document root
+        return 0;
+    } else if (strcmp(ri->request_method, "POST") == 0) {
+        if (strcmp(ri->uri, URI_ASSIGNMENT) == 0) {
+            // return a 200
+            mg_printf(connection, "%s", RESPONSE_200);
+            // upload the file
+            mg_upload(connection, "/tmp");
+            
+            return 1;
+        }
+        
+        return 0;
+    } else if (strcmp(ri->request_method, "DELETE") == 0) {
+        // this is a DELETE request
+        
+        // check if it is for an assignment
+        if (memcmp(ri->uri, URI_NODE, strlen(URI_NODE)) == 0) {
+            // pull the UUID from the url
+            QUuid deleteUUID = QUuid(QString(ri->uri + strlen(URI_NODE) + sizeof('/')));
+            
+            if (!deleteUUID.isNull()) {
+                Node *nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
+                
+                if (nodeToKill) {
+                    // start with a 200 response
+                    mg_printf(connection, "%s", RESPONSE_200);
+                    
+                    // we have a valid UUID and node - kill the node that has this assignment
+                    NodeList::getInstance()->killNode(nodeToKill);
+                    
+                    // successfully processed request
+                    return 1;
+                }
+            }
+        }
+        
+        // request not processed - bad request
+        mg_printf(connection, "%s", RESPONSE_400);
+        
+        // this was processed by civetweb
+        return 1;
     } else {
         // have mongoose process this request from the document_root
         return 0;
@@ -160,20 +202,12 @@ void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const
     domainServerInstance->_assignmentQueueMutex.unlock();
 }
 
-void DomainServer::nodeAdded(Node* node) {
+void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
-    
+    qDebug() << "Adding assignment" << *releasedAssignment << " back to queue.\n";
-}
-
-void DomainServer::nodeKilled(Node* node) {
-    // if this node has linked data it was from an assignment
-    if (node->getLinkedData()) {
-        Assignment* nodeAssignment =  (Assignment*) node->getLinkedData();
-        
-        qDebug() << "Adding assignment" << *nodeAssignment << " back to queue.\n";
     
     // find this assignment in the static file
     for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
-            if (_staticAssignments[i].getUUID() == nodeAssignment->getUUID()) {
+        if (_staticAssignments[i].getUUID() == releasedAssignment->getUUID()) {
             // reset the UUID on the static assignment
             _staticAssignments[i].resetUUID();
             
@@ -189,6 +223,17 @@ void DomainServer::nodeKilled(Node* node) {
     }
 }
 
+void DomainServer::nodeAdded(Node* node) {
+    
+}
+
+void DomainServer::nodeKilled(Node* node) {
+    // if this node has linked data it was from an assignment
+    if (node->getLinkedData()) {
+        Assignment* nodeAssignment =  (Assignment*) node->getLinkedData();
+        
+        addReleasedAssignmentBackToQueue(nodeAssignment);
+    }
 }
 
 unsigned char* DomainServer::addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd) {

domain-server/src/DomainServer.h

@@ -47,6 +47,7 @@ private:
     void removeAssignmentFromQueue(Assignment* removableAssignment);
     bool checkInWithUUIDMatchesExistingNode(sockaddr* nodePublicSocket, sockaddr* nodeLocalSocket, const QUuid& checkInUUI);
     void possiblyAddStaticAssignmentsBackToQueueAfterRestart(timeval* startTime);
+    void addReleasedAssignmentBackToQueue(Assignment* releasedAssignment);
     
     void cleanup();
     

interface/src/renderer/FBXReader.cpp

@@ -565,6 +565,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
                         jointNeckID = object.properties.at(0).value<qint64>();
                     }
                     glm::vec3 translation;
+                    glm::vec3 rotationOffset;
                     glm::vec3 preRotation, rotation, postRotation;
                     glm::vec3 scale = glm::vec3(1.0f, 1.0f, 1.0f);
                     glm::vec3 scalePivot, rotationPivot;
@@ -578,6 +579,11 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
                                             property.properties.at(5).value<double>(),
                                             property.properties.at(6).value<double>());
 
+                                    } else if (property.properties.at(0) == "RotationOffset") {
+                                        rotationOffset = glm::vec3(property.properties.at(4).value<double>(),
+                                            property.properties.at(5).value<double>(),
+                                            property.properties.at(6).value<double>());
+                                        
                                     } else if (property.properties.at(0) == "RotationPivot") {
                                         rotationPivot = glm::vec3(property.properties.at(4).value<double>(),
                                             property.properties.at(5).value<double>(),
@@ -613,11 +619,12 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
                         }
                     }
                     // see FBX documentation, http://download.autodesk.com/us/fbx/20112/FBX_SDK_HELP/index.html
-                    model.preRotation = glm::translate(translation) * glm::translate(rotationPivot) *
+                    model.preRotation = glm::translate(translation) * glm::translate(rotationOffset) *
-                        glm::mat4_cast(glm::quat(glm::radians(preRotation)));                   
+                        glm::translate(rotationPivot) * glm::mat4_cast(glm::quat(glm::radians(preRotation)));                   
                     model.rotation = glm::quat(glm::radians(rotation));
-                    model.postRotation = glm::mat4_cast(glm::quat(glm::radians(postRotation))) * glm::translate(-rotationPivot) *
+                    model.postRotation = glm::mat4_cast(glm::quat(glm::radians(postRotation))) *
-                        glm::translate(scalePivot) * glm::scale(scale) * glm::translate(-scalePivot);
+                        glm::translate(-rotationPivot) * glm::translate(scalePivot) *
+                        glm::scale(scale) * glm::translate(-scalePivot);
                     models.insert(object.properties.at(0).value<qint64>(), model);
                 
                 } else if (object.name == "Texture") {

interface/src/starfield/renderer/Tiling.h

@@ -12,10 +12,10 @@
 #include "starfield/Config.h"
 
 namespace starfield {
+    const float LOG2 = 1.4426950408889634;
     
     class Tiling {
     public:
-
         Tiling(unsigned tileResolution) : _tileResolution(tileResolution), _rcpSlice(tileResolution / Radians::twicePi()) {
                                     _nBits = ceil(log(getTileCount()) * LOG2); }
         
@@ -39,10 +39,7 @@ namespace starfield {
         unsigned _tileResolution;
         float _rcpSlice;
         unsigned _nBits;
-        
-        const float LOG2 = 1.4426950408889634;
     };
-
 }
 
 #endif

libraries/shared/src/NodeList.cpp

@@ -715,6 +715,22 @@ Node* NodeList::soloNodeOfType(char nodeType) {
     return NULL;
 }
 
+void NodeList::killNode(Node* node, bool mustLockNode) {
+    if (mustLockNode) {
+        node->lock();
+    }
+    
+    qDebug() << "Killed " << *node << "\n";
+    
+    notifyHooksOfKilledNode(&*node);
+    
+    node->setAlive(false);
+    
+    if (mustLockNode) {
+        node->unlock();
+    }
+}
+
 void* removeSilentNodes(void *args) {
     NodeList* nodeList = (NodeList*) args;
     uint64_t checkTimeUsecs = 0;
@@ -728,12 +744,8 @@ void* removeSilentNodes(void *args) {
             node->lock();
             
             if ((usecTimestampNow() - node->getLastHeardMicrostamp()) > NODE_SILENCE_THRESHOLD_USECS) {
-
+                // kill this node, don't lock - we already did it
-                qDebug() << "Killed " << *node << "\n";
+                nodeList->killNode(&(*node), false);
-                
-                nodeList->notifyHooksOfKilledNode(&*node);
-                
-                node->setAlive(false);
             }
             
             node->unlock();

libraries/shared/src/NodeList.h

@@ -113,6 +113,7 @@ public:
     Node* nodeWithUUID(const QUuid& nodeUUID);
     
     Node* addOrUpdateNode(const QUuid& uuid, char nodeType, sockaddr* publicSocket, sockaddr* localSocket);
+    void killNode(Node* node, bool mustLockNode = true);
     
     void processNodeData(sockaddr *senderAddress, unsigned char *packetData, size_t dataBytes);
     void processBulkNodeData(sockaddr *senderAddress, unsigned char *packetData, int numTotalBytes);