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,79 +46,121 @@ 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
+            // user is asking for json list of assignments
             
-        // start with a 200 response
+            // start with a 200 response
-        mg_printf(connection, "%s", RESPONSE_200);
+            mg_printf(connection, "%s", RESPONSE_200);
             
-        // setup the JSON
+            // setup the JSON
-        QJsonObject assignmentJSON;
+            QJsonObject assignmentJSON;
             
-        QJsonObject assignedNodesJSON;
+            QJsonObject assignedNodesJSON;
             
-        // enumerate the NodeList to find the assigned nodes
+            // enumerate the NodeList to find the assigned nodes
-        NodeList* nodeList = NodeList::getInstance();
+            NodeList* nodeList = NodeList::getInstance();
             
-        const char ASSIGNMENT_JSON_UUID_KEY[] = "UUID";
+            const char ASSIGNMENT_JSON_UUID_KEY[] = "UUID";
             
-        for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+            for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
-            if (node->getLinkedData()) {
+                if (node->getLinkedData()) {
-                // this is a node with assignment
+                    // this is a node with assignment
-                QJsonObject assignedNodeJSON;
+                    QJsonObject assignedNodeJSON;
                     
-                // add the assignment UUID
+                    // add the assignment UUID
-                QString assignmentUUID = uuidStringWithoutCurlyBraces(((Assignment*) node->getLinkedData())->getUUID());
+                    QString assignmentUUID = uuidStringWithoutCurlyBraces(((Assignment*) node->getLinkedData())->getUUID());
-                assignedNodeJSON[ASSIGNMENT_JSON_UUID_KEY] = assignmentUUID;
+                    assignedNodeJSON[ASSIGNMENT_JSON_UUID_KEY] = assignmentUUID;
                     
-                // add the node socket information
+                    // add the node socket information
-                assignedNodeJSON["public"] = jsonForSocket(node->getPublicSocket());
+                    assignedNodeJSON["public"] = jsonForSocket(node->getPublicSocket());
-                assignedNodeJSON["local"] = jsonForSocket(node->getLocalSocket());
+                    assignedNodeJSON["local"] = jsonForSocket(node->getLocalSocket());
                     
-                // re-format the type name so it matches the target name
+                    // re-format the type name so it matches the target name
-                QString nodeTypeName(node->getTypeName());
+                    QString nodeTypeName(node->getTypeName());
-                nodeTypeName = nodeTypeName.toLower();
+                    nodeTypeName = nodeTypeName.toLower();
-                nodeTypeName.replace(' ', '-');
+                    nodeTypeName.replace(' ', '-');
                     
-                assignedNodesJSON[nodeTypeName] = assignedNodeJSON;
+                    assignedNodesJSON[nodeTypeName] = assignedNodeJSON;
+                }
+            }
+            
+            assignmentJSON["fulfilled"] = assignedNodesJSON;
+            
+            QJsonObject queuedAssignmentsJSON;
+            
+            // add the queued but unfilled assignments to the json
+            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
+            
+            while (assignment != domainServerInstance->_assignmentQueue.end()) {
+                QJsonObject queuedAssignmentJSON;
+                
+                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
+                queuedAssignmentJSON[ASSIGNMENT_JSON_UUID_KEY] = uuidString;
+                
+                // add this queued assignment to the JSON
+                queuedAssignmentsJSON[(*assignment)->getTypeName()] = queuedAssignmentJSON;
+                
+                // push forward the iterator to check the next assignment
+                assignment++;
+            }
+            
+            assignmentJSON["queued"] = queuedAssignmentsJSON;
+            
+            // print out the created JSON
+            QJsonDocument assignmentDocument(assignmentJSON);
+            mg_printf(connection, "%s", assignmentDocument.toJson().constData());
+            
+            // 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;
+                }
             }
         }
         
-        assignmentJSON["fulfilled"] = assignedNodesJSON;
+        // request not processed - bad request
+        mg_printf(connection, "%s", RESPONSE_400);
         
-        QJsonObject queuedAssignmentsJSON;
+        // this was processed by civetweb
-        
-        // add the queued but unfilled assignments to the json
-        std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
-        
-        while (assignment != domainServerInstance->_assignmentQueue.end()) {
-            QJsonObject queuedAssignmentJSON;
-            
-            QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
-            queuedAssignmentJSON[ASSIGNMENT_JSON_UUID_KEY] = uuidString;
-            
-            // add this queued assignment to the JSON
-            queuedAssignmentsJSON[(*assignment)->getTypeName()] = queuedAssignmentJSON;
-            
-            // push forward the iterator to check the next assignment
-            assignment++;
-        }
-        
-        assignmentJSON["queued"] = queuedAssignmentsJSON;
-        
-        // print out the created JSON
-        QJsonDocument assignmentDocument(assignmentJSON);
-        mg_printf(connection, "%s", assignmentDocument.toJson().constData());
-        
-        // we've processed this request
         return 1;
     } else {
         // have mongoose process this request from the document_root
@@ -160,6 +202,27 @@ void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const
     domainServerInstance->_assignmentQueueMutex.unlock();
 }
 
+void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
+    qDebug() << "Adding assignment" << *releasedAssignment << " 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() == releasedAssignment->getUUID()) {
+            // reset the UUID on the static assignment
+            _staticAssignments[i].resetUUID();
+            
+            // put this assignment back in the queue so it goes out
+            _assignmentQueueMutex.lock();
+            _assignmentQueue.push_back(&_staticAssignments[i]);
+            _assignmentQueueMutex.unlock();
+            
+        } else if (_staticAssignments[i].getUUID().isNull()) {
+            // we are at the blank part of the static assignments - break out
+            break;
+        }
+    }
+}
+
 void DomainServer::nodeAdded(Node* node) {
     
 }
@@ -169,26 +232,8 @@ void DomainServer::nodeKilled(Node* node) {
     if (node->getLinkedData()) {
         Assignment* nodeAssignment =  (Assignment*) node->getLinkedData();
         
-        qDebug() << "Adding assignment" << *nodeAssignment << " back to queue.\n";
+        addReleasedAssignmentBackToQueue(nodeAssignment);
-        
-        // find this assignment in the static file
-        for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
-            if (_staticAssignments[i].getUUID() == nodeAssignment->getUUID()) {
-                // reset the UUID on the static assignment
-                _staticAssignments[i].resetUUID();
-                
-                // put this assignment back in the queue so it goes out
-                _assignmentQueueMutex.lock();
-                _assignmentQueue.push_back(&_staticAssignments[i]);
-                _assignmentQueueMutex.unlock();
-                
-            } else if (_staticAssignments[i].getUUID().isNull()) {
-                // we are at the blank part of the static assignments - break out
-                break;
-            }
-        }
     }
-    
 }
 
 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);