Merge branch 'master' of github.com:highfidelity/hifi into tablet-ui

interface/src/avatar/CauterizedModel.cpp

@@ -56,9 +56,9 @@ void CauterizedModel::createVisibleRenderItemSet() {
         }
 
         // We should not have any existing renderItems if we enter this section of code
-        Q_ASSERT(_modelMeshRenderItemsSet.isEmpty());
+        Q_ASSERT(_modelMeshRenderItems.isEmpty());
 
-        _modelMeshRenderItemsSet.clear();
+        _modelMeshRenderItems.clear();
 
         Transform transform;
         transform.setTranslation(_translation);
@@ -81,7 +81,7 @@ void CauterizedModel::createVisibleRenderItemSet() {
             int numParts = (int)mesh->getNumParts();
             for (int partIndex = 0; partIndex < numParts; partIndex++) {
                 auto ptr = std::make_shared<CauterizedMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
-                _modelMeshRenderItemsSet << std::static_pointer_cast<ModelMeshPartPayload>(ptr);
+                _modelMeshRenderItems << std::static_pointer_cast<ModelMeshPartPayload>(ptr);
                 shapeID++;
             }
         }

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -371,7 +371,18 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
         _model->updateRenderItems();
     }
 
-    if (hasModel()) {
+    if (!hasModel() || (_model && _model->didVisualGeometryRequestFail())) {
+        static glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f);
+        gpu::Batch& batch = *args->_batch;
+        bool success;
+        auto shapeTransform = getTransformToCenter(success);
+        if (success) {
+            batch.setModelTransform(shapeTransform); // we want to include the scale as well
+            DependencyManager::get<GeometryCache>()->renderWireCubeInstance(batch, greenColor);
+        }
+        return;
+    }
+
     // Prepare the current frame
     {
         if (!_model || _needsModelReload) {
@@ -473,16 +484,6 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
             getModel(_myRenderer);
         }
     }
-    } else {
-        static glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f);
-        gpu::Batch& batch = *args->_batch;
-        bool success;
-        auto shapeTransform = getTransformToCenter(success);
-        if (success) {
-            batch.setModelTransform(shapeTransform); // we want to include the scale as well
-            DependencyManager::get<GeometryCache>()->renderWireCubeInstance(batch, greenColor);
-        }
-    }
 }
 
 ModelPointer RenderableModelEntityItem::getModelNotSafe() {
@@ -587,6 +588,10 @@ EntityItemProperties RenderableModelEntityItem::getProperties(EntityPropertyFlag
     return properties;
 }
 
+bool RenderableModelEntityItem::supportsDetailedRayIntersection() const {
+    return _model && _model->isLoaded();
+}
+
 bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction, 
                          bool& keepSearching, OctreeElementPointer& element, float& distance, BoxFace& face, 
                          glm::vec3& surfaceNormal, void** intersectedObject, bool precisionPicking) const {
@@ -807,6 +812,13 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
         auto& meshes = _model->getGeometry()->getMeshes();
         int32_t numMeshes = (int32_t)(meshes.size());
 
+        const int MAX_ALLOWED_MESH_COUNT = 500;
+        if (numMeshes > MAX_ALLOWED_MESH_COUNT) {
+            // too many will cause the deadlock timer to throw...
+            shapeInfo.setParams(SHAPE_TYPE_BOX, 0.5f * dimensions);
+            return;
+        }
+
         ShapeInfo::PointCollection& pointCollection = shapeInfo.getPointCollection();
         pointCollection.clear();
         if (type == SHAPE_TYPE_SIMPLE_COMPOUND) {

libraries/entities-renderer/src/RenderableModelEntityItem.h

@@ -46,7 +46,7 @@ public:
 
     void updateModelBounds();
     virtual void render(RenderArgs* args) override;
-    virtual bool supportsDetailedRayIntersection() const override { return true; }
+    virtual bool supportsDetailedRayIntersection() const override;
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                         bool& keepSearching, OctreeElementPointer& element, float& distance,
                         BoxFace& face, glm::vec3& surfaceNormal,

libraries/physics/src/PhysicalEntitySimulation.cpp

@@ -208,6 +208,7 @@ void PhysicalEntitySimulation::getObjectsToAddToPhysics(VectorOfMotionStates& re
         assert(!entity->getPhysicsInfo());
         if (entity->isDead()) {
             prepareEntityForDelete(entity);
+            entityItr = _entitiesToAddToPhysics.erase(entityItr);
         } else if (!entity->shouldBePhysical()) {
             // this entity should no longer be on the internal _entitiesToAddToPhysics
             entityItr = _entitiesToAddToPhysics.erase(entityItr);

libraries/render-utils/src/Model.cpp

@@ -176,11 +176,11 @@ void Model::setOffset(const glm::vec3& offset) {
 }
 
 void Model::calculateTextureInfo() {
-    if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItems.isEmpty()) {
+    if (!_hasCalculatedTextureInfo && isLoaded() && getGeometry()->areTexturesLoaded() && !_modelMeshRenderItemsMap.isEmpty()) {
         size_t textureSize = 0;
         int textureCount = 0;
         bool allTexturesLoaded = true;
-        foreach(auto renderItem, _modelMeshRenderItemsSet) {
+        foreach(auto renderItem, _modelMeshRenderItems) {
             auto meshPart = renderItem.get();
             textureSize += meshPart->getMaterialTextureSize();
             textureCount += meshPart->getMaterialTextureCount();
@@ -236,7 +236,7 @@ void Model::updateRenderItems() {
         uint32_t deleteGeometryCounter = self->_deleteGeometryCounter;
 
         render::PendingChanges pendingChanges;
-        foreach (auto itemID, self->_modelMeshRenderItems.keys()) {
+        foreach (auto itemID, self->_modelMeshRenderItemsMap.keys()) {
             pendingChanges.updateItem<ModelMeshPartPayload>(itemID, [deleteGeometryCounter](ModelMeshPartPayload& data) {
                 if (data._model && data._model->isLoaded()) {
                     // Ensure the model geometry was not reset between frames
@@ -259,7 +259,7 @@ void Model::updateRenderItems() {
         Transform collisionMeshOffset;
         collisionMeshOffset.setIdentity();
         Transform modelTransform = self->getTransform();
-        foreach (auto itemID, self->_collisionRenderItems.keys()) {
+		foreach(auto itemID, self->_collisionRenderItemsMap.keys()) {
             pendingChanges.updateItem<MeshPartPayload>(itemID, [modelTransform, collisionMeshOffset](MeshPartPayload& data) {
                 // update the model transform for this render item.
                 data.updateTransform(modelTransform, collisionMeshOffset);
@@ -539,11 +539,11 @@ void Model::setVisibleInScene(bool newValue, std::shared_ptr<render::Scene> scen
         _isVisible = newValue;
 
         render::PendingChanges pendingChanges;
-        foreach (auto item, _modelMeshRenderItems.keys()) {
+        foreach (auto item, _modelMeshRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _modelMeshRenderItems[item]);
+            pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
         }
-        foreach (auto item, _collisionRenderItems.keys()) {
+		foreach(auto item, _collisionRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _collisionRenderItems[item]);
+			pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
         }
         scene->enqueuePendingChanges(pendingChanges);
     }
@@ -555,11 +555,11 @@ void Model::setLayeredInFront(bool layered, std::shared_ptr<render::Scene> scene
         _isLayeredInFront = layered;
 
         render::PendingChanges pendingChanges;
-        foreach(auto item, _modelMeshRenderItems.keys()) {
+        foreach(auto item, _modelMeshRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _modelMeshRenderItems[item]);
+            pendingChanges.resetItem(item, _modelMeshRenderItemsMap[item]);
         }
-        foreach(auto item, _collisionRenderItems.keys()) {
+		foreach(auto item, _collisionRenderItemsMap.keys()) {
-            pendingChanges.resetItem(item, _collisionRenderItems[item]);
+			pendingChanges.resetItem(item, _collisionRenderItemsMap[item]);
         }
         scene->enqueuePendingChanges(pendingChanges);
     }
@@ -576,39 +576,39 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
     bool somethingAdded = false;
     if (_collisionGeometry) {
         if (_collisionRenderItems.empty()) {
-            foreach (auto renderItem, _collisionRenderItemsSet) {
+            foreach (auto renderItem, _collisionRenderItems) {
                 auto item = scene->allocateID();
                 auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
-                if (statusGetters.size()) {
+				if (_collisionRenderItems.empty() && statusGetters.size()) {
                     renderPayload->addStatusGetters(statusGetters);
                 }
                 pendingChanges.resetItem(item, renderPayload);
-                _collisionRenderItems.insert(item, renderPayload);
+				_collisionRenderItemsMap.insert(item, renderPayload);
             }
             somethingAdded = !_collisionRenderItems.empty();
         }
     } else {
-        if (_modelMeshRenderItems.empty()) {
+        if (_modelMeshRenderItemsMap.empty()) {
 
             bool hasTransparent = false;
             size_t verticesCount = 0;
-            foreach(auto renderItem, _modelMeshRenderItemsSet) {
+            foreach(auto renderItem, _modelMeshRenderItems) {
                 auto item = scene->allocateID();
                 auto renderPayload = std::make_shared<ModelMeshPartPayload::Payload>(renderItem);
-                if (statusGetters.size()) {
+				if (_modelMeshRenderItemsMap.empty() && statusGetters.size()) {
                     renderPayload->addStatusGetters(statusGetters);
                 }
                 pendingChanges.resetItem(item, renderPayload);
 
                 hasTransparent = hasTransparent || renderItem.get()->getShapeKey().isTranslucent();
                 verticesCount += renderItem.get()->getVerticesCount();
-                _modelMeshRenderItems.insert(item, renderPayload);
+                _modelMeshRenderItemsMap.insert(item, renderPayload);
                 _modelMeshRenderItemIDs.emplace_back(item);
             }
-            somethingAdded = !_modelMeshRenderItems.empty();
+            somethingAdded = !_modelMeshRenderItemsMap.empty();
 
             _renderInfoVertexCount = verticesCount;
-            _renderInfoDrawCalls = _modelMeshRenderItems.count();
+            _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
             _renderInfoHasTransparent = hasTransparent;
         }
     }
@@ -623,18 +623,18 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene,
 }
 
 void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
-    foreach (auto item, _modelMeshRenderItems.keys()) {
+    foreach (auto item, _modelMeshRenderItemsMap.keys()) {
         pendingChanges.removeItem(item);
     }
     _modelMeshRenderItemIDs.clear();
+    _modelMeshRenderItemsMap.clear();
     _modelMeshRenderItems.clear();
-    _modelMeshRenderItemsSet.clear();
 
-    foreach (auto item, _collisionRenderItems.keys()) {
+	foreach(auto item, _collisionRenderItemsMap.keys()) {
         pendingChanges.removeItem(item);
     }
     _collisionRenderItems.clear();
-    _collisionRenderItemsSet.clear();
+    _collisionRenderItems.clear();
     _addedToScene = false;
 
     _renderInfoVertexCount = 0;
@@ -1052,8 +1052,8 @@ void Model::updateRig(float deltaTime, glm::mat4 parentTransform) {
 }
 
 void Model::computeMeshPartLocalBounds() {
-    for (auto& part : _modelMeshRenderItemsSet) {
+    for (auto& part : _modelMeshRenderItems) {
-        assert(part->_meshIndex < _modelMeshRenderItemsSet.size());
+        assert(part->_meshIndex < _modelMeshRenderItems.size());
         const Model::MeshState& state = _meshStates.at(part->_meshIndex);
         part->computeAdjustedLocalBound(state.clusterMatrices);
     }
@@ -1167,7 +1167,7 @@ AABox Model::getRenderableMeshBound() const {
     } else {
         // Build a bound using the last known bound from all the renderItems.
         AABox totalBound;
-        for (auto& renderItem : _modelMeshRenderItemsSet) {
+        for (auto& renderItem : _modelMeshRenderItems) {
             totalBound += renderItem->getBound();
         }
         return totalBound;
@@ -1180,11 +1180,11 @@ const render::ItemIDs& Model::fetchRenderItemIDs() const {
 
 void Model::createRenderItemSet() {
     if (_collisionGeometry) {
-        if (_collisionRenderItemsSet.empty()) {
+        if (_collisionRenderItems.empty()) {
             createCollisionRenderItemSet();
         }
     } else {
-        if (_modelMeshRenderItemsSet.empty()) {
+        if (_modelMeshRenderItems.empty()) {
             createVisibleRenderItemSet();
         }
     }
@@ -1201,9 +1201,9 @@ void Model::createVisibleRenderItemSet() {
     }
 
     // We should not have any existing renderItems if we enter this section of code
-    Q_ASSERT(_modelMeshRenderItemsSet.isEmpty());
+    Q_ASSERT(_modelMeshRenderItems.isEmpty());
 
-    _modelMeshRenderItemsSet.clear();
+    _modelMeshRenderItems.clear();
 
     Transform transform;
     transform.setTranslation(_translation);
@@ -1225,7 +1225,7 @@ void Model::createVisibleRenderItemSet() {
         // Create the render payloads
         int numParts = (int)mesh->getNumParts();
         for (int partIndex = 0; partIndex < numParts; partIndex++) {
-            _modelMeshRenderItemsSet << std::make_shared<ModelMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
+            _modelMeshRenderItems << std::make_shared<ModelMeshPartPayload>(this, i, partIndex, shapeID, transform, offset);
             shapeID++;
         }
     }
@@ -1241,7 +1241,7 @@ void Model::createCollisionRenderItemSet() {
     const auto& meshes = _collisionGeometry->getMeshes();
 
     // We should not have any existing renderItems if we enter this section of code
-    Q_ASSERT(_collisionRenderItemsSet.isEmpty());
+    Q_ASSERT(_collisionRenderItems.isEmpty());
 
     Transform identity;
     identity.setIdentity();
@@ -1262,7 +1262,7 @@ void Model::createCollisionRenderItemSet() {
             model::MaterialPointer& material = _collisionMaterials[partIndex % NUM_COLLISION_HULL_COLORS];
             auto payload = std::make_shared<MeshPartPayload>(mesh, partIndex, material);
             payload->updateTransform(identity, offset);
-            _collisionRenderItemsSet << payload;
+            _collisionRenderItems << payload;
         }
     }
 }
@@ -1283,28 +1283,28 @@ bool Model::initWhenReady(render::ScenePointer scene) {
 
     bool addedPendingChanges = false;
     if (_collisionGeometry) {
-        foreach (auto renderItem, _collisionRenderItemsSet) {
+        foreach (auto renderItem, _collisionRenderItems) {
             auto item = scene->allocateID();
             auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderItem);
-            _collisionRenderItems.insert(item, renderPayload);
+            _collisionRenderItemsMap.insert(item, renderPayload);
             pendingChanges.resetItem(item, renderPayload);
         }
         addedPendingChanges = !_collisionRenderItems.empty();
     } else {
         bool hasTransparent = false;
         size_t verticesCount = 0;
-        foreach (auto renderItem, _modelMeshRenderItemsSet) {
+        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();
-            _modelMeshRenderItems.insert(item, renderPayload);
+            _modelMeshRenderItemsMap.insert(item, renderPayload);
             pendingChanges.resetItem(item, renderPayload);
         }
-        addedPendingChanges = !_modelMeshRenderItems.empty();
+        addedPendingChanges = !_modelMeshRenderItemsMap.empty();
         _renderInfoVertexCount = verticesCount;
-        _renderInfoDrawCalls = _modelMeshRenderItems.count();
+        _renderInfoDrawCalls = _modelMeshRenderItemsMap.count();
         _renderInfoHasTransparent = hasTransparent;
     }
     _addedToScene = addedPendingChanges;

libraries/render-utils/src/Model.h

@@ -248,7 +248,7 @@ public:
     const MeshState& getMeshState(int index) { return _meshStates.at(index); }
 
     uint32_t getGeometryCounter() const { return _deleteGeometryCounter; }
-    const QMap<render::ItemID, render::PayloadPointer>& getRenderItems() const { return _modelMeshRenderItems; }
+    const QMap<render::ItemID, render::PayloadPointer>& getRenderItems() const { return _modelMeshRenderItemsMap; }
 
     void renderDebugMeshBoxes(gpu::Batch& batch);
 
@@ -373,11 +373,11 @@ protected:
 
     static AbstractViewStateInterface* _viewState;
 
-    QSet<std::shared_ptr<MeshPartPayload>> _collisionRenderItemsSet;
+    QVector<std::shared_ptr<MeshPartPayload>> _collisionRenderItems;
-    QMap<render::ItemID, render::PayloadPointer> _collisionRenderItems;
+    QMap<render::ItemID, render::PayloadPointer> _collisionRenderItemsMap;
 
-    QSet<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItemsSet;
+	QVector<std::shared_ptr<ModelMeshPartPayload>> _modelMeshRenderItems;
-    QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItems;
+	QMap<render::ItemID, render::PayloadPointer> _modelMeshRenderItemsMap;
 
     render::ItemIDs _modelMeshRenderItemIDs;
 

plugins/oculus/src/OculusControllerManager.cpp

@@ -20,6 +20,8 @@
 #include <PerfStat.h>
 #include <PathUtils.h>
 
+#include <OVR_CAPI.h>
+
 #include "OculusHelpers.h"
 
 Q_DECLARE_LOGGING_CATEGORY(oculus)
@@ -42,26 +44,33 @@ bool OculusControllerManager::activate() {
     }
     Q_ASSERT(_session);
 
-    // register with UserInputMapper
+    checkForConnectedDevices();
-    auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
+
+    return true;
+}
+
+void OculusControllerManager::checkForConnectedDevices() {
+    if (_touch && _remote) {
+        return;
+    }
 
     unsigned int controllerConnected = ovr_GetConnectedControllerTypes(_session);
 
-    if ((controllerConnected & ovrControllerType_Remote) == ovrControllerType_Remote) {
+    if (!_remote && (controllerConnected & ovrControllerType_Remote) == ovrControllerType_Remote) {
         if (OVR_SUCCESS(ovr_GetInputState(_session, ovrControllerType_Remote, &_inputState))) {
+            auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
             _remote = std::make_shared<RemoteDevice>(*this);
             userInputMapper->registerDevice(_remote);
         }
     }
 
-    if ((controllerConnected & ovrControllerType_Touch) != 0) {
+    if (!_touch && (controllerConnected & ovrControllerType_Touch) != 0) {
         if (OVR_SUCCESS(ovr_GetInputState(_session, ovrControllerType_Touch, &_inputState))) {
+            auto userInputMapper = DependencyManager::get<controller::UserInputMapper>();
             _touch = std::make_shared<TouchDevice>(*this);
             userInputMapper->registerDevice(_touch);
         }
     }
-
-    return true;
 }
 
 void OculusControllerManager::deactivate() {
@@ -85,6 +94,8 @@ void OculusControllerManager::deactivate() {
 void OculusControllerManager::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
     PerformanceTimer perfTimer("OculusControllerManager::TouchDevice::update");
 
+    checkForConnectedDevices();
+
     if (_touch) {
         if (OVR_SUCCESS(ovr_GetInputState(_session, ovrControllerType_Touch, &_inputState))) {
             _touch->update(deltaTime, inputCalibrationData);

plugins/oculus/src/OculusControllerManager.h

@@ -91,6 +91,8 @@ private:
         friend class OculusControllerManager;
     };
 
+    void checkForConnectedDevices();
+
     ovrSession _session { nullptr };
     ovrInputState _inputState {};
     RemoteDevice::Pointer _remote;

scripts/developer/libraries/utils.js

@@ -311,3 +311,6 @@ clamp = function(val, min, max){
      return Math.max(min, Math.min(max, val))
  } 
 
+easeIn = function(t) {
+    return Math.pow(t / 1, 5);
+}

scripts/system/audioMuteOverlay.js

@@ -0,0 +1,104 @@
+"use strict";
+/* jslint vars: true, plusplus: true, forin: true*/
+/* globals Tablet, Script, AvatarList, Users, Entities, MyAvatar, Camera, Overlays, Vec3, Quat, Controller, print, getControllerWorldLocation */
+/* eslint indent: ["error", 4, { "outerIIFEBody": 0 }] */
+//
+// audioMuteOverlay.js
+//
+// client script that creates an overlay to provide mute feedback
+//
+// Created by Triplelexx on 17/03/09
+// Copyright 2017 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
+//
+
+(function() { // BEGIN LOCAL_SCOPE
+    var utilsPath = Script.resolvePath('../developer/libraries/utils.js');
+    Script.include(utilsPath);
+
+    var TWEEN_SPEED = 0.025;
+    var MIX_AMOUNT = 0.25;
+
+    var overlayPosition = Vec3.ZERO;
+    var tweenPosition = 0;
+    var startColor = {
+        red: 170,
+        green: 170,
+        blue: 170
+    };
+    var endColor = {
+        red: 255,
+        green: 0,
+        blue: 0
+    };
+    var overlayID;
+
+    Script.update.connect(update);
+    Script.scriptEnding.connect(cleanup);
+
+    function update(dt) {
+        if (!AudioDevice.getMuted()) {
+            if (hasOverlay()) {
+                deleteOverlay();
+            }
+        } else if (!hasOverlay()) {
+            createOverlay();
+        } else {
+            updateOverlay();
+        }    
+    }
+
+    function getOffsetPosition() {
+        return Vec3.sum(Camera.position, Quat.getFront(Camera.orientation));
+    }
+
+    function createOverlay() {
+        overlayPosition = getOffsetPosition();
+        overlayID = Overlays.addOverlay("sphere", {
+            position: overlayPosition,
+            rotation: Camera.orientation,
+            alpha: 0.9,
+            dimensions: 0.1,
+            solid: true,
+            ignoreRayIntersection: true
+        });
+    }
+
+    function hasOverlay() {
+       return Overlays.getProperty(overlayID, "position") !== undefined;
+    }
+
+    function updateOverlay() {
+        // increase by TWEEN_SPEED until completion
+        if (tweenPosition < 1) {
+            tweenPosition += TWEEN_SPEED;
+        } else {
+            // after tween completion reset to zero and flip values to ping pong 
+            tweenPosition = 0;
+            for (var component in startColor) {
+                var storedColor = startColor[component];
+                startColor[component] = endColor[component];
+                endColor[component] = storedColor;
+            }
+        }
+        // mix previous position with new and mix colors
+        overlayPosition = Vec3.mix(overlayPosition, getOffsetPosition(), MIX_AMOUNT);
+        Overlays.editOverlay(overlayID, {
+            color: colorMix(startColor, endColor, easeIn(tweenPosition)),
+            position: overlayPosition,
+            rotation: Camera.orientation
+        });
+    }
+
+    function deleteOverlay() {
+        Overlays.deleteOverlay(overlayID);
+    }
+
+    function cleanup() {
+        deleteOverlay();
+        AudioDevice.muteToggled.disconnect(onMuteToggled);
+        Script.update.disconnect(update);
+    }
+}()); // END LOCAL_SCOPE