Merge branch 'master' of github.com:highfidelity/hifi into groups

domain-server/src/DomainServer.cpp

@@ -391,6 +391,8 @@ void DomainServer::setupNodeListAndAssignments() {
     const QVariant* idValueVariant = valueForKeyPath(settingsMap, METAVERSE_DOMAIN_ID_KEY_PATH);
     if (idValueVariant) {
         nodeList->setSessionUUID(idValueVariant->toString());
+    } else {
+        nodeList->setSessionUUID(QUuid::createUuid()); // Use random UUID
     }
 
     connect(nodeList.data(), &LimitedNodeList::nodeAdded, this, &DomainServer::nodeAdded);

interface/resources/controllers/oculus_touch.json

@@ -1,10 +1,10 @@
 {
     "name": "Oculus Touch to Standard",
     "channels": [
-        { "from": "OculusTouch.A", "to": "Standard.A" },
-        { "from": "OculusTouch.B", "to": "Standard.B" },
-        { "from": "OculusTouch.X", "to": "Standard.X" },
-        { "from": "OculusTouch.Y", "to": "Standard.Y" },
+        { "from": "OculusTouch.A", "to": "Standard.RightPrimaryThumb" },
+        { "from": "OculusTouch.B", "to": "Standard.RightSecondaryThumb" },
+        { "from": "OculusTouch.X", "to": "Standard.LeftPrimaryThumb" },
+        { "from": "OculusTouch.Y", "to": "Standard.LeftSecondaryThumb" },
 
         { "from": "OculusTouch.LY", "filters": "invert", "to": "Standard.LY" },
         { "from": "OculusTouch.LX", "to": "Standard.LX" },

interface/resources/controllers/touchscreen.json

@@ -0,0 +1,23 @@
+{
+    "name": "Touchscreen to Actions",
+    "channels": [
+        { "from": "Touchscreen.GesturePinchOut", "to": "Actions.BoomOut", "filters": [ { "type": "scale", "scale": 0.02 } ] },
+        { "from": "Touchscreen.GesturePinchIn", "to": "Actions.BoomIn", "filters": [ { "type": "scale", "scale": 0.02 } ] },
+
+        { "from": { "makeAxis" : [
+              [ "Touchscreen.DragLeft" ],
+              [ "Touchscreen.DragRight" ] 
+          ] 
+        },
+          "to": "Actions.Yaw", "filters": [ { "type": "scale", "scale": 0.12 } ]
+        },
+
+        { "from": { "makeAxis" : [
+                [ "Touchscreen.DragUp" ],
+                [ "Touchscreen.DragDown" ] 
+            ] 
+          },
+          "to": "Actions.Pitch", "filters": [ { "type": "scale", "scale": 0.04 } ]
+        }	
+    ]
+}

interface/src/Application.cpp

@@ -957,8 +957,12 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
         return DependencyManager::get<OffscreenUi>()->navigationFocused() ? 1 : 0;
     });
 
-    // Setup the keyboardMouseDevice and the user input mapper with the default bindings
+    // Setup the _keyboardMouseDevice, _touchscreenDevice and the user input mapper with the default bindings
     userInputMapper->registerDevice(_keyboardMouseDevice->getInputDevice());
+    // if the _touchscreenDevice is not supported it will not be registered
+    if (_touchscreenDevice) {
+        userInputMapper->registerDevice(_touchscreenDevice->getInputDevice());
+    }
 
     // force the model the look at the correct directory (weird order of operations issue)
     scriptEngines->setScriptsLocation(scriptEngines->getScriptsLocation());
@@ -1600,6 +1604,9 @@ void Application::initializeUi() {
         if (KeyboardMouseDevice::NAME == inputPlugin->getName()) {
             _keyboardMouseDevice = std::dynamic_pointer_cast<KeyboardMouseDevice>(inputPlugin);
         }
+        if (TouchscreenDevice::NAME == inputPlugin->getName()) {
+            _touchscreenDevice = std::dynamic_pointer_cast<TouchscreenDevice>(inputPlugin);
+        }
     }
     _window->setMenuBar(new Menu());
 
@@ -2096,6 +2103,9 @@ bool Application::event(QEvent* event) {
         case QEvent::TouchUpdate:
             touchUpdateEvent(static_cast<QTouchEvent*>(event));
             return true;
+        case QEvent::Gesture:
+            touchGestureEvent((QGestureEvent*)event);
+            return true;
         case QEvent::Wheel:
             wheelEvent(static_cast<QWheelEvent*>(event));
             return true;
@@ -2727,6 +2737,9 @@ void Application::touchUpdateEvent(QTouchEvent* event) {
     if (_keyboardMouseDevice->isActive()) {
         _keyboardMouseDevice->touchUpdateEvent(event);
     }
+    if (_touchscreenDevice->isActive()) {
+        _touchscreenDevice->touchUpdateEvent(event);
+    }
 }
 
 void Application::touchBeginEvent(QTouchEvent* event) {
@@ -2745,6 +2758,9 @@ void Application::touchBeginEvent(QTouchEvent* event) {
     if (_keyboardMouseDevice->isActive()) {
         _keyboardMouseDevice->touchBeginEvent(event);
     }
+    if (_touchscreenDevice->isActive()) {
+        _touchscreenDevice->touchBeginEvent(event);
+    }
 
 }
 
@@ -2762,10 +2778,19 @@ void Application::touchEndEvent(QTouchEvent* event) {
     if (_keyboardMouseDevice->isActive()) {
         _keyboardMouseDevice->touchEndEvent(event);
     }
+    if (_touchscreenDevice->isActive()) {
+        _touchscreenDevice->touchEndEvent(event);
+    }
 
     // put any application specific touch behavior below here..
 }
 
+void Application::touchGestureEvent(QGestureEvent* event) {
+    if (_touchscreenDevice->isActive()) {
+        _touchscreenDevice->touchGestureEvent(event);
+    }
+}
+
 void Application::wheelEvent(QWheelEvent* event) const {
     _altPressed = false;
     _controllerScriptingInterface->emitWheelEvent(event); // send events to any registered scripts

interface/src/Application.h

@@ -29,6 +29,7 @@
 #include <EntityEditPacketSender.h>
 #include <EntityTreeRenderer.h>
 #include <input-plugins/KeyboardMouseDevice.h>
+#include <input-plugins/TouchscreenDevice.h>
 #include <OctreeQuery.h>
 #include <PhysicalEntitySimulation.h>
 #include <PhysicsEngine.h>
@@ -403,6 +404,7 @@ private:
     void touchBeginEvent(QTouchEvent* event);
     void touchEndEvent(QTouchEvent* event);
     void touchUpdateEvent(QTouchEvent* event);
+    void touchGestureEvent(QGestureEvent* event);
 
     void wheelEvent(QWheelEvent* event) const;
     void dropEvent(QDropEvent* event);
@@ -455,6 +457,7 @@ private:
 
     std::shared_ptr<controller::StateController> _applicationStateDevice; // Default ApplicationDevice reflecting the state of different properties of the session
     std::shared_ptr<KeyboardMouseDevice> _keyboardMouseDevice;   // Default input device, the good old keyboard mouse and maybe touchpad
+    std::shared_ptr<TouchscreenDevice> _touchscreenDevice;   // the good old touchscreen
     SimpleMovingAverage _avatarSimsPerSecond {10};
     int _avatarSimsPerSecondReport {0};
     quint64 _lastAvatarSimsPerSecondUpdate {0};

interface/src/ui/overlays/ModelOverlay.cpp

@@ -43,7 +43,6 @@ ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
 void ModelOverlay::update(float deltatime) {
     if (_updateModel) {
         _updateModel = false;
-        
         _model->setSnapModelToCenter(true);
         _model->setScaleToFit(true, getDimensions());
         _model->setRotation(getRotation());
@@ -87,23 +86,15 @@ void ModelOverlay::render(RenderArgs* args) {
 void ModelOverlay::setProperties(const QVariantMap& properties) {
     auto position = getPosition();
     auto rotation = getRotation();
-    auto scale = getDimensions();
-    
+
     Volume3DOverlay::setProperties(properties);
-    
+
     if (position != getPosition() || rotation != getRotation()) {
         _updateModel = true;
     }
 
-    if (scale != getDimensions()) {
-        auto newScale = getDimensions();
-        if (newScale.x <= 0 || newScale.y <= 0 || newScale.z <= 0) {
-            setDimensions(scale);
-        } else {
-            _updateModel = true;
-        }
-    }
-    
+    _updateModel = true;
+
     auto urlValue = properties["url"];
     if (urlValue.isValid() && urlValue.canConvert<QString>()) {
         _url = urlValue.toString();

libraries/gl/src/gl/GLWidget.cpp

@@ -43,6 +43,7 @@ int GLWidget::getDeviceHeight() const {
 
 void GLWidget::initializeGL() {
     setAttribute(Qt::WA_AcceptTouchEvents);
+    grabGesture(Qt::PinchGesture);
     setAcceptDrops(true);
     // Note, we *DO NOT* want Qt to automatically swap buffers for us.  This results in the "ringing" bug mentioned in WL#19514 when we're throttling the framerate.
     setAutoBufferSwap(false);
@@ -81,6 +82,7 @@ bool GLWidget::event(QEvent* event) {
         case QEvent::TouchBegin:
         case QEvent::TouchEnd:
         case QEvent::TouchUpdate:
+        case QEvent::Gesture:
         case QEvent::Wheel:
         case QEvent::DragEnter:
         case QEvent::Drop:

libraries/input-plugins/src/input-plugins/InputPlugin.cpp

@@ -13,11 +13,13 @@
 #include <plugins/PluginManager.h>
 
 #include "KeyboardMouseDevice.h"
+#include "TouchscreenDevice.h"
 
 // TODO migrate to a DLL model where plugins are discovered and loaded at runtime by the PluginManager class
 InputPluginList getInputPlugins() {
     InputPlugin* PLUGIN_POOL[] = {
         new KeyboardMouseDevice(),
+        new TouchscreenDevice(),
         nullptr
     };
 

libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.cpp

@@ -19,6 +19,7 @@
 #include <NumericalConstants.h>
 
 const QString KeyboardMouseDevice::NAME = "Keyboard/Mouse";
+bool KeyboardMouseDevice::_enableTouch = true;
 
 void KeyboardMouseDevice::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
     auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
@@ -79,7 +80,7 @@ void KeyboardMouseDevice::mouseReleaseEvent(QMouseEvent* event) {
 
     // if we pressed and released at the same location within a small time window, then create a "_CLICKED" 
     // input for this button we might want to add some small tolerance to this so if you do a small drag it 
-    // till counts as a clicked.
+    // still counts as a click.
     static const int CLICK_TIME = USECS_PER_MSEC * 500; // 500 ms to click
     if (!_mouseMoved && (usecTimestampNow() - _mousePressTime < CLICK_TIME)) {
         _inputDevice->_buttonPressedMap.insert(_inputDevice->makeInput((Qt::MouseButton) event->button(), true).getChannel());
@@ -98,7 +99,7 @@ void KeyboardMouseDevice::mouseMoveEvent(QMouseEvent* event) {
 
     _inputDevice->_axisStateMap[MOUSE_AXIS_X_POS] = (currentMove.x() > 0 ? currentMove.x() : 0.0f);
     _inputDevice->_axisStateMap[MOUSE_AXIS_X_NEG] = (currentMove.x() < 0 ? -currentMove.x() : 0.0f);
-     // Y mouse is inverted positive is pointing up the screen
+    // Y mouse is inverted positive is pointing up the screen
     _inputDevice->_axisStateMap[MOUSE_AXIS_Y_POS] = (currentMove.y() < 0 ? -currentMove.y() : 0.0f);
     _inputDevice->_axisStateMap[MOUSE_AXIS_Y_NEG] = (currentMove.y() > 0 ? currentMove.y() : 0.0f);
 
@@ -132,34 +133,40 @@ glm::vec2 evalAverageTouchPoints(const QList<QTouchEvent::TouchPoint>& points) {
 }
 
 void KeyboardMouseDevice::touchBeginEvent(const QTouchEvent* event) {
-    _isTouching = event->touchPointStates().testFlag(Qt::TouchPointPressed);
-    _lastTouch = evalAverageTouchPoints(event->touchPoints());
-    _lastTouchTime = _clock.now();
+    if (_enableTouch) {
+        _isTouching = event->touchPointStates().testFlag(Qt::TouchPointPressed);
+        _lastTouch = evalAverageTouchPoints(event->touchPoints());
+        _lastTouchTime = _clock.now();
+    }
 }
 
 void KeyboardMouseDevice::touchEndEvent(const QTouchEvent* event) {
-    _isTouching = false;
-    _lastTouch = evalAverageTouchPoints(event->touchPoints());
-    _lastTouchTime = _clock.now();
+    if (_enableTouch) {
+        _isTouching = false;
+        _lastTouch = evalAverageTouchPoints(event->touchPoints());
+        _lastTouchTime = _clock.now();
+    }
 }
 
 void KeyboardMouseDevice::touchUpdateEvent(const QTouchEvent* event) {
-    auto currentPos = evalAverageTouchPoints(event->touchPoints());
-    _lastTouchTime = _clock.now();
-    
-    if (!_isTouching) {
-        _isTouching = event->touchPointStates().testFlag(Qt::TouchPointPressed);
-    } else {
-        auto currentMove = currentPos - _lastTouch;
-    
-        _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_POS).getChannel()] = (currentMove.x > 0 ? currentMove.x : 0.0f);
-        _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_NEG).getChannel()] = (currentMove.x < 0 ? -currentMove.x : 0.0f);
-        // Y mouse is inverted positive is pointing up the screen
-        _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_POS).getChannel()] = (currentMove.y < 0 ? -currentMove.y : 0.0f);
-        _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_NEG).getChannel()] = (currentMove.y > 0 ? currentMove.y : 0.0f);
-    }
+    if (_enableTouch) {
+        auto currentPos = evalAverageTouchPoints(event->touchPoints());
+        _lastTouchTime = _clock.now();
 
-    _lastTouch = currentPos;
+        if (!_isTouching) {
+            _isTouching = event->touchPointStates().testFlag(Qt::TouchPointPressed);
+        } else {
+            auto currentMove = currentPos - _lastTouch;
+
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_POS).getChannel()] = (currentMove.x > 0 ? currentMove.x : 0.0f);
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_NEG).getChannel()] = (currentMove.x < 0 ? -currentMove.x : 0.0f);
+            // Y mouse is inverted positive is pointing up the screen
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_POS).getChannel()] = (currentMove.y < 0 ? -currentMove.y : 0.0f);
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_NEG).getChannel()] = (currentMove.y > 0 ? currentMove.y : 0.0f);
+        }
+
+        _lastTouch = currentPos;
+    }
 }
 
 controller::Input KeyboardMouseDevice::InputDevice::makeInput(Qt::Key code) const {
@@ -247,4 +254,3 @@ QString KeyboardMouseDevice::InputDevice::getDefaultMappingConfig() const {
     static const QString MAPPING_JSON = PathUtils::resourcesPath() + "/controllers/keyboardMouse.json";
     return MAPPING_JSON;
 }
-

libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.h

@@ -84,6 +84,8 @@ public:
     void touchUpdateEvent(const QTouchEvent* event);
 
     void wheelEvent(QWheelEvent* event);
+
+    static void enableTouch(bool enableTouch) { _enableTouch = enableTouch; }
     
     static const QString NAME;
 
@@ -122,6 +124,8 @@ protected:
     bool _isTouching = false;
     std::chrono::high_resolution_clock _clock;
     std::chrono::high_resolution_clock::time_point _lastTouchTime;
+
+    static bool _enableTouch;
 };
 
 #endif // hifi_KeyboardMouseDevice_h

libraries/input-plugins/src/input-plugins/TouchscreenDevice.cpp

@@ -0,0 +1,132 @@
+//
+//  TouchscreenDevice.cpp
+//  input-plugins/src/input-plugins
+//
+//  Created by Triplelexx on 01/31/16.
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#include "TouchscreenDevice.h"
+#include "KeyboardMouseDevice.h"
+
+#include <QtGui/QTouchEvent>
+#include <QGestureEvent>
+#include <QGuiApplication>
+#include <QWindow>
+#include <QScreen>
+
+#include <controllers/UserInputMapper.h>
+#include <PathUtils.h>
+#include <NumericalConstants.h>
+
+const QString TouchscreenDevice::NAME = "Touchscreen";
+
+bool TouchscreenDevice::isSupported() const {
+    for (auto touchDevice : QTouchDevice::devices()) {
+        if (touchDevice->type() == QTouchDevice::TouchScreen) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void TouchscreenDevice::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
+    auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
+    userInputMapper->withLock([&, this]() {
+        _inputDevice->update(deltaTime, inputCalibrationData);
+    });
+
+    float distanceScaleX, distanceScaleY;
+    if (_touchPointCount == 1) {
+        if (_firstTouchVec.x < _currentTouchVec.x) {
+            distanceScaleX = (_currentTouchVec.x - _firstTouchVec.x) / _screenDPIScale.x;
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_POS).getChannel()] = distanceScaleX;
+        } else if (_firstTouchVec.x > _currentTouchVec.x) {
+            distanceScaleX = (_firstTouchVec.x - _currentTouchVec.x) / _screenDPIScale.x;
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_X_NEG).getChannel()] = distanceScaleX;
+        }
+        // Y axis is inverted, positive is pointing up the screen
+        if (_firstTouchVec.y > _currentTouchVec.y) {
+            distanceScaleY = (_firstTouchVec.y - _currentTouchVec.y) / _screenDPIScale.y;
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_POS).getChannel()] = distanceScaleY;
+        } else if (_firstTouchVec.y < _currentTouchVec.y) {
+            distanceScaleY = (_currentTouchVec.y - _firstTouchVec.y) / _screenDPIScale.y;
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_AXIS_Y_NEG).getChannel()] = distanceScaleY;
+        }
+    } else  if (_touchPointCount == 2) {
+        if (_pinchScale > _lastPinchScale && _pinchScale != 0) {
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_GESTURE_PINCH_POS).getChannel()] = 1.0f;
+        } else if (_pinchScale != 0) {
+            _inputDevice->_axisStateMap[_inputDevice->makeInput(TOUCH_GESTURE_PINCH_NEG).getChannel()] = 1.0f;
+        }
+        _lastPinchScale = _pinchScale;
+    }
+}
+
+void TouchscreenDevice::InputDevice::update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
+    _axisStateMap.clear();
+}
+
+void TouchscreenDevice::InputDevice::focusOutEvent() {
+}
+
+void TouchscreenDevice::touchBeginEvent(const QTouchEvent* event) {
+    const QTouchEvent::TouchPoint& point = event->touchPoints().at(0);
+    _firstTouchVec = glm::vec2(point.pos().x(), point.pos().y());
+    KeyboardMouseDevice::enableTouch(false);
+    QScreen* eventScreen = event->window()->screen();
+    if (_screenDPI != eventScreen->physicalDotsPerInch()) {
+        _screenDPIScale.x = (float)eventScreen->physicalDotsPerInchX();
+        _screenDPIScale.y = (float)eventScreen->physicalDotsPerInchY();
+        _screenDPI = eventScreen->physicalDotsPerInch();
+    }
+}
+
+void TouchscreenDevice::touchEndEvent(const QTouchEvent* event) {
+    _touchPointCount = 0;
+    KeyboardMouseDevice::enableTouch(true);
+}
+
+void TouchscreenDevice::touchUpdateEvent(const QTouchEvent* event) {
+    const QTouchEvent::TouchPoint& point = event->touchPoints().at(0);
+    _currentTouchVec = glm::vec2(point.pos().x(), point.pos().y());
+    _touchPointCount = event->touchPoints().count();
+}
+
+void TouchscreenDevice::touchGestureEvent(const QGestureEvent* event) {
+    if (QGesture* gesture = event->gesture(Qt::PinchGesture)) {
+        QPinchGesture* pinch = static_cast<QPinchGesture*>(gesture);
+        _pinchScale = pinch->totalScaleFactor();
+    }
+}
+
+controller::Input TouchscreenDevice::InputDevice::makeInput(TouchscreenDevice::TouchAxisChannel axis) const {
+    return controller::Input(_deviceID, axis, controller::ChannelType::AXIS);
+}
+
+controller::Input TouchscreenDevice::InputDevice::makeInput(TouchscreenDevice::TouchGestureAxisChannel gesture) const {
+    return controller::Input(_deviceID, gesture, controller::ChannelType::AXIS);
+}
+
+controller::Input::NamedVector TouchscreenDevice::InputDevice::getAvailableInputs() const {
+    using namespace controller;
+    static QVector<Input::NamedPair> availableInputs;
+    static std::once_flag once;
+    std::call_once(once, [&] {
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_AXIS_X_POS), "DragRight"));
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_AXIS_X_NEG), "DragLeft"));
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_AXIS_Y_POS), "DragUp"));
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_AXIS_Y_NEG), "DragDown"));
+
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_GESTURE_PINCH_POS), "GesturePinchOut"));
+        availableInputs.append(Input::NamedPair(makeInput(TOUCH_GESTURE_PINCH_NEG), "GesturePinchIn"));
+    });
+    return availableInputs;
+}
+
+QString TouchscreenDevice::InputDevice::getDefaultMappingConfig() const {
+    static const QString MAPPING_JSON = PathUtils::resourcesPath() + "/controllers/touchscreen.json";
+    return MAPPING_JSON;
+}

libraries/input-plugins/src/input-plugins/TouchscreenDevice.h

@@ -0,0 +1,84 @@
+//
+//  TouchscreenDevice.h
+//  input-plugins/src/input-plugins
+//
+//  Created by Triplelexx on 1/31/16.
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_TouchscreenDevice_h
+#define hifi_TouchscreenDevice_h
+
+#include <controllers/InputDevice.h>
+#include "InputPlugin.h"
+#include <QtGui/qtouchdevice.h>
+
+class QTouchEvent;
+class QGestureEvent;
+
+class TouchscreenDevice : public InputPlugin {
+    Q_OBJECT
+public:
+        
+    enum TouchAxisChannel {
+        TOUCH_AXIS_X_POS = 0,
+        TOUCH_AXIS_X_NEG,
+        TOUCH_AXIS_Y_POS,
+        TOUCH_AXIS_Y_NEG,
+    };
+
+	enum TouchGestureAxisChannel {
+        TOUCH_GESTURE_PINCH_POS = TOUCH_AXIS_Y_NEG + 1,
+        TOUCH_GESTURE_PINCH_NEG,
+    };
+
+    // Plugin functions
+    virtual bool isSupported() const override;
+    virtual const QString& getName() const override { return NAME; }
+
+    virtual void pluginFocusOutEvent() override { _inputDevice->focusOutEvent(); }
+    virtual void pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;
+
+    void touchBeginEvent(const QTouchEvent* event);
+    void touchEndEvent(const QTouchEvent* event);
+    void touchUpdateEvent(const QTouchEvent* event);
+    void touchGestureEvent(const QGestureEvent* event);
+    
+    static const QString NAME;
+
+protected:
+
+    class InputDevice : public controller::InputDevice {
+    public:
+        InputDevice() : controller::InputDevice("Touchscreen") {}
+    private:
+        // Device functions
+        virtual controller::Input::NamedVector getAvailableInputs() const override;
+        virtual QString getDefaultMappingConfig() const override;
+        virtual void update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;
+        virtual void focusOutEvent() override;
+
+        controller::Input makeInput(TouchAxisChannel axis) const;
+        controller::Input makeInput(TouchGestureAxisChannel gesture) const;
+
+        friend class TouchscreenDevice;
+    };
+
+public:
+    const std::shared_ptr<InputDevice>& getInputDevice() const { return _inputDevice; }
+
+protected:
+    qreal _lastPinchScale;
+    qreal _pinchScale;
+    qreal _screenDPI;
+    glm::vec2 _screenDPIScale;
+    glm::vec2 _firstTouchVec;
+    glm::vec2 _currentTouchVec;
+    int _touchPointCount;
+    std::shared_ptr<InputDevice> _inputDevice { std::make_shared<InputDevice>() };
+};
+
+#endif // hifi_TouchscreenDevice_h

libraries/model/src/model/skybox.slv

@@ -36,4 +36,4 @@ void main(void) {
     
     // Position is supposed to come in clip space
     gl_Position = vec4(inPosition.xy, 0.0, 1.0);
-}
+}

libraries/networking/src/LimitedNodeList.cpp

@@ -526,6 +526,7 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
                                                    const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
                                                    const NodePermissions& permissions,
                                                    const QUuid& connectionSecret) {
+    QReadLocker readLocker(&_nodeMutex);
     NodeHash::const_iterator it = _nodeHash.find(uuid);
 
     if (it != _nodeHash.end()) {

libraries/networking/src/LimitedNodeList.h

@@ -131,7 +131,7 @@ public:
 
     std::function<void(Node*)> linkedDataCreateCallback;
 
-    size_t size() const { return _nodeHash.size(); }
+    size_t size() const { QReadLocker readLock(&_nodeMutex); return _nodeHash.size(); }
 
     SharedNodePointer nodeWithUUID(const QUuid& nodeUUID);
 
@@ -287,7 +287,7 @@ protected:
 
     QUuid _sessionUUID;
     NodeHash _nodeHash;
-    QReadWriteLock _nodeMutex;
+    mutable QReadWriteLock _nodeMutex;
     udt::Socket _nodeSocket;
     QUdpSocket* _dtlsSocket;
     HifiSockAddr _localSockAddr;

libraries/networking/src/NodeList.cpp

@@ -513,6 +513,7 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedM
 
 void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message) {
     if (_domainHandler.getSockAddr().isNull()) {
+        qWarning() << "IGNORING DomainList packet while not connected to a Domain Server";
         // refuse to process this packet if we aren't currently connected to the DS
         return;
     }
@@ -535,6 +536,10 @@ void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message)
     if (!_domainHandler.isConnected()) {
         _domainHandler.setUUID(domainUUID);
         _domainHandler.setIsConnected(true);
+    } else if (_domainHandler.getUUID() != domainUUID) {
+        // Recieved packet from different domain.
+        qWarning() << "IGNORING DomainList packet from" << domainUUID << "while connected to" << _domainHandler.getUUID();
+        return;
     }
 
     // pull our owner UUID from the packet, it's always the first thing

scripts/defaultScripts.js

@@ -23,5 +23,6 @@ Script.load("system/controllers/handControllerGrab.js");
 Script.load("system/controllers/handControllerPointer.js");
 Script.load("system/controllers/squeezeHands.js");
 Script.load("system/controllers/grab.js");
+Script.load("system/controllers/teleport.js");
 Script.load("system/dialTone.js");
 Script.load("system/firstPersonHMD.js");

scripts/developer/utilities/tools/overlayFinder.js

@@ -0,0 +1,17 @@
+function mousePressEvent(event) {
+    var overlay = Overlays.getOverlayAtPoint({
+        x: event.x,
+        y: event.y
+    });
+    // var pickRay = Camera.computePickRay(event.x, event.y);
+    // var intersection =  Overlays.findRayIntersection(pickRay);
+    // print('intersection is: ' + intersection)
+};
+
+Controller.mousePressEvent.connect(function(event) {
+    mousePressEvent(event)
+});
+
+Script.scriptEnding.connect(function() {
+    Controller.mousePressEvent.disconnect(mousePressEvent);
+})

scripts/system/controllers/teleport.js

@@ -0,0 +1,619 @@
+// Created by james b. pollack @imgntn on 7/2/2016
+// Copyright 2016 High Fidelity, Inc.
+//
+//  Creates a beam and target and then teleports you there when you let go of either activation button.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+
+var inTeleportMode = false;
+
+var currentFadeSphereOpacity = 1;
+var fadeSphereInterval = null;
+var fadeSphereUpdateInterval = null;
+//milliseconds between fading one-tenth -- so this is a half second fade total
+var USE_FADE_MODE = false;
+var USE_FADE_OUT = true;
+var FADE_OUT_INTERVAL = 25;
+
+// instant
+// var NUMBER_OF_STEPS = 0;
+// var SMOOTH_ARRIVAL_SPACING = 0;
+
+// // slow
+// var SMOOTH_ARRIVAL_SPACING = 150;
+// var NUMBER_OF_STEPS = 2;
+
+// medium-slow
+// var SMOOTH_ARRIVAL_SPACING = 100;
+// var NUMBER_OF_STEPS = 4;
+
+// medium-fast
+var SMOOTH_ARRIVAL_SPACING = 33;
+var NUMBER_OF_STEPS = 6;
+
+//fast
+// var SMOOTH_ARRIVAL_SPACING = 10;
+// var NUMBER_OF_STEPS = 20;
+
+
+var TARGET_MODEL_URL = Script.resolvePath("../assets/models/teleport.fbx");
+var TARGET_MODEL_DIMENSIONS = {
+    x: 1.15,
+    y: 0.5,
+    z: 1.15
+
+};
+
+function ThumbPad(hand) {
+    this.hand = hand;
+    var _thisPad = this;
+
+    this.buttonPress = function(value) {
+        _thisPad.buttonValue = value;
+    };
+
+}
+
+function Trigger(hand) {
+    this.hand = hand;
+    var _this = this;
+
+    this.buttonPress = function(value) {
+        _this.buttonValue = value;
+
+    };
+
+    this.down = function() {
+        var down = _this.buttonValue === 1 ? 1.0 : 0.0;
+        return down
+    };
+}
+
+function Teleporter() {
+    var _this = this;
+    this.intersection = null;
+    this.rightOverlayLine = null;
+    this.leftOverlayLine = null;
+    this.targetOverlay = null;
+    this.updateConnected = null;
+    this.smoothArrivalInterval = null;
+    this.fadeSphere = null;
+    this.teleportHand = null;
+
+    this.initialize = function() {
+        this.createMappings();
+        this.disableGrab();
+    };
+
+    this.createTargetOverlay = function() {
+
+        var targetOverlayProps = {
+            url: TARGET_MODEL_URL,
+            dimensions: TARGET_MODEL_DIMENSIONS,
+            visible: true,
+        };
+
+        _this.targetOverlay = Overlays.addOverlay("model", targetOverlayProps);
+    };
+
+    this.createMappings = function() {
+        teleporter.telporterMappingInternalName = 'Hifi-Teleporter-Internal-Dev-' + Math.random();
+        teleporter.teleportMappingInternal = Controller.newMapping(teleporter.telporterMappingInternalName);
+
+        Controller.enableMapping(teleporter.telporterMappingInternalName);
+    };
+
+    this.disableMappings = function() {
+        Controller.disableMapping(teleporter.telporterMappingInternalName);
+    };
+
+    this.enterTeleportMode = function(hand) {
+        if (inTeleportMode === true) {
+            return;
+        }
+        inTeleportMode = true;
+        if (this.smoothArrivalInterval !== null) {
+            Script.clearInterval(this.smoothArrivalInterval);
+        }
+        if (fadeSphereInterval !== null) {
+            Script.clearInterval(fadeSphereInterval);
+        }
+        this.teleportHand = hand;
+        this.initialize();
+        Script.update.connect(this.update);
+        this.updateConnected = true;
+    };
+
+    this.createFadeSphere = function(avatarHead) {
+        var sphereProps = {
+            position: avatarHead,
+            size: -1,
+            color: {
+                red: 0,
+                green: 0,
+                blue: 0,
+            },
+            alpha: 1,
+            solid: true,
+            visible: true,
+            ignoreRayIntersection: true,
+            drawInFront: false
+        };
+
+        currentFadeSphereOpacity = 10;
+
+        _this.fadeSphere = Overlays.addOverlay("sphere", sphereProps);
+        Script.clearInterval(fadeSphereInterval)
+        Script.update.connect(_this.updateFadeSphere);
+        if (USE_FADE_OUT === true) {
+            this.fadeSphereOut();
+        }
+
+
+    };
+
+    this.fadeSphereOut = function() {
+
+        fadeSphereInterval = Script.setInterval(function() {
+            if (currentFadeSphereOpacity <= 0) {
+                Script.clearInterval(fadeSphereInterval);
+                _this.deleteFadeSphere();
+                fadeSphereInterval = null;
+                return;
+            }
+            if (currentFadeSphereOpacity > 0) {
+                currentFadeSphereOpacity = currentFadeSphereOpacity - 1;
+            }
+
+            Overlays.editOverlay(_this.fadeSphere, {
+                alpha: currentFadeSphereOpacity / 10
+            })
+
+        }, FADE_OUT_INTERVAL);
+    };
+
+
+    this.updateFadeSphere = function() {
+        var headPosition = MyAvatar.getHeadPosition();
+        Overlays.editOverlay(_this.fadeSphere, {
+            position: headPosition
+        })
+    };
+
+    this.deleteFadeSphere = function() {
+        if (_this.fadeSphere !== null) {
+            Script.update.disconnect(_this.updateFadeSphere);
+            Overlays.deleteOverlay(_this.fadeSphere);
+            _this.fadeSphere = null;
+        }
+
+    };
+
+    this.deleteTargetOverlay = function() {
+        Overlays.deleteOverlay(this.targetOverlay);
+        this.intersection = null;
+        this.targetOverlay = null;
+    }
+
+    this.turnOffOverlayBeams = function() {
+        this.rightOverlayOff();
+        this.leftOverlayOff();
+    }
+
+    this.exitTeleportMode = function(value) {
+        if (this.updateConnected === true) {
+            Script.update.disconnect(this.update);
+        }
+        this.disableMappings();
+        this.turnOffOverlayBeams();
+
+
+        this.updateConnected = null;
+
+        Script.setTimeout(function() {
+            inTeleportMode = false;
+            _this.enableGrab();
+        }, 100);
+    };
+
+
+
+    this.update = function() {
+
+        if (teleporter.teleportHand === 'left') {
+            teleporter.leftRay();
+
+            if ((leftPad.buttonValue === 0 || leftTrigger.buttonValue === 0) && inTeleportMode === true) {
+                _this.teleport();
+                return;
+            }
+
+        } else {
+            teleporter.rightRay();
+
+            if ((rightPad.buttonValue === 0 || rightTrigger.buttonValue === 0) && inTeleportMode === true) {
+                _this.teleport();
+                return;
+            }
+        }
+
+    };
+
+    this.rightRay = function() {
+
+
+        var rightPosition = Vec3.sum(Vec3.multiplyQbyV(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.RightHand).translation), MyAvatar.position);
+
+        var rightControllerRotation = Controller.getPoseValue(Controller.Standard.RightHand).rotation;
+
+        var rightRotation = Quat.multiply(MyAvatar.orientation, rightControllerRotation)
+
+
+        var rightFinal = Quat.multiply(rightRotation, Quat.angleAxis(90, {
+            x: 1,
+            y: 0,
+            z: 0
+        }));
+
+        var rightPickRay = {
+            origin: rightPosition,
+            direction: Quat.getUp(rightRotation),
+        };
+
+        this.rightPickRay = rightPickRay;
+
+        var location = Vec3.sum(rightPickRay.origin, Vec3.multiply(rightPickRay.direction, 500));
+
+
+        var rightIntersection = Entities.findRayIntersection(teleporter.rightPickRay, true, [], [this.targetEntity]);
+
+        if (rightIntersection.intersects) {
+            this.rightLineOn(rightPickRay.origin, rightIntersection.intersection, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+            if (this.targetOverlay !== null) {
+                this.updateTargetOverlay(rightIntersection);
+            } else {
+                this.createTargetOverlay();
+            }
+
+        } else {
+
+            this.deleteTargetOverlay();
+            this.rightLineOn(rightPickRay.origin, location, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+        }
+    }
+
+
+    this.leftRay = function() {
+        var leftPosition = Vec3.sum(Vec3.multiplyQbyV(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.LeftHand).translation), MyAvatar.position);
+
+        var leftRotation = Quat.multiply(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.LeftHand).rotation)
+
+
+        var leftFinal = Quat.multiply(leftRotation, Quat.angleAxis(90, {
+            x: 1,
+            y: 0,
+            z: 0
+        }));
+
+
+        var leftPickRay = {
+            origin: leftPosition,
+            direction: Quat.getUp(leftRotation),
+        };
+
+        this.leftPickRay = leftPickRay;
+
+        var location = Vec3.sum(MyAvatar.position, Vec3.multiply(leftPickRay.direction, 500));
+
+
+        var leftIntersection = Entities.findRayIntersection(teleporter.leftPickRay, true, [], [this.targetEntity]);
+
+        if (leftIntersection.intersects) {
+
+            this.leftLineOn(leftPickRay.origin, leftIntersection.intersection, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+            if (this.targetOverlay !== null) {
+                this.updateTargetOverlay(leftIntersection);
+            } else {
+                this.createTargetOverlay();
+            }
+
+
+        } else {
+
+
+            this.deleteTargetOverlay();
+            this.leftLineOn(leftPickRay.origin, location, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+        }
+    };
+
+    this.rightLineOn = function(closePoint, farPoint, color) {
+        if (this.rightOverlayLine === null) {
+            var lineProperties = {
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                ignoreRayIntersection: true, // always ignore this
+                visible: true,
+                alpha: 1,
+                solid: true,
+                drawInFront: true,
+                glow: 1.0
+            };
+
+            this.rightOverlayLine = Overlays.addOverlay("line3d", lineProperties);
+
+        } else {
+            var success = Overlays.editOverlay(this.rightOverlayLine, {
+                lineWidth: 50,
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                ignoreRayIntersection: true, // always ignore this
+                alpha: 1,
+                glow: 1.0
+            });
+        }
+    };
+
+    this.leftLineOn = function(closePoint, farPoint, color) {
+        if (this.leftOverlayLine === null) {
+            var lineProperties = {
+                ignoreRayIntersection: true, // always ignore this
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                alpha: 1,
+                solid: true,
+                glow: 1.0,
+                drawInFront: true
+            };
+
+            this.leftOverlayLine = Overlays.addOverlay("line3d", lineProperties);
+
+        } else {
+            var success = Overlays.editOverlay(this.leftOverlayLine, {
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                alpha: 1,
+                solid: true,
+                glow: 1.0
+            });
+        }
+    };
+    this.rightOverlayOff = function() {
+        if (this.rightOverlayLine !== null) {
+            Overlays.deleteOverlay(this.rightOverlayLine);
+            this.rightOverlayLine = null;
+        }
+    };
+
+    this.leftOverlayOff = function() {
+        if (this.leftOverlayLine !== null) {
+            Overlays.deleteOverlay(this.leftOverlayLine);
+            this.leftOverlayLine = null;
+        }
+    };
+
+    this.updateTargetOverlay = function(intersection) {
+        _this.intersection = intersection;
+
+        var rotation = Quat.lookAt(intersection.intersection, MyAvatar.position, Vec3.UP)
+        var euler = Quat.safeEulerAngles(rotation)
+        var position = {
+            x: intersection.intersection.x,
+            y: intersection.intersection.y + TARGET_MODEL_DIMENSIONS.y / 2,
+            z: intersection.intersection.z
+        }
+        Overlays.editOverlay(this.targetOverlay, {
+            position: position,
+            rotation: Quat.fromPitchYawRollDegrees(0, euler.y, 0),
+        });
+
+    };
+
+    this.disableGrab = function() {
+        Messages.sendLocalMessage('Hifi-Hand-Disabler', this.teleportHand);
+    };
+
+    this.enableGrab = function() {
+        Messages.sendLocalMessage('Hifi-Hand-Disabler', 'none');
+    };
+
+    this.triggerHaptics = function() {
+        var hand = this.teleportHand === 'left' ? 0 : 1;
+        var haptic = Controller.triggerShortHapticPulse(0.2, hand);
+    };
+
+    this.teleport = function(value) {
+        if (value === undefined) {
+            this.exitTeleportMode();
+        }
+        if (this.intersection !== null) {
+            if (USE_FADE_MODE === true) {
+                this.createFadeSphere();
+            }
+            var offset = getAvatarFootOffset();
+            this.intersection.intersection.y += offset;
+            this.exitTeleportMode();
+            this.smoothArrival();
+
+        }
+
+    };
+
+
+    this.findMidpoint = function(start, end) {
+        var xy = Vec3.sum(start, end);
+        var midpoint = Vec3.multiply(0.5, xy);
+        return midpoint
+    };
+
+
+
+    this.getArrivalPoints = function(startPoint, endPoint) {
+        var arrivalPoints = [];
+
+
+        var i;
+        var lastPoint;
+
+        for (i = 0; i < NUMBER_OF_STEPS; i++) {
+            if (i === 0) {
+                lastPoint = startPoint;
+            }
+            var newPoint = _this.findMidpoint(lastPoint, endPoint);
+            lastPoint = newPoint;
+            arrivalPoints.push(newPoint);
+        }
+
+        arrivalPoints.push(endPoint)
+
+        return arrivalPoints
+    };
+
+    this.smoothArrival = function() {
+
+        _this.arrivalPoints = _this.getArrivalPoints(MyAvatar.position, _this.intersection.intersection);
+        _this.smoothArrivalInterval = Script.setInterval(function() {
+            if (_this.arrivalPoints.length === 0) {
+                Script.clearInterval(_this.smoothArrivalInterval);
+                return;
+            }
+
+            var landingPoint = _this.arrivalPoints.shift();
+            MyAvatar.position = landingPoint;
+
+            if (_this.arrivalPoints.length === 1 || _this.arrivalPoints.length === 0) {
+                _this.deleteTargetOverlay();
+            }
+
+
+        }, SMOOTH_ARRIVAL_SPACING)
+    }
+}
+
+
+//related to repositioning the avatar after you teleport
+function getAvatarFootOffset() {
+    var data = getJointData();
+    var upperLeg, lowerLeg, foot, toe, toeTop;
+    data.forEach(function(d) {
+
+        var jointName = d.joint;
+        if (jointName === "RightUpLeg") {
+            upperLeg = d.translation.y;
+        }
+        if (jointName === "RightLeg") {
+            lowerLeg = d.translation.y;
+        }
+        if (jointName === "RightFoot") {
+            foot = d.translation.y;
+        }
+        if (jointName === "RightToeBase") {
+            toe = d.translation.y;
+        }
+        if (jointName === "RightToe_End") {
+            toeTop = d.translation.y
+        }
+    })
+
+    var myPosition = MyAvatar.position;
+    var offset = upperLeg + lowerLeg + foot + toe + toeTop;
+    offset = offset / 100;
+    return offset
+};
+
+function getJointData() {
+    var allJointData = [];
+    var jointNames = MyAvatar.jointNames;
+    jointNames.forEach(function(joint, index) {
+        var translation = MyAvatar.getJointTranslation(index);
+        var rotation = MyAvatar.getJointRotation(index)
+        allJointData.push({
+            joint: joint,
+            index: index,
+            translation: translation,
+            rotation: rotation
+        });
+    });
+
+    return allJointData;
+};
+
+var leftPad = new ThumbPad('left');
+var rightPad = new ThumbPad('right');
+var leftTrigger = new Trigger('left');
+var rightTrigger = new Trigger('right');
+
+var mappingName, teleportMapping;
+
+var TELEPORT_DELAY = 100;
+
+
+function registerMappings() {
+    mappingName = 'Hifi-Teleporter-Dev-' + Math.random();
+    teleportMapping = Controller.newMapping(mappingName);
+    teleportMapping.from(Controller.Standard.RT).peek().to(rightTrigger.buttonPress);
+    teleportMapping.from(Controller.Standard.LT).peek().to(leftTrigger.buttonPress);
+
+    teleportMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(rightPad.buttonPress);
+    teleportMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(leftPad.buttonPress);
+
+    teleportMapping.from(Controller.Standard.LeftPrimaryThumb).when(leftTrigger.down).to(function(value) {
+        teleporter.enterTeleportMode('left')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.RightPrimaryThumb).when(rightTrigger.down).to(function(value) {
+        teleporter.enterTeleportMode('right')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.RT).when(Controller.Standard.RightPrimaryThumb).to(function(value) {
+        teleporter.enterTeleportMode('right')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.LT).when(Controller.Standard.LeftPrimaryThumb).to(function(value) {
+        teleporter.enterTeleportMode('left')
+        return;
+    });
+
+}
+
+registerMappings();
+
+var teleporter = new Teleporter();
+
+Controller.enableMapping(mappingName);
+
+Script.scriptEnding.connect(cleanup);
+
+function cleanup() {
+    teleportMapping.disable();
+    teleporter.disableMappings();
+    teleporter.deleteTargetOverlay();
+    teleporter.turnOffOverlayBeams();
+    teleporter.deleteFadeSphere();
+    if (teleporter.updateConnected !== null) {
+        Script.update.disconnect(teleporter.update);
+    }
+}

tests/controllers/src/main.cpp

@@ -38,6 +38,7 @@
 #include <plugins/PluginManager.h>
 #include <input-plugins/InputPlugin.h>
 #include <input-plugins/KeyboardMouseDevice.h>
+#include <input-plugins/TouchscreenDevice.h>
 #include <controllers/ScriptingInterface.h>
 
 #include <DependencyManager.h>
@@ -91,7 +92,7 @@ public:
     virtual QOpenGLContext* getPrimaryContext() override { return nullptr; }
     virtual ui::Menu* getPrimaryMenu() override { return nullptr; }
     virtual bool isForeground() const override { return true; }
-    virtual DisplayPluginPointer getActiveDisplayPlugin() const override { return DisplayPluginPointer();  }
+    virtual DisplayPluginPointer getActiveDisplayPlugin() const override { return DisplayPluginPointer(); }
 };
 
 class MyControllerScriptingInterface : public controller::ScriptingInterface {
@@ -144,6 +145,9 @@ int main(int argc, char** argv) {
             if (name == KeyboardMouseDevice::NAME) {
                 userInputMapper->registerDevice(std::dynamic_pointer_cast<KeyboardMouseDevice>(inputPlugin)->getInputDevice());
             }
+            if (name == TouchscreenDevice::NAME) {
+                userInputMapper->registerDevice(std::dynamic_pointer_cast<TouchscreenDevice>(inputPlugin)->getInputDevice());
+            }
             inputPlugin->pluginUpdate(0, calibrationData);
         }
         rootContext->setContextProperty("Controllers", new MyControllerScriptingInterface());