add access to Voxels and Particles inside of collision scripts

libraries/particles/src/Particle.cpp

@@ -14,9 +14,14 @@
 #include <SharedUtil.h> // usecTimestampNow()
 #include <Octree.h>
 
+#include <VoxelScriptingInterface.h>
+#include "ParticleScriptingInterface.h"
+
 #include "Particle.h"
 
 uint32_t Particle::_nextID = 0;
+VoxelScriptingInterface* Particle::_voxelScriptingInterface = NULL;
+ParticleScriptingInterface* Particle::_particlesScriptingInterface = NULL;
 
 
 Particle::Particle(glm::vec3 position, float radius, rgbColor color, glm::vec3 velocity, glm::vec3 gravity, 
@@ -321,6 +326,7 @@ void Particle::debugDump() const {
     printf(" position:%f,%f,%f\n", _position.x, _position.y, _position.z);
     printf(" velocity:%f,%f,%f\n", _velocity.x, _velocity.y, _velocity.z);
     printf(" gravity:%f,%f,%f\n", _gravity.x, _gravity.y, _gravity.z);
+    printf(" color:%d,%d,%d\n", _color[0], _color[1], _color[2]);
 }
 
 bool Particle::encodeParticleEditMessageDetails(PACKET_TYPE command, int count, const ParticleDetail* details, 
@@ -549,10 +555,32 @@ void Particle::collisionWithParticle(unsigned int otherID) {
         QScriptValue treeScaleValue = engine.newVariant(QVariant(TREE_SCALE));
         engine.globalObject().setProperty("TREE_SCALE", TREE_SCALE);
 
+
+        if (getVoxelsScriptingInterface()) {
+            QScriptValue voxelScripterValue =  engine.newQObject(getVoxelsScriptingInterface());
+            engine.globalObject().setProperty("Voxels", voxelScripterValue);
+        }
+
+        if (getParticlesScriptingInterface()) {
+            QScriptValue particleScripterValue =  engine.newQObject(getParticlesScriptingInterface());
+            engine.globalObject().setProperty("Particles", particleScripterValue);
+            printf("has Particles...\n");
+        } else {
+            printf("no Particles...\n");
+        }
+        
         QScriptValue result = engine.evaluate(_script);
         
         particleScriptable.emitCollisionWithParticle(otherID);
 
+        if (getVoxelsScriptingInterface()) {
+            getVoxelsScriptingInterface()->getPacketSender()->releaseQueuedMessages();
+        }
+
+        if (getParticlesScriptingInterface()) {
+            getParticlesScriptingInterface()->getPacketSender()->releaseQueuedMessages();
+        }
+
         if (engine.hasUncaughtException()) {
             int line = engine.uncaughtExceptionLineNumber();
             qDebug() << "Uncaught exception at line" << line << ":" << result.toString() << "\n";

libraries/particles/src/Particle.h

@@ -19,6 +19,10 @@
 #include <SharedUtil.h>
 #include <OctreePacketData.h>
 
+class VoxelScriptingInterface;
+class ParticleScriptingInterface;
+
+
 const uint32_t NEW_PARTICLE = 0xFFFFFFFF;
 const uint32_t UNKNOWN_TOKEN = 0xFFFFFFFF;
 
@@ -117,7 +121,19 @@ 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 void setVoxelsScriptingInterface(VoxelScriptingInterface* interface) 
+                    { _voxelScriptingInterface = interface; }
+                    
+    static void setParticlesScriptingInterface(ParticleScriptingInterface* interface) 
+                    { _particlesScriptingInterface = interface; }
+    
 protected:
+    static VoxelScriptingInterface* _voxelScriptingInterface;
+    static ParticleScriptingInterface* _particlesScriptingInterface;
+
     void runUpdateScript();
     static QScriptValue vec3toScriptValue(QScriptEngine *engine, const glm::vec3 &vec3);
     static void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3);

libraries/particles/src/ParticleScriptingInterface.cpp

@@ -10,12 +10,12 @@
 
 
 
-void ParticleScriptingInterface::queueParticleAdd(PACKET_TYPE addPacketType, ParticleDetail& addParticleDetails) {
+void ParticleScriptingInterface::queueParticleMessage(PACKET_TYPE packetType, ParticleDetail& particleDetails) {
-    getParticlePacketSender()->queueParticleEditMessages(addPacketType, 1, &addParticleDetails);
+    getParticlePacketSender()->queueParticleEditMessages(packetType, 1, &particleDetails);
 }
 
 unsigned int ParticleScriptingInterface::queueParticleAdd(glm::vec3 position, float radius, 
-            xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString updateScript) {
+            xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString script) {
 
     // The application will keep track of creatorTokenID
     uint32_t creatorTokenID = _nextCreatorTokenID;
@@ -25,10 +25,24 @@ unsigned int ParticleScriptingInterface::queueParticleAdd(glm::vec3 position, fl
     uint64_t now = usecTimestampNow();
     ParticleDetail addParticleDetail = { NEW_PARTICLE, now,
                                         position, radius, {color.red, color.green, color.blue }, velocity, 
-                                        gravity, damping, inHand, updateScript, creatorTokenID };
+                                        gravity, damping, inHand, script, creatorTokenID };
     
     // queue the packet
-    queueParticleAdd(PACKET_TYPE_PARTICLE_ADD_OR_EDIT, addParticleDetail);
+    queueParticleMessage(PACKET_TYPE_PARTICLE_ADD_OR_EDIT, addParticleDetail);
     
     return creatorTokenID;
 }
+
+
+void ParticleScriptingInterface::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
+    uint64_t now = usecTimestampNow();
+    ParticleDetail editParticleDetail = { particleID, now,
+                                        position, radius, {color.red, color.green, color.blue }, velocity, 
+                                        gravity, damping, inHand, script, UNKNOWN_TOKEN };
+    
+    // queue the packet
+    queueParticleMessage(PACKET_TYPE_PARTICLE_ADD_OR_EDIT, editParticleDetail);
+}

libraries/particles/src/ParticleScriptingInterface.h

@@ -27,10 +27,13 @@ public slots:
     /// queues the creation of a Particle which will be sent by calling process on the PacketSender
     /// returns the creatorTokenID for the newly created particle
     unsigned int queueParticleAdd(glm::vec3 position, float radius, 
-            xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString updateScript);
+            xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString script);
+
+    void queueParticleEdit(unsigned int particleID, glm::vec3 position, float radius, 
+            xColor color, glm::vec3 velocity, glm::vec3 gravity, float damping, bool inHand, QString script);
 
 private:
-    void queueParticleAdd(PACKET_TYPE addPacketType, ParticleDetail& addParticleDetails);
+    void queueParticleMessage(PACKET_TYPE packetType, ParticleDetail& particleDetails);
     
     uint32_t _nextCreatorTokenID;
 };

libraries/script-engine/src/ScriptEngine.cpp

@@ -23,6 +23,9 @@
 #include "ScriptEngine.h"
 
 int ScriptEngine::_scriptNumber = 1;
+VoxelScriptingInterface ScriptEngine::_voxelScriptingInterface;
+ParticleScriptingInterface ScriptEngine::_particleScriptingInterface;
+
 
 ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems,
                                 const char* scriptMenuName, AbstractMenuInterface* menu,
@@ -43,6 +46,15 @@ ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems,
     }
     _menu = menu;
     _controllerScriptingInterface = controllerScriptingInterface;
+
+    // hook up our interfaces
+    if (!Particle::getVoxelsScriptingInterface()) {
+        Particle::setVoxelsScriptingInterface(getVoxelScriptingInterface());
+    }
+    
+    if (!Particle::getParticlesScriptingInterface()) {
+        Particle::setParticlesScriptingInterface(getParticleScriptingInterface());
+    }
 }
 
 ScriptEngine::~ScriptEngine() {

libraries/script-engine/src/ScriptEngine.h

@@ -58,8 +58,8 @@ protected:
 
 
 private:
-    VoxelScriptingInterface _voxelScriptingInterface;
+    static VoxelScriptingInterface _voxelScriptingInterface;
-    ParticleScriptingInterface _particleScriptingInterface;
+    static ParticleScriptingInterface _particleScriptingInterface;
     AbstractControllerScriptingInterface* _controllerScriptingInterface;
     bool _wantMenuItems;
     QString _scriptMenuName;