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

interface/src/Application.cpp

@@ -8484,6 +8484,16 @@ QUuid Application::getTabletFrameID() const {
     return HMD->getCurrentTabletFrameID();
 }
 
+QVector<QUuid> Application::getTabletIDs() const {
+    // Most important overlays first. 
+    QVector<QUuid> result;
+    auto HMD = DependencyManager::get<HMDScriptingInterface>();
+    result << HMD->getCurrentTabletScreenID();
+    result << HMD->getCurrentHomeButtonID();
+    result << HMD->getCurrentTabletFrameID();
+    return result;
+}
+
 void Application::setAvatarOverrideUrl(const QUrl& url, bool save) {
     _avatarOverrideUrl = url;
     _saveAvatarOverrideUrl = save;

interface/src/Application.h

@@ -298,6 +298,7 @@ public:
     OverlayID getTabletScreenID() const;
     OverlayID getTabletHomeButtonID() const;
     QUuid getTabletFrameID() const; // may be an entity or an overlay
+    QVector<QUuid> getTabletIDs() const; // In order of most important IDs first.
 
     void setAvatarOverrideUrl(const QUrl& url, bool save);
     void clearAvatarOverrideUrl() { _avatarOverrideUrl = QUrl(); _saveAvatarOverrideUrl = false; }

interface/src/ui/overlays/Overlays.cpp

@@ -532,6 +532,8 @@ RayToOverlayIntersectionResult Overlays::findRayIntersectionVector(const PickRay
                                                                    bool visibleOnly, bool collidableOnly) {
     float bestDistance = std::numeric_limits<float>::max();
     bool bestIsFront = false;
+    bool bestIsTablet = false;
+    auto tabletIDs = qApp->getTabletIDs();
 
     QMutexLocker locker(&_mutex);
     RayToOverlayIntersectionResult result;
@@ -554,10 +556,11 @@ RayToOverlayIntersectionResult Overlays::findRayIntersectionVector(const PickRay
             if (thisOverlay->findRayIntersectionExtraInfo(ray.origin, ray.direction, thisDistance,
                                                           thisFace, thisSurfaceNormal, thisExtraInfo, precisionPicking)) {
                 bool isDrawInFront = thisOverlay->getDrawInFront();
-                if ((bestIsFront && isDrawInFront && thisDistance < bestDistance)
+                bool isTablet = tabletIDs.contains(thisID);
-                    || (!bestIsFront && (isDrawInFront || thisDistance < bestDistance))) {
+                if ((isDrawInFront && !bestIsFront && !bestIsTablet)
-
+                        || ((isTablet || isDrawInFront || !bestIsFront) && thisDistance < bestDistance)) {
                     bestIsFront = isDrawInFront;
+                    bestIsTablet = isTablet;
                     bestDistance = thisDistance;
                     result.intersects = true;
                     result.distance = thisDistance;
@@ -828,40 +831,12 @@ PointerEvent Overlays::calculateOverlayPointerEvent(OverlayID overlayID, PickRay
 }
 
 
-RayToOverlayIntersectionResult Overlays::findRayIntersectionForMouseEvent(PickRay ray) {
-    QVector<OverlayID> overlaysToInclude;
-    QVector<OverlayID> overlaysToDiscard;
-    RayToOverlayIntersectionResult rayPickResult;
-
-    // first priority is tablet screen
-    overlaysToInclude << qApp->getTabletScreenID();
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then tablet home button
-    overlaysToInclude.clear();
-    overlaysToInclude << qApp->getTabletHomeButtonID();
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then tablet frame
-    overlaysToInclude.clear();
-    overlaysToInclude << OverlayID(qApp->getTabletFrameID());
-    rayPickResult = findRayIntersectionVector(ray, true, overlaysToInclude, overlaysToDiscard);
-    if (rayPickResult.intersects) {
-        return rayPickResult;
-    }
-    // then whatever
-    return findRayIntersection(ray);
-}
-
 bool Overlays::mousePressEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mousePressEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         _currentClickingOnOverlayID = rayPickResult.overlayID;
 
@@ -901,7 +876,8 @@ bool Overlays::mouseDoublePressEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseDoublePressEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         _currentClickingOnOverlayID = rayPickResult.overlayID;
 
@@ -964,7 +940,8 @@ bool Overlays::mouseReleaseEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseReleaseEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         auto pointerEvent = calculateOverlayPointerEvent(rayPickResult.overlayID, ray, rayPickResult, event, PointerEvent::Release);
         mouseReleasePointerEvent(rayPickResult.overlayID, pointerEvent);
@@ -993,7 +970,8 @@ bool Overlays::mouseMoveEvent(QMouseEvent* event) {
     PerformanceTimer perfTimer("Overlays::mouseMoveEvent");
 
     PickRay ray = qApp->computePickRay(event->x(), event->y());
-    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionForMouseEvent(ray);
+    RayToOverlayIntersectionResult rayPickResult = findRayIntersectionVector(ray, true, QVector<OverlayID>(),
+        QVector<OverlayID>());
     if (rayPickResult.intersects) {
         auto pointerEvent = calculateOverlayPointerEvent(rayPickResult.overlayID, ray, rayPickResult, event, PointerEvent::Move);
         mouseMovePointerEvent(rayPickResult.overlayID, pointerEvent);

interface/src/ui/overlays/Overlays.h

@@ -44,8 +44,7 @@ void OverlayPropertyResultFromScriptValue(const QScriptValue& object, OverlayPro
 const OverlayID UNKNOWN_OVERLAY_ID = OverlayID();
 
 /**jsdoc
- * The result of a {@link PickRay} search using {@link Overlays.findRayIntersection|findRayIntersection} or 
+ * The result of a {@link PickRay} search using {@link Overlays.findRayIntersection|findRayIntersection}.
- * {@link Overlays.findRayIntersectionVector|findRayIntersectionVector}.
  * @typedef {object} Overlays.RayToOverlayIntersectionResult
  * @property {boolean} intersects - <code>true</code> if the {@link PickRay} intersected with a 3D overlay, otherwise
  *     <code>false</code>.
@@ -383,7 +382,11 @@ public slots:
     OverlayPropertyResult getOverlaysProperties(const QVariant& overlaysProperties);
 
     /**jsdoc
-     * Find the closest 3D overlay intersected by a {@link PickRay}.
+     *  Find the closest 3D overlay intersected by a {@link PickRay}. Overlays with their <code>drawInFront</code> property set  
+     * to <code>true</code> have priority over overlays that don't, except that tablet overlays have priority over any  
+     * <code>drawInFront</code> overlays behind them. I.e., if a <code>drawInFront</code> overlay is behind one that isn't  
+     * <code>drawInFront</code>, the <code>drawInFront</code> overlay is returned, but if a tablet overlay is in front of a  
+     * <code>drawInFront</code> overlay, the tablet overlay is returned.
      * @function Overlays.findRayIntersection
      * @param {PickRay} pickRay - The PickRay to use for finding overlays.
      * @param {boolean} [precisionPicking=false] - <em>Unused</em>; exists to match Entity API.
@@ -750,8 +753,6 @@ private:
     OverlayID _currentClickingOnOverlayID { UNKNOWN_OVERLAY_ID };
     OverlayID _currentHoverOverOverlayID { UNKNOWN_OVERLAY_ID };
 
-    RayToOverlayIntersectionResult findRayIntersectionForMouseEvent(PickRay ray);
-
 private slots:
     void mousePressPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
     void mouseMovePointerEvent(const OverlayID& overlayID, const PointerEvent& event);

libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp

@@ -67,6 +67,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::gl::GLBackend::do_clearFramebuffer),
     (&::gpu::gl::GLBackend::do_blit),
     (&::gpu::gl::GLBackend::do_generateTextureMips),
+    (&::gpu::gl::GLBackend::do_generateTextureMipsWithPipeline),
 
     (&::gpu::gl::GLBackend::do_advance),
 
@@ -166,6 +167,10 @@ GLBackend::GLBackend() {
 GLBackend::~GLBackend() {}
 
 void GLBackend::shutdown() {
+    if (_mipGenerationFramebufferId) {
+        glDeleteFramebuffers(1, &_mipGenerationFramebufferId);
+        _mipGenerationFramebufferId = 0;
+    }
     killInput();
     killTransform();
     killTextureManagementStage();

libraries/gpu-gl-common/src/gpu/gl/GLBackend.h

@@ -288,6 +288,7 @@ public:
     virtual void do_setIndexBuffer(const Batch& batch, size_t paramOffset) final;
     virtual void do_setIndirectBuffer(const Batch& batch, size_t paramOffset) final;
     virtual void do_generateTextureMips(const Batch& batch, size_t paramOffset) final;
+    virtual void do_generateTextureMipsWithPipeline(const Batch& batch, size_t paramOffset) final;
 
     // Transform Stage
     virtual void do_setModelTransform(const Batch& batch, size_t paramOffset) final;
@@ -407,6 +408,8 @@ public:
 protected:
     virtual GLint getRealUniformLocation(GLint location) const;
 
+    virtual void draw(GLenum mode, uint32 numVertices, uint32 startVertex) = 0;
+
     void recycle() const override;
 
     // FIXME instead of a single flag, create a features struct similar to
@@ -696,6 +699,8 @@ protected:
     virtual void initTextureManagementStage();
     virtual void killTextureManagementStage();
 
+    GLuint _mipGenerationFramebufferId{ 0 };
+
     typedef void (GLBackend::*CommandCall)(const Batch&, size_t);
     static CommandCall _commandCalls[Batch::NUM_COMMANDS];
     friend class GLState;

libraries/gpu-gl-common/src/gpu/gl/GLBackendTexture.cpp

@@ -79,3 +79,55 @@ void GLBackend::do_generateTextureMips(const Batch& batch, size_t paramOffset) {
 
     object->generateMips();
 }
+
+void GLBackend::do_generateTextureMipsWithPipeline(const Batch& batch, size_t paramOffset) {
+    TexturePointer resourceTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
+    if (!resourceTexture) {
+        return;
+    }
+
+    // Always make sure the GLObject is in sync
+    GLTexture* object = syncGPUObject(resourceTexture);
+    if (object) {
+        GLuint to = object->_texture;
+        glActiveTexture(GL_TEXTURE0 + gpu::slot::texture::MipCreationInput);
+        glBindTexture(object->_target, to);
+        (void)CHECK_GL_ERROR();
+    } else {
+        return;
+    }
+
+    auto numMips = batch._params[paramOffset + 1]._int;
+    if (numMips < 0) {
+        numMips = resourceTexture->getNumMips();
+    } else {
+        numMips = std::min(numMips, (int)resourceTexture->getNumMips());
+    }
+
+    if (_mipGenerationFramebufferId == 0) {
+        glGenFramebuffers(1, &_mipGenerationFramebufferId);
+        Q_ASSERT(_mipGenerationFramebufferId > 0);
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, _mipGenerationFramebufferId);
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
+
+    for (int level = 1; level < numMips; level++) {
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, object->_id, level);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, level - 1);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, level - 1);
+
+        const auto mipDimensions = resourceTexture->evalMipDimensions(level);
+        glViewport(0, 0, mipDimensions.x, mipDimensions.y);
+        draw(GL_TRIANGLE_STRIP, 4, 0);
+    }
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numMips - 1);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    resetOutputStage();
+    // Restore viewport
+    ivec4& vp = _transform._viewport;
+    glViewport(vp.x, vp.y, vp.z, vp.w);
+}

libraries/gpu-gl/src/gpu/gl41/GL41Backend.cpp

@@ -20,6 +20,29 @@ using namespace gpu::gl41;
 
 const std::string GL41Backend::GL41_VERSION { "GL41" };
 
+void GL41Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GL41Backend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gl/src/gpu/gl41/GL41Backend.h

@@ -130,6 +130,9 @@ public:
     };
 
 protected:
+
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
+
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;
     GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer) override;
 

libraries/gpu-gl/src/gpu/gl45/GL45Backend.cpp

@@ -42,6 +42,30 @@ void GL45Backend::recycle() const {
     Parent::recycle();
 }
 
+void GL45Backend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GL45Backend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gl/src/gpu/gl45/GL45Backend.h

@@ -229,6 +229,7 @@ public:
 
 protected:
 
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
     void recycle() const override;
 
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;

libraries/gpu-gles/src/gpu/gles/GLESBackend.cpp

@@ -20,6 +20,29 @@ using namespace gpu::gles;
 
 const std::string GLESBackend::GLES_VERSION { "GLES" };
 
+void GLESBackend::draw(GLenum mode, uint32 numVertices, uint32 startVertex) {
+    if (isStereo()) {
+#ifdef GPU_STEREO_DRAWCALL_INSTANCED
+        glDrawArraysInstanced(mode, startVertex, numVertices, 2);
+#else
+        setupStereoSide(0);
+        glDrawArrays(mode, startVertex, numVertices);
+        setupStereoSide(1);
+        glDrawArrays(mode, startVertex, numVertices);
+#endif
+        _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
+
+    } else {
+        glDrawArrays(mode, startVertex, numVertices);
+        _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
+    }
+    _stats._DSNumAPIDrawcalls++;
+
+    (void)CHECK_GL_ERROR();
+}
+
 void GLESBackend::do_draw(const Batch& batch, size_t paramOffset) {
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = gl::PRIMITIVE_TO_GL[primitiveType];

libraries/gpu-gles/src/gpu/gles/GLESBackend.h

@@ -126,6 +126,9 @@ public:
     };
 
 protected:
+
+    void draw(GLenum mode, uint32 numVertices, uint32 startVertex) override;
+
     GLuint getFramebufferID(const FramebufferPointer& framebuffer) override;
     GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer) override;
 

libraries/gpu/src/gpu/Batch.cpp

@@ -426,6 +426,13 @@ void Batch::generateTextureMips(const TexturePointer& texture) {
     _params.emplace_back(_textures.cache(texture));
 }
 
+void Batch::generateTextureMipsWithPipeline(const TexturePointer& texture, int numMips) {
+    ADD_COMMAND(generateTextureMipsWithPipeline);
+
+    _params.emplace_back(_textures.cache(texture));
+    _params.emplace_back(numMips);
+}
+
 void Batch::beginQuery(const QueryPointer& query) {
     ADD_COMMAND(beginQuery);
 

libraries/gpu/src/gpu/Batch.h

@@ -226,6 +226,8 @@ public:
 
     // Generate the mips for a texture
     void generateTextureMips(const TexturePointer& texture);
+    // Generate the mips for a texture using the current pipeline
+    void generateTextureMipsWithPipeline(const TexturePointer& destTexture, int numMips = -1);
 
     // Query Section
     void beginQuery(const QueryPointer& query);
@@ -326,6 +328,7 @@ public:
         COMMAND_clearFramebuffer,
         COMMAND_blit,
         COMMAND_generateTextureMips,
+        COMMAND_generateTextureMipsWithPipeline,
 
         COMMAND_advance,
 

libraries/gpu/src/gpu/MipGeneration.slh

@@ -0,0 +1,20 @@
+<!
+//  MipGeneration.slh
+//  libraries/gpu/src
+//
+//  Created by Olivier Prat on 10/16/18.
+//  Copyright 2018 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
+!>
+<@if not MIP_GENERATION_SLH@>
+<@def MIP_GENERATION_SLH@>
+
+<@include gpu/ShaderConstants.h@>
+
+layout(binding=GPU_TEXTURE_MIP_CREATION_INPUT) uniform sampler2D texMap;
+
+in vec2 varTexCoord0;
+
+<@endif@>

libraries/gpu/src/gpu/ShaderConstants.h

@@ -21,6 +21,9 @@
 
 #define GPU_TEXTURE_TRANSFORM_OBJECT 31
 
+// Mip creation
+#define GPU_TEXTURE_MIP_CREATION_INPUT 30
+
 #define GPU_STORAGE_TRANSFORM_OBJECT 7
 
 #define GPU_ATTR_POSITION 0
@@ -67,7 +70,8 @@ enum Buffer {
 namespace texture {
 enum Texture {
     ObjectTransforms = GPU_TEXTURE_TRANSFORM_OBJECT,
-}; 
+    MipCreationInput = GPU_TEXTURE_MIP_CREATION_INPUT,
+};
 } // namespace texture
 
 namespace storage {

scripts/system/controllers/controllerModules/hudOverlayPointer.js

@@ -24,7 +24,7 @@
         this.reticleMinY = MARGIN;
         this.reticleMaxY;
         this.parameters = ControllerDispatcherUtils.makeDispatcherModuleParameters(
-            540,
+            160, // Same as webSurfaceLaserInput.
             this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
             [],
             100,
@@ -63,7 +63,6 @@
 
         this.processLaser = function(controllerData) {
             var controllerLocation = controllerData.controllerLocations[this.hand];
-            // var otherModuleRunning = this.getOtherModule().running;
             if ((controllerData.triggerValues[this.hand] < ControllerDispatcherUtils.TRIGGER_ON_VALUE || !controllerLocation.valid) ||
                 this.pointingAtTablet(controllerData)) {
                 return false;

scripts/system/controllers/controllerModules/inEditMode.js

@@ -28,7 +28,7 @@ Script.include("/~/system/libraries/utils.js");
         this.reticleMaxY = null;
 
         this.parameters = makeDispatcherModuleParameters(
-            160,
+            165, // Lower priority than webSurfaceLaserInput and hudOverlayPointer.
             this.hand === RIGHT_HAND ? ["rightHand", "rightHandEquip", "rightHandTrigger"] : ["leftHand", "leftHandEquip", "leftHandTrigger"],
             [],
             100,
@@ -127,29 +127,41 @@ Script.include("/~/system/libraries/utils.js");
         };
 
         this.run = function(controllerData) {
-            var tabletStylusInput = getEnabledModuleByName(this.hand === RIGHT_HAND ? "RightTabletStylusInput" : "LeftTabletStylusInput");
+            var tabletStylusInput = getEnabledModuleByName(this.hand === RIGHT_HAND
+                ? "RightTabletStylusInput" : "LeftTabletStylusInput");
             if (tabletStylusInput) {
                 var tabletReady = tabletStylusInput.isReady(controllerData);
-
                 if (tabletReady.active) {
                     return this.exitModule();
                 }
             }
 
-            var overlayLaser = getEnabledModuleByName(this.hand === RIGHT_HAND ? "RightWebSurfaceLaserInput" : "LeftWebSurfaceLaserInput");
+            var webLaser = getEnabledModuleByName(this.hand === RIGHT_HAND
-            if (overlayLaser) {
+                ? "RightWebSurfaceLaserInput" : "LeftWebSurfaceLaserInput");
-                var overlayLaserReady = overlayLaser.isReady(controllerData);
+            if (webLaser) {
+                var webLaserReady = webLaser.isReady(controllerData);
                 var target = controllerData.rayPicks[this.hand].objectID;
                 this.sendPointingAtData(controllerData);
-                if (overlayLaserReady.active && this.pointingAtTablet(target)) {
+                if (webLaserReady.active && this.pointingAtTablet(target)) {
                     return this.exitModule();
                 }
             }
 
-            var nearOverlay = getEnabledModuleByName(this.hand === RIGHT_HAND ? "RightNearParentingGrabOverlay" : "LeftNearParentingGrabOverlay");
+            if (!controllerData.triggerClicks[this.hand]) { // Don't grab if trigger pressed when laser starts intersecting.
+                var hudLaser = getEnabledModuleByName(this.hand === RIGHT_HAND
+                    ? "RightHudOverlayPointer" : "LeftHudOverlayPointer");
+                if (hudLaser) {
+                    var hudLaserReady = hudLaser.isReady(controllerData);
+                    if (hudLaserReady.active) {
+                        return this.exitModule();
+                    }
+                }
+            }
+
+            var nearOverlay = getEnabledModuleByName(this.hand === RIGHT_HAND
+                ? "RightNearParentingGrabOverlay" : "LeftNearParentingGrabOverlay");
             if (nearOverlay) {
                 var nearOverlayReady = nearOverlay.isReady(controllerData);
-
                 if (nearOverlayReady.active && HMD.tabletID && nearOverlay.grabbedThingID === HMD.tabletID) {
                     return this.exitModule();
                 }

scripts/system/controllers/controllerModules/inVREditMode.js

@@ -19,12 +19,13 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
     function InVREditMode(hand) {
         this.hand = hand;
         this.disableModules = false;
-        var NO_HAND_LASER = -1; // Invalid hand parameter so that default laser is not displayed.
+        this.running = false;
+        var NO_HAND_LASER = -1; // Invalid hand parameter so that standard laser is not displayed.
         this.parameters = makeDispatcherModuleParameters(
-            200, // Not too high otherwise the tablet laser doesn't work.
+            166, // Slightly lower priority than inEditMode.
-            this.hand === RIGHT_HAND ?
+            this.hand === RIGHT_HAND
-                ["rightHand", "rightHandEquip", "rightHandTrigger"] :
+                ? ["rightHand", "rightHandEquip", "rightHandTrigger"]
-                ["leftHand", "leftHandEquip", "leftHandTrigger"],
+                : ["leftHand", "leftHandEquip", "leftHandTrigger"],
             [],
             100,
             makeLaserParams(NO_HAND_LASER, false)
@@ -35,6 +36,35 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
                 (HMD.homeButtonID && objectID === HMD.homeButtonID);
         };
 
+        // The Shapes app has a non-standard laser: in particular, the laser end dot displays on its own when the laser is 
+        // pointing at the Shapes UI. The laser on/off is controlled by this module but the laser is implemented in the Shapes 
+        // app.
+        // If, in the future, the Shapes app laser interaction is adopted as a standard UI style then the laser could be 
+        // implemented in the controller modules along side the other laser styles.
+        var INVREDIT_MODULE_RUNNING = "Hifi-InVREdit-Module-Running";
+
+        this.runModule = function () {
+            if (!this.running) {
+                Messages.sendLocalMessage(INVREDIT_MODULE_RUNNING, JSON.stringify({
+                    hand: this.hand,
+                    running: true
+                }));
+                this.running = true;
+            }
+            return makeRunningValues(true, [], []);
+        };
+
+        this.exitModule = function () {
+            if (this.running) {
+                Messages.sendLocalMessage(INVREDIT_MODULE_RUNNING, JSON.stringify({
+                    hand: this.hand,
+                    running: false
+                }));
+                this.running = false;
+            }
+            return makeRunningValues(false, [], []);
+        };
+
         this.isReady = function (controllerData) {
             if (this.disableModules) {
                 return makeRunningValues(true, [], []);
@@ -45,7 +75,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
         this.run = function (controllerData) {
             // Default behavior if disabling is not enabled.
             if (!this.disableModules) {
-                return makeRunningValues(false, [], []);
+                return this.exitModule();
             }
 
             // Tablet stylus.
@@ -55,7 +85,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
             if (tabletStylusInput) {
                 var tabletReady = tabletStylusInput.isReady(controllerData);
                 if (tabletReady.active) {
-                    return makeRunningValues(false, [], []);
+                    return this.exitModule();
                 }
             }
 
@@ -67,7 +97,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
                 var overlayLaserReady = overlayLaser.isReady(controllerData);
                 var target = controllerData.rayPicks[this.hand].objectID;
                 if (overlayLaserReady.active && this.pointingAtTablet(target)) {
-                    return makeRunningValues(false, [], []);
+                    return this.exitModule();
                 }
             }
 
@@ -78,7 +108,20 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
             if (nearOverlay) {
                 var nearOverlayReady = nearOverlay.isReady(controllerData);
                 if (nearOverlayReady.active && HMD.tabletID && nearOverlay.grabbedThingID === HMD.tabletID) {
-                    return makeRunningValues(false, [], []);
+                    return this.exitModule();
+                }
+            }
+
+            // HUD overlay.
+            if (!controllerData.triggerClicks[this.hand]) {
+                var hudLaser = getEnabledModuleByName(this.hand === RIGHT_HAND
+                    ? "RightHudOverlayPointer"
+                    : "LeftHudOverlayPointer");
+                if (hudLaser) {
+                    var hudLaserReady = hudLaser.isReady(controllerData);
+                    if (hudLaserReady.active) {
+                        return this.exitModule();
+                    }
                 }
             }
 
@@ -89,12 +132,12 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
             if (teleporter) {
                 var teleporterReady = teleporter.isReady(controllerData);
                 if (teleporterReady.active) {
-                    return makeRunningValues(false, [], []);
+                    return this.exitModule();
                 }
             }
 
             // Other behaviors are disabled.
-            return makeRunningValues(true, [], []);
+            return this.runModule();
         };
     }