Merge branch 'master' of github.com:highfidelity/hifi into fix-grab-vs-trigger

interface/src/ui/overlays/Base3DOverlay.cpp

@@ -268,18 +268,17 @@ void Base3DOverlay::update(float duration) {
     
     // In Base3DOverlay, if its location or bound changed, the renderTrasnformDirty flag is true.
     // then the correct transform used for rendering is computed in the update transaction and assigned.
-    // TODO: Fix the value to be computed in main thread now and passed by value to the render item.
-    //       This is the simplest fix for the web overlay of the tablet for now
     if (_renderTransformDirty) {
-        _renderTransformDirty = false;
         auto itemID = getRenderItemID();
         if (render::Item::isValidID(itemID)) {
+            _renderTransformDirty = false;
+            // Capture the render transform value in game loop before 
+            auto latestTransform = evalRenderTransform();
             render::ScenePointer scene = qApp->getMain3DScene();
             render::Transaction transaction;
-            transaction.updateItem<Overlay>(itemID, [](Overlay& data) {
+            transaction.updateItem<Overlay>(itemID, [latestTransform](Overlay& data) {
                 auto overlay3D = dynamic_cast<Base3DOverlay*>(&data);
                 if (overlay3D) {
-                    auto latestTransform = overlay3D->evalRenderTransform();
                     overlay3D->setRenderTransform(latestTransform);
                 }
             });
@@ -292,7 +291,7 @@ void Base3DOverlay::notifyRenderTransformChange() const {
     _renderTransformDirty = true;
 }
 
-Transform Base3DOverlay::evalRenderTransform() const {
+Transform Base3DOverlay::evalRenderTransform() {
     return getTransform();
 }
 

interface/src/ui/overlays/Base3DOverlay.h

@@ -72,7 +72,7 @@ protected:
     virtual void parentDeleted() override;
 
     mutable Transform _renderTransform;
-    virtual Transform evalRenderTransform() const;
+    virtual Transform evalRenderTransform();
     virtual void setRenderTransform(const Transform& transform);
     const Transform& getRenderTransform() const { return _renderTransform; }
 

interface/src/ui/overlays/Billboard3DOverlay.cpp

@@ -45,3 +45,14 @@ bool Billboard3DOverlay::applyTransformTo(Transform& transform, bool force) {
     }
     return transformChanged;
 }
+
+Transform Billboard3DOverlay::evalRenderTransform() {
+    Transform transform = getTransform();
+    bool transformChanged = applyTransformTo(transform, true);
+    // If the transform is not modified, setting the transform to
+    // itself will cause drift over time due to floating point errors.
+    if (transformChanged) {
+        setTransform(transform);
+    }
+    return transform;
+}

interface/src/ui/overlays/Billboard3DOverlay.h

@@ -28,6 +28,8 @@ public:
 
 protected:
     virtual bool applyTransformTo(Transform& transform, bool force = false) override;
+
+    Transform evalRenderTransform() override;
 };
 
 #endif // hifi_Billboard3DOverlay_h

interface/src/ui/overlays/Circle3DOverlay.cpp

@@ -84,12 +84,7 @@ void Circle3DOverlay::render(RenderArgs* args) {
         batch.setPipeline(args->_shapePipeline->pipeline);
     }
 
-    // FIXME: THe line width of _lineWidth is not supported anymore, we ll need a workaround
+    batch.setModelTransform(getRenderTransform());
-    // FIXME Start using the _renderTransform instead of calling for Transform from here, do the custom things needed in evalRenderTransform()
-
-    auto transform = getTransform();
-    transform.postScale(glm::vec3(getDimensions(), 1.0f));
-    batch.setModelTransform(transform);
 
     // for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
     // we just draw a line...

interface/src/ui/overlays/Cube3DOverlay.cpp

@@ -53,18 +53,11 @@ void Cube3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     glm::vec4 cubeColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
 
-    // TODO: handle registration point??
+
-    // FIXME Start using the _renderTransform instead of calling for Transform from here, do the custom things needed in evalRenderTransform()
-    glm::vec3 position = getPosition();
-    glm::vec3 dimensions = getDimensions();
-    glm::quat rotation = getRotation();
 
     auto batch = args->_batch;
-
     if (batch) {
-        Transform transform;
+        Transform transform = getRenderTransform();
-        transform.setTranslation(position);
-        transform.setRotation(rotation);
         auto geometryCache = DependencyManager::get<GeometryCache>();
         auto shapePipeline = args->_shapePipeline;
         if (!shapePipeline) {
@@ -72,12 +65,12 @@ void Cube3DOverlay::render(RenderArgs* args) {
         }
 
         if (_isSolid) {
-            transform.setScale(dimensions);
             batch->setModelTransform(transform);
             geometryCache->renderSolidCubeInstance(args, *batch, cubeColor, shapePipeline);
         } else {
             geometryCache->bindSimpleProgram(*batch, false, false, false, true, true);
             if (getIsDashedLine()) {
+                auto dimensions = transform.getScale();
                 transform.setScale(1.0f);
                 batch->setModelTransform(transform);
 
@@ -108,7 +101,6 @@ void Cube3DOverlay::render(RenderArgs* args) {
                 geometryCache->renderDashedLine(*batch, bottomRightFar, topRightFar, cubeColor, _geometryIds[11]);
 
             } else {
-                transform.setScale(dimensions);
                 batch->setModelTransform(transform);
                 geometryCache->renderWireCubeInstance(args, *batch, cubeColor, shapePipeline);
             }
@@ -149,3 +141,16 @@ QVariant Cube3DOverlay::getProperty(const QString& property) {
 
     return Volume3DOverlay::getProperty(property);
 }
+
+Transform Cube3DOverlay::evalRenderTransform() {
+    // TODO: handle registration point??
+    glm::vec3 position = getPosition();
+    glm::vec3 dimensions = getDimensions();
+    glm::quat rotation = getRotation();
+
+    Transform transform;
+    transform.setScale(dimensions);
+    transform.setTranslation(position);
+    transform.setRotation(rotation);
+    return transform;
+}

interface/src/ui/overlays/Cube3DOverlay.h

@@ -36,6 +36,9 @@ public:
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     float _borderSize;
     // edges on a cube

interface/src/ui/overlays/Grid3DOverlay.cpp

@@ -79,10 +79,7 @@ void Grid3DOverlay::render(RenderArgs* args) {
             position += glm::vec3(cameraPosition.x, 0.0f, cameraPosition.z);
         }
 
-        // FIXME Start using the _renderTransform instead of calling for Transform from here, do the custom things needed in evalRenderTransform()
+        Transform transform = getRenderTransform();
-        Transform transform;
-        transform.setRotation(getRotation());
-        transform.setScale(glm::vec3(getDimensions(), 1.0f));
         transform.setTranslation(position);
         batch->setModelTransform(transform);
         const float MINOR_GRID_EDGE = 0.0025f;
@@ -146,3 +143,10 @@ void Grid3DOverlay::updateGrid() {
     _minorGridRowDivisions = getDimensions().x / _minorGridEvery;
     _minorGridColDivisions = getDimensions().y / _minorGridEvery;
 }
+
+Transform Grid3DOverlay::evalRenderTransform() {
+    Transform transform;
+    transform.setRotation(getRotation());
+    transform.setScale(glm::vec3(getDimensions(), 1.0f));
+    return transform;
+}

interface/src/ui/overlays/Grid3DOverlay.h

@@ -37,6 +37,9 @@ public:
     // Grids are UI tools, and may not be intersected (pickable)
     virtual bool findRayIntersection(const glm::vec3&, const glm::vec3&, float&, BoxFace&, glm::vec3&) override { return false; }
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     void updateGrid();
 

interface/src/ui/overlays/Image3DOverlay.cpp

@@ -58,6 +58,7 @@ void Image3DOverlay::update(float deltatime) {
         setTransform(transform);
     }
 #endif
+    Parent::update(deltatime);
 }
 
 void Image3DOverlay::render(RenderArgs* args) {
@@ -116,18 +117,8 @@ void Image3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     xColor color = getColor();
     float alpha = getAlpha();
-    
-    // FIXME Start using the _renderTransform instead of calling for Transform from here, do the custom things needed in evalRenderTransform()
-    Transform transform = getTransform();
-    bool transformChanged = applyTransformTo(transform, true);
-    // If the transform is not modified, setting the transform to
-    // itself will cause drift over time due to floating point errors.
-    if (transformChanged) {
-        setTransform(transform);
-    }
-    transform.postScale(glm::vec3(getDimensions(), 1.0f));
 
-    batch->setModelTransform(transform);
+    batch->setModelTransform(getRenderTransform());
     batch->setResourceTexture(0, _texture->getGPUTexture());
 
     DependencyManager::get<GeometryCache>()->renderQuad(
@@ -249,3 +240,9 @@ bool Image3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec
 Image3DOverlay* Image3DOverlay::createClone() const {
     return new Image3DOverlay(this);
 }
+
+Transform Image3DOverlay::evalRenderTransform() {
+    auto transform = Parent::evalRenderTransform();
+    transform.postScale(glm::vec3(getDimensions(), 1.0f));
+    return transform;
+}

interface/src/ui/overlays/Image3DOverlay.h

@@ -19,6 +19,7 @@
 
 class Image3DOverlay : public Billboard3DOverlay {
     Q_OBJECT
+    using Parent = Billboard3DOverlay;
 
 public:
     static QString const TYPE;
@@ -46,6 +47,9 @@ public:
 
     virtual Image3DOverlay* createClone() const override;
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     QString _url;
     NetworkTexturePointer _texture;

interface/src/ui/overlays/Line3DOverlay.cpp

@@ -132,10 +132,10 @@ void Line3DOverlay::render(RenderArgs* args) {
     glm::vec4 colorv4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
     auto batch = args->_batch;
     if (batch) {
-        // FIXME Start using the _renderTransform instead of calling for Transform and start and end from here, do the custom things needed in evalRenderTransform()
         batch->setModelTransform(Transform());
-        glm::vec3 start = getStart();
+        auto& renderTransform = getRenderTransform();
-        glm::vec3 end = getEnd();
+        glm::vec3 start = renderTransform.getTranslation();
+        glm::vec3 end = renderTransform.transform(vec3(0.0, 0.0, -1.0));
 
         auto geometryCache = DependencyManager::get<GeometryCache>();
         if (getIsDashedLine()) {
@@ -268,3 +268,21 @@ QVariant Line3DOverlay::getProperty(const QString& property) {
 Line3DOverlay* Line3DOverlay::createClone() const {
     return new Line3DOverlay(this);
 }
+
+Transform Line3DOverlay::evalRenderTransform() {
+    // Capture start and endin the renderTransform:
+    // start is the origin
+    // end is at the tip of the front axis aka -Z
+    Transform transform;
+    transform.setTranslation( getStart());
+    auto endPos = getEnd();
+
+    auto vec = endPos - transform.getTranslation();
+    auto scale = glm::length(vec);
+    auto dir = vec / scale;
+    auto orientation = glm::rotation(glm::vec3(0,0,-1), dir);
+    transform.setRotation(orientation);
+    transform.setScale(scale);
+
+    return transform;
+}

interface/src/ui/overlays/Line3DOverlay.h

@@ -15,6 +15,7 @@
 
 class Line3DOverlay : public Base3DOverlay {
     Q_OBJECT
+    using Parent = Base3DOverlay;
 
 public:
     static QString const TYPE;
@@ -56,6 +57,9 @@ public:
     QUuid getEndParentID() const { return _endParentID; }
     quint16 getEndJointIndex() const { return _endParentJointIndex; }
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     QUuid _endParentID;
     quint16 _endParentJointIndex { INVALID_JOINT_INDEX };

interface/src/ui/overlays/ModelOverlay.cpp

@@ -46,8 +46,7 @@ void ModelOverlay::update(float deltatime) {
     if (_updateModel) {
         _updateModel = false;
         _model->setSnapModelToCenter(true);
-        Transform transform = getTransform();
+        Transform transform = evalRenderTransform();
-        transform.setScale(1.0f); // disable inherited scale
         if (_scaleToFit) {
             _model->setScaleToFit(true, transform.getScale() * getDimensions());
         } else {
@@ -280,6 +279,12 @@ ModelOverlay* ModelOverlay::createClone() const {
     return new ModelOverlay(this);
 }
 
+Transform ModelOverlay::evalRenderTransform() {
+    Transform transform = getTransform();
+    transform.setScale(1.0f); // disable inherited scale
+    return transform;
+}
+
 void ModelOverlay::locationChanged(bool tellPhysics) {
     Base3DOverlay::locationChanged(tellPhysics);
 

interface/src/ui/overlays/ModelOverlay.h

@@ -46,6 +46,8 @@ public:
     float getLoadPriority() const { return _loadPriority; }
 
 protected:
+    Transform evalRenderTransform() override;
+
     // helper to extract metadata from our Model's rigged joints
     template <typename itemType> using mapFunction = std::function<itemType(int jointIndex)>;
     template <typename vectorType, typename itemType>

interface/src/ui/overlays/Planar3DOverlay.cpp

@@ -35,6 +35,11 @@ AABox Planar3DOverlay::getBounds() const {
     return AABox(extents);
 }
 
+void Planar3DOverlay::setDimensions(const glm::vec2& value) {
+    _dimensions = value;
+    notifyRenderTransformChange();
+}
+
 void Planar3DOverlay::setProperties(const QVariantMap& properties) {
     Base3DOverlay::setProperties(properties);
 
@@ -67,7 +72,7 @@ bool Planar3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     return findRayRectangleIntersection(origin, direction, getRotation(), getPosition(), getDimensions(), distance);
 }
 
-Transform Planar3DOverlay::evalRenderTransform() const {
+Transform Planar3DOverlay::evalRenderTransform() {
     auto transform = getTransform();
     transform.setScale(1.0f); // ignore inherited scale factor from parents
     if (glm::length2(getDimensions()) != 1.0f) {

interface/src/ui/overlays/Planar3DOverlay.h

@@ -24,8 +24,8 @@ public:
     virtual glm::vec2 getSize() const { return _dimensions; };
     
     glm::vec2 getDimensions() const { return _dimensions; }
-    void setDimensions(float value) { _dimensions = glm::vec2(value); }
+    void setDimensions(float value) { setDimensions(glm::vec2(value)); }
-    void setDimensions(const glm::vec2& value) { _dimensions = value; }
+    void setDimensions(const glm::vec2& value);
     
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
@@ -33,10 +33,10 @@ public:
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, 
                                         BoxFace& face, glm::vec3& surfaceNormal) override;
   
-    Transform evalRenderTransform() const override;
-
 protected:
     glm::vec2 _dimensions;
+
+    Transform evalRenderTransform() override;
 };
 
  

interface/src/ui/overlays/Rectangle3DOverlay.cpp

@@ -124,3 +124,8 @@ void Rectangle3DOverlay::setProperties(const QVariantMap& properties) {
 Rectangle3DOverlay* Rectangle3DOverlay::createClone() const {
     return new Rectangle3DOverlay(this);
 }
+
+Transform Rectangle3DOverlay::evalRenderTransform() {
+    return getTransform();
+}
+

interface/src/ui/overlays/Rectangle3DOverlay.h

@@ -28,6 +28,10 @@ public:
     void setProperties(const QVariantMap& properties) override;
 
     virtual Rectangle3DOverlay* createClone() const override;
+
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     int _geometryCacheID;
     std::array<int, 4> _rectGeometryIds;

interface/src/ui/overlays/Shape3DOverlay.cpp

@@ -33,26 +33,15 @@ void Shape3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     glm::vec4 cubeColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
 
-    // FIXME Start using the _renderTransform instead of calling for Transform and Dimensions from here, do the custom things needed in evalRenderTransform()
-    // TODO: handle registration point??
-    glm::vec3 position = getPosition();
-    glm::vec3 dimensions = getDimensions();
-    glm::quat rotation = getRotation();
-
     auto batch = args->_batch;
-
     if (batch) {
-        Transform transform;
-        transform.setTranslation(position);
-        transform.setRotation(rotation);
         auto geometryCache = DependencyManager::get<GeometryCache>();
         auto shapePipeline = args->_shapePipeline;
         if (!shapePipeline) {
             shapePipeline = _isSolid ? geometryCache->getOpaqueShapePipeline() : geometryCache->getWireShapePipeline();
         }
 
-        transform.setScale(dimensions);
+        batch->setModelTransform(getRenderTransform());
-        batch->setModelTransform(transform);
         if (_isSolid) {
             geometryCache->renderSolidShapeInstance(args, *batch, _shape, cubeColor, shapePipeline);
         } else {
@@ -129,3 +118,16 @@ QVariant Shape3DOverlay::getProperty(const QString& property) {
 
     return Volume3DOverlay::getProperty(property);
 }
+
+Transform Shape3DOverlay::evalRenderTransform() {
+    // TODO: handle registration point??
+    glm::vec3 position = getPosition();
+    glm::vec3 dimensions = getDimensions();
+    glm::quat rotation = getRotation();
+
+    Transform transform;
+    transform.setScale(dimensions);
+    transform.setTranslation(position);
+    transform.setRotation(rotation);
+    return transform;
+}

interface/src/ui/overlays/Shape3DOverlay.h

@@ -37,6 +37,9 @@ public:
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     float _borderSize;
     GeometryCache::Shape _shape { GeometryCache::Hexagon };

interface/src/ui/overlays/Sphere3DOverlay.cpp

@@ -39,11 +39,7 @@ void Sphere3DOverlay::render(RenderArgs* args) {
     auto batch = args->_batch;
 
     if (batch) {
-        // FIXME Start using the _renderTransform instead of calling for Transform and Dimensions from here, do the custom things needed in evalRenderTransform()
+        batch->setModelTransform(getRenderTransform());
-        Transform transform = getTransform();
-        transform.setScale(1.0f);  // ignore inherited scale from SpatiallyNestable
-        transform.postScale(getDimensions() * SPHERE_OVERLAY_SCALE);
-        batch->setModelTransform(transform);
 
         auto geometryCache = DependencyManager::get<GeometryCache>();
         auto shapePipeline = args->_shapePipeline;
@@ -73,3 +69,11 @@ const render::ShapeKey Sphere3DOverlay::getShapeKey() {
 Sphere3DOverlay* Sphere3DOverlay::createClone() const {
     return new Sphere3DOverlay(this);
 }
+
+Transform Sphere3DOverlay::evalRenderTransform() {
+    Transform transform = getTransform();
+    transform.setScale(1.0f);  // ignore inherited scale from SpatiallyNestable
+    transform.postScale(getDimensions() * SPHERE_OVERLAY_SCALE);
+
+    return transform;
+}

interface/src/ui/overlays/Sphere3DOverlay.h

@@ -27,6 +27,9 @@ public:
     virtual const render::ShapeKey getShapeKey() override;
 
     virtual Sphere3DOverlay* createClone() const override;
+
+protected:
+    Transform evalRenderTransform() override;
 };
 
  

interface/src/ui/overlays/Text3DOverlay.cpp

@@ -98,10 +98,7 @@ void Text3DOverlay::render(RenderArgs* args) {
     Q_ASSERT(args->_batch);
     auto& batch = *args->_batch;
 
-    // FIXME Start using the _renderTransform instead of calling for Transform and Dimensions from here, do the custom things needed in evalRenderTransform()
+    auto transform = getRenderTransform();
-    Transform transform = getTransform();
-    applyTransformTo(transform, true);
-    setTransform(transform);
     batch.setModelTransform(transform);
 
     const float MAX_COLOR = 255.0f;
@@ -258,3 +255,8 @@ bool Text3DOverlay::findRayIntersection(const glm::vec3 &origin, const glm::vec3
     setTransform(transform);
     return Billboard3DOverlay::findRayIntersection(origin, direction, distance, face, surfaceNormal);
 }
+
+Transform Text3DOverlay::evalRenderTransform() {
+    return Parent::evalRenderTransform();
+}
+

interface/src/ui/overlays/Text3DOverlay.h

@@ -19,6 +19,7 @@ class TextRenderer3D;
 
 class Text3DOverlay : public Billboard3DOverlay {
     Q_OBJECT
+    using Parent = Billboard3DOverlay;
 
 public:
     static QString const TYPE;
@@ -64,6 +65,9 @@ public:
 
     virtual Text3DOverlay* createClone() const override;
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     TextRenderer3D* _textRenderer = nullptr;
 

interface/src/ui/overlays/Volume3DOverlay.cpp

@@ -26,6 +26,11 @@ AABox Volume3DOverlay::getBounds() const {
     return AABox(extents);
 }
 
+void Volume3DOverlay::setDimensions(const glm::vec3& value) {
+    _localBoundingBox.setBox(-value / 2.0f, value);
+    notifyRenderTransformChange();
+}
+
 void Volume3DOverlay::setProperties(const QVariantMap& properties) {
     Base3DOverlay::setProperties(properties);
 
@@ -67,3 +72,11 @@ bool Volume3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     // and testing intersection there.
     return _localBoundingBox.findRayIntersection(overlayFrameOrigin, overlayFrameDirection, distance, face, surfaceNormal);
 }
+
+Transform Volume3DOverlay::evalRenderTransform() {
+    Transform transform = getTransform();
+#ifndef USE_SN_SCALE
+    transform.setScale(1.0f);  // ignore any inherited scale from SpatiallyNestable
+#endif
+    return transform;
+}

interface/src/ui/overlays/Volume3DOverlay.h

@@ -15,6 +15,7 @@
 
 class Volume3DOverlay : public Base3DOverlay {
     Q_OBJECT
+    using Parent = Base3DOverlay;
 
 public:
     Volume3DOverlay() {}
@@ -23,8 +24,8 @@ public:
     virtual AABox getBounds() const override;
 
     const glm::vec3& getDimensions() const { return _localBoundingBox.getDimensions(); }
-    void setDimensions(float value) { _localBoundingBox.setBox(glm::vec3(-value / 2.0f), value); }
+    void setDimensions(float value) { setDimensions(glm::vec3(value)); }
-    void setDimensions(const glm::vec3& value) { _localBoundingBox.setBox(-value / 2.0f, value); }
+    void setDimensions(const glm::vec3& value);
 
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
@@ -35,6 +36,8 @@ public:
 protected:
     // Centered local bounding box
     AABox _localBoundingBox{ vec3(0.0f), 1.0f };
+
+    Transform evalRenderTransform() override;
 };
 
 

interface/src/ui/overlays/Web3DOverlay.cpp

@@ -286,7 +286,6 @@ void Web3DOverlay::render(RenderArgs* args) {
         emit resizeWebSurface();
     }
 
-    vec2 halfSize = getSize() / 2.0f;
     vec4 color(toGlm(getColor()), getAlpha());
 
     if (!_texture) {
@@ -302,8 +301,11 @@ void Web3DOverlay::render(RenderArgs* args) {
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
     batch.setResourceTexture(0, _texture);
+
     auto renderTransform = getRenderTransform();
-    batch.setModelTransform(getRenderTransform());
+    auto size = renderTransform.getScale();
+    renderTransform.setScale(1.0f);
+    batch.setModelTransform(renderTransform);
 
     auto geometryCache = DependencyManager::get<GeometryCache>();
     if (color.a < OPAQUE_ALPHA_THRESHOLD) {
@@ -311,10 +313,19 @@ void Web3DOverlay::render(RenderArgs* args) {
     } else {
         geometryCache->bindWebBrowserProgram(batch);
     }
+
+    vec2 halfSize = vec2(size.x, size.y) / 2.0f;
     geometryCache->renderQuad(batch, halfSize * -1.0f, halfSize, vec2(0), vec2(1), color, _geometryId);
     batch.setResourceTexture(0, nullptr); // restore default white color after me
 }
 
+Transform Web3DOverlay::evalRenderTransform() {
+    Transform transform = Parent::evalRenderTransform();
+    transform.setScale(1.0f);
+    transform.postScale(glm::vec3(getSize(), 1.0f));
+    return transform;
+}
+
 const render::ShapeKey Web3DOverlay::getShapeKey() {
     auto builder = render::ShapeKey::Builder().withoutCullFace().withDepthBias().withOwnPipeline();
     if (isTransparent()) {

interface/src/ui/overlays/Web3DOverlay.h

@@ -76,6 +76,9 @@ signals:
     void requestWebSurface();
     void releaseWebSurface();
 
+protected:
+    Transform evalRenderTransform() override;
+
 private:
     void setupQmlSurface();
     void rebuildWebSurface();

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -1078,4 +1078,4 @@ void EntityTreeRenderer::onEntityChanged(const EntityItemID& id) {
     _changedEntitiesGuard.withWriteLock([&] {
         _changedEntities.insert(id);
     });
-}
+}

libraries/render-utils/src/Model.cpp

@@ -228,18 +228,20 @@ void Model::updateRenderItems() {
         // We need to update them here so we can correctly update the bounding box.
         self->updateClusterMatrices();
 
+        Transform modelTransform = self->getTransform();
+        Transform physicsTransform = modelTransform;
+        modelTransform.setScale(glm::vec3(1.0f));
+
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::Transaction transaction;
         foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
-            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) {
+            transaction.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter, modelTransform](ModelMeshPartPayload& data) {
                 ModelPointer model = data._model.lock();
                 if (model && model->isLoaded()) {
                     // Ensure the model geometry was not reset between frames
                     if (deleteGeometryCounter == model->_deleteGeometryCounter) {
-                        Transform modelTransform = model->getTransform();
+                        
-                        modelTransform.setScale(glm::vec3(1.0f));
-
                         const Model::MeshState& state = model->getMeshState(data._meshIndex);
                         Transform renderTransform = modelTransform;
                         if (state.clusterMatrices.size() == 1) {
@@ -254,11 +256,10 @@ void Model::updateRenderItems() {
         // collision mesh does not share the same unit scale as the FBX file's mesh: only apply offset
         Transform collisionMeshOffset;
         collisionMeshOffset.setIdentity();
-        Transform modelTransform = self->getTransform();
         foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
-            transaction.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
+            transaction.updateItem<MeshPartPayload>(itemID, [physicsTransform, collisionMeshOffset](MeshPartPayload& data) {
                 // update the model transform for this render item.
-                data.updateTransform(modelTransform, collisionMeshOffset);
+                data.updateTransform(physicsTransform, collisionMeshOffset);
             });
         }
 
@@ -1306,55 +1307,6 @@ bool Model::isRenderable() const {
     return !_meshStates.isEmpty() || (isLoaded() && _renderGeometry->getMeshes().empty());
 }
 
-bool Model::initWhenReady(const render::ScenePointer& scene) {
-    // NOTE: this only called by SkeletonModel
-    if (_addedToScene || !isRenderable()) {
-        return false;
-    }
-
-    createRenderItemSet();
-
-    render::Transaction transaction;
-
-    bool addedTransaction = false;
-    if (_collisionGeometry) {
-        foreach (auto renderItem, _collisionRenderItems) {
-            auto item = scene->allocateID();
-            auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
-            _collisionRenderItemsMap.insert(item, renderPayload);
-            transaction.resetItem(item, renderPayload);
-        }
-        addedTransaction = !_collisionRenderItems.empty();
-    } else {
-        bool hasTransparent = false;
-        size_t verticesCount = 0;
-        foreach (auto renderItem, _modelMeshRenderItems) {
-            auto item = scene->allocateID();
-            auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
-
-            hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
-            verticesCount += renderItem.get()->getVerticesCount();
-            _modelMeshRenderItemsMap.insert(item, renderPayload);
-            transaction.resetItem(item, renderPayload);
-        }
-        addedTransaction = !_modelMeshRenderItemsMap.empty();
-        _renderInfoVertexCount = verticesCount;
-        _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
-        _renderInfoHasTransparent = hasTransparent;
-    }
-    _addedToScene = addedTransaction;
-    if (addedTransaction) {
-        scene->enqueueTransaction(transaction);
-        // NOTE: updateRender items enqueues identical transaction (using a lambda)
-        // so it looks like we're doing double work here, but I don't want to remove the call
-        // for fear there is some side effect we'll miss. -- Andrew 2016.07.21
-        // TODO: figure out if we really need this call to updateRenderItems() or not.
-        updateRenderItems();
-    }
-
-    return true;
-}
-
 class CollisionRenderGeometry : public Geometry {
 public:
     CollisionRenderGeometry(model::MeshPointer mesh) {

libraries/render-utils/src/Model.h

@@ -87,7 +87,6 @@ public:
     bool needsFixupInScene() const;
 
     bool needsReload() const { return _needsReload; }
-    bool initWhenReady(const render::ScenePointer& scene);
     bool addToScene(const render::ScenePointer& scene,
                     render::Transaction& transaction) {
         auto getters = render::Item::Status::Getters(0);

plugins/openvr/src/ViveControllerManager.cpp

@@ -708,8 +708,6 @@ controller::Pose ViveControllerManager::InputDevice::addOffsetToPuckPose(const c
             puckPoseIter++;
         }
 
-        //auto puckPoseIter = _poseStateMap.find(puckIndex);
-
         if (puckPoseIter != _validTrackedObjects.end()) {
 
             glm::mat4 postMat; // identity

scripts/system/controllers/controllerModules/teleport.js

@@ -14,7 +14,6 @@
    enableDispatcherModule, disableDispatcherModule, Messages, makeDispatcherModuleParameters, makeRunningValues, Vec3,
    LaserPointers, RayPick, HMD, Uuid, AvatarList
 */
-/* eslint indent: ["error", 4, { "outerIIFEBody": 0 }] */
 
 Script.include("/~/system/libraries/Xform.js");
 Script.include("/~/system/libraries/controllerDispatcherUtils.js");
@@ -22,388 +21,354 @@ Script.include("/~/system/libraries/controllers.js");
 
 (function() { // BEGIN LOCAL_SCOPE
 
-var inTeleportMode = false;
+    var TARGET_MODEL_URL = Script.resolvePath("../../assets/models/teleport-destination.fbx");
+    var TOO_CLOSE_MODEL_URL = Script.resolvePath("../../assets/models/teleport-cancel.fbx");
+    var SEAT_MODEL_URL = Script.resolvePath("../../assets/models/teleport-seat.fbx");
 
-var SMOOTH_ARRIVAL_SPACING = 33;
+    var TARGET_MODEL_DIMENSIONS = {
-var NUMBER_OF_STEPS = 6;
+        x: 1.15,
-
+        y: 0.5,
-var TARGET_MODEL_URL = Script.resolvePath("../../assets/models/teleport-destination.fbx");
+        z: 1.15
-var TOO_CLOSE_MODEL_URL = Script.resolvePath("../../assets/models/teleport-cancel.fbx");
-var SEAT_MODEL_URL = Script.resolvePath("../../assets/models/teleport-seat.fbx");
-
-var TARGET_MODEL_DIMENSIONS = {
-    x: 1.15,
-    y: 0.5,
-    z: 1.15
-};
-
-var COLORS_TELEPORT_SEAT = {
-    red: 255,
-    green: 0,
-    blue: 170
-};
-
-var COLORS_TELEPORT_CAN_TELEPORT = {
-    red: 97,
-    green: 247,
-    blue: 255
-};
-
-var COLORS_TELEPORT_CANCEL = {
-    red: 255,
-    green: 184,
-    blue: 73
-};
-
-var TELEPORT_CANCEL_RANGE = 1;
-var COOL_IN_DURATION = 500;
-
-var handInfo = {
-    right: {
-        controllerInput: Controller.Standard.RightHand
-    },
-    left: {
-        controllerInput: Controller.Standard.LeftHand
-    }
-};
-
-var cancelPath = {
-    type: "line3d",
-    color: COLORS_TELEPORT_CANCEL,
-    ignoreRayIntersection: true,
-    alpha: 1,
-    solid: true,
-    drawInFront: true,
-    glow: 1.0
-};
-var teleportPath = {
-    type: "line3d",
-    color: COLORS_TELEPORT_CAN_TELEPORT,
-    ignoreRayIntersection: true,
-    alpha: 1,
-    solid: true,
-    drawInFront: true,
-    glow: 1.0
-};
-var seatPath = {
-    type: "line3d",
-    color: COLORS_TELEPORT_SEAT,
-    ignoreRayIntersection: true,
-    alpha: 1,
-    solid: true,
-    drawInFront: true,
-    glow: 1.0
-};
-var cancelEnd = {
-    type: "model",
-    url: TOO_CLOSE_MODEL_URL,
-    dimensions: TARGET_MODEL_DIMENSIONS,
-    ignoreRayIntersection: true
-};
-var teleportEnd = {
-    type: "model",
-    url: TARGET_MODEL_URL,
-    dimensions: TARGET_MODEL_DIMENSIONS,
-    ignoreRayIntersection: true
-};
-var seatEnd = {
-    type: "model",
-    url: SEAT_MODEL_URL,
-    dimensions: TARGET_MODEL_DIMENSIONS,
-    ignoreRayIntersection: true
-};
-
-var teleportRenderStates = [{name: "cancel", path: cancelPath, end: cancelEnd},
-                            {name: "teleport", path: teleportPath, end: teleportEnd},
-                            {name: "seat", path: seatPath, end: seatEnd}];
-
-var DEFAULT_DISTANCE = 50;
-var teleportDefaultRenderStates = [{name: "cancel", distance: DEFAULT_DISTANCE, path: cancelPath}];
-
-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 COLORS_TELEPORT_SEAT = {
-        var down = _this.buttonValue === 1 ? 1.0 : 0.0;
+        red: 255,
-        return down;
+        green: 0,
-    };
+        blue: 170
-}
-
-var coolInTimeout = null;
-var ignoredEntities = [];
-
-var TELEPORTER_STATES = {
-    IDLE: 'idle',
-    COOL_IN: 'cool_in',
-    TARGETTING: 'targetting',
-    TARGETTING_INVALID: 'targetting_invalid',
-};
-
-var TARGET = {
-    NONE: 'none',            // Not currently targetting anything
-    INVISIBLE: 'invisible',  // The current target is an invvsible surface
-    INVALID: 'invalid',      // The current target is invalid (wall, ceiling, etc.)
-    SURFACE: 'surface',      // The current target is a valid surface
-    SEAT: 'seat',            // The current target is a seat
-};
-
-function Teleporter(hand) {
-    var _this = this;
-    this.hand = hand;
-    this.buttonValue = 0;
-    this.active = false;
-    this.state = TELEPORTER_STATES.IDLE;
-    this.currentTarget = TARGET.INVALID;
-    this.currentResult = null;
-
-    this.getOtherModule = function() {
-        var otherModule = this.hand === RIGHT_HAND ? leftTeleporter : rightTeleporter;
-        return otherModule;
     };
 
-    this.teleportRayHandVisible = LaserPointers.createLaserPointer({
+    var COLORS_TELEPORT_CAN_TELEPORT = {
-        joint: (_this.hand === RIGHT_HAND) ? "RightHand" : "LeftHand",
+        red: 97,
-        filter: RayPick.PICK_ENTITIES,
+        green: 247,
-        faceAvatar: true,
+        blue: 255
-        centerEndY: false,
-        renderStates: teleportRenderStates,
-        defaultRenderStates: teleportDefaultRenderStates
-    });
-    this.teleportRayHandInvisible = LaserPointers.createLaserPointer({
-        joint: (_this.hand === RIGHT_HAND) ? "RightHand" : "LeftHand",
-        filter: RayPick.PICK_ENTITIES | RayPick.PICK_INCLUDE_INVISIBLE,
-        faceAvatar: true,
-        centerEndY: false,
-        renderStates: teleportRenderStates
-    });
-    this.teleportRayHeadVisible = LaserPointers.createLaserPointer({
-        joint: "Avatar",
-        filter: RayPick.PICK_ENTITIES,
-        faceAvatar: true,
-        centerEndY: false,
-        renderStates: teleportRenderStates,
-        defaultRenderStates: teleportDefaultRenderStates
-    });
-    this.teleportRayHeadInvisible = LaserPointers.createLaserPointer({
-        joint: "Avatar",
-        filter: RayPick.PICK_ENTITIES | RayPick.PICK_INCLUDE_INVISIBLE,
-        faceAvatar: true,
-        centerEndY: false,
-        renderStates: teleportRenderStates
-    });
-
-    this.teleporterMappingInternalName = 'Hifi-Teleporter-Internal-Dev-' + Math.random();
-    this.teleportMappingInternal = Controller.newMapping(this.teleporterMappingInternalName);
-
-    this.enableMappings = function() {
-        Controller.enableMapping(this.teleporterMappingInternalName);
     };
 
-    this.disableMappings = function() {
+    var COLORS_TELEPORT_CANCEL = {
-        Controller.disableMapping(teleporter.teleporterMappingInternalName);
+        red: 255,
+        green: 184,
+        blue: 73
     };
 
-    this.cleanup = function() {
+    var TELEPORT_CANCEL_RANGE = 1;
-        this.disableMappings();
+    var COOL_IN_DURATION = 300;
 
-        LaserPointers.removeLaserPointer(this.teleportRayHandVisible);
+    var handInfo = {
-        LaserPointers.removeLaserPointer(this.teleportRayHandInvisible);
+        right: {
-        LaserPointers.removeLaserPointer(this.teleportRayHeadVisible);
+            controllerInput: Controller.Standard.RightHand
-        LaserPointers.removeLaserPointer(this.teleportRayHeadInvisible);
+        },
-    };
+        left: {
-
+            controllerInput: Controller.Standard.LeftHand
-    this.buttonPress = function(value) {
-        _this.buttonValue = value;
-    };
-
-    this.parameters = makeDispatcherModuleParameters(
-        80,
-        this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
-        [],
-        100);
-
-    this.enterTeleport = function() {
-        if (coolInTimeout !== null) {
-            Script.clearTimeout(coolInTimeout);
         }
+    };
 
-        this.state = TELEPORTER_STATES.COOL_IN;
+    var cancelPath = {
-        coolInTimeout = Script.setTimeout(function() {
+        type: "line3d",
-            if (_this.state === TELEPORTER_STATES.COOL_IN) {
+        color: COLORS_TELEPORT_CANCEL,
-                _this.state = TELEPORTER_STATES.TARGETTING;
+        ignoreRayIntersection: true,
+        alpha: 1,
+        solid: true,
+        drawInFront: true,
+        glow: 1.0
+    };
+    var teleportPath = {
+        type: "line3d",
+        color: COLORS_TELEPORT_CAN_TELEPORT,
+        ignoreRayIntersection: true,
+        alpha: 1,
+        solid: true,
+        drawInFront: true,
+        glow: 1.0
+    };
+    var seatPath = {
+        type: "line3d",
+        color: COLORS_TELEPORT_SEAT,
+        ignoreRayIntersection: true,
+        alpha: 1,
+        solid: true,
+        drawInFront: true,
+        glow: 1.0
+    };
+    var cancelEnd = {
+        type: "model",
+        url: TOO_CLOSE_MODEL_URL,
+        dimensions: TARGET_MODEL_DIMENSIONS,
+        ignoreRayIntersection: true
+    };
+    var teleportEnd = {
+        type: "model",
+        url: TARGET_MODEL_URL,
+        dimensions: TARGET_MODEL_DIMENSIONS,
+        ignoreRayIntersection: true
+    };
+    var seatEnd = {
+        type: "model",
+        url: SEAT_MODEL_URL,
+        dimensions: TARGET_MODEL_DIMENSIONS,
+        ignoreRayIntersection: true
+    };
+
+    var teleportRenderStates = [{name: "cancel", path: cancelPath, end: cancelEnd},
+                                {name: "teleport", path: teleportPath, end: teleportEnd},
+                                {name: "seat", path: seatPath, end: seatEnd}];
+
+    var DEFAULT_DISTANCE = 50;
+    var teleportDefaultRenderStates = [{name: "cancel", distance: DEFAULT_DISTANCE, path: cancelPath}];
+
+    var coolInTimeout = null;
+    var ignoredEntities = [];
+
+    var TELEPORTER_STATES = {
+        IDLE: 'idle',
+        COOL_IN: 'cool_in',
+        TARGETTING: 'targetting',
+        TARGETTING_INVALID: 'targetting_invalid'
+    };
+
+    var TARGET = {
+        NONE: 'none',            // Not currently targetting anything
+        INVISIBLE: 'invisible',  // The current target is an invvsible surface
+        INVALID: 'invalid',      // The current target is invalid (wall, ceiling, etc.)
+        SURFACE: 'surface',      // The current target is a valid surface
+        SEAT: 'seat'             // The current target is a seat
+    };
+
+    function Teleporter(hand) {
+        var _this = this;
+        this.hand = hand;
+        this.buttonValue = 0;
+        this.disabled = false;  // used by the 'Hifi-Teleport-Disabler' message handler
+        this.active = false;
+        this.state = TELEPORTER_STATES.IDLE;
+        this.currentTarget = TARGET.INVALID;
+        this.currentResult = null;
+
+        this.getOtherModule = function() {
+            var otherModule = this.hand === RIGHT_HAND ? leftTeleporter : rightTeleporter;
+            return otherModule;
+        };
+
+        this.teleportRayHandVisible = LaserPointers.createLaserPointer({
+            joint: (_this.hand === RIGHT_HAND) ? "RightHand" : "LeftHand",
+            filter: RayPick.PICK_ENTITIES,
+            faceAvatar: true,
+            centerEndY: false,
+            renderStates: teleportRenderStates,
+            defaultRenderStates: teleportDefaultRenderStates
+        });
+        this.teleportRayHandInvisible = LaserPointers.createLaserPointer({
+            joint: (_this.hand === RIGHT_HAND) ? "RightHand" : "LeftHand",
+            filter: RayPick.PICK_ENTITIES | RayPick.PICK_INCLUDE_INVISIBLE,
+            faceAvatar: true,
+            centerEndY: false,
+            renderStates: teleportRenderStates
+        });
+        this.teleportRayHeadVisible = LaserPointers.createLaserPointer({
+            joint: "Avatar",
+            filter: RayPick.PICK_ENTITIES,
+            faceAvatar: true,
+            centerEndY: false,
+            renderStates: teleportRenderStates,
+            defaultRenderStates: teleportDefaultRenderStates
+        });
+        this.teleportRayHeadInvisible = LaserPointers.createLaserPointer({
+            joint: "Avatar",
+            filter: RayPick.PICK_ENTITIES | RayPick.PICK_INCLUDE_INVISIBLE,
+            faceAvatar: true,
+            centerEndY: false,
+            renderStates: teleportRenderStates
+        });
+
+        this.cleanup = function() {
+            LaserPointers.removeLaserPointer(this.teleportRayHandVisible);
+            LaserPointers.removeLaserPointer(this.teleportRayHandInvisible);
+            LaserPointers.removeLaserPointer(this.teleportRayHeadVisible);
+            LaserPointers.removeLaserPointer(this.teleportRayHeadInvisible);
+        };
+
+        this.buttonPress = function(value) {
+            _this.buttonValue = value;
+        };
+
+        this.parameters = makeDispatcherModuleParameters(
+            80,
+            this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
+            [],
+            100);
+
+        this.enterTeleport = function() {
+            if (coolInTimeout !== null) {
+                Script.clearTimeout(coolInTimeout);
             }
-        }, COOL_IN_DURATION);
 
-        // pad scale with avatar size
+            this.state = TELEPORTER_STATES.COOL_IN;
-        var AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS = Vec3.multiply(MyAvatar.sensorToWorldScale, TARGET_MODEL_DIMENSIONS);
+            coolInTimeout = Script.setTimeout(function() {
+                if (_this.state === TELEPORTER_STATES.COOL_IN) {
+                    _this.state = TELEPORTER_STATES.TARGETTING;
+                }
+            }, COOL_IN_DURATION);
 
-        if (!Vec3.equal(AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS, cancelEnd.dimensions)) {
+            // pad scale with avatar size
-            cancelEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
+            var AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS = Vec3.multiply(MyAvatar.sensorToWorldScale, TARGET_MODEL_DIMENSIONS);
-            teleportEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
-            seatEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
 
-            teleportRenderStates = [{name: "cancel", path: cancelPath, end: cancelEnd},
+            if (!Vec3.equal(AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS, cancelEnd.dimensions)) {
-                                    {name: "teleport", path: teleportPath, end: teleportEnd},
+                cancelEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
-                                    {name: "seat", path: seatPath, end: seatEnd}];
+                teleportEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
+                seatEnd.dimensions = AVATAR_PROPORTIONAL_TARGET_MODEL_DIMENSIONS;
 
-            LaserPointers.editRenderState(this.teleportRayHandVisible, "cancel", teleportRenderStates[0]);
+                teleportRenderStates = [{name: "cancel", path: cancelPath, end: cancelEnd},
-            LaserPointers.editRenderState(this.teleportRayHandInvisible, "cancel", teleportRenderStates[0]);
+                                        {name: "teleport", path: teleportPath, end: teleportEnd},
-            LaserPointers.editRenderState(this.teleportRayHeadVisible, "cancel", teleportRenderStates[0]);
+                                        {name: "seat", path: seatPath, end: seatEnd}];
-            LaserPointers.editRenderState(this.teleportRayHeadInvisible, "cancel", teleportRenderStates[0]);
 
-            LaserPointers.editRenderState(this.teleportRayHandVisible, "teleport", teleportRenderStates[1]);
+                LaserPointers.editRenderState(this.teleportRayHandVisible, "cancel", teleportRenderStates[0]);
-            LaserPointers.editRenderState(this.teleportRayHandInvisible, "teleport", teleportRenderStates[1]);
+                LaserPointers.editRenderState(this.teleportRayHandInvisible, "cancel", teleportRenderStates[0]);
-            LaserPointers.editRenderState(this.teleportRayHeadVisible, "teleport", teleportRenderStates[1]);
+                LaserPointers.editRenderState(this.teleportRayHeadVisible, "cancel", teleportRenderStates[0]);
-            LaserPointers.editRenderState(this.teleportRayHeadInvisible, "teleport", teleportRenderStates[1]);
+                LaserPointers.editRenderState(this.teleportRayHeadInvisible, "cancel", teleportRenderStates[0]);
 
-            LaserPointers.editRenderState(this.teleportRayHandVisible, "seat", teleportRenderStates[2]);
+                LaserPointers.editRenderState(this.teleportRayHandVisible, "teleport", teleportRenderStates[1]);
-            LaserPointers.editRenderState(this.teleportRayHandInvisible, "seat", teleportRenderStates[2]);
+                LaserPointers.editRenderState(this.teleportRayHandInvisible, "teleport", teleportRenderStates[1]);
-            LaserPointers.editRenderState(this.teleportRayHeadVisible, "seat", teleportRenderStates[2]);
+                LaserPointers.editRenderState(this.teleportRayHeadVisible, "teleport", teleportRenderStates[1]);
-            LaserPointers.editRenderState(this.teleportRayHeadInvisible, "seat", teleportRenderStates[2]);
+                LaserPointers.editRenderState(this.teleportRayHeadInvisible, "teleport", teleportRenderStates[1]);
-        }
-    };
 
-    this.isReady = function(controllerData, deltaTime) {
+                LaserPointers.editRenderState(this.teleportRayHandVisible, "seat", teleportRenderStates[2]);
-        var otherModule = this.getOtherModule();
+                LaserPointers.editRenderState(this.teleportRayHandInvisible, "seat", teleportRenderStates[2]);
-        if (_this.buttonValue !== 0 && !otherModule.active) {
+                LaserPointers.editRenderState(this.teleportRayHeadVisible, "seat", teleportRenderStates[2]);
-            this.active = true;
+                LaserPointers.editRenderState(this.teleportRayHeadInvisible, "seat", teleportRenderStates[2]);
-            this.enterTeleport();
+            }
-            return makeRunningValues(true, [], []);
+        };
-        }
-        return makeRunningValues(false, [], []);
-    };
 
-    this.run = function(controllerData, deltaTime) {
+        this.isReady = function(controllerData, deltaTime) {
-        //_this.state = TELEPORTER_STATES.TARGETTING;
+            var otherModule = this.getOtherModule();
+            if (!this.disabled && this.buttonValue !== 0 && !otherModule.active) {
+                this.active = true;
+                this.enterTeleport();
+                return makeRunningValues(true, [], []);
+            }
+            return makeRunningValues(false, [], []);
+        };
 
-        // Get current hand pose information to see if the pose is valid
+        this.run = function(controllerData, deltaTime) {
-        var pose = Controller.getPoseValue(handInfo[(_this.hand === RIGHT_HAND) ? 'right' : 'left'].controllerInput);
+
-        var mode = pose.valid ? _this.hand : 'head';
+            // Get current hand pose information to see if the pose is valid
-        if (!pose.valid) {
+            var pose = Controller.getPoseValue(handInfo[(_this.hand === RIGHT_HAND) ? 'right' : 'left'].controllerInput);
+            var mode = pose.valid ? _this.hand : 'head';
+            if (!pose.valid) {
+                LaserPointers.disableLaserPointer(_this.teleportRayHandVisible);
+                LaserPointers.disableLaserPointer(_this.teleportRayHandInvisible);
+                LaserPointers.enableLaserPointer(_this.teleportRayHeadVisible);
+                LaserPointers.enableLaserPointer(_this.teleportRayHeadInvisible);
+            } else {
+                LaserPointers.enableLaserPointer(_this.teleportRayHandVisible);
+                LaserPointers.enableLaserPointer(_this.teleportRayHandInvisible);
+                LaserPointers.disableLaserPointer(_this.teleportRayHeadVisible);
+                LaserPointers.disableLaserPointer(_this.teleportRayHeadInvisible);
+            }
+
+            // We do up to 2 ray picks to find a teleport location.
+            // There are 2 types of teleport locations we are interested in:
+            //   1. A visible floor. This can be any entity surface that points within some degree of "up"
+            //   2. A seat. The seat can be visible or invisible.
+            //
+            //  * In the first pass we pick against visible and invisible entities so that we can find invisible seats.
+            //    We might hit an invisible entity that is not a seat, so we need to do a second pass.
+            //  * In the second pass we pick against visible entities only.
+            //
+            var result;
+            if (mode === 'head') {
+                result = LaserPointers.getPrevRayPickResult(_this.teleportRayHeadInvisible);
+            } else {
+                result = LaserPointers.getPrevRayPickResult(_this.teleportRayHandInvisible);
+            }
+
+            var teleportLocationType = getTeleportTargetType(result);
+            if (teleportLocationType === TARGET.INVISIBLE) {
+                if (mode === 'head') {
+                    result = LaserPointers.getPrevRayPickResult(_this.teleportRayHeadVisible);
+                } else {
+                    result = LaserPointers.getPrevRayPickResult(_this.teleportRayHandVisible);
+                }
+                teleportLocationType = getTeleportTargetType(result);
+            }
+
+            if (teleportLocationType === TARGET.NONE) {
+                // Use the cancel default state
+                this.setTeleportState(mode, "cancel", "");
+            } else if (teleportLocationType === TARGET.INVALID || teleportLocationType === TARGET.INVISIBLE) {
+                this.setTeleportState(mode, "", "cancel");
+            } else if (teleportLocationType === TARGET.SURFACE) {
+                if (this.state === TELEPORTER_STATES.COOL_IN) {
+                    this.setTeleportState(mode, "cancel", "");
+                } else {
+                    this.setTeleportState(mode, "teleport", "");
+                }
+            } else if (teleportLocationType === TARGET.SEAT) {
+                this.setTeleportState(mode, "", "seat");
+            }
+            return this.teleport(result, teleportLocationType);
+        };
+
+        this.teleport = function(newResult, target) {
+            var result = newResult;
+            if (_this.buttonValue !== 0) {
+                return makeRunningValues(true, [], []);
+            }
+
+            if (target === TARGET.NONE || target === TARGET.INVALID || this.state === TELEPORTER_STATES.COOL_IN) {
+                // Do nothing
+            } else if (target === TARGET.SEAT) {
+                Entities.callEntityMethod(result.objectID, 'sit');
+            } else if (target === TARGET.SURFACE) {
+                var offset = getAvatarFootOffset();
+                result.intersection.y += offset;
+                MyAvatar.goToLocation(result.intersection, false, {x: 0, y: 0, z: 0, w: 1}, false);
+                HMD.centerUI();
+                MyAvatar.centerBody();
+            }
+
+            this.disableLasers();
+            this.active = false;
+            return makeRunningValues(false, [], []);
+        };
+
+        this.disableLasers = function() {
             LaserPointers.disableLaserPointer(_this.teleportRayHandVisible);
             LaserPointers.disableLaserPointer(_this.teleportRayHandInvisible);
-            LaserPointers.enableLaserPointer(_this.teleportRayHeadVisible);
-            LaserPointers.enableLaserPointer(_this.teleportRayHeadInvisible);
-        } else {
-            LaserPointers.enableLaserPointer(_this.teleportRayHandVisible);
-            LaserPointers.enableLaserPointer(_this.teleportRayHandInvisible);
             LaserPointers.disableLaserPointer(_this.teleportRayHeadVisible);
             LaserPointers.disableLaserPointer(_this.teleportRayHeadInvisible);
-        }
+        };
 
-        // We do up to 2 ray picks to find a teleport location.
+        this.setTeleportState = function(mode, visibleState, invisibleState) {
-        // There are 2 types of teleport locations we are interested in:
-        //   1. A visible floor. This can be any entity surface that points within some degree of "up"
-        //   2. A seat. The seat can be visible or invisible.
-        //
-        //  * In the first pass we pick against visible and invisible entities so that we can find invisible seats.
-        //    We might hit an invisible entity that is not a seat, so we need to do a second pass.
-        //  * In the second pass we pick against visible entities only.
-        //
-        var result;
-        if (mode === 'head') {
-            result = LaserPointers.getPrevRayPickResult(_this.teleportRayHeadInvisible);
-        } else {
-            result = LaserPointers.getPrevRayPickResult(_this.teleportRayHandInvisible);
-        }
-
-        var teleportLocationType = getTeleportTargetType(result);
-        if (teleportLocationType === TARGET.INVISIBLE) {
             if (mode === 'head') {
-                result = LaserPointers.getPrevRayPickResult(_this.teleportRayHeadVisible);
+                LaserPointers.setRenderState(_this.teleportRayHeadVisible, visibleState);
+                LaserPointers.setRenderState(_this.teleportRayHeadInvisible, invisibleState);
             } else {
-                result = LaserPointers.getPrevRayPickResult(_this.teleportRayHandVisible);
+                LaserPointers.setRenderState(_this.teleportRayHandVisible, visibleState);
+                LaserPointers.setRenderState(_this.teleportRayHandInvisible, invisibleState);
             }
-            teleportLocationType = getTeleportTargetType(result);
+        };
-        }
 
-        if (teleportLocationType === TARGET.NONE) {
+        this.setIgnoreEntities = function(entitiesToIgnore) {
-            // Use the cancel default state
+            LaserPointers.setIgnoreEntities(this.teleportRayHandVisible, entitiesToIgnore);
-            this.setTeleportState(mode, "cancel", "");
+            LaserPointers.setIgnoreEntities(this.teleportRayHandInvisible, entitiesToIgnore);
-        } else if (teleportLocationType === TARGET.INVALID || teleportLocationType === TARGET.INVISIBLE) {
+            LaserPointers.setIgnoreEntities(this.teleportRayHeadVisible, entitiesToIgnore);
-            this.setTeleportState(mode, "", "cancel");
+            LaserPointers.setIgnoreEntities(this.teleportRayHeadInvisible, entitiesToIgnore);
-        } else if (teleportLocationType === TARGET.SURFACE) {
+        };
-            if (this.state === TELEPORTER_STATES.COOL_IN) {
+    }
-                this.setTeleportState(mode, "cancel", "");
-            } else {
-                this.setTeleportState(mode, "teleport", "");
-            }
-        } else if (teleportLocationType === TARGET.SEAT) {
-            this.setTeleportState(mode, "", "seat");
-        }
-        return this.teleport(result, teleportLocationType);
-    };
-
-    this.teleport = function(newResult, target) {
-        var result = newResult;
-        if (_this.buttonValue !== 0) {
-            return makeRunningValues(true, [], []);
-        }
-
-        if (target === TARGET.NONE || target === TARGET.INVALID || this.state === TELEPORTER_STATES.COOL_IN) {
-            // Do nothing
-        } else if (target === TARGET.SEAT) {
-            Entities.callEntityMethod(result.objectID, 'sit');
-        } else if (target === TARGET.SURFACE) {
-            var offset = getAvatarFootOffset();
-            result.intersection.y += offset;
-            MyAvatar.goToLocation(result.intersection, false, {x: 0, y: 0, z: 0, w: 1}, false);
-            HMD.centerUI();
-            MyAvatar.centerBody();
-        }
-
-        this.disableLasers();
-        this.active = false;
-        return makeRunningValues(false, [], []);
-    };
-
-    this.disableLasers = function() {
-        LaserPointers.disableLaserPointer(_this.teleportRayHandVisible);
-        LaserPointers.disableLaserPointer(_this.teleportRayHandInvisible);
-        LaserPointers.disableLaserPointer(_this.teleportRayHeadVisible);
-        LaserPointers.disableLaserPointer(_this.teleportRayHeadInvisible);
-    };
-
-    this.setTeleportState = function(mode, visibleState, invisibleState) {
-        if (mode === 'head') {
-            LaserPointers.setRenderState(_this.teleportRayHeadVisible, visibleState);
-            LaserPointers.setRenderState(_this.teleportRayHeadInvisible, invisibleState);
-        } else {
-            LaserPointers.setRenderState(_this.teleportRayHandVisible, visibleState);
-            LaserPointers.setRenderState(_this.teleportRayHandInvisible, invisibleState);
-        }
-    };
-}
 
     // related to repositioning the avatar after you teleport
     var FOOT_JOINT_NAMES = ["RightToe_End", "RightToeBase", "RightFoot"];
     var DEFAULT_ROOT_TO_FOOT_OFFSET = 0.5;
     function getAvatarFootOffset() {
-        
+
         // find a valid foot jointIndex
         var footJointIndex = -1;
         var i, l = FOOT_JOINT_NAMES.length;
         for (i = 0; i < l; i++) {
             footJointIndex = MyAvatar.getJointIndex(FOOT_JOINT_NAMES[i]);
-            if (footJointIndex != -1) {
+            if (footJointIndex !== -1) {
                 break;
             }
         }
-        if (footJointIndex != -1) {
+        if (footJointIndex !== -1) {
             // default vertical offset from foot to avatar root.
             var footPos = MyAvatar.getAbsoluteDefaultJointTranslationInObjectFrame(footJointIndex);
             if (footPos.x === 0 && footPos.y === 0 && footPos.z === 0.0) {
@@ -417,23 +382,8 @@ function Teleporter(hand) {
         }
     }
 
-    var leftPad = new ThumbPad('left');
-    var rightPad = new ThumbPad('right');
-    
     var mappingName, teleportMapping;
 
-    var TELEPORT_DELAY = 0;
-
-    function isMoving() {
-        var LY = Controller.getValue(Controller.Standard.LY);
-        var LX = Controller.getValue(Controller.Standard.LX);
-        if (LY !== 0 || LX !== 0) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
     function parseJSON(json) {
         try {
             return JSON.parse(json);
@@ -447,10 +397,10 @@ function Teleporter(hand) {
     // you can't teleport there.
     var MAX_ANGLE_FROM_UP_TO_TELEPORT = 70;
     function getTeleportTargetType(result) {
-        if (result.type == RayPick.INTERSECTED_NONE) {
+        if (result.type === RayPick.INTERSECTED_NONE) {
             return TARGET.NONE;
         }
-        
+
         var props = Entities.getEntityProperties(result.objectID, ['userData', 'visible']);
         var data = parseJSON(props.userData);
         if (data !== undefined && data.seat !== undefined) {
@@ -472,7 +422,7 @@ function Teleporter(hand) {
 
         if (angleUp < (90 - MAX_ANGLE_FROM_UP_TO_TELEPORT) ||
             angleUp > (90 + MAX_ANGLE_FROM_UP_TO_TELEPORT) ||
-            Vec3.distance(MyAvatar.position, result.intersection) <= TELEPORT_CANCEL_RANGE) {
+            Vec3.distance(MyAvatar.position, result.intersection) <= TELEPORT_CANCEL_RANGE * MyAvatar.sensorToWorldScale) {
             return TARGET.INVALID;
         } else {
             return TARGET.SURFACE;
@@ -482,7 +432,7 @@ function Teleporter(hand) {
     function registerMappings() {
         mappingName = 'Hifi-Teleporter-Dev-' + Math.random();
         teleportMapping = Controller.newMapping(mappingName);
-        
+
         teleportMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(rightTeleporter.buttonPress);
         teleportMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(leftTeleporter.buttonPress);
     }
@@ -502,41 +452,37 @@ function Teleporter(hand) {
     }
     Script.scriptEnding.connect(cleanup);
 
-    var setIgnoreEntities = function() {
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayRightVisible, ignoredEntities);
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayRightInvisible, ignoredEntities);
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayLeftVisible, ignoredEntities);
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayLeftInvisible, ignoredEntities);
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayHeadVisible, ignoredEntities);
-        LaserPointers.setIgnoreEntities(teleporter.teleportRayHeadInvisible, ignoredEntities);
-    };
-
-    var isDisabled = false;
     var handleTeleportMessages = function(channel, message, sender) {
         if (sender === MyAvatar.sessionUUID) {
             if (channel === 'Hifi-Teleport-Disabler') {
                 if (message === 'both') {
-                    isDisabled = 'both';
+                    leftTeleporter.disabled = true;
+                    rightTeleporter.disabled = true;
                 }
                 if (message === 'left') {
-                    isDisabled = 'left';
+                    leftTeleporter.disabled = true;
+                    rightTeleporter.disabled = false;
                 }
                 if (message === 'right') {
-                    isDisabled = 'right';
+                    leftTeleporter.disabled = false;
+                    rightTeleporter.disabled = true;
                 }
                 if (message === 'none') {
-                    isDisabled = false;
+                    leftTeleporter.disabled = false;
+                    rightTeleporter.disabled = false;
                 }
             } else if (channel === 'Hifi-Teleport-Ignore-Add' &&
                        !Uuid.isNull(message) &&
                        ignoredEntities.indexOf(message) === -1) {
                 ignoredEntities.push(message);
-                setIgnoreEntities();
+                leftTeleporter.setIgnoreEntities(ignoredEntities);
+                rightTeleporter.setIgnoreEntities(ignoredEntities);
             } else if (channel === 'Hifi-Teleport-Ignore-Remove' && !Uuid.isNull(message)) {
                 var removeIndex = ignoredEntities.indexOf(message);
                 if (removeIndex > -1) {
                     ignoredEntities.splice(removeIndex, 1);
-                    setIgnoreEntities();
+                    leftTeleporter.setIgnoreEntities(ignoredEntities);
+                    rightTeleporter.setIgnoreEntities(ignoredEntities);
                 }
             }
         }

scripts/system/libraries/WebTablet.js

@@ -222,6 +222,10 @@ WebTablet.prototype.getTabletTextureResolution = function() {
     }
 };
 
+WebTablet.prototype.getLandscape = function() {
+    return this.landscape;
+}
+
 WebTablet.prototype.setLandscape = function(newLandscapeValue) {
     if (this.landscape === newLandscapeValue) {
         return;

scripts/system/tablet-ui/tabletUI.js

@@ -192,7 +192,9 @@
             return;
         }
 
-        if (now - validCheckTime > MSECS_PER_SEC) {
+        var needInstantUpdate = UIWebTablet && UIWebTablet.getLandscape() !== landscape;
+
+        if ((now - validCheckTime > MSECS_PER_SEC) || needInstantUpdate) {
             validCheckTime = now;
 
             updateTabletWidthFromSettings();