rename voxels and particles scripting interfaces

assignment-client/src/Agent.cpp

@@ -32,12 +32,12 @@ void Agent::processDatagram(const QByteArray& dataByteArray, const HifiSockAddr&
         // PACKET_TYPE_JURISDICTION, first byte is the node type...
         switch (dataByteArray[headerBytes]) {
             case NODE_TYPE_VOXEL_SERVER:
-                _scriptEngine.getVoxelScriptingInterface()->getJurisdictionListener()->queueReceivedPacket(senderSockAddr,
+                _scriptEngine.getVoxelsScriptingInterface()->getJurisdictionListener()->queueReceivedPacket(senderSockAddr,
                                                                                 (unsigned char*) dataByteArray.data(),
                                                                                 dataByteArray.size());
                 break;
             case NODE_TYPE_PARTICLE_SERVER:
-                _scriptEngine.getParticleScriptingInterface()->getJurisdictionListener()->queueReceivedPacket(senderSockAddr,
+                _scriptEngine.getParticlesScriptingInterface()->getJurisdictionListener()->queueReceivedPacket(senderSockAddr,
                                                                                 (unsigned char*) dataByteArray.data(),
                                                                                 dataByteArray.size());
                 break;

assignment-client/src/Agent.h

@@ -18,9 +18,6 @@
 #include <ScriptEngine.h>
 #include <ThreadedAssignment.h>
 
-#include <VoxelScriptingInterface.h>
-#include <ParticleScriptingInterface.h>
-
 class Agent : public ThreadedAssignment {
     Q_OBJECT
 public:

interface/src/Application.cpp

@@ -4455,8 +4455,8 @@ void Application::loadScript() {
     
     // setup the packet senders and jurisdiction listeners of the script engine's scripting interfaces so
     // we can use the same ones from the application.
-    scriptEngine->getVoxelScriptingInterface()->setPacketSender(&_voxelEditSender);
-    scriptEngine->getParticleScriptingInterface()->setPacketSender(&_particleEditSender);
+    scriptEngine->getVoxelsScriptingInterface()->setPacketSender(&_voxelEditSender);
+    scriptEngine->getParticlesScriptingInterface()->setPacketSender(&_particleEditSender);
 
     QThread* workerThread = new QThread(this);
 

libraries/particles/src/Particle.cpp

@@ -14,14 +14,14 @@
 #include <SharedUtil.h> // usecTimestampNow()
 #include <Octree.h>
 
-#include <VoxelScriptingInterface.h>
-#include "ParticleScriptingInterface.h"
+#include <VoxelsScriptingInterface.h>
+#include "ParticlesScriptingInterface.h"
 
 #include "Particle.h"
 
 uint32_t Particle::_nextID = 0;
-VoxelScriptingInterface* Particle::_voxelScriptingInterface = NULL;
-ParticleScriptingInterface* Particle::_particlesScriptingInterface = NULL;
+VoxelsScriptingInterface* Particle::_voxelsScriptingInterface = NULL;
+ParticlesScriptingInterface* Particle::_particlesScriptingInterface = NULL;
 
 
 Particle::Particle(glm::vec3 position, float radius, rgbColor color, glm::vec3 velocity, glm::vec3 gravity, 

libraries/particles/src/Particle.h

@@ -19,8 +19,8 @@
 #include <SharedUtil.h>
 #include <OctreePacketData.h>
 
-class VoxelScriptingInterface;
-class ParticleScriptingInterface;
+class VoxelsScriptingInterface;
+class ParticlesScriptingInterface;
 
 
 const uint32_t NEW_PARTICLE = 0xFFFFFFFF;
@@ -121,18 +121,18 @@ public:
     // similar to assignment/copy, but it handles keeping lifetime accurate
     void copyChangedProperties(const Particle& other);
     
-    static VoxelScriptingInterface* getVoxelsScriptingInterface() { return _voxelScriptingInterface; }
-    static ParticleScriptingInterface* getParticlesScriptingInterface() { return _particlesScriptingInterface; }
+    static VoxelsScriptingInterface* getVoxelsScriptingInterface() { return _voxelsScriptingInterface; }
+    static ParticlesScriptingInterface* getParticlesScriptingInterface() { return _particlesScriptingInterface; }
 
-    static void setVoxelsScriptingInterface(VoxelScriptingInterface* interface) 
-                    { _voxelScriptingInterface = interface; }
+    static void setVoxelsScriptingInterface(VoxelsScriptingInterface* interface) 
+                    { _voxelsScriptingInterface = interface; }
                     
-    static void setParticlesScriptingInterface(ParticleScriptingInterface* interface) 
+    static void setParticlesScriptingInterface(ParticlesScriptingInterface* interface) 
                     { _particlesScriptingInterface = interface; }
     
 protected:
-    static VoxelScriptingInterface* _voxelScriptingInterface;
-    static ParticleScriptingInterface* _particlesScriptingInterface;
+    static VoxelsScriptingInterface* _voxelsScriptingInterface;
+    static ParticlesScriptingInterface* _particlesScriptingInterface;
 
     void runUpdateScript();
     static QScriptValue vec3toScriptValue(QScriptEngine *engine, const glm::vec3 &vec3);

libraries/particles/src/ParticlesScriptingInterface.cpp

@@ -1,20 +1,20 @@
 //
-//  ParticleScriptingInterface.cpp
+//  ParticlesScriptingInterface.cpp
 //  hifi
 //
 //  Created by Brad Hefta-Gaub on 12/6/13
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
-#include "ParticleScriptingInterface.h"
+#include "ParticlesScriptingInterface.h"
 
 
 
-void ParticleScriptingInterface::queueParticleMessage(PACKET_TYPE packetType, ParticleDetail& particleDetails) {
+void ParticlesScriptingInterface::queueParticleMessage(PACKET_TYPE packetType, ParticleDetail& particleDetails) {
     getParticlePacketSender()->queueParticleEditMessages(packetType, 1, &particleDetails);
 }
 
-unsigned int ParticleScriptingInterface::queueParticleAdd(glm::vec3 position, float radius, 
+unsigned int ParticlesScriptingInterface::queueParticleAdd(glm::vec3 position, float radius, 
             xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString script) {
 
     // The application will keep track of creatorTokenID
@@ -34,7 +34,7 @@ unsigned int ParticleScriptingInterface::queueParticleAdd(glm::vec3 position, fl
 }
 
 
-void ParticleScriptingInterface::queueParticleEdit(unsigned int particleID, glm::vec3 position, float radius, 
+void ParticlesScriptingInterface::queueParticleEdit(unsigned int particleID, glm::vec3 position, float radius, 
             xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString script) {
 
     // setup a ParticleDetail struct with the data

libraries/particles/src/ParticlesScriptingInterface.h

@@ -1,13 +1,13 @@
 //
-//  ParticleScriptingInterface.h
+//  ParticlesScriptingInterface.h
 //  hifi
 //
 //  Created by Brad Hefta-Gaub on 12/6/13
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
-#ifndef __hifi__ParticleScriptingInterface__
-#define __hifi__ParticleScriptingInterface__
+#ifndef __hifi__ParticlesScriptingInterface__
+#define __hifi__ParticlesScriptingInterface__
 
 #include <QtCore/QObject>
 
@@ -16,7 +16,7 @@
 #include "ParticleEditPacketSender.h"
 
 /// handles scripting of Particle commands from JS passed to assigned clients
-class ParticleScriptingInterface : public OctreeScriptingInterface {
+class ParticlesScriptingInterface : public OctreeScriptingInterface {
     Q_OBJECT
 public:
     ParticleEditPacketSender* getParticlePacketSender() const { return (ParticleEditPacketSender*)getPacketSender(); }
@@ -38,4 +38,4 @@ private:
     uint32_t _nextCreatorTokenID;
 };
 
-#endif /* defined(__hifi__ParticleScriptingInterface__) */
+#endif /* defined(__hifi__ParticlesScriptingInterface__) */

libraries/script-engine/src/ScriptEngine.cpp

@@ -1,5 +1,5 @@
 //
-//  Agent.cpp
+//  ScriptEngine.cpp
 //  hifi
 //
 //  Created by Brad Hefta-Gaub on 12/14/13.
@@ -23,8 +23,8 @@
 #include "ScriptEngine.h"
 
 int ScriptEngine::_scriptNumber = 1;
-VoxelScriptingInterface ScriptEngine::_voxelScriptingInterface;
-ParticleScriptingInterface ScriptEngine::_particleScriptingInterface;
+VoxelsScriptingInterface ScriptEngine::_voxelsScriptingInterface;
+ParticlesScriptingInterface ScriptEngine::_particlesScriptingInterface;
 
 
 ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems,
@@ -49,11 +49,11 @@ ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems,
 
     // hook up our interfaces
     if (!Particle::getVoxelsScriptingInterface()) {
-        Particle::setVoxelsScriptingInterface(getVoxelScriptingInterface());
+        Particle::setVoxelsScriptingInterface(getVoxelsScriptingInterface());
     }
     
     if (!Particle::getParticlesScriptingInterface()) {
-        Particle::setParticlesScriptingInterface(getParticleScriptingInterface());
+        Particle::setParticlesScriptingInterface(getParticlesScriptingInterface());
     }
 }
 
@@ -86,8 +86,8 @@ void ScriptEngine::run() {
     _isRunning = true;
     QScriptEngine engine;
     
-    _voxelScriptingInterface.init();
-    _particleScriptingInterface.init();
+    _voxelsScriptingInterface.init();
+    _particlesScriptingInterface.init();
     
     // register meta-type for glm::vec3 conversions
     registerMetaTypes(&engine);
@@ -95,10 +95,10 @@ void ScriptEngine::run() {
     QScriptValue agentValue = engine.newQObject(this);
     engine.globalObject().setProperty("Agent", agentValue);
     
-    QScriptValue voxelScripterValue =  engine.newQObject(&_voxelScriptingInterface);
+    QScriptValue voxelScripterValue =  engine.newQObject(&_voxelsScriptingInterface);
     engine.globalObject().setProperty("Voxels", voxelScripterValue);
 
-    QScriptValue particleScripterValue =  engine.newQObject(&_particleScriptingInterface);
+    QScriptValue particleScripterValue =  engine.newQObject(&_particlesScriptingInterface);
     engine.globalObject().setProperty("Particles", particleScripterValue);
     
     if (_controllerScriptingInterface) {
@@ -112,8 +112,8 @@ void ScriptEngine::run() {
     const unsigned int VISUAL_DATA_CALLBACK_USECS = (1.0 / 60.0) * 1000 * 1000;
     
     // let the VoxelPacketSender know how frequently we plan to call it
-    _voxelScriptingInterface.getVoxelPacketSender()->setProcessCallIntervalHint(VISUAL_DATA_CALLBACK_USECS);
-    _particleScriptingInterface.getParticlePacketSender()->setProcessCallIntervalHint(VISUAL_DATA_CALLBACK_USECS);
+    _voxelsScriptingInterface.getVoxelPacketSender()->setProcessCallIntervalHint(VISUAL_DATA_CALLBACK_USECS);
+    _particlesScriptingInterface.getParticlePacketSender()->setProcessCallIntervalHint(VISUAL_DATA_CALLBACK_USECS);
 
     //qDebug() << "Script:\n" << _scriptContents << "\n";
     
@@ -147,29 +147,29 @@ void ScriptEngine::run() {
         }
         
         bool willSendVisualDataCallBack = false;
-        if (_voxelScriptingInterface.getVoxelPacketSender()->serversExist()) {            
+        if (_voxelsScriptingInterface.getVoxelPacketSender()->serversExist()) {            
             // allow the scripter's call back to setup visual data
             willSendVisualDataCallBack = true;
             
             // release the queue of edit voxel messages.
-            _voxelScriptingInterface.getVoxelPacketSender()->releaseQueuedMessages();
+            _voxelsScriptingInterface.getVoxelPacketSender()->releaseQueuedMessages();
             
             // since we're in non-threaded mode, call process so that the packets are sent
-            if (!_voxelScriptingInterface.getVoxelPacketSender()->isThreaded()) {
-                _voxelScriptingInterface.getVoxelPacketSender()->process();
+            if (!_voxelsScriptingInterface.getVoxelPacketSender()->isThreaded()) {
+                _voxelsScriptingInterface.getVoxelPacketSender()->process();
             }
         }
 
-        if (_particleScriptingInterface.getParticlePacketSender()->serversExist()) {
+        if (_particlesScriptingInterface.getParticlePacketSender()->serversExist()) {
             // allow the scripter's call back to setup visual data
             willSendVisualDataCallBack = true;
             
             // release the queue of edit voxel messages.
-            _particleScriptingInterface.getParticlePacketSender()->releaseQueuedMessages();
+            _particlesScriptingInterface.getParticlePacketSender()->releaseQueuedMessages();
             
             // since we're in non-threaded mode, call process so that the packets are sent
-            if (!_particleScriptingInterface.getParticlePacketSender()->isThreaded()) {
-                _particleScriptingInterface.getParticlePacketSender()->process();
+            if (!_particlesScriptingInterface.getParticlePacketSender()->isThreaded()) {
+                _particlesScriptingInterface.getParticlePacketSender()->process();
             }
         }
         

libraries/script-engine/src/ScriptEngine.h

@@ -16,8 +16,8 @@
 #include <QtCore/QUrl>
 
 #include <AbstractMenuInterface.h>
-#include <ParticleScriptingInterface.h>
-#include <VoxelScriptingInterface.h>
+#include <ParticlesScriptingInterface.h>
+#include <VoxelsScriptingInterface.h>
 #include "AbstractControllerScriptingInterface.h"
 
 const QString NO_SCRIPT("");
@@ -31,11 +31,11 @@ public:
 
     ~ScriptEngine();
     
-    /// Access the VoxelScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
-    VoxelScriptingInterface* getVoxelScriptingInterface() { return &_voxelScriptingInterface; }
+    /// Access the VoxelsScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
+    VoxelsScriptingInterface* getVoxelsScriptingInterface() { return &_voxelsScriptingInterface; }
 
-    /// Access the ParticleScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
-    ParticleScriptingInterface* getParticleScriptingInterface() { return &_particleScriptingInterface; }
+    /// Access the ParticlesScriptingInterface in order to initialize it with a custom packet sender and jurisdiction listener
+    ParticlesScriptingInterface* getParticlesScriptingInterface() { return &_particlesScriptingInterface; }
 
     /// sets the script contents, will return false if failed, will fail if script is already running
     bool setScriptContents(const QString& scriptContents);
@@ -58,8 +58,8 @@ protected:
 
 
 private:
-    static VoxelScriptingInterface _voxelScriptingInterface;
-    static ParticleScriptingInterface _particleScriptingInterface;
+    static VoxelsScriptingInterface _voxelsScriptingInterface;
+    static ParticlesScriptingInterface _particlesScriptingInterface;
     AbstractControllerScriptingInterface* _controllerScriptingInterface;
     bool _wantMenuItems;
     QString _scriptMenuName;

libraries/voxels/src/VoxelsScriptingInterface.cpp

@@ -1,18 +1,18 @@
 //
-//  VoxelScriptingInterface.cpp
+//  VoxelsScriptingInterface.cpp
 //  hifi
 //
 //  Created by Stephen Birarda on 9/17/13.
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
-#include "VoxelScriptingInterface.h"
+#include "VoxelsScriptingInterface.h"
 
-void VoxelScriptingInterface::queueVoxelAdd(PACKET_TYPE addPacketType, VoxelDetail& addVoxelDetails) {
+void VoxelsScriptingInterface::queueVoxelAdd(PACKET_TYPE addPacketType, VoxelDetail& addVoxelDetails) {
     getVoxelPacketSender()->queueVoxelEditMessages(addPacketType, 1, &addVoxelDetails);
 }
 
-void VoxelScriptingInterface::queueVoxelAdd(float x, float y, float z, float scale, uchar red, uchar green, uchar blue) {
+void VoxelsScriptingInterface::queueVoxelAdd(float x, float y, float z, float scale, uchar red, uchar green, uchar blue) {
     // setup a VoxelDetail struct with the data
     VoxelDetail addVoxelDetail = {x, y, z, scale, red, green, blue};
     
@@ -20,7 +20,7 @@ void VoxelScriptingInterface::queueVoxelAdd(float x, float y, float z, float sca
     queueVoxelAdd(PACKET_TYPE_VOXEL_SET, addVoxelDetail);
 }
 
-void VoxelScriptingInterface::queueDestructiveVoxelAdd(float x, float y, float z, float scale,
+void VoxelsScriptingInterface::queueDestructiveVoxelAdd(float x, float y, float z, float scale,
                                                         uchar red, uchar green, uchar blue) {
     // setup a VoxelDetail struct with the data
     VoxelDetail addVoxelDetail = {x, y, z, scale, red, green, blue};
@@ -29,7 +29,7 @@ void VoxelScriptingInterface::queueDestructiveVoxelAdd(float x, float y, float z
     queueVoxelAdd(PACKET_TYPE_VOXEL_SET_DESTRUCTIVE, addVoxelDetail);
 }
 
-void VoxelScriptingInterface::queueVoxelDelete(float x, float y, float z, float scale) {
+void VoxelsScriptingInterface::queueVoxelDelete(float x, float y, float z, float scale) {
     
     // setup a VoxelDetail struct with data
     VoxelDetail deleteVoxelDetail = {x, y, z, scale, 0, 0, 0};

libraries/voxels/src/VoxelsScriptingInterface.h

@@ -1,13 +1,13 @@
 //
-//  VoxelScriptingInterface.h
+//  VoxelsScriptingInterface.h
 //  hifi
 //
 //  Created by Stephen Birarda on 9/17/13.
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
-#ifndef __hifi__VoxelScriptingInterface__
-#define __hifi__VoxelScriptingInterface__
+#ifndef __hifi__VoxelsScriptingInterface__
+#define __hifi__VoxelsScriptingInterface__
 
 #include <QtCore/QObject>
 
@@ -16,7 +16,7 @@
 #include "VoxelEditPacketSender.h"
 
 /// handles scripting of voxel commands from JS passed to assigned clients
-class VoxelScriptingInterface : public OctreeScriptingInterface {
+class VoxelsScriptingInterface : public OctreeScriptingInterface {
     Q_OBJECT
 public:
     VoxelEditPacketSender* getVoxelPacketSender() { return (VoxelEditPacketSender*)getPacketSender(); }
@@ -56,4 +56,4 @@ private:
     void queueVoxelAdd(PACKET_TYPE addPacketType, VoxelDetail& addVoxelDetails);
 };
 
-#endif /* defined(__hifi__VoxelScriptingInterface__) */
+#endif /* defined(__hifi__VoxelsScriptingInterface__) */