Merge pull request #4562 from sethalves/editors-are-rezzers

add a bool value to Node which indicates if it is allowed to rez new ent...

assignment-client/src/AssignmentClientMonitor.cpp

@@ -180,7 +180,7 @@ void AssignmentClientMonitor::readPendingDatagrams() {
                         senderSockAddr.getAddress() == QHostAddress::LocalHostIPv6) {
                         if (!packetUUID.isNull()) {
                             matchingNode = DependencyManager::get<LimitedNodeList>()->addOrUpdateNode
-                                (packetUUID, NodeType::Unassigned, senderSockAddr, senderSockAddr, false);
+                                (packetUUID, NodeType::Unassigned, senderSockAddr, senderSockAddr, false, false);
                             AssignmentClientChildData *childData = new AssignmentClientChildData("unknown");
                             matchingNode->setLinkedData(childData);
                         } else {

domain-server/resources/describe-settings.json

@@ -95,6 +95,13 @@
             "can_set": true
           }
         ]
+      },
+      {
+        "name": "editors_are_rezzers",
+        "type": "checkbox",
+        "label": "Only editors can create new entities",
+        "help": "When checked, only those who can edit the domain can create new entites.",
+        "default": false
       }
     ]
   },

domain-server/src/DomainServer.cpp

@@ -47,6 +47,7 @@ const QString ICE_SERVER_DEFAULT_HOSTNAME = "ice.highfidelity.io";
 const QString ALLOWED_USERS_SETTINGS_KEYPATH = "security.allowed_users";
 const QString MAXIMUM_USER_CAPACITY = "security.maximum_user_capacity";
 const QString ALLOWED_EDITORS_SETTINGS_KEYPATH = "security.allowed_editors";
+const QString EDITORS_ARE_REZZERS_KEYPATH = "security.editors_are_rezzers";
 
 
 DomainServer::DomainServer(int argc, char* argv[]) :
@@ -646,9 +647,23 @@ void DomainServer::handleConnectRequest(const QByteArray& packet, const HifiSock
         QStringList allowedEditors = allowedEditorsVariant ? allowedEditorsVariant->toStringList() : QStringList();
         bool canAdjustLocks = allowedEditors.isEmpty() || allowedEditors.contains(username);
 
+        const QVariant* editorsAreRezzersVariant =
+            valueForKeyPath(_settingsManager.getSettingsMap(), EDITORS_ARE_REZZERS_KEYPATH);
+        
+        bool onlyEditorsAreRezzers = false;
+        if (editorsAreRezzersVariant) {
+            onlyEditorsAreRezzers = editorsAreRezzersVariant->toBool();
+        }
+
+        bool canRez = true;
+        if (onlyEditorsAreRezzers) {
+            canRez = canAdjustLocks;
+        }
+
         SharedNodePointer newNode =
             DependencyManager::get<LimitedNodeList>()->addOrUpdateNode(nodeUUID, nodeType,
-                                                                       publicSockAddr, localSockAddr, canAdjustLocks);
+                                                                       publicSockAddr, localSockAddr,
+                                                                       canAdjustLocks, canRez);
         // when the newNode is created the linked data is also created
         // if this was a static assignment set the UUID, set the sendingSockAddr
         DomainServerNodeData* nodeData = reinterpret_cast<DomainServerNodeData*>(newNode->getLinkedData());
@@ -903,6 +918,7 @@ void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const Hif
     QDataStream broadcastDataStream(&broadcastPacket, QIODevice::Append);
     broadcastDataStream << node->getUUID();
     broadcastDataStream << node->getCanAdjustLocks();
+    broadcastDataStream << node->getCanRez();
 
     int numBroadcastPacketLeadBytes = broadcastDataStream.device()->pos();
 

examples/dice.js

@@ -23,6 +23,8 @@ HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
 
 var rollSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/dice/diceRoll.wav");
 
+var INSUFFICIENT_PERMISSIONS_ERROR_MSG = "You do not have the necessary permissions to create new objects."
+
 var screenSize = Controller.getViewportDimensions();
 var offButton = Overlays.addOverlay("image", {
                     x: screenSize.x - 48,
@@ -49,20 +51,26 @@ var LIFETIME = 300;
 var MAX_ANGULAR_SPEED = Math.PI;
 
 function shootDice(position, velocity) {
-    for (var i = 0; i < NUMBER_OF_DICE; i++) {
+    if (!Entities.canRez()) {
-        dice.push(Entities.addEntity(
+        Window.alert(INSUFFICIENT_PERMISSIONS_ERROR_MSG);
-        { type: "Model",
+    } else {
-          modelURL: HIFI_PUBLIC_BUCKET + "models/props/Dice/goldDie.fbx",
+        for (var i = 0; i < NUMBER_OF_DICE; i++) {
-          position: position,  
+            dice.push(Entities.addEntity(
-          velocity: velocity, 
+                { type: "Model",
-          rotation: Quat.fromPitchYawRollDegrees(Math.random() * 360, Math.random() * 360, Math.random() * 360),
+                  modelURL: HIFI_PUBLIC_BUCKET + "models/props/Dice/goldDie.fbx",
-          angularVelocity: { x: Math.random() * MAX_ANGULAR_SPEED, y: Math.random() * MAX_ANGULAR_SPEED, z: Math.random() * MAX_ANGULAR_SPEED },
+                  position: position,  
-          lifetime: LIFETIME,
+                  velocity: velocity, 
-          gravity: {  x: 0, y: GRAVITY, z: 0 },
+                  rotation: Quat.fromPitchYawRollDegrees(Math.random() * 360, Math.random() * 360, Math.random() * 360),
-          shapeType: "box",
+                  angularVelocity: { x: Math.random() * MAX_ANGULAR_SPEED,
-          collisionsWillMove: true
+                                     y: Math.random() * MAX_ANGULAR_SPEED,
-      }));
+                                     z: Math.random() * MAX_ANGULAR_SPEED },
-      position = Vec3.sum(position, Vec3.multiply(DIE_SIZE, Vec3.normalize(Quat.getRight(Camera.getOrientation()))));
+                  lifetime: LIFETIME,
+                  gravity: {  x: 0, y: GRAVITY, z: 0 },
+                  shapeType: "box",
+                  collisionsWillMove: true
+                }));
+            position = Vec3.sum(position, Vec3.multiply(DIE_SIZE, Vec3.normalize(Quat.getRight(Camera.getOrientation()))));
+        }
     }
 }
 

libraries/entities/src/EntityScriptingInterface.cpp

@@ -23,6 +23,7 @@ EntityScriptingInterface::EntityScriptingInterface() :
 {
     auto nodeList = DependencyManager::get<NodeList>();
     connect(nodeList.data(), &NodeList::canAdjustLocksChanged, this, &EntityScriptingInterface::canAdjustLocksChanged);
+    connect(nodeList.data(), &NodeList::canRezChanged, this, &EntityScriptingInterface::canRezChanged);
 }
 
 void EntityScriptingInterface::queueEntityMessage(PacketType packetType,
@@ -30,12 +31,15 @@ void EntityScriptingInterface::queueEntityMessage(PacketType packetType,
     getEntityPacketSender()->queueEditEntityMessage(packetType, entityID, properties);
 }
 
-
 bool EntityScriptingInterface::canAdjustLocks() {
     auto nodeList = DependencyManager::get<NodeList>();
     return nodeList->getThisNodeCanAdjustLocks();
 }
 
+bool EntityScriptingInterface::canRez() {
+    auto nodeList = DependencyManager::get<NodeList>();
+    return nodeList->getThisNodeCanRez();
+}
 
 void EntityScriptingInterface::setEntityTree(EntityTree* modelTree) {
     if (_entityTree) {

libraries/entities/src/EntityScriptingInterface.h

@@ -66,6 +66,9 @@ public slots:
     // returns true if the DomainServer will allow this Node/Avatar to make changes
     Q_INVOKABLE bool canAdjustLocks();
 
+    // returns true if the DomainServer will allow this Node/Avatar to rez new entities
+    Q_INVOKABLE bool canRez();
+
     /// adds a model with the specific properties
     Q_INVOKABLE EntityItemID addEntity(const EntityItemProperties& properties);
 
@@ -117,6 +120,7 @@ signals:
     void entityCollisionWithEntity(const EntityItemID& idA, const EntityItemID& idB, const Collision& collision);
 
     void canAdjustLocksChanged(bool canAdjustLocks);
+    void canRezChanged(bool canRez);
 
     void mousePressOnEntity(const EntityItemID& entityItemID, const MouseEvent& event);
     void mouseMoveOnEntity(const EntityItemID& entityItemID, const MouseEvent& event);

libraries/entities/src/EntityTree.cpp

@@ -659,12 +659,14 @@ int EntityTree::processEditPacketData(PacketType packetType, const unsigned char
                         qDebug() << "User attempted to edit an unknown entity. ID:" << entityItemID;
                     }
                 } else {
-                    // this is a new entity... assign a new entityID
+                    if (senderNode->getCanRez()) {
-                    entityItemID = assignEntityID(entityItemID);
+                        // this is a new entity... assign a new entityID
-                    EntityItem* newEntity = addEntity(entityItemID, properties);
+                        entityItemID = assignEntityID(entityItemID);
-                    if (newEntity) {
+                        EntityItem* newEntity = addEntity(entityItemID, properties);
-                        newEntity->markAsChangedOnServer();
+                        if (newEntity) {
-                        notifyNewlyCreatedEntity(*newEntity, senderNode);
+                            newEntity->markAsChangedOnServer();
+                            notifyNewlyCreatedEntity(*newEntity, senderNode);
+                        }
                     }
                 }
             }

libraries/networking/src/LimitedNodeList.cpp

@@ -47,7 +47,8 @@ LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short
     _publicSockAddr(),
     _stunSockAddr(STUN_SERVER_HOSTNAME, STUN_SERVER_PORT),
     _packetStatTimer(),
-    _thisNodeCanAdjustLocks(false)
+    _thisNodeCanAdjustLocks(false),
+    _thisNodeCanRez(true)
 {
     static bool firstCall = true;
     if (firstCall) {
@@ -106,6 +107,13 @@ void LimitedNodeList::setThisNodeCanAdjustLocks(bool canAdjustLocks) {
     }
 }
 
+void LimitedNodeList::setThisNodeCanRez(bool canRez) {
+    if (_thisNodeCanRez != canRez) {
+        _thisNodeCanRez = canRez;
+        emit canRezChanged(canRez);
+    }
+}
+
 QUdpSocket& LimitedNodeList::getDTLSSocket() {
     if (!_dtlsSocket) {
         // DTLS socket getter called but no DTLS socket exists, create it now
@@ -415,7 +423,7 @@ void LimitedNodeList::handleNodeKill(const SharedNodePointer& node) {
 
 SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                                    const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
-                                                   bool canAdjustLocks) {
+                                                   bool canAdjustLocks, bool canRez) {
     NodeHash::const_iterator it = _nodeHash.find(uuid);
     
     if (it != _nodeHash.end()) {
@@ -424,11 +432,12 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
         matchingNode->setPublicSocket(publicSocket);
         matchingNode->setLocalSocket(localSocket);
         matchingNode->setCanAdjustLocks(canAdjustLocks);
+        matchingNode->setCanRez(canRez);
         
         return matchingNode;
     } else {
         // we didn't have this node, so add them
-        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, canAdjustLocks);
+        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, canAdjustLocks, canRez);
         SharedNodePointer newNodePointer(newNode);
         
         _nodeHash.insert(UUIDNodePair(newNode->getUUID(), newNodePointer));

libraries/networking/src/LimitedNodeList.h

@@ -84,6 +84,9 @@ public:
 
     bool getThisNodeCanAdjustLocks() const { return _thisNodeCanAdjustLocks; }
     void setThisNodeCanAdjustLocks(bool canAdjustLocks);
+
+    bool getThisNodeCanRez() const { return _thisNodeCanRez; }
+    void setThisNodeCanRez(bool canRez);
     
     void rebindNodeSocket();
     QUdpSocket& getNodeSocket() { return _nodeSocket; }
@@ -114,7 +117,8 @@ public:
     SharedNodePointer sendingNodeForPacket(const QByteArray& packet);
     
     SharedNodePointer addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
-                                      const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket, bool canAdjustLocks);
+                                      const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
+                                      bool canAdjustLocks, bool canRez);
     
     const HifiSockAddr& getLocalSockAddr() const { return _localSockAddr; }
     const HifiSockAddr& getSTUNSockAddr() const { return _stunSockAddr; }
@@ -206,6 +210,7 @@ signals:
     void publicSockAddrChanged(const HifiSockAddr& publicSockAddr);
 
     void canAdjustLocksChanged(bool canAdjustLocks);
+    void canRezChanged(bool canRez);
 
     void dataSent(const quint8 channel_type, const int bytes);
     void dataReceived(const quint8 channel_type, const int bytes);
@@ -241,6 +246,7 @@ protected:
 
     QElapsedTimer _packetStatTimer;
     bool _thisNodeCanAdjustLocks;
+    bool _thisNodeCanRez;
     
     template<typename IteratorLambda>
     void eachNodeHashIterator(IteratorLambda functor) {

libraries/networking/src/Node.cpp

@@ -41,7 +41,7 @@ const QString& NodeType::getNodeTypeName(NodeType_t nodeType) {
 }
 
 Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
-           const HifiSockAddr& localSocket, bool canAdjustLocks) :
+           const HifiSockAddr& localSocket, bool canAdjustLocks, bool canRez) :
     NetworkPeer(uuid, publicSocket, localSocket),
     _type(type),
     _activeSocket(NULL),
@@ -53,7 +53,8 @@ Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
     _clockSkewUsec(0),
     _mutex(),
     _clockSkewMovingPercentile(30, 0.8f),   // moving 80th percentile of 30 samples
-    _canAdjustLocks(canAdjustLocks)
+    _canAdjustLocks(canAdjustLocks),
+    _canRez(canRez)
 {
     
 }
@@ -133,6 +134,7 @@ QDataStream& operator<<(QDataStream& out, const Node& node) {
     out << node._publicSocket;
     out << node._localSocket;
     out << node._canAdjustLocks;
+    out << node._canRez;
     
     return out;
 }
@@ -143,6 +145,7 @@ QDataStream& operator>>(QDataStream& in, Node& node) {
     in >> node._publicSocket;
     in >> node._localSocket;
     in >> node._canAdjustLocks;
+    in >> node._canRez;
     
     return in;
 }

libraries/networking/src/Node.h

@@ -45,7 +45,7 @@ class Node : public NetworkPeer {
     Q_OBJECT
 public:
     Node(const QUuid& uuid, NodeType_t type,
-         const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket, bool canAdjustLocks);
+         const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket, bool canAdjustLocks, bool canRez);
     ~Node();
 
     bool operator==(const Node& otherNode) const { return _uuid == otherNode._uuid; }
@@ -79,6 +79,9 @@ public:
 
     void setCanAdjustLocks(bool canAdjustLocks) { _canAdjustLocks = canAdjustLocks; }
     bool getCanAdjustLocks() { return _canAdjustLocks; }
+
+    void setCanRez(bool canRez) { _canRez = canRez; }
+    bool getCanRez() { return _canRez; }
     
     void activatePublicSocket();
     void activateLocalSocket();
@@ -105,6 +108,7 @@ private:
     QMutex _mutex;
     MovingPercentile _clockSkewMovingPercentile;
     bool _canAdjustLocks;
+    bool _canRez;
 };
 
 QDebug operator<<(QDebug debug, const Node &message);

libraries/networking/src/NodeList.cpp

@@ -403,6 +403,10 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
     bool thisNodeCanAdjustLocks;
     packetStream >> thisNodeCanAdjustLocks;
     setThisNodeCanAdjustLocks(thisNodeCanAdjustLocks);
+
+    bool thisNodeCanRez;
+    packetStream >> thisNodeCanRez;
+    setThisNodeCanRez(thisNodeCanRez);
     
     // pull each node in the packet
     while(packetStream.device()->pos() < packet.size()) {
@@ -411,8 +415,9 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
         QUuid nodeUUID, connectionUUID;
         HifiSockAddr nodePublicSocket, nodeLocalSocket;
         bool canAdjustLocks;
+        bool canRez;
 
-        packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> canAdjustLocks;
+        packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> canAdjustLocks >> canRez;
 
         // if the public socket address is 0 then it's reachable at the same IP
         // as the domain server
@@ -420,7 +425,8 @@ int NodeList::processDomainServerList(const QByteArray& packet) {
             nodePublicSocket.setAddress(_domainHandler.getIP());
         }
 
-        SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket, nodeLocalSocket, canAdjustLocks);
+        SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket,
+                                                 nodeLocalSocket, canAdjustLocks, canRez);
         
         packetStream >> connectionUUID;
         node->setConnectionSecret(connectionUUID);

libraries/networking/src/PacketHeaders.cpp

@@ -64,7 +64,7 @@ PacketVersion versionForPacketType(PacketType type) {
             return 2;
         case PacketTypeDomainList:
         case PacketTypeDomainListRequest:
-            return 4;
+            return 5;
         case PacketTypeCreateAssignment:
         case PacketTypeRequestAssignment:
             return 2;