first cut at scriptable controller

interface/src/Application.cpp

@@ -4432,7 +4432,8 @@ void Application::loadScript() {
     bool wantMenuItems = true; // tells the ScriptEngine object to add menu items for itself
 
 
-    ScriptEngine* scriptEngine = new ScriptEngine(script, wantMenuItems, fileName, Menu::getInstance());
+    ScriptEngine* scriptEngine = new ScriptEngine(script, wantMenuItems, fileName, Menu::getInstance(), 
+                                                    &_controllerScriptingInterface);
     scriptEngine->setupMenuItems();
     
     // setup the packet senders and jurisdiction listeners of the script engine's scripting interfaces so

interface/src/Application.h

@@ -68,6 +68,8 @@
 #include "ui/LodToolsDialog.h"
 #include "ParticleTreeRenderer.h"
 #include "ParticleEditHandle.h"
+#include "InterfaceControllerScriptingInterface.h"
+
 
 class QAction;
 class QActionGroup;
@@ -498,6 +500,8 @@ private:
     
     std::vector<VoxelFade> _voxelFades;
     std::vector<Avatar*> _avatarFades;
+    
+    InterfaceControllerScriptingInterface _controllerScriptingInterface;
 };
 
 #endif /* defined(__interface__Application__) */

interface/src/InterfaceControllerScriptingInterface.cpp

@@ -0,0 +1,45 @@
+//
+//  InterfaceControllerScriptingInterface.h
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 12/17/13
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+
+#include <HandData.h>
+#include "Application.h"
+#include "InterfaceControllerScriptingInterface.h"
+
+const PalmData* InterfaceControllerScriptingInterface::getPrimaryPalm() const {
+    int leftPalmIndex, rightPalmIndex;
+
+    const HandData* handData = Application::getInstance()->getAvatar()->getHandData();
+    handData->getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
+    
+    if (rightPalmIndex != -1) {
+        return &handData->getPalms()[rightPalmIndex];
+    }
+
+    return NULL;
+}
+
+bool InterfaceControllerScriptingInterface::isPrimaryButtonPressed() const {
+    const PalmData* primaryPalm = getPrimaryPalm();
+    if (primaryPalm) {
+        if (primaryPalm->getControllerButtons() & BUTTON_FWD) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+glm::vec2 InterfaceControllerScriptingInterface::getPrimaryJoystickPosition() const {
+    const PalmData* primaryPalm = getPrimaryPalm();
+    if (primaryPalm) {
+        return glm::vec2(primaryPalm->getJoystickX(), primaryPalm->getJoystickY());
+    }
+
+    return glm::vec2(0);
+}
+

interface/src/InterfaceControllerScriptingInterface.h

@@ -0,0 +1,28 @@
+//
+//  InterfaceControllerScriptingInterface.h
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 12/17/13
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+
+#ifndef __hifi__InterfaceControllerScriptingInterface__
+#define __hifi__InterfaceControllerScriptingInterface__
+
+#include <QtCore/QObject>
+
+#include <ControllerScriptingInterface.h>
+
+/// handles scripting of input controller commands from JS
+class InterfaceControllerScriptingInterface : public ControllerScriptingInterface {
+    Q_OBJECT
+
+public slots:
+    virtual bool isPrimaryButtonPressed() const;
+    virtual glm::vec2 getPrimaryJoystickPosition() const;
+
+private:
+    const PalmData* getPrimaryPalm() const;
+};
+
+#endif /* defined(__hifi__InterfaceControllerScriptingInterface__) */

libraries/avatars/src/HandData.h

@@ -53,9 +53,10 @@ public:
     glm::vec3 worldPositionToLeapPosition(const glm::vec3& worldPosition) const;
     glm::vec3 worldVectorToLeapVector(const glm::vec3& worldVector) const;
 
-    std::vector<PalmData>& getPalms()    { return _palms; }
-    size_t                 getNumPalms() { return _palms.size(); }
-    PalmData&              addNewPalm();
+    std::vector<PalmData>& getPalms() { return _palms; }
+    const std::vector<PalmData>& getPalms() const { return _palms; }
+    size_t getNumPalms() { return _palms.size(); }
+    PalmData& addNewPalm();
 
     /// Finds the indices of the left and right palms according to their locations, or -1 if either or
     /// both is not found.
@@ -137,17 +138,18 @@ public:
 
     const glm::vec3& getRawPosition() const { return _rawPosition; }
     const glm::vec3& getRawNormal()   const { return _rawNormal; }
-    bool             isActive()       const { return _isActive; }
-    int              getLeapID()      const { return _leapID; }
-    int              getSixenseID()   const { return _sixenseID; }
+    bool isActive() const { return _isActive; }
+    int getLeapID() const { return _leapID; }
+    int getSixenseID() const { return _sixenseID; }
 
 
-    std::vector<FingerData>& getFingers()    { return _fingers; }
-    size_t                   getNumFingers() { return _fingers.size(); }
+    std::vector<FingerData>& getFingers() { return _fingers; }
+    const std::vector<FingerData>& getFingers() const { return _fingers; }
+    size_t getNumFingers() const { return _fingers.size(); }
 
-    void setActive(bool active)                { _isActive = active; }
-    void setLeapID(int id)                     { _leapID = id; }
-    void setSixenseID(int id)                  { _sixenseID = id; }
+    void setActive(bool active) { _isActive = active; }
+    void setLeapID(int id) { _leapID = id; }
+    void setSixenseID(int id) { _sixenseID = id; }
 
     void setRawRotation(const glm::quat rawRotation) { _rawRotation = rawRotation; };
     glm::quat getRawRotation() const { return _rawRotation; }
@@ -162,26 +164,28 @@ public:
     const glm::vec3& getTipVelocity() const { return _tipVelocity; }
     void setTipVelocity(const glm::vec3& velocity) { _tipVelocity = velocity; }
     
-    void incrementFramesWithoutData()          { _numFramesWithoutData++; }
-    void resetFramesWithoutData()              { _numFramesWithoutData = 0; }
-    int  getFramesWithoutData()          const { return _numFramesWithoutData; }
+    void incrementFramesWithoutData() { _numFramesWithoutData++; }
+    void resetFramesWithoutData() { _numFramesWithoutData = 0; }
+    int  getFramesWithoutData() const { return _numFramesWithoutData; }
     
     // Controller buttons
     void setControllerButtons(int controllerButtons) { _controllerButtons = controllerButtons; }
     void setLastControllerButtons(int controllerButtons) { _lastControllerButtons = controllerButtons; }
 
-    int getControllerButtons() { return _controllerButtons; }
-    int getLastControllerButtons() { return _lastControllerButtons; }
+    int getControllerButtons() const { return _controllerButtons; }
+    int getLastControllerButtons() const { return _lastControllerButtons; }
     
     void setTrigger(float trigger) { _trigger = trigger; }
-    float getTrigger() { return _trigger; }
+    float getTrigger() const { return _trigger; }
     void setJoystick(float joystickX, float joystickY) { _joystickX = joystickX; _joystickY = joystickY; }
-    float getJoystickX() { return _joystickX; }
-    float getJoystickY() { return _joystickY; }
+    float getJoystickX() const { return _joystickX; }
+    float getJoystickY() const { return _joystickY; }
     
-    bool getIsCollidingWithVoxel() { return _isCollidingWithVoxel; }
+    bool getIsCollidingWithVoxel() const { return _isCollidingWithVoxel; }
     void setIsCollidingWithVoxel(bool isCollidingWithVoxel) { _isCollidingWithVoxel = isCollidingWithVoxel; }
 
+    bool getIsCollidingWithPalm() const { return _isCollidingWithPalm; }
+    void setIsCollidingWithPalm(bool isCollidingWithPalm) { _isCollidingWithPalm = isCollidingWithPalm; }
 private:
     std::vector<FingerData> _fingers;
     glm::quat _rawRotation;

libraries/scriptengine/src/ScriptEngine.cpp

@@ -24,8 +24,9 @@
 
 int ScriptEngine::_scriptNumber = 1;
 
-ScriptEngine::ScriptEngine(QString scriptContents, bool wantMenuItems, 
-                                const char* scriptMenuName, AbstractMenuInterface* menu) {
+ScriptEngine::ScriptEngine(const QString& scriptContents, bool wantMenuItems,
+                                const char* scriptMenuName, AbstractMenuInterface* menu,
+                                ControllerScriptingInterface* controllerScriptingInterface) {
     _scriptContents = scriptContents;
     _isFinished = false;
     _wantMenuItems = wantMenuItems;
@@ -38,6 +39,7 @@ ScriptEngine::ScriptEngine(QString scriptContents, bool wantMenuItems,
         _scriptMenuName.append(_scriptNumber);
     }
     _menu = menu;
+    _controllerScriptingInterface = controllerScriptingInterface;
 }
 
 ScriptEngine::~ScriptEngine() {
@@ -78,6 +80,11 @@ void ScriptEngine::run() {
     QScriptValue particleScripterValue =  engine.newQObject(&_particleScriptingInterface);
     engine.globalObject().setProperty("Particles", particleScripterValue);
     
+    if (_controllerScriptingInterface) {
+        QScriptValue controllerScripterValue =  engine.newQObject(_controllerScriptingInterface);
+        engine.globalObject().setProperty("Controller", controllerScripterValue);
+    }
+        
     QScriptValue treeScaleValue = engine.newVariant(QVariant(TREE_SCALE));
     engine.globalObject().setProperty("TREE_SCALE", treeScaleValue);
     

libraries/scriptengine/src/ScriptEngine.h

@@ -18,12 +18,14 @@
 #include <AbstractMenuInterface.h>
 #include <ParticleScriptingInterface.h>
 #include <VoxelScriptingInterface.h>
+#include "ControllerScriptingInterface.h"
 
 class ScriptEngine : public QObject {
     Q_OBJECT
 public:
-    ScriptEngine(QString scriptContents, bool wantMenuItems = false, 
-                    const char* scriptMenuName = NULL, AbstractMenuInterface* menu = NULL);
+    ScriptEngine(const QString& scriptContents = NO_SCRIPT, bool wantMenuItems = false, 
+                    const char* scriptMenuName = NULL, AbstractMenuInterface* menu = NULL,
+                    ControllerScriptingInterface* controllerScriptingInterface = NULL);
 
     ~ScriptEngine();
     
@@ -52,6 +54,7 @@ protected:
 private:
     VoxelScriptingInterface _voxelScriptingInterface;
     ParticleScriptingInterface _particleScriptingInterface;
+    ControllerScriptingInterface* _controllerScriptingInterface;
     bool _wantMenuItems;
     QString _scriptMenuName;
     AbstractMenuInterface* _menu;

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -12,6 +12,7 @@
 
 void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, vec3toScriptValue, vec3FromScriptValue);
+    qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, xColorToScriptValue, xColorFromScriptValue);
 }
 
@@ -29,6 +30,19 @@ void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
     vec3.z = object.property("z").toVariant().toFloat();
 }
 
+QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2) {
+    QScriptValue obj = engine->newObject();
+    obj.setProperty("x", vec2.x);
+    obj.setProperty("y", vec2.y);
+    return obj;
+}
+
+void vec2FromScriptValue(const QScriptValue &object, glm::vec2 &vec2) {
+    vec2.x = object.property("x").toVariant().toFloat();
+    vec2.y = object.property("y").toVariant().toFloat();
+}
+
+
 QScriptValue xColorToScriptValue(QScriptEngine *engine, const xColor& color) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("red", color.red);

libraries/shared/src/RegisteredMetaTypes.h

@@ -17,11 +17,17 @@
 #include "SharedUtil.h"
 
 Q_DECLARE_METATYPE(glm::vec3)
+Q_DECLARE_METATYPE(glm::vec2)
 Q_DECLARE_METATYPE(xColor)
 
 void registerMetaTypes(QScriptEngine* engine);
+
 QScriptValue vec3toScriptValue(QScriptEngine* engine, const glm::vec3 &vec3);
 void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3);
+
+QScriptValue vec2toScriptValue(QScriptEngine* engine, const glm::vec2 &vec2);
+void vec2FromScriptValue(const QScriptValue &object, glm::vec2 &vec2);
+
 QScriptValue xColorToScriptValue(QScriptEngine* engine, const xColor& color);
 void xColorFromScriptValue(const QScriptValue &object, xColor& color);