diff --git a/.gitignore b/.gitignore
index f45572c388..1ffb93fe80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -85,4 +85,7 @@ npm-debug.log
 android/app/src/main/assets
 
 # Resource binary file
-interface/compiledResources
\ No newline at end of file
+interface/compiledResources
+
+# GPUCache
+interface/resources/GPUCache/*
\ No newline at end of file
diff --git a/interface/resources/qml/hifi/commerce/inspectionCertificate/InspectionCertificate.qml b/interface/resources/qml/hifi/commerce/inspectionCertificate/InspectionCertificate.qml
index 421fa4b074..f493747c5e 100644
--- a/interface/resources/qml/hifi/commerce/inspectionCertificate/InspectionCertificate.qml
+++ b/interface/resources/qml/hifi/commerce/inspectionCertificate/InspectionCertificate.qml
@@ -19,21 +19,31 @@ import "../../../controls-uit" as HifiControlsUit
 import "../../../controls" as HifiControls
 import "../wallet" as HifiWallet
 
-// references XXX from root context
-
 Rectangle {
     HifiConstants { id: hifi; }
 
     id: root;
-    property string marketplaceUrl;
-    property string certificateId;
+    property string marketplaceUrl: "";
+    property string entityId: "";
+    property string certificateId: "";
     property string itemName: "--";
     property string itemOwner: "--";
     property string itemEdition: "--";
     property string dateOfPurchase: "--";
+    property string itemCost: "--";
+    property string certTitleTextColor: hifi.colors.darkGray;
+    property string certTextColor: hifi.colors.white;
+    property string infoTextColor: hifi.colors.blueAccent;
+    // 0 means replace none
+    // 4 means replace all but "Item Edition"
+    // 5 means replace all 5 replaceable fields
+    property int certInfoReplaceMode: 5;
     property bool isLightbox: false;
     property bool isMyCert: false;
-    property bool isCertificateInvalid: false;
+    property bool useGoldCert: true;
+    property bool certificateInfoPending: true;
+    property int certificateStatus: 0;
+    property bool certificateStatusPending: true;
     // Style
     color: hifi.colors.faintGray;
     Connections {
@@ -45,72 +55,135 @@ Rectangle {
             } else {
                 root.marketplaceUrl = result.data.marketplace_item_url;
                 root.isMyCert = result.isMyCert ? result.isMyCert : false;
-                root.itemOwner = root.isCertificateInvalid ? "--" : (root.isMyCert ? Account.username :
-                "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022");
-                root.itemEdition = root.isCertificateInvalid ? "Uncertified Copy" :
-                (result.data.edition_number + "/" + (result.data.limited_run === -1 ? "\u221e" : result.data.limited_run));
-                root.dateOfPurchase = root.isCertificateInvalid ? "" : getFormattedDate(result.data.transfer_created_at * 1000);
-                root.itemName = result.data.marketplace_item_name;
+
+                if (root.certInfoReplaceMode > 3) {
+                    root.itemName = result.data.marketplace_item_name;
+                    // "\u2022" is the Unicode character 'BULLET' - it's what's used in password fields on the web, etc
+                    root.itemOwner = root.isMyCert ? Account.username :
+                    "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+                    root.dateOfPurchase = root.isMyCert ? getFormattedDate(result.data.transfer_created_at * 1000) : "Undisclosed";
+                    root.itemCost = (root.isMyCert && result.data.cost !== undefined) ? result.data.cost : "Undisclosed";
+                }
+                if (root.certInfoReplaceMode > 4) {
+                    root.itemEdition = result.data.edition_number + "/" + (result.data.limited_run === -1 ? "\u221e" : result.data.limited_run);
+                }
+
+                if (root.certificateStatus === 4) { // CERTIFICATE_STATUS_OWNER_VERIFICATION_FAILED
+                    if (root.isMyCert) {
+                        errorText.text = "This item is an uncertified copy of an item you purchased.";
+                    } else {
+                        errorText.text = "The person who placed this item doesn't own it.";
+                    }
+                }
 
                 if (result.data.invalid_reason || result.data.transfer_status[0] === "failed") {
-                    titleBarText.text = "Invalid Certificate";
-                    titleBarText.color = hifi.colors.redHighlight;
+                    root.useGoldCert = false;
+                    root.certTitleTextColor = hifi.colors.redHighlight;
+                    root.certTextColor = hifi.colors.redHighlight;
+                    root.infoTextColor = hifi.colors.redHighlight;
+                    titleBarText.text = "Certificate\nNo Longer Valid";
                     popText.text = "";
+                    showInMarketplaceButton.visible = false;
+                    // "Edition" text previously set above in this function
+                    // "Owner" text previously set above in this function
+                    // "Purchase Date" text previously set above in this function
+                    // "Purchase Price" text previously set above in this function
                     if (result.data.invalid_reason) {
                         errorText.text = result.data.invalid_reason;
                     }
                 } else if (result.data.transfer_status[0] === "pending") {
+                    root.useGoldCert = false;
+                    root.certTitleTextColor = hifi.colors.redHighlight;
+                    root.certTextColor = hifi.colors.redHighlight;
+                    root.infoTextColor = hifi.colors.redHighlight;
                     titleBarText.text = "Certificate Pending";
+                    popText.text = "";
+                    showInMarketplaceButton.visible = true;
+                    // "Edition" text previously set above in this function
+                    // "Owner" text previously set above in this function
+                    // "Purchase Date" text previously set above in this function
+                    // "Purchase Price" text previously set above in this function
                     errorText.text = "The status of this item is still pending confirmation. If the purchase is not confirmed, " +
                     "this entity will be cleaned up by the domain.";
-                    errorText.color = hifi.colors.baseGray;
                 }
             }
+            root.certificateInfoPending = false;
         }
 
         onUpdateCertificateStatus: {
-            if (certStatus === 1) { // CERTIFICATE_STATUS_VERIFICATION_SUCCESS
-                // NOP
-            } else if (certStatus === 2) { // CERTIFICATE_STATUS_VERIFICATION_TIMEOUT
-                root.isCertificateInvalid = true;
-                errorText.text = "Verification of this certificate timed out.";
-                errorText.color = hifi.colors.redHighlight;
-            } else if (certStatus === 3) { // CERTIFICATE_STATUS_STATIC_VERIFICATION_FAILED
-                root.isCertificateInvalid = true;
-                titleBarText.text = "Invalid Certificate";
-                titleBarText.color = hifi.colors.redHighlight;
-
-                popText.text = "";
-                root.itemOwner = "";
-                dateOfPurchaseHeader.text = "";
-                root.dateOfPurchase = "";
-                root.itemEdition = "Uncertified Copy";
-
-                errorText.text = "The information associated with this item has been modified and it no longer matches the original certified item.";
-                errorText.color = hifi.colors.baseGray;
-            } else if (certStatus === 4) { // CERTIFICATE_STATUS_OWNER_VERIFICATION_FAILED
-                root.isCertificateInvalid = true;
-                titleBarText.text = "Invalid Certificate";
-                titleBarText.color = hifi.colors.redHighlight;
-
-                popText.text = "";
-                root.itemOwner = "";
-                dateOfPurchaseHeader.text = "";
-                root.dateOfPurchase = "";
-                root.itemEdition = "Uncertified Copy";
-
-                errorText.text = "The avatar who rezzed this item doesn't own it.";
-                errorText.color = hifi.colors.baseGray;
-            } else {
-                console.log("Unknown certificate status received from ledger signal!");
-            }
+            updateCertificateStatus(certStatus);
         }
     }
 
-    onCertificateIdChanged: {
-        if (certificateId !== "") {
-            Commerce.certificateInfo(certificateId);
+    function updateCertificateStatus(status) {
+        root.certificateStatus = status;
+        if (root.certificateStatus === 1) { // CERTIFICATE_STATUS_VERIFICATION_SUCCESS
+            root.useGoldCert = true;
+            root.certTitleTextColor = hifi.colors.darkGray;
+            root.certTextColor = hifi.colors.white;
+            root.infoTextColor = hifi.colors.blueAccent;
+            titleBarText.text = "Certificate";
+            popText.text = "PROOF OF PROVENANCE";
+            showInMarketplaceButton.visible = true;
+            root.certInfoReplaceMode = 5;
+            // "Item Name" text will be set in "onCertificateInfoResult()"
+            // "Edition" text will be set in "onCertificateInfoResult()"
+            // "Owner" text will be set in "onCertificateInfoResult()"
+            // "Purchase Date" text will be set in "onCertificateInfoResult()"
+            // "Purchase Price" text will be set in "onCertificateInfoResult()"
+            errorText.text = "";
+        } else if (root.certificateStatus === 2) { // CERTIFICATE_STATUS_VERIFICATION_TIMEOUT
+            root.useGoldCert = false;
+            root.certTitleTextColor = hifi.colors.redHighlight;
+            root.certTextColor = hifi.colors.redHighlight;
+            root.infoTextColor = hifi.colors.redHighlight;
+            titleBarText.text = "Request Timed Out";
+            popText.text = "";
+            showInMarketplaceButton.visible = false;
+            root.certInfoReplaceMode = 0;
+            root.itemName = "";
+            root.itemEdition = "";
+            root.itemOwner = "";
+            root.dateOfPurchase = "";
+            root.itemCost = "";
+            errorText.text = "Your request to inspect this item timed out. Please try again later.";
+        } else if (root.certificateStatus === 3) { // CERTIFICATE_STATUS_STATIC_VERIFICATION_FAILED
+            root.useGoldCert = false;
+            root.certTitleTextColor = hifi.colors.redHighlight;
+            root.certTextColor = hifi.colors.redHighlight;
+            root.infoTextColor = hifi.colors.redHighlight;
+            titleBarText.text = "Certificate\nNo Longer Valid";
+            popText.text = "";
+            showInMarketplaceButton.visible = true;
+            root.certInfoReplaceMode = 5;
+            // "Item Name" text will be set in "onCertificateInfoResult()"
+            // "Edition" text will be set in "onCertificateInfoResult()"
+            // "Owner" text will be set in "onCertificateInfoResult()"
+            // "Purchase Date" text will be set in "onCertificateInfoResult()"
+            // "Purchase Price" text will be set in "onCertificateInfoResult()"
+            errorText.text = "The information associated with this item has been modified and it no longer matches the original certified item.";
+        } else if (root.certificateStatus === 4) { // CERTIFICATE_STATUS_OWNER_VERIFICATION_FAILED
+            root.useGoldCert = false;
+            root.certTitleTextColor = hifi.colors.redHighlight;
+            root.certTextColor = hifi.colors.redHighlight;
+            root.infoTextColor = hifi.colors.redHighlight;
+            titleBarText.text = "Invalid Certificate";
+            popText.text = "";
+            showInMarketplaceButton.visible = true;
+            root.certInfoReplaceMode = 4;
+            // "Item Name" text will be set in "onCertificateInfoResult()"
+            root.itemEdition = "Uncertified Copy"
+            // "Owner" text will be set in "onCertificateInfoResult()"
+            // "Purchase Date" text will be set in "onCertificateInfoResult()"
+            // "Purchase Price" text will be set in "onCertificateInfoResult()"
+            // "Error Text" text will be set in "onCertificateInfoResult()"
+        } else {
+            console.log("Unknown certificate status received from ledger signal!");
         }
+            
+        root.certificateStatusPending = false;
+        // We've gotten cert status - we are GO on getting the cert info
+        Commerce.certificateInfo(root.certificateId);
     }
 
     // This object is always used in a popup.
@@ -122,9 +195,35 @@ Rectangle {
         hoverEnabled: true;
     }
 
-    Image {
+    Rectangle {
+        id: loadingOverlay;
+        z: 998;
+
+        visible: root.certificateInfoPending || root.certificateStatusPending;
         anchors.fill: parent;
-        source: "images/cert-bg.jpg";
+        color: Qt.rgba(0.0, 0.0, 0.0, 0.7);
+
+        // This object is always used in a popup or full-screen Wallet section.
+        // This MouseArea is used to prevent a user from being
+        //     able to click on a button/mouseArea underneath the popup/section.
+        MouseArea {
+            anchors.fill: parent;
+            propagateComposedEvents: false;
+        }
+                
+        AnimatedImage {
+            source: "../common/images/loader.gif"
+            width: 96;
+            height: width;
+            anchors.verticalCenter: parent.verticalCenter;
+            anchors.horizontalCenter: parent.horizontalCenter;
+        }
+    }
+
+    Image {
+        id: backgroundImage;
+        anchors.fill: parent;
+        source: root.useGoldCert ? "images/cert-bg-gold-split.png" : "images/nocert-bg-split.png";
     }
 
     // Title text
@@ -137,16 +236,17 @@ Rectangle {
         anchors.top: parent.top;
         anchors.topMargin: 40;
         anchors.left: parent.left;
-        anchors.leftMargin: 45;
+        anchors.leftMargin: 36;
         anchors.right: parent.right;
+        anchors.rightMargin: 8;
         height: paintedHeight;
         // Style
-        color: hifi.colors.darkGray;
+        color: root.certTitleTextColor;
+        wrapMode: Text.WordWrap;
     }
     // Title text
     RalewayRegular {
         id: popText;
-        text: "Proof of Provenance";
         // Text size
         size: 16;
         // Anchors
@@ -154,9 +254,39 @@ Rectangle {
         anchors.topMargin: 4;
         anchors.left: titleBarText.left;
         anchors.right: titleBarText.right;
-        height: paintedHeight;
+        height: text === "" ? 0 : paintedHeight;
         // Style
-        color: hifi.colors.darkGray;
+        color: root.certTitleTextColor;
+    }
+            
+    // "Close" button
+    HiFiGlyphs {
+        z: 999; 
+        id: closeGlyphButton;
+        text: hifi.glyphs.close;
+        color: hifi.colors.white;
+        size: 26;
+        anchors.top: parent.top;
+        anchors.topMargin: 10;
+        anchors.right: parent.right;
+        anchors.rightMargin: 10;
+        MouseArea {
+            anchors.fill: parent;
+            hoverEnabled: true;
+            onEntered: {
+                parent.text = hifi.glyphs.closeInverted;
+            }
+            onExited: {
+                parent.text = hifi.glyphs.close;
+            }
+            onClicked: {
+                if (root.isLightbox) {
+                    root.visible = false;
+                } else {
+                    sendToScript({method: 'inspectionCertificate_closeClicked', closeGoesToPurchases: root.closeGoesToPurchases});
+                }
+            }
+        }
     }
 
     //
@@ -164,11 +294,13 @@ Rectangle {
     //
     Item {
         id: certificateContainer;
-        anchors.top: popText.bottom;
-        anchors.topMargin: 30;
-        anchors.bottom: buttonsContainer.top;
+        anchors.top: titleBarText.top;
+        anchors.topMargin: 110;
+        anchors.bottom: infoContainer.top;
         anchors.left: parent.left;
+        anchors.leftMargin: titleBarText.anchors.leftMargin;
         anchors.right: parent.right;
+        anchors.rightMargin: 24;
 
         RalewayRegular {
             id: itemNameHeader;
@@ -178,9 +310,7 @@ Rectangle {
             // Anchors
             anchors.top: parent.top;
             anchors.left: parent.left;
-            anchors.leftMargin: 45;
             anchors.right: parent.right;
-            anchors.rightMargin: 16;
             height: paintedHeight;
             // Style
             color: hifi.colors.darkGray;
@@ -197,79 +327,30 @@ Rectangle {
             anchors.right: itemNameHeader.right;
             height: paintedHeight;
             // Style
-            color: hifi.colors.white;
+            color: root.certTextColor;
             elide: Text.ElideRight;
             MouseArea {
+                enabled: showInMarketplaceButton.visible;
                 anchors.fill: parent;
                 hoverEnabled: enabled;
                 onClicked: {
                     sendToScript({method: 'inspectionCertificate_showInMarketplaceClicked', marketplaceUrl: root.marketplaceUrl});
                 }
                 onEntered: itemName.color = hifi.colors.blueHighlight;
-                onExited: itemName.color = hifi.colors.white;
+                onExited: itemName.color = root.certTextColor;
             }
         }
 
-        RalewayRegular {
-            id: ownedByHeader;
-            text: "OWNER";
-            // Text size
-            size: 16;
-            // Anchors
-            anchors.top: itemName.bottom;
-            anchors.topMargin: 28;
-            anchors.left: parent.left;
-            anchors.leftMargin: 45;
-            anchors.right: parent.right;
-            anchors.rightMargin: 16;
-            height: paintedHeight;
-            // Style
-            color: hifi.colors.darkGray;
-        }
-        RalewayRegular {
-            id: ownedBy;
-            text: root.itemOwner;
-            // Text size
-            size: 22;
-            // Anchors
-            anchors.top: ownedByHeader.bottom;
-            anchors.topMargin: 8;
-            anchors.left: ownedByHeader.left;
-            height: paintedHeight;
-            // Style
-            color: hifi.colors.white;
-            elide: Text.ElideRight;
-        }
-        AnonymousProRegular {
-            id: isMyCertText;
-            visible: root.isMyCert && !root.isCertificateInvalid;
-            text: "(Private)";
-            size: 18;
-            // Anchors
-            anchors.top: ownedBy.top;
-            anchors.topMargin: 4;
-            anchors.bottom: ownedBy.bottom;
-            anchors.left: ownedBy.right;
-            anchors.leftMargin: 6;
-            anchors.right: ownedByHeader.right;
-            // Style
-            color: hifi.colors.white;
-            elide: Text.ElideRight;
-            verticalAlignment: Text.AlignVCenter;
-        }
-
         RalewayRegular {
             id: editionHeader;
             text: "EDITION";
             // Text size
             size: 16;
             // Anchors
-            anchors.top: ownedBy.bottom;
+            anchors.top: itemName.bottom;
             anchors.topMargin: 28;
             anchors.left: parent.left;
-            anchors.leftMargin: 45;
             anchors.right: parent.right;
-            anchors.rightMargin: 16;
             height: paintedHeight;
             // Style
             color: hifi.colors.darkGray;
@@ -286,21 +367,117 @@ Rectangle {
             anchors.right: editionHeader.right;
             height: paintedHeight;
             // Style
-            color: hifi.colors.white;
+            color: root.certTextColor;
+        }
+
+        // "Show In Marketplace" button
+        HifiControlsUit.Button {
+            id: showInMarketplaceButton;
+            enabled: root.marketplaceUrl;
+            color: hifi.buttons.blue;
+            colorScheme: hifi.colorSchemes.light;
+            anchors.bottom: parent.bottom;
+            anchors.bottomMargin: 48;
+            anchors.right: parent.right;
+            width: 200;
+            height: 40;
+            text: "View In Market"
+            onClicked: {
+                sendToScript({method: 'inspectionCertificate_showInMarketplaceClicked', marketplaceUrl: root.marketplaceUrl});
+            }
+        }
+    }
+    //
+    // "CERTIFICATE" END
+    //
+
+    //
+    // "INFO CONTAINER" START
+    //
+    Item {
+        id: infoContainer;
+        anchors.bottom: parent.bottom;
+        anchors.left: parent.left;
+        anchors.leftMargin: titleBarText.anchors.leftMargin;
+        anchors.right: parent.right;
+        anchors.rightMargin: 24;
+        height: root.useGoldCert ? 220 : 372;
+
+        RalewayRegular {
+            id: errorText;
+            visible: !root.useGoldCert;
+            // Text size
+            size: 20;
+            // Anchors
+            anchors.top: parent.top;
+            anchors.topMargin: 36;
+            anchors.left: parent.left;
+            anchors.right: parent.right;
+            height: 116;
+            // Style
+            wrapMode: Text.WordWrap;
+            color: hifi.colors.baseGray;
+            verticalAlignment: Text.AlignTop;
+        }
+
+        RalewayRegular {
+            id: ownedByHeader;
+            text: "OWNER";
+            // Text size
+            size: 16;
+            // Anchors
+            anchors.top: errorText.visible ? errorText.bottom : parent.top;
+            anchors.topMargin: 28;
+            anchors.left: parent.left;
+            anchors.right: parent.right;
+            height: paintedHeight;
+            // Style
+            color: hifi.colors.darkGray;
+        }
+
+        RalewayRegular {
+            id: ownedBy;
+            text: root.itemOwner;
+            // Text size
+            size: 22;
+            // Anchors
+            anchors.top: ownedByHeader.bottom;
+            anchors.topMargin: 8;
+            anchors.left: ownedByHeader.left;
+            height: paintedHeight;
+            // Style
+            color: root.infoTextColor;
+            elide: Text.ElideRight;
+        }
+        AnonymousProRegular {
+            id: isMyCertText;
+            visible: root.isMyCert && ownedBy.text !== "--" && ownedBy.text !== "";
+            text: "(Private)";
+            size: 18;
+            // Anchors
+            anchors.top: ownedBy.top;
+            anchors.topMargin: 4;
+            anchors.bottom: ownedBy.bottom;
+            anchors.left: ownedBy.right;
+            anchors.leftMargin: 6;
+            anchors.right: ownedByHeader.right;
+            // Style
+            color: root.infoTextColor;
+            elide: Text.ElideRight;
+            verticalAlignment: Text.AlignVCenter;
         }
 
         RalewayRegular {
             id: dateOfPurchaseHeader;
-            text: "DATE OF PURCHASE";
+            text: "PURCHASE DATE";
             // Text size
             size: 16;
             // Anchors
-            anchors.top: edition.bottom;
+            anchors.top: ownedBy.bottom;
             anchors.topMargin: 28;
             anchors.left: parent.left;
-            anchors.leftMargin: 45;
-            anchors.right: parent.right;
-            anchors.rightMargin: 16;
+            anchors.right: parent.horizontalCenter;
+            anchors.rightMargin: 8;
             height: paintedHeight;
             // Style
             color: hifi.colors.darkGray;
@@ -317,73 +494,58 @@ Rectangle {
             anchors.right: dateOfPurchaseHeader.right;
             height: paintedHeight;
             // Style
-            color: hifi.colors.white;
+            color: root.infoTextColor;
         }
 
         RalewayRegular {
-            id: errorText;
+            id: priceHeader;
+            text: "PURCHASE PRICE";
             // Text size
-            size: 20;
+            size: 16;
             // Anchors
-            anchors.top: dateOfPurchase.bottom;
-            anchors.topMargin: 36;
-            anchors.left: dateOfPurchase.left;
-            anchors.right: dateOfPurchase.right;
-            anchors.bottom: parent.bottom;
-            // Style
-            wrapMode: Text.WordWrap;
-            color: hifi.colors.redHighlight;
-            verticalAlignment: Text.AlignTop;
-        }
-    }
-    //
-    // "CERTIFICATE" END
-    //
-
-    Item {
-        id: buttonsContainer;
-        anchors.bottom: parent.bottom;
-        anchors.bottomMargin: 30;
-        anchors.left: parent.left;
-        anchors.right: parent.right;
-        height: 50;
-        
-        // "Cancel" button
-        HifiControlsUit.Button {
-            color: hifi.buttons.noneBorderlessWhite;
-            colorScheme: hifi.colorSchemes.light;
-            anchors.top: parent.top;
-            anchors.left: parent.left;
-            anchors.leftMargin: 30;
-            width: parent.width/2 - 50;
-            height: 50;
-            text: "close";
-            onClicked: {
-                if (root.isLightbox) {
-                    root.visible = false;
-                } else {
-                    sendToScript({method: 'inspectionCertificate_closeClicked', closeGoesToPurchases: root.closeGoesToPurchases});
-                }
-            }
-        }   
-
-        // "Show In Marketplace" button
-        HifiControlsUit.Button {
-            id: showInMarketplaceButton;
-            enabled: root.marketplaceUrl;
-            color: hifi.buttons.blue;
-            colorScheme: hifi.colorSchemes.light;
-            anchors.top: parent.top;
+            anchors.top: ownedBy.bottom;
+            anchors.topMargin: 28;
+            anchors.left: parent.horizontalCenter;
             anchors.right: parent.right;
-            anchors.rightMargin: 30;
-            width: parent.width/2 - 50;
-            height: 50;
-            text: "View In Market"
-            onClicked: {
-                sendToScript({method: 'inspectionCertificate_showInMarketplaceClicked', marketplaceUrl: root.marketplaceUrl});
-            }
+            height: paintedHeight;
+            // Style
+            color: hifi.colors.darkGray;
+        }
+        HiFiGlyphs {
+            id: hfcGlyph;
+            visible: priceText.text !== "Undisclosed" && priceText.text !== "";
+            text: hifi.glyphs.hfc;
+            // Size
+            size: 24;
+            // Anchors
+            anchors.top: priceHeader.bottom;
+            anchors.topMargin: 8;
+            anchors.left: priceHeader.left;
+            width: visible ? paintedWidth + 6 : 0;
+            height: 40;
+            // Style
+            color: root.infoTextColor;
+            verticalAlignment: Text.AlignTop;
+            horizontalAlignment: Text.AlignLeft;
+        }
+        AnonymousProRegular {
+            id: priceText;
+            text: root.itemCost;
+            // Text size
+            size: 18;
+            // Anchors
+            anchors.top: priceHeader.bottom;
+            anchors.topMargin: 8;
+            anchors.left: hfcGlyph.right;
+            anchors.right: priceHeader.right;
+            height: paintedHeight;
+            // Style
+            color: root.infoTextColor;
         }
     }
+    //
+    // "INFO CONTAINER" END
+    //
 
     //
     // FUNCTION DEFINITIONS START
@@ -404,19 +566,17 @@ Rectangle {
     function fromScript(message) {
         switch (message.method) {
             case 'inspectionCertificate_setCertificateId':
+                resetCert(false);
                 root.certificateId = message.certificateId;
+                if (message.entityId === "") {
+                    updateCertificateStatus(1); // CERTIFICATE_STATUS_VERIFICATION_SUCCESS
+                } else {
+                    root.entityId = message.entityId;
+                    sendToScript({method: 'inspectionCertificate_requestOwnershipVerification', entity: root.entityId});
+                }
             break;
             case 'inspectionCertificate_resetCert':
-                titleBarText.text = "Certificate";
-                popText.text = "PROOF OF PURCHASE";
-                root.certificateId = "";
-                root.itemName = "--";
-                root.itemOwner = "--";
-                root.itemEdition = "--";
-                root.dateOfPurchase = "--";
-                root.marketplaceUrl = "";
-                root.isMyCert = false;
-                errorText.text = "";
+                resetCert(true);
             break;
             default:
                 console.log('Unrecognized message from marketplaces.js:', JSON.stringify(message));
@@ -424,7 +584,34 @@ Rectangle {
     }
     signal sendToScript(var message);
 
+    function resetCert(alsoResetCertID) {
+        if (alsoResetCertID) {
+            root.entityId = "";
+            root.certificateId = "";
+        }
+        root.certInfoReplaceMode = 5;
+        root.certificateInfoPending = true;
+        root.certificateStatusPending = true;
+        root.useGoldCert = true;
+        root.certTitleTextColor = hifi.colors.darkGray;
+        root.certTextColor = hifi.colors.white;
+        root.infoTextColor = hifi.colors.blueAccent;
+        titleBarText.text = "Certificate";
+        popText.text = "";
+        root.itemName = "--";
+        root.itemOwner = "--";
+        root.itemEdition = "--";
+        root.dateOfPurchase = "--";
+        root.marketplaceUrl = "";
+        root.itemCost = "--";
+        root.isMyCert = false;
+        errorText.text = "";
+    }
+
     function getFormattedDate(timestamp) {
+        if (timestamp === "--") {
+            return "--";
+        }
         function addLeadingZero(n) {
             return n < 10 ? '0' + n : '' + n;
         }
@@ -449,7 +636,7 @@ Rectangle {
 
         var min = addLeadingZero(a.getMinutes());
         var sec = addLeadingZero(a.getSeconds());
-        return year + '-' + month + '-' + day + '<br>' + drawnHour + ':' + min + amOrPm;
+        return year + '-' + month + '-' + day + ' ' + drawnHour + ':' + min + amOrPm;
     }
     //
     // FUNCTION DEFINITIONS END
diff --git a/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg-gold-split.png b/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg-gold-split.png
new file mode 100644
index 0000000000..14a17df0b1
Binary files /dev/null and b/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg-gold-split.png differ
diff --git a/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg.jpg b/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg.jpg
deleted file mode 100644
index b39a55e4e8..0000000000
Binary files a/interface/resources/qml/hifi/commerce/inspectionCertificate/images/cert-bg.jpg and /dev/null differ
diff --git a/interface/resources/qml/hifi/commerce/inspectionCertificate/images/nocert-bg-split.png b/interface/resources/qml/hifi/commerce/inspectionCertificate/images/nocert-bg-split.png
new file mode 100644
index 0000000000..b2f5a49265
Binary files /dev/null and b/interface/resources/qml/hifi/commerce/inspectionCertificate/images/nocert-bg-split.png differ
diff --git a/interface/resources/qml/hifi/commerce/wallet/sendMoney/SendMoney.qml b/interface/resources/qml/hifi/commerce/wallet/sendMoney/SendMoney.qml
index ee1246c0c4..7dd72b904e 100644
--- a/interface/resources/qml/hifi/commerce/wallet/sendMoney/SendMoney.qml
+++ b/interface/resources/qml/hifi/commerce/wallet/sendMoney/SendMoney.qml
@@ -1115,7 +1115,7 @@ Item {
                 
         AnimatedImage {
             id: sendingMoneyImage;
-            source: "./images/loader.gif"
+            source: "../../common/images/loader.gif"
             width: 96;
             height: width;
             anchors.verticalCenter: parent.verticalCenter;
diff --git a/interface/resources/qml/hifi/commerce/wallet/sendMoney/images/loader.gif b/interface/resources/qml/hifi/commerce/wallet/sendMoney/images/loader.gif
deleted file mode 100644
index 0536bd1884..0000000000
Binary files a/interface/resources/qml/hifi/commerce/wallet/sendMoney/images/loader.gif and /dev/null differ
diff --git a/interface/resources/qml/js/Utils.jsc b/interface/resources/qml/js/Utils.jsc
new file mode 100644
index 0000000000..8da68e4e19
Binary files /dev/null and b/interface/resources/qml/js/Utils.jsc differ
diff --git a/interface/resources/styles/log_dialog.qss b/interface/resources/styles/log_dialog.qss
index e0ec17549d..ebf2fc7318 100644
--- a/interface/resources/styles/log_dialog.qss
+++ b/interface/resources/styles/log_dialog.qss
@@ -67,7 +67,7 @@ QPushButton#revealLogButton {
     font-size: 11px;
 }
 
-QPushButton#showAllButton {
+QPushButton#allLogsButton {
     font-family: Helvetica, Arial, sans-serif;
     background-color: #333333;
     color: #BBBBBB;
@@ -112,4 +112,11 @@ QComboBox::drop-down {
 QComboBox::down-arrow {
     image: url(:/styles/filter.png);
     border-width: 0px;
+}
+
+QLabel#messageCount {
+    font-family: Helvetica, Arial, sans-serif;
+    text-align: center;
+    color: #3d3d3d;
+    font-size: 11px;
 }
\ No newline at end of file
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 67796bcc8b..719a919721 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -959,6 +959,18 @@ void MyAvatar::restoreRoleAnimation(const QString& role) {
     _skeletonModel->getRig().restoreRoleAnimation(role);
 }
 
+void MyAvatar::saveAvatarUrl() {
+    Settings settings;
+    settings.beginGroup("Avatar");
+    if (qApp->getSaveAvatarOverrideUrl() || !qApp->getAvatarOverrideUrl().isValid() ) {
+        settings.setValue("fullAvatarURL",
+                          _fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
+                          "" :
+                          _fullAvatarURLFromPreferences.toString());
+    }
+    settings.endGroup();
+}
+
 void MyAvatar::saveData() {
     Settings settings;
     settings.beginGroup("Avatar");
@@ -1455,8 +1467,8 @@ void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     _headBoneSet.clear();
     _cauterizationNeedsUpdate = true;
 
-     std::shared_ptr<QMetaObject::Connection> skeletonConnection = std::make_shared<QMetaObject::Connection>();
-     *skeletonConnection = QObject::connect(_skeletonModel.get(), &SkeletonModel::skeletonLoaded, [this, skeletonModelChangeCount, skeletonConnection]() {
+    std::shared_ptr<QMetaObject::Connection> skeletonConnection = std::make_shared<QMetaObject::Connection>();
+    *skeletonConnection = QObject::connect(_skeletonModel.get(), &SkeletonModel::skeletonLoaded, [this, skeletonModelChangeCount, skeletonConnection]() {
             if (skeletonModelChangeCount == _skeletonModelChangeCount) {
                 initHeadBones();
                 _skeletonModel->setCauterizeBoneSet(_headBoneSet);
@@ -1465,6 +1477,7 @@ void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
             }
             QObject::disconnect(*skeletonConnection);
     });
+    saveAvatarUrl();
     emit skeletonChanged();
 
 }
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 180cf04a18..3e063547d0 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -647,6 +647,7 @@ private:
 
     void simulate(float deltaTime);
     void updateFromTrackers(float deltaTime);
+    void saveAvatarUrl();
     virtual void render(RenderArgs* renderArgs) override;
     virtual bool shouldRenderHead(const RenderArgs* renderArgs) const override;
     void setShouldRenderLocally(bool shouldRender) { _shouldRender = shouldRender; setEnableMeshVisible(shouldRender); }
diff --git a/interface/src/ui/BaseLogDialog.cpp b/interface/src/ui/BaseLogDialog.cpp
index 969f9895de..e27b622262 100644
--- a/interface/src/ui/BaseLogDialog.cpp
+++ b/interface/src/ui/BaseLogDialog.cpp
@@ -29,8 +29,8 @@ const int SEARCH_TOGGLE_BUTTON_WIDTH = 50;
 const int SEARCH_TEXT_WIDTH = 240;
 const int TIME_STAMP_LENGTH = 16;
 const int FONT_WEIGHT = 75;
-const QColor HIGHLIGHT_COLOR = QColor("#3366CC");
-const QColor BOLD_COLOR = QColor("#445c8c");
+const QColor HIGHLIGHT_COLOR = QColor("#00B4EF");
+const QColor BOLD_COLOR = QColor("#1080B8");
 const QString BOLD_PATTERN = "\\[\\d*\\/.*:\\d*:\\d*\\]";
 
 BaseLogDialog::BaseLogDialog(QWidget* parent) : QDialog(parent, Qt::Window) {
@@ -182,6 +182,7 @@ void BaseLogDialog::updateSelection() {
 Highlighter::Highlighter(QTextDocument* parent) : QSyntaxHighlighter(parent) {
     boldFormat.setFontWeight(FONT_WEIGHT);
     boldFormat.setForeground(BOLD_COLOR);
+    keywordFormat.setFontWeight(FONT_WEIGHT);
     keywordFormat.setForeground(HIGHLIGHT_COLOR);
 }
 
diff --git a/interface/src/ui/LogDialog.cpp b/interface/src/ui/LogDialog.cpp
index 108edbfd39..26a5a24de8 100644
--- a/interface/src/ui/LogDialog.cpp
+++ b/interface/src/ui/LogDialog.cpp
@@ -15,11 +15,12 @@
 #include <QPushButton>
 #include <QComboBox>
 #include <QPlainTextEdit>
+#include <QLabel>
 
 #include <shared/AbstractLoggerInterface.h>
 
 const int REVEAL_BUTTON_WIDTH = 122;
-const int CLEAR_FILTER_BUTTON_WIDTH = 80;
+const int ALL_LOGS_BUTTON_WIDTH = 90;
 const int MARGIN_LEFT = 25;
 const int DEBUG_CHECKBOX_WIDTH = 70;
 const int INFO_CHECKBOX_WIDTH = 65;
@@ -142,6 +143,11 @@ LogDialog::LogDialog(QWidget* parent, AbstractLoggerInterface* logger) : BaseLog
     _filterDropdown->addItem("qml");
     connect(_filterDropdown, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LogDialog::handleFilterDropdownChanged);
 
+    _leftPad += COMBOBOX_WIDTH + MARGIN_LEFT + MARGIN_LEFT;
+    _messageCount = new QLabel("", this);
+    _messageCount->setObjectName("messageCount");
+    _messageCount->show();
+
     _extraDebuggingBox = new QCheckBox("Extra debugging", this);
     if (_logger->extraDebugging()) {
         _extraDebuggingBox->setCheckState(Qt::Checked);
@@ -149,12 +155,13 @@ LogDialog::LogDialog(QWidget* parent, AbstractLoggerInterface* logger) : BaseLog
     _extraDebuggingBox->show();
     connect(_extraDebuggingBox, &QCheckBox::stateChanged, this, &LogDialog::handleExtraDebuggingCheckbox);
 
-    _clearFilterButton = new QPushButton("Clear Filters", this);
+    _allLogsButton = new QPushButton("All Messages", this);
     // set object name for css styling
-    _clearFilterButton->setObjectName("showAllButton");
-    _clearFilterButton->show();
-    connect(_clearFilterButton, &QPushButton::clicked, this, &LogDialog::handleClearFilterButton);
-    handleClearFilterButton();
+
+    _allLogsButton->setObjectName("allLogsButton");
+    _allLogsButton->show();
+    connect(_allLogsButton, &QPushButton::clicked, this, &LogDialog::handleAllLogsButton);
+    handleAllLogsButton();
 
     auto windowGeometry = _windowGeometry.get();
     if (windowGeometry.isValid()) {
@@ -168,11 +175,15 @@ void LogDialog::resizeEvent(QResizeEvent* event) {
         ELEMENT_MARGIN,
         REVEAL_BUTTON_WIDTH,
         ELEMENT_HEIGHT);
-    _clearFilterButton->setGeometry(width() - ELEMENT_MARGIN - CLEAR_FILTER_BUTTON_WIDTH,
+    _allLogsButton->setGeometry(width() - ELEMENT_MARGIN - ALL_LOGS_BUTTON_WIDTH,
         THIRD_ROW,
-        CLEAR_FILTER_BUTTON_WIDTH,
+        ALL_LOGS_BUTTON_WIDTH,
         ELEMENT_HEIGHT);
-    _extraDebuggingBox->setGeometry(width() - ELEMENT_MARGIN - COMBOBOX_WIDTH - ELEMENT_MARGIN - CLEAR_FILTER_BUTTON_WIDTH,
+    _extraDebuggingBox->setGeometry(width() - ELEMENT_MARGIN - COMBOBOX_WIDTH - ELEMENT_MARGIN - ALL_LOGS_BUTTON_WIDTH,
+        THIRD_ROW,
+        COMBOBOX_WIDTH,
+        ELEMENT_HEIGHT);
+    _messageCount->setGeometry(_leftPad,
         THIRD_ROW,
         COMBOBOX_WIDTH,
         ELEMENT_HEIGHT);
@@ -187,13 +198,13 @@ void LogDialog::handleRevealButton() {
     _logger->locateLog();
 }
 
-void LogDialog::handleClearFilterButton() {
+void LogDialog::handleAllLogsButton() {
     _logger->setExtraDebugging(false);
     _extraDebuggingBox->setCheckState(Qt::Unchecked);
-    _logger->setDebugPrint(false);
-    _debugPrintBox->setCheckState(Qt::Unchecked);
-    _logger->setInfoPrint(false);
-    _infoPrintBox->setCheckState(Qt::Unchecked);
+    _logger->setDebugPrint(true);
+    _debugPrintBox->setCheckState(Qt::Checked);
+    _logger->setInfoPrint(true);
+    _infoPrintBox->setCheckState(Qt::Checked);
     _logger->setCriticalPrint(true);
     _criticalPrintBox->setCheckState(Qt::Checked);
     _logger->setWarningPrint(true);
@@ -270,40 +281,67 @@ void LogDialog::appendLogLine(QString logLine) {
         if (logLine.contains(DEBUG_TEXT, Qt::CaseSensitive)) {
             if (_logger->debugPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         } else if (logLine.contains(INFO_TEXT, Qt::CaseSensitive)) {
             if (_logger->infoPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             } 
         } else if (logLine.contains(CRITICAL_TEXT, Qt::CaseSensitive)) {
             if (_logger->criticalPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         } else if (logLine.contains(WARNING_TEXT, Qt::CaseSensitive)) {
             if (_logger->warningPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         } else if (logLine.contains(SUPPRESS_TEXT, Qt::CaseSensitive)) {
             if (_logger->suppressPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         } else if (logLine.contains(FATAL_TEXT, Qt::CaseSensitive)) {
             if (_logger->fatalPrint()) {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         } else {
-            if (_logger->unknownPrint()) {
+            if (_logger->unknownPrint() && logLine.trimmed() != "") {
                 _logTextBox->appendPlainText(logLine.trimmed());
+                _count++;
+                updateMessageCount();
             }
         }
     }
 }
 
 void LogDialog::printLogFile() {
+    _count = 0;
     _logTextBox->clear();
     QString log = getCurrentLog();
     QStringList logList = log.split('\n');
     for (const auto& message : logList) {
         appendLogLine(message);
     }
+    updateMessageCount();
+}
+
+void LogDialog::updateMessageCount() {
+    _countLabel = QString::number(_count);
+    if (_count != 1) {
+        _countLabel.append("  log messages");
+    }
+    else {
+        _countLabel.append("  log message");
+    }
+    _messageCount->setText(_countLabel);
 }
diff --git a/interface/src/ui/LogDialog.h b/interface/src/ui/LogDialog.h
index 3cc7584fe8..eb92d4b381 100644
--- a/interface/src/ui/LogDialog.h
+++ b/interface/src/ui/LogDialog.h
@@ -18,6 +18,7 @@
 class QCheckBox;
 class QPushButton;
 class QComboBox;
+class QLabel;
 class QResizeEvent;
 class AbstractLoggerInterface;
 
@@ -41,19 +42,21 @@ private slots:
     void handleFatalPrintBox(int);
     void handleUnknownPrintBox(int);
     void handleFilterDropdownChanged(int);
-    void handleClearFilterButton();
+    void handleAllLogsButton();
+    void printLogFile();
 
 protected:
     void resizeEvent(QResizeEvent* event) override;
     void closeEvent(QCloseEvent* event) override;
 
     QString getCurrentLog() override;
-    void printLogFile();
+    void updateMessageCount();
+    
 
 private:
     QCheckBox* _extraDebuggingBox;
     QPushButton* _revealLogButton;
-    QPushButton* _clearFilterButton;
+    QPushButton* _allLogsButton;
     QCheckBox* _debugPrintBox;
     QCheckBox* _infoPrintBox;
     QCheckBox* _criticalPrintBox;
@@ -62,10 +65,12 @@ private:
     QCheckBox* _fatalPrintBox;
     QCheckBox* _unknownPrintBox;
     QComboBox* _filterDropdown;
+    QLabel* _messageCount;
     QString _filterSelection;
-
+    QString _countLabel;
     AbstractLoggerInterface* _logger;
     Setting::Handle<QRect> _windowGeometry;
+    int _count = 0;
 };
 
 #endif // hifi_LogDialog_h
diff --git a/interface/src/ui/overlays/Base3DOverlay.cpp b/interface/src/ui/overlays/Base3DOverlay.cpp
index 23e09fe5ca..ff5a202910 100644
--- a/interface/src/ui/overlays/Base3DOverlay.cpp
+++ b/interface/src/ui/overlays/Base3DOverlay.cpp
@@ -181,6 +181,8 @@ void Base3DOverlay::setProperties(const QVariantMap& originalProperties) {
 
     if (properties["parentID"].isValid()) {
         setParentID(QUuid(properties["parentID"].toString()));
+        bool success;
+        getParentPointer(success); // call this to hook-up the parent's back-pointers to its child overlays
         needRenderItemUpdate = true;
     }
     if (properties["parentJointIndex"].isValid()) {
diff --git a/interface/src/ui/overlays/ContextOverlayInterface.cpp b/interface/src/ui/overlays/ContextOverlayInterface.cpp
index ed7b811fb0..dd05e5c6a8 100644
--- a/interface/src/ui/overlays/ContextOverlayInterface.cpp
+++ b/interface/src/ui/overlays/ContextOverlayInterface.cpp
@@ -274,82 +274,88 @@ void ContextOverlayInterface::requestOwnershipVerification(const QUuid& entityID
 
     auto nodeList = DependencyManager::get<NodeList>();
 
-    if (entityProperties.getClientOnly()) {
-        if (entityProperties.verifyStaticCertificateProperties()) {
-            SharedNodePointer entityServer = nodeList->soloNodeOfType(NodeType::EntityServer);
+    if (entityProperties.verifyStaticCertificateProperties()) {
+        if (entityProperties.getClientOnly()) {
+                SharedNodePointer entityServer = nodeList->soloNodeOfType(NodeType::EntityServer);
 
-            if (entityServer) {
-                QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance();
-                QNetworkRequest networkRequest;
-                networkRequest.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
-                networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-                QUrl requestURL = NetworkingConstants::METAVERSE_SERVER_URL();
-                requestURL.setPath("/api/v1/commerce/proof_of_purchase_status/transfer");
-                QJsonObject request;
-                request["certificate_id"] = entityProperties.getCertificateID();
-                networkRequest.setUrl(requestURL);
+                if (entityServer) {
+                    QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance();
+                    QNetworkRequest networkRequest;
+                    networkRequest.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
+                    networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+                    QUrl requestURL = NetworkingConstants::METAVERSE_SERVER_URL();
+                    requestURL.setPath("/api/v1/commerce/proof_of_purchase_status/transfer");
+                    QJsonObject request;
+                    request["certificate_id"] = entityProperties.getCertificateID();
+                    networkRequest.setUrl(requestURL);
 
-                QNetworkReply* networkReply = NULL;
-                networkReply = networkAccessManager.put(networkRequest, QJsonDocument(request).toJson());
+                    QNetworkReply* networkReply = NULL;
+                    networkReply = networkAccessManager.put(networkRequest, QJsonDocument(request).toJson());
 
-                connect(networkReply, &QNetworkReply::finished, [=]() {
-                    QJsonObject jsonObject = QJsonDocument::fromJson(networkReply->readAll()).object();
-                    jsonObject = jsonObject["data"].toObject();
+                    connect(networkReply, &QNetworkReply::finished, [=]() {
+                        QJsonObject jsonObject = QJsonDocument::fromJson(networkReply->readAll()).object();
+                        jsonObject = jsonObject["data"].toObject();
 
-                    if (networkReply->error() == QNetworkReply::NoError) {
-                        if (!jsonObject["invalid_reason"].toString().isEmpty()) {
-                            qCDebug(entities) << "invalid_reason not empty";
-                        } else if (jsonObject["transfer_status"].toArray().first().toString() == "failed") {
-                            qCDebug(entities) << "'transfer_status' is 'failed'";
-                        } else if (jsonObject["transfer_status"].toArray().first().toString() == "pending") {
-                            qCDebug(entities) << "'transfer_status' is 'pending'";
-                        } else {
-                            QString ownerKey = jsonObject["transfer_recipient_key"].toString();
-
-                            QByteArray certID = entityProperties.getCertificateID().toUtf8();
-                            QByteArray text = DependencyManager::get<EntityTreeRenderer>()->getTree()->computeNonce(certID, ownerKey);
-                            QByteArray nodeToChallengeByteArray = entityProperties.getOwningAvatarID().toRfc4122();
-
-                            int certIDByteArraySize = certID.length();
-                            int textByteArraySize = text.length();
-                            int nodeToChallengeByteArraySize = nodeToChallengeByteArray.length();
-
-                            auto challengeOwnershipPacket = NLPacket::create(PacketType::ChallengeOwnershipRequest,
-                                certIDByteArraySize + textByteArraySize + nodeToChallengeByteArraySize + 3 * sizeof(int),
-                                true);
-                            challengeOwnershipPacket->writePrimitive(certIDByteArraySize);
-                            challengeOwnershipPacket->writePrimitive(textByteArraySize);
-                            challengeOwnershipPacket->writePrimitive(nodeToChallengeByteArraySize);
-                            challengeOwnershipPacket->write(certID);
-                            challengeOwnershipPacket->write(text);
-                            challengeOwnershipPacket->write(nodeToChallengeByteArray);
-                            nodeList->sendPacket(std::move(challengeOwnershipPacket), *entityServer);
-
-                            // Kickoff a 10-second timeout timer that marks the cert if we don't get an ownership response in time
-                            if (thread() != QThread::currentThread()) {
-                                QMetaObject::invokeMethod(this, "startChallengeOwnershipTimer");
-                                return;
+                        if (networkReply->error() == QNetworkReply::NoError) {
+                            if (!jsonObject["invalid_reason"].toString().isEmpty()) {
+                                qCDebug(entities) << "invalid_reason not empty";
+                            } else if (jsonObject["transfer_status"].toArray().first().toString() == "failed") {
+                                qCDebug(entities) << "'transfer_status' is 'failed'";
+                            } else if (jsonObject["transfer_status"].toArray().first().toString() == "pending") {
+                                qCDebug(entities) << "'transfer_status' is 'pending'";
                             } else {
-                                startChallengeOwnershipTimer();
-                            }
-                        }
-                    } else {
-                        qCDebug(entities) << "Call to" << networkReply->url() << "failed with error" << networkReply->error() <<
-                            "More info:" << networkReply->readAll();
-                    }
+                                QString ownerKey = jsonObject["transfer_recipient_key"].toString();
 
-                    networkReply->deleteLater();
-                });
-            } else {
-                qCWarning(context_overlay) << "Couldn't get Entity Server!";
-            }
+                                QByteArray certID = entityProperties.getCertificateID().toUtf8();
+                                QByteArray text = DependencyManager::get<EntityTreeRenderer>()->getTree()->computeNonce(certID, ownerKey);
+                                QByteArray nodeToChallengeByteArray = entityProperties.getOwningAvatarID().toRfc4122();
+
+                                int certIDByteArraySize = certID.length();
+                                int textByteArraySize = text.length();
+                                int nodeToChallengeByteArraySize = nodeToChallengeByteArray.length();
+
+                                auto challengeOwnershipPacket = NLPacket::create(PacketType::ChallengeOwnershipRequest,
+                                    certIDByteArraySize + textByteArraySize + nodeToChallengeByteArraySize + 3 * sizeof(int),
+                                    true);
+                                challengeOwnershipPacket->writePrimitive(certIDByteArraySize);
+                                challengeOwnershipPacket->writePrimitive(textByteArraySize);
+                                challengeOwnershipPacket->writePrimitive(nodeToChallengeByteArraySize);
+                                challengeOwnershipPacket->write(certID);
+                                challengeOwnershipPacket->write(text);
+                                challengeOwnershipPacket->write(nodeToChallengeByteArray);
+                                nodeList->sendPacket(std::move(challengeOwnershipPacket), *entityServer);
+
+                                // Kickoff a 10-second timeout timer that marks the cert if we don't get an ownership response in time
+                                if (thread() != QThread::currentThread()) {
+                                    QMetaObject::invokeMethod(this, "startChallengeOwnershipTimer");
+                                    return;
+                                } else {
+                                    startChallengeOwnershipTimer();
+                                }
+                            }
+                        } else {
+                            qCDebug(entities) << "Call to" << networkReply->url() << "failed with error" << networkReply->error() <<
+                                "More info:" << networkReply->readAll();
+                        }
+
+                        networkReply->deleteLater();
+                    });
+                } else {
+                    qCWarning(context_overlay) << "Couldn't get Entity Server!";
+                }
         } else {
+            // We don't currently verify ownership of entities that aren't Avatar Entities,
+            // so they always pass Ownership Verification. It's necessary to emit this signal
+            // so that the Inspection Certificate can continue its information-grabbing process.
             auto ledger = DependencyManager::get<Ledger>();
-            _challengeOwnershipTimeoutTimer.stop();
-            emit ledger->updateCertificateStatus(entityProperties.getCertificateID(), (uint)(ledger->CERTIFICATE_STATUS_STATIC_VERIFICATION_FAILED));
-            emit DependencyManager::get<WalletScriptingInterface>()->ownershipVerificationFailed(_lastInspectedEntity);
-            qCDebug(context_overlay) << "Entity" << _lastInspectedEntity << "failed static certificate verification!";
+            emit ledger->updateCertificateStatus(entityProperties.getCertificateID(), (uint)(ledger->CERTIFICATE_STATUS_VERIFICATION_SUCCESS));
         }
+    } else {
+        auto ledger = DependencyManager::get<Ledger>();
+        _challengeOwnershipTimeoutTimer.stop();
+        emit ledger->updateCertificateStatus(entityProperties.getCertificateID(), (uint)(ledger->CERTIFICATE_STATUS_STATIC_VERIFICATION_FAILED));
+        emit DependencyManager::get<WalletScriptingInterface>()->ownershipVerificationFailed(_lastInspectedEntity);
+        qCDebug(context_overlay) << "Entity" << _lastInspectedEntity << "failed static certificate verification!";
     }
 }
 
@@ -357,12 +363,10 @@ static const QString INSPECTION_CERTIFICATE_QML_PATH = "hifi/commerce/inspection
 void ContextOverlayInterface::openInspectionCertificate() {
     // lets open the tablet to the inspection certificate QML
     if (!_currentEntityWithContextOverlay.isNull() && _entityMarketplaceID.length() > 0) {
+        setLastInspectedEntity(_currentEntityWithContextOverlay);
         auto tablet = dynamic_cast<TabletProxy*>(_tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
         tablet->loadQMLSource(INSPECTION_CERTIFICATE_QML_PATH);
         _hmdScriptingInterface->openTablet();
-
-        setLastInspectedEntity(_currentEntityWithContextOverlay);
-        requestOwnershipVerification(_lastInspectedEntity);
     }
 }
 
diff --git a/interface/src/ui/overlays/ContextOverlayInterface.h b/interface/src/ui/overlays/ContextOverlayInterface.h
index 6aad2a773b..fcdf2d5820 100644
--- a/interface/src/ui/overlays/ContextOverlayInterface.h
+++ b/interface/src/ui/overlays/ContextOverlayInterface.h
@@ -57,7 +57,7 @@ public:
     bool getEnabled() { return _enabled; }
     bool getIsInMarketplaceInspectionMode() { return _isInMarketplaceInspectionMode; }
     void setIsInMarketplaceInspectionMode(bool mode) { _isInMarketplaceInspectionMode = mode; }
-    void requestOwnershipVerification(const QUuid& entityID);
+    Q_INVOKABLE void requestOwnershipVerification(const QUuid& entityID);
     EntityPropertyFlags getEntityPropertyFlags() { return _entityPropertyFlags; }
 
 signals:
diff --git a/interface/src/ui/overlays/Line3DOverlay.cpp b/interface/src/ui/overlays/Line3DOverlay.cpp
index 7200abf74e..c2e5ad1fb4 100644
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/interface/src/ui/overlays/Line3DOverlay.cpp
@@ -63,7 +63,7 @@ glm::vec3 Line3DOverlay::getEnd() const {
     localEnd = getLocalEnd();
     worldEnd = localToWorld(localEnd, getParentID(), getParentJointIndex(), getScalesWithParent(), success);
     if (!success) {
-        qDebug() << "Line3DOverlay::getEnd failed";
+        qDebug() << "Line3DOverlay::getEnd failed, parentID = " << getParentID();
     }
     return worldEnd;
 }
diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h
index a363fb6d15..f24bd51bde 100644
--- a/libraries/avatars/src/AvatarData.h
+++ b/libraries/avatars/src/AvatarData.h
@@ -707,7 +707,11 @@ public slots:
     void setJointMappingsFromNetworkReply();
     void setSessionUUID(const QUuid& sessionUUID) {
         if (sessionUUID != getID()) {
-            setID(sessionUUID);
+            if (sessionUUID == QUuid()) {
+                setID(AVATAR_SELF_ID);
+            } else {
+                setID(sessionUUID);
+            }
             emit sessionUUIDChanged();
         }
     }
diff --git a/libraries/fbx/src/FBX.h b/libraries/fbx/src/FBX.h
index e40b218344..224d19fe96 100644
--- a/libraries/fbx/src/FBX.h
+++ b/libraries/fbx/src/FBX.h
@@ -180,6 +180,8 @@ public:
     float emissiveIntensity{ 1.0f };
     float ambientFactor{ 1.0f };
 
+    float bumpMultiplier { 1.0f }; // TODO: to be implemented
+
     QString materialID;
     QString name;
     QString shadingModel;
diff --git a/libraries/fbx/src/OBJReader.cpp b/libraries/fbx/src/OBJReader.cpp
index ba93a49cb9..63fb93ae46 100644
--- a/libraries/fbx/src/OBJReader.cpp
+++ b/libraries/fbx/src/OBJReader.cpp
@@ -15,6 +15,7 @@
 #include "OBJReader.h"
 
 #include <ctype.h>  // .obj files are not locale-specific. The C/ASCII charset applies.
+#include <sstream> 
 
 #include <QtCore/QBuffer>
 #include <QtCore/QIODevice>
@@ -35,6 +36,11 @@ QHash<QString, float> COMMENT_SCALE_HINTS = {{"This file uses centimeters as uni
 
 const QString SMART_DEFAULT_MATERIAL_NAME = "High Fidelity smart default material name";
 
+const float ILLUMINATION_MODEL_MIN_OPACITY = 0.1f;
+const float ILLUMINATION_MODEL_APPLY_SHININESS = 0.5f;
+const float ILLUMINATION_MODEL_APPLY_ROUGHNESS = 1.0f;
+const float ILLUMINATION_MODEL_APPLY_NON_METALLIC = 0.0f;
+
 namespace {
 template<class T>
 T& checked_at(QVector<T>& vector, int i) {
@@ -70,6 +76,7 @@ int OBJTokenizer::nextToken(bool allowSpaceChar /*= false*/) {
         }
         switch (ch) {
             case '#': {
+                _datum = "";
                 _comment = _device->readLine(); // stash comment for a future call to getComment
                 return COMMENT_TOKEN;
             }
@@ -256,7 +263,14 @@ void OBJReader::parseMaterialLibrary(QIODevice* device) {
             default:
                 materials[matName] = currentMaterial;
                 #ifdef WANT_DEBUG
-                qCDebug(modelformat) << "OBJ Reader Last material shininess:" << currentMaterial.shininess << " opacity:" << currentMaterial.opacity << " diffuse color:" << currentMaterial.diffuseColor << " specular color:" << currentMaterial.specularColor << " diffuse texture:" << currentMaterial.diffuseTextureFilename << " specular texture:" << currentMaterial.specularTextureFilename;
+                qCDebug(modelformat) << "OBJ Reader Last material illumination model:" << currentMaterial.illuminationModel <<
+                                     " shininess:" << currentMaterial.shininess << " opacity:" << currentMaterial.opacity <<
+                                     " diffuse color:" << currentMaterial.diffuseColor << " specular color:" << 
+                                     currentMaterial.specularColor << " emissive color:" << currentMaterial.emissiveColor << 
+                                     " diffuse texture:" << currentMaterial.diffuseTextureFilename << " specular texture:" <<
+                                     currentMaterial.specularTextureFilename << " emissive texture:" <<
+                                     currentMaterial.emissiveTextureFilename << " bump texture:" <<
+                                     currentMaterial.bumpTextureFilename;
                 #endif
                 return;
         }
@@ -272,20 +286,46 @@ void OBJReader::parseMaterialLibrary(QIODevice* device) {
             qCDebug(modelformat) << "OBJ Reader Starting new material definition " << matName;
             #endif
             currentMaterial.diffuseTextureFilename = "";
+            currentMaterial.emissiveTextureFilename = "";
+            currentMaterial.specularTextureFilename = "";
+            currentMaterial.bumpTextureFilename = "";
         } else if (token == "Ns") {
             currentMaterial.shininess = tokenizer.getFloat();
-        } else if ((token == "d") || (token == "Tr")) {
+        } else if (token == "Ni") {
+            #ifdef WANT_DEBUG
+            qCDebug(modelformat) << "OBJ Reader Ignoring material Ni " << tokenizer.getFloat();
+            #else
+            tokenizer.getFloat();
+            #endif
+        } else if (token == "d") {
             currentMaterial.opacity = tokenizer.getFloat();
+        } else if (token == "Tr") {
+            currentMaterial.opacity = 1.0f - tokenizer.getFloat();
+        } else if (token == "illum") {
+            currentMaterial.illuminationModel = tokenizer.getFloat();
+        } else if (token == "Tf") {
+            #ifdef WANT_DEBUG
+            qCDebug(modelformat) << "OBJ Reader Ignoring material Tf " << tokenizer.getVec3();
+            #else
+            tokenizer.getVec3();
+            #endif
         } else if (token == "Ka") {
             #ifdef WANT_DEBUG
-            qCDebug(modelformat) << "OBJ Reader Ignoring material Ka " << tokenizer.getVec3();
+            qCDebug(modelformat) << "OBJ Reader Ignoring material Ka " << tokenizer.getVec3();;
+            #else
+            tokenizer.getVec3();
             #endif
         } else if (token == "Kd") {
             currentMaterial.diffuseColor = tokenizer.getVec3();
+        } else if (token == "Ke") {
+            currentMaterial.emissiveColor = tokenizer.getVec3();
         } else if (token == "Ks") {
             currentMaterial.specularColor = tokenizer.getVec3();
-        } else if ((token == "map_Kd") || (token == "map_Ks")) {
-            QByteArray filename = QUrl(tokenizer.getLineAsDatum()).fileName().toUtf8();
+        } else if ((token == "map_Kd") || (token == "map_Ke") || (token == "map_Ks") || (token == "map_bump") || (token == "bump")) {
+            const QByteArray textureLine = tokenizer.getLineAsDatum();
+            QByteArray filename;
+            OBJMaterialTextureOptions textureOptions;
+            parseTextureLine(textureLine, filename, textureOptions);
             if (filename.endsWith(".tga")) {
                 #ifdef WANT_DEBUG
                 qCDebug(modelformat) << "OBJ Reader WARNING: currently ignoring tga texture " << filename << " in " << _url;
@@ -294,11 +334,104 @@ void OBJReader::parseMaterialLibrary(QIODevice* device) {
             }
             if (token == "map_Kd") {
                 currentMaterial.diffuseTextureFilename = filename;
-            } else if( token == "map_Ks" ) {
+            } else if (token == "map_Ke") {
+                currentMaterial.emissiveTextureFilename = filename;
+            } else if (token == "map_Ks" ) {
                 currentMaterial.specularTextureFilename = filename;
+            } else if ((token == "map_bump") || (token == "bump")) {
+                currentMaterial.bumpTextureFilename = filename;
+                currentMaterial.bumpTextureOptions = textureOptions;
             }
         }
     }
+} 
+
+void OBJReader::parseTextureLine(const QByteArray& textureLine, QByteArray& filename, OBJMaterialTextureOptions& textureOptions) {
+    // Texture options reference http://paulbourke.net/dataformats/mtl/
+    // and https://wikivisually.com/wiki/Material_Template_Library
+
+    std::istringstream iss(textureLine.toStdString());
+    const std::vector<std::string> parser(std::istream_iterator<std::string>{iss}, std::istream_iterator<std::string>());
+
+    uint i = 0;
+    while (i < parser.size()) {
+        if (i + 1 < parser.size() && parser[i][0] == '-') {
+            const std::string& option = parser[i++];
+            if (option == "-blendu" || option == "-blendv") {
+                #ifdef WANT_DEBUG
+                const std::string& onoff = parser[i++];
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << onoff.c_str();
+                #endif
+            } else if (option == "-bm") {
+                const std::string& bm = parser[i++];
+                textureOptions.bumpMultiplier = std::stof(bm);
+            } else if (option == "-boost") {
+                #ifdef WANT_DEBUG
+                const std::string& boost = parser[i++];
+                float boostFloat = std::stof(boost);
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << boost.c_str();
+                #endif
+            } else if (option == "-cc") {
+                #ifdef WANT_DEBUG
+                const std::string& onoff = parser[i++];
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << onoff.c_str();
+                #endif
+            } else if (option == "-clamp") {
+                #ifdef WANT_DEBUG
+                const std::string& onoff = parser[i++];
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << onoff.c_str();
+                #endif
+            } else if (option == "-imfchan") {
+                #ifdef WANT_DEBUG
+                const std::string& imfchan = parser[i++];
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << imfchan.c_str();
+                #endif
+            } else if (option == "-mm") {
+                if (i + 1 < parser.size()) {
+                    #ifdef WANT_DEBUG
+                    const std::string& mmBase = parser[i++];
+                    const std::string& mmGain = parser[i++];
+                    float mmBaseFloat = std::stof(mmBase);
+                    float mmGainFloat = std::stof(mmGain);
+                    qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << mmBase.c_str() << mmGain.c_str();
+                    #endif
+                }
+            } else if (option == "-o" || option == "-s" || option == "-t") {
+                if (i + 2 < parser.size()) {
+                    #ifdef WANT_DEBUG
+                    const std::string& u = parser[i++];
+                    const std::string& v = parser[i++];
+                    const std::string& w = parser[i++];
+                    float uFloat = std::stof(u);
+                    float vFloat = std::stof(v);
+                    float wFloat = std::stof(w);
+                    qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << u.c_str() << v.c_str() << w.c_str();
+                    #endif
+                }
+            } else if (option == "-texres") {
+                #ifdef WANT_DEBUG
+                const std::string& texres = parser[i++];
+                float texresFloat = std::stof(texres);
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << texres.c_str();
+                #endif
+            } else if (option == "-type") {
+                #ifdef WANT_DEBUG
+                const std::string& type = parser[i++];
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring texture option" << option.c_str() << type.c_str();
+                #endif
+            } else if (option[0] == '-') {
+                #ifdef WANT_DEBUG
+                qCDebug(modelformat) << "OBJ Reader WARNING: Ignoring unsupported texture option" << option.c_str();
+                #endif
+            }
+        } else { // assume filename at end when no more options
+            std::string filenameString = parser[i++];
+            while (i < parser.size()) { // filename has space in it
+                filenameString += " " + parser[i++];
+            }
+            filename = filenameString.c_str();
+        }
+    }
 }
 
 std::tuple<bool, QByteArray> requestData(QUrl& url) {
@@ -745,7 +878,7 @@ FBXGeometry* OBJReader::readOBJ(QByteArray& model, const QVariantHash& mapping,
         }
         geometry.materials[materialID] = FBXMaterial(objMaterial.diffuseColor,
                                                      objMaterial.specularColor,
-                                                     glm::vec3(0.0f),
+                                                     objMaterial.emissiveColor,
                                                      objMaterial.shininess,
                                                      objMaterial.opacity);
         FBXMaterial& fbxMaterial = geometry.materials[materialID];
@@ -759,17 +892,88 @@ FBXGeometry* OBJReader::readOBJ(QByteArray& model, const QVariantHash& mapping,
         if (!objMaterial.specularTextureFilename.isEmpty()) {
             fbxMaterial.specularTexture.filename = objMaterial.specularTextureFilename;
         }
+        if (!objMaterial.emissiveTextureFilename.isEmpty()) {
+            fbxMaterial.emissiveTexture.filename = objMaterial.emissiveTextureFilename;
+        }
+        if (!objMaterial.bumpTextureFilename.isEmpty()) {
+            fbxMaterial.normalTexture.filename = objMaterial.bumpTextureFilename;
+            fbxMaterial.normalTexture.isBumpmap = true;
+            fbxMaterial.bumpMultiplier = objMaterial.bumpTextureOptions.bumpMultiplier;
+        }
 
         modelMaterial->setEmissive(fbxMaterial.emissiveColor);
         modelMaterial->setAlbedo(fbxMaterial.diffuseColor);
         modelMaterial->setMetallic(glm::length(fbxMaterial.specularColor));
         modelMaterial->setRoughness(graphics::Material::shininessToRoughness(fbxMaterial.shininess));
 
-        if (fbxMaterial.opacity <= 0.0f) {
-            modelMaterial->setOpacity(1.0f);
-        } else {
-            modelMaterial->setOpacity(fbxMaterial.opacity);
+        bool applyTransparency = false;
+        bool applyShininess = false;
+        bool applyRoughness = false;
+        bool applyNonMetallic = false;
+        bool fresnelOn = false;
+
+        // Illumination model reference http://paulbourke.net/dataformats/mtl/ 
+        switch (objMaterial.illuminationModel) {
+            case 0: // Color on and Ambient off
+                // We don't support ambient = do nothing?
+                break;
+            case 1: // Color on and Ambient on
+                // We don't support ambient = do nothing?
+                break;
+            case 2: // Highlight on
+                // Change specular intensity = do nothing for now?
+                break;
+            case 3: // Reflection on and Ray trace on
+                applyShininess = true;
+                break;
+            case 4: // Transparency: Glass on and Reflection: Ray trace on
+                applyTransparency = true;
+                applyShininess = true;
+                break;
+            case 5: // Reflection: Fresnel on and Ray trace on
+                applyShininess = true;
+                fresnelOn = true;
+                break;
+            case 6: // Transparency: Refraction on and Reflection: Fresnel off and Ray trace on
+                applyTransparency = true;
+                applyNonMetallic = true;
+                applyShininess = true;
+                break;
+            case 7: // Transparency: Refraction on and Reflection: Fresnel on and Ray trace on
+                applyTransparency = true;
+                applyNonMetallic = true;
+                applyShininess = true;
+                fresnelOn = true;
+                break;
+            case 8: // Reflection on and Ray trace off
+                applyShininess = true;
+                break;
+            case 9: // Transparency: Glass on and Reflection: Ray trace off
+                applyTransparency = true;
+                applyNonMetallic = true;
+                applyRoughness = true;
+                break;
+            case 10: // Casts shadows onto invisible surfaces
+                // Do nothing?
+                break;
+        }      
+
+        if (applyTransparency) {
+            fbxMaterial.opacity = std::max(fbxMaterial.opacity, ILLUMINATION_MODEL_MIN_OPACITY);
         }
+        if (applyShininess) {
+            modelMaterial->setRoughness(ILLUMINATION_MODEL_APPLY_SHININESS);
+        } else if (applyRoughness) {
+            modelMaterial->setRoughness(ILLUMINATION_MODEL_APPLY_ROUGHNESS);
+        }
+        if (applyNonMetallic) {
+            modelMaterial->setMetallic(ILLUMINATION_MODEL_APPLY_NON_METALLIC);
+        }
+        if (fresnelOn) {
+            modelMaterial->setFresnel(glm::vec3(1.0f));
+        }
+
+        modelMaterial->setOpacity(fbxMaterial.opacity);
     }
 
     return geometryPtr;
diff --git a/libraries/fbx/src/OBJReader.h b/libraries/fbx/src/OBJReader.h
index 45e3f79480..df356fada8 100644
--- a/libraries/fbx/src/OBJReader.h
+++ b/libraries/fbx/src/OBJReader.h
@@ -48,6 +48,11 @@ private:
     void addFrom(const OBJFace* face, int index);
 };
 
+class OBJMaterialTextureOptions {
+public:
+    float bumpMultiplier { 1.0f };
+}
+;
 // Materials and references to material names can come in any order, and different mesh parts can refer to the same material.
 // Therefore it would get pretty hacky to try to use FBXMeshPart to store these as we traverse the files.
 class OBJMaterial {
@@ -56,11 +61,16 @@ public:
     float opacity;
     glm::vec3 diffuseColor;
     glm::vec3 specularColor;
+    glm::vec3 emissiveColor;
     QByteArray diffuseTextureFilename;
     QByteArray specularTextureFilename;
+    QByteArray emissiveTextureFilename;
+    QByteArray bumpTextureFilename;
+    OBJMaterialTextureOptions bumpTextureOptions;
+    int illuminationModel;
     bool used { false };
     bool userSpecifiesUV { false };
-    OBJMaterial() : shininess(0.0f), opacity(1.0f), diffuseColor(0.9f), specularColor(0.9f) {}
+    OBJMaterial() : shininess(0.0f), opacity(1.0f), diffuseColor(0.9f), specularColor(0.9f), emissiveColor(0.0f), illuminationModel(-1) {}
 };
 
 class OBJReader: public QObject { // QObject so we can make network requests.
@@ -84,6 +94,7 @@ private:
     bool parseOBJGroup(OBJTokenizer& tokenizer, const QVariantHash& mapping, FBXGeometry& geometry,
                        float& scaleGuess, bool combineParts);
     void parseMaterialLibrary(QIODevice* device);
+    void parseTextureLine(const QByteArray& textureLine, QByteArray& filename, OBJMaterialTextureOptions& textureOptions);
     bool isValidTexture(const QByteArray &filename); // true if the file exists. TODO?: check content-type header and that it is a supported format.
 
     int _partCounter { 0 };
diff --git a/libraries/render-utils/src/LightAmbient.slh b/libraries/render-utils/src/LightAmbient.slh
index 0502446db8..3f52760eff 100644
--- a/libraries/render-utils/src/LightAmbient.slh
+++ b/libraries/render-utils/src/LightAmbient.slh
@@ -75,10 +75,10 @@ void evalLightingAmbient(out vec3 diffuse, out vec3 specular, LightAmbient ambie
     ) {
 
     // Rotate surface normal and eye direction
-    vec3 ambientSpaceSurfaceNormal = (ambient.transform * vec4(surface.normal,   0.0)).xyz;
-    vec3 ambientSpaceSurfaceEyeDir = (ambient.transform * vec4(surface.eyeDir,   0.0)).xyz;
+    vec3 ambientSpaceSurfaceNormal = (ambient.transform * vec4(surface.normal, 0.0)).xyz;
+    vec3 ambientSpaceSurfaceEyeDir = (ambient.transform * vec4(surface.eyeDir, 0.0)).xyz;
 <@if supportScattering@>
-    vec3 ambientSpaceLowNormalCurvature = (ambient.transform * lowNormalCurvature).xyz;
+    vec3 ambientSpaceLowNormal = (ambient.transform * vec4(lowNormalCurvature.xyz, 0.0)).xyz;
 <@endif@>
 
     vec3 ambientFresnel = fresnelSchlickAmbient(fresnelF0, surface.ndotv, 1.0-surface.roughness);
@@ -99,7 +99,7 @@ void evalLightingAmbient(out vec3 diffuse, out vec3 specular, LightAmbient ambie
         obscurance = min(obscurance, ambientOcclusion);
 
         // Diffuse from ambient
-        diffuse = sphericalHarmonics_evalSphericalLight(getLightAmbientSphere(ambient), ambientSpaceLowNormalCurvature).xyz;
+        diffuse = sphericalHarmonics_evalSphericalLight(getLightAmbientSphere(ambient), ambientSpaceLowNormal).xyz;
 
         // Scattering ambient specular is the same as non scattering for now
         // TODO: we should use the same specular answer as for direct lighting
diff --git a/libraries/shared/src/BitVectorHelpers.h b/libraries/shared/src/BitVectorHelpers.h
index 9f5af0c380..a619fe3999 100644
--- a/libraries/shared/src/BitVectorHelpers.h
+++ b/libraries/shared/src/BitVectorHelpers.h
@@ -12,6 +12,8 @@
 #ifndef hifi_BitVectorHelpers_h
 #define hifi_BitVectorHelpers_h
 
+#include "NumericalConstants.h"
+
 int calcBitVectorSize(int numBits) {
     return ((numBits - 1) >> 3) + 1;
 }
diff --git a/libraries/shared/src/shared/AbstractLoggerInterface.h b/libraries/shared/src/shared/AbstractLoggerInterface.h
index c202496103..f48496324b 100644
--- a/libraries/shared/src/shared/AbstractLoggerInterface.h
+++ b/libraries/shared/src/shared/AbstractLoggerInterface.h
@@ -50,8 +50,8 @@ signals:
 
 private:
     bool _extraDebugging{ false };
-    bool _debugPrint{ false };
-    bool _infoPrint{ false };
+    bool _debugPrint{ true };
+    bool _infoPrint{ true };
     bool _criticalPrint{ true };
     bool _warningPrint{ true };
     bool _suppressPrint{ true };
diff --git a/scripts/system/controllers/controllerModules/farActionGrabEntity.js b/scripts/system/controllers/controllerModules/farActionGrabEntity.js
index 32bf7316a9..b72a38f986 100644
--- a/scripts/system/controllers/controllerModules/farActionGrabEntity.js
+++ b/scripts/system/controllers/controllerModules/farActionGrabEntity.js
@@ -208,7 +208,7 @@ Script.include("/~/system/libraries/Xform.js");
             var worldToSensorMat = Mat4.inverse(MyAvatar.getSensorToWorldMatrix());
             var roomControllerPosition = Mat4.transformPoint(worldToSensorMat, worldControllerPosition);
 
-            var grabbedProperties = Entities.getEntityProperties(this.grabbedThingID, ["position"]);
+            var grabbedProperties = Entities.getEntityProperties(this.grabbedThingID, GRABBABLE_PROPERTIES);
             var now = Date.now();
             var deltaObjectTime = (now - this.currentObjectTime) / MSECS_PER_SEC; // convert to seconds
             this.currentObjectTime = now;
@@ -369,6 +369,14 @@ Script.include("/~/system/libraries/Xform.js");
             }
         };
 
+        this.targetIsNull = function() {
+            var properties = Entities.getEntityProperties(this.grabbedThingID);
+            if (Object.keys(properties).length === 0 && this.distanceHolding) {
+                return true;
+            }
+            return false;
+        }
+
         this.isReady = function (controllerData) {
             if (HMD.active) {
                 if (this.notPointingAtEntity(controllerData)) {
@@ -391,7 +399,7 @@ Script.include("/~/system/libraries/Xform.js");
 
         this.run = function (controllerData) {
             if (controllerData.triggerValues[this.hand] < TRIGGER_OFF_VALUE ||
-                this.notPointingAtEntity(controllerData)) {
+                this.notPointingAtEntity(controllerData) || this.targetIsNull()) {
                 this.endNearGrabAction();
                 return makeRunningValues(false, [], []);
             }
diff --git a/scripts/system/edit.js b/scripts/system/edit.js
index 863c185cb4..4ef88fcd21 100644
--- a/scripts/system/edit.js
+++ b/scripts/system/edit.js
@@ -1250,7 +1250,6 @@ var lastPosition = null;
 // Do some stuff regularly, like check for placement of various overlays
 Script.update.connect(function (deltaTime) {
     progressDialog.move();
-    selectionDisplay.checkMove();
     selectionDisplay.checkControllerMove();
     var dOrientation = Math.abs(Quat.dot(Camera.orientation, lastOrientation) - 1);
     var dPosition = Vec3.distance(Camera.position, lastPosition);
diff --git a/scripts/system/libraries/entitySelectionTool.js b/scripts/system/libraries/entitySelectionTool.js
index b8ba146757..24ec12a2c8 100644
--- a/scripts/system/libraries/entitySelectionTool.js
+++ b/scripts/system/libraries/entitySelectionTool.js
@@ -1,9 +1,10 @@
 //
-//  entitySelectionToolClass.js
+//  entitySelectionTool.js
 //  examples
 //
 //  Created by Brad hefta-Gaub on 10/1/14.
 //    Modified by Daniela Fontes * @DanielaFifo and Tiago Andrade @TagoWill on 4/7/2017
+//    Modified by David Back on 1/9/2018
 //  Copyright 2014 High Fidelity, Inc.
 //
 //  This script implements a class useful for building tools for editing entities.
@@ -18,15 +19,10 @@ HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
 
 SPACE_LOCAL = "local";
 SPACE_WORLD = "world";
+HIGHLIGHT_LIST_NAME = "editHandleHighlightList";
 
 Script.include("./controllers.js");
 
-function objectTranslationPlanePoint(position, dimensions) {
-    var newPosition = { x: position.x, y: position.y, z: position.z };
-    newPosition.y -= dimensions.y / 2.0;
-    return newPosition;
-}
-
 SelectionManager = (function() {
     var that = {};
 
@@ -53,10 +49,6 @@ SelectionManager = (function() {
             print("ERROR: entitySelectionTool.handleEntitySelectionToolUpdates - got malformed message: " + message);
         }
 
-        // if (message === 'callUpdate') {
-        //     that._update();
-        // }
-
         if (messageParsed.method === "selectEntity") {
             if (wantDebug) {
                 print("setting selection to " + messageParsed.entityID);
@@ -67,6 +59,22 @@ SelectionManager = (function() {
 
     subscribeToUpdateMessages();
 
+    var COLOR_ORANGE_HIGHLIGHT = { red: 255, green: 99, blue: 9 }
+    var editHandleOutlineStyle = {
+        outlineUnoccludedColor: COLOR_ORANGE_HIGHLIGHT,
+        outlineOccludedColor: COLOR_ORANGE_HIGHLIGHT,
+        fillUnoccludedColor: COLOR_ORANGE_HIGHLIGHT,
+        fillOccludedColor: COLOR_ORANGE_HIGHLIGHT,
+        outlineUnoccludedAlpha: 1,
+        outlineOccludedAlpha: 0,
+        fillUnoccludedAlpha: 0,
+        fillOccludedAlpha: 0,
+        outlineWidth: 3,
+        isOutlineSmooth: true
+    };
+    //disabling this for now as it is causing rendering issues with the other handle overlays
+    //Selection.enableListHighlight(HIGHLIGHT_LIST_NAME, editHandleOutlineStyle);
+
     that.savedProperties = {};
     that.selections = [];
     var listeners = [];
@@ -103,6 +111,7 @@ SelectionManager = (function() {
         for (var i = 0; i < entityIDs.length; i++) {
             var entityID = entityIDs[i];
             that.selections.push(entityID);
+            Selection.addToSelectedItemsList(HIGHLIGHT_LIST_NAME, "entity", entityID);
         }
 
         that._update(true);
@@ -119,8 +128,10 @@ SelectionManager = (function() {
             }
             if (idx === -1) {
                 that.selections.push(entityID);
+                Selection.addToSelectedItemsList(HIGHLIGHT_LIST_NAME, "entity", entityID);
             } else if (toggleSelection) {
                 that.selections.splice(idx, 1);
+                Selection.removeFromSelectedItemsList(HIGHLIGHT_LIST_NAME, "entity", entityID);
             }
         }
 
@@ -131,6 +142,7 @@ SelectionManager = (function() {
         var idx = that.selections.indexOf(entityID);
         if (idx >= 0) {
             that.selections.splice(idx, 1);
+            Selection.removeFromSelectedItemsList(HIGHLIGHT_LIST_NAME, "entity", entityID);
         }
         that._update(true);
     };
@@ -147,6 +159,7 @@ SelectionManager = (function() {
             that.localPosition = null;
             that.worldDimensions = null;
             that.worldPosition = null;
+            that.worldRotation = null;
         } else if (that.selections.length === 1) {
             properties = Entities.getEntityProperties(that.selections[0]);
             that.localDimensions = properties.dimensions;
@@ -156,6 +169,7 @@ SelectionManager = (function() {
 
             that.worldDimensions = properties.boundingBox.dimensions;
             that.worldPosition = properties.boundingBox.center;
+            that.worldRotation = properties.boundingBox.rotation;
 
             SelectionDisplay.setSpaceMode(SPACE_LOCAL);
         } else {
@@ -203,13 +217,12 @@ SelectionManager = (function() {
                 print("ERROR: entitySelectionTool.update got exception: " + JSON.stringify(e));
             }
         }
-
     };
 
     return that;
 })();
 
-// Normalize degrees to be in the range (-180, 180]
+// Normalize degrees to be in the range (-180, 180)
 function normalizeDegrees(degrees) {
     degrees = ((degrees + 180) % 360) - 180;
     if (degrees <= -180) {
@@ -219,36 +232,83 @@ function normalizeDegrees(degrees) {
     return degrees;
 }
 
-// FUNCTION: getRelativeCenterPosition
-// Return the enter position of an entity relative to it's registrationPoint
-// A registration point of (0.5, 0.5, 0.5) will have an offset of (0, 0, 0)
-// A registration point of (1.0, 1.0, 1.0) will have an offset of (-dimensions.x / 2, -dimensions.y / 2, -dimensions.z / 2)
-function getRelativeCenterPosition(dimensions, registrationPoint) {
-    return {
-        x: -dimensions.x * (registrationPoint.x - 0.5),
-        y: -dimensions.y * (registrationPoint.y - 0.5),
-        z: -dimensions.z * (registrationPoint.z - 0.5)
-    };
-}
-
 // SELECTION DISPLAY DEFINITION
 SelectionDisplay = (function() {
     var that = {};
 
-    var MINIMUM_DIMENSION = 0.001;
+    var NEGATE_VECTOR = -1;
 
-    var GRABBER_DISTANCE_TO_SIZE_RATIO = 0.0075;
+    var COLOR_GREEN = { red:31, green:198, blue:166 };
+    var COLOR_BLUE = { red:0, green:147, blue:197 };
+    var COLOR_RED = { red:226, green:51, blue:77 };
+    var COLOR_HOVER = { red:227, green:227, blue:227 };
+    var COLOR_ROTATE_CURRENT_RING = { red: 255, green: 99, blue: 9 };
+    var COLOR_SCALE_EDGE = { red:87, green:87, blue:87 };
+    var COLOR_SCALE_CUBE = { red:106, green:106, blue:106 };
+    var COLOR_SCALE_CUBE_SELECTED = { red:18, green:18, blue:18 };
+
+    var TRANSLATE_ARROW_CYLINDER_OFFSET = 0.1;
+    var TRANSLATE_ARROW_CYLINDER_CAMERA_DISTANCE_MULTIPLE = 0.005;
+    var TRANSLATE_ARROW_CYLINDER_Y_MULTIPLE = 7.5;
+    var TRANSLATE_ARROW_CONE_CAMERA_DISTANCE_MULTIPLE = 0.025;
+    var TRANSLATE_ARROW_CONE_OFFSET_CYLINDER_DIMENSION_MULTIPLE = 0.83;
+
+    var ROTATE_RING_CAMERA_DISTANCE_MULTIPLE = 0.15;
+    var ROTATE_CTRL_SNAP_ANGLE = 22.5;
+    var ROTATE_DEFAULT_SNAP_ANGLE = 1;
+    var ROTATE_DEFAULT_TICK_MARKS_ANGLE = 5;
+    var ROTATE_RING_IDLE_INNER_RADIUS = 0.95;
+    var ROTATE_RING_SELECTED_INNER_RADIUS = 0.9;
 
     // These are multipliers for sizing the rotation degrees display while rotating an entity
-    var ROTATION_DISPLAY_DISTANCE_MULTIPLIER = 1.2;
-    var ROTATION_DISPLAY_SIZE_X_MULTIPLIER = 0.6;
-    var ROTATION_DISPLAY_SIZE_Y_MULTIPLIER = 0.18;
-    var ROTATION_DISPLAY_LINE_HEIGHT_MULTIPLIER = 0.14;
+    var ROTATE_DISPLAY_DISTANCE_MULTIPLIER = 2;
+    var ROTATE_DISPLAY_SIZE_X_MULTIPLIER = 0.2;
+    var ROTATE_DISPLAY_SIZE_Y_MULTIPLIER = 0.09;
+    var ROTATE_DISPLAY_LINE_HEIGHT_MULTIPLIER = 0.07;
 
-    var ROTATE_ARROW_WEST_NORTH_URL = HIFI_PUBLIC_BUCKET + "images/rotate-arrow-west-north.svg";
-    var ROTATE_ARROW_WEST_SOUTH_URL = HIFI_PUBLIC_BUCKET + "images/rotate-arrow-west-south.svg";
+    var STRETCH_SPHERE_OFFSET = 0.06;
+    var STRETCH_SPHERE_CAMERA_DISTANCE_MULTIPLE = 0.01;
+    var STRETCH_MINIMUM_DIMENSION = 0.001;
+    var STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE = 2;
+    var STRETCH_PANEL_WIDTH = 0.01;
 
-    var showExtendedStretchHandles = false;
+    var SCALE_CUBE_OFFSET = 0.5;
+    var SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE = 0.015;
+    var SCALE_MINIMUM_DIMENSION = 0.02;
+
+    var CLONER_OFFSET = { x:0.9, y:-0.9, z:0.9 };    
+    
+    var CTRL_KEY_CODE = 16777249;
+
+    var TRANSLATE_DIRECTION = {
+        X : 0,
+        Y : 1,
+        Z : 2
+    }
+
+    var STRETCH_DIRECTION = {
+        X : 0,
+        Y : 1,
+        Z : 2,
+        ALL : 3
+    }
+
+    var SCALE_DIRECTION = {
+        LBN : 0,
+        RBN : 1,
+        LBF : 2,
+        RBF : 3,
+        LTN : 4,
+        RTN : 5,
+        LTF : 6,
+        RTF : 7
+    }
+
+    var ROTATE_DIRECTION = {
+        PITCH : 0,
+        YAW : 1,
+        ROLL : 2
+    }
 
     var spaceMode = SPACE_LOCAL;
     var overlayNames = [];
@@ -259,185 +319,96 @@ SelectionDisplay = (function() {
         getControllerWorldLocation(Controller.Standard.RightHand, true)
     ];
 
-    var handleHoverColor = {
-        red: 224,
-        green: 67,
-        blue: 36
-    };
-    var handleHoverAlpha = 1.0;
-
-    var innerSnapAngle = 22.5; // the angle which we snap to on the inner rotation tool
-    var innerRadius;
-    var outerRadius;
-    var yawHandleRotation;
-    var pitchHandleRotation;
-    var rollHandleRotation;
-    var yawCenter;
-    var pitchCenter;
-    var rollCenter;
-    var rotZero;
+    var rotationZero;
     var rotationNormal;
+    var rotationDegreesPosition;
 
+    var worldRotationX;
+    var worldRotationY;
+    var worldRotationZ;
 
-    var handleColor = {
-        red: 255,
-        green: 255,
-        blue: 255
-    };
-    var handleAlpha = 0.7;
-
-    var highlightedHandleColor = {
-        red: 183,
-        green: 64,
-        blue: 44
-    };
-    var highlightedHandleAlpha = 0.9;
-
-    var previousHandle = false;
+    var previousHandle = null;
+    var previousHandleHelper = null;
     var previousHandleColor;
-    var previousHandleAlpha;
 
-    var grabberSizeCorner = 0.025; // These get resized by updateHandleSizes().
-    var grabberSizeEdge = 0.015;
-    var grabberSizeFace = 0.025;
-    var grabberAlpha = 1;
-    var grabberColorCorner = {
-        red: 120,
-        green: 120,
-        blue: 120
-    };
-    var grabberColorEdge = {
-        red: 0,
-        green: 0,
-        blue: 0
-    };
-    var grabberColorFace = {
-        red: 120,
-        green: 120,
-        blue: 120
-    };
-    var grabberColorCloner = {
-        red: 0,
-        green: 155,
-        blue: 0
-    };
-    var grabberLineWidth = 0.5;
-    var grabberSolid = true;
-    var grabberMoveUpPosition = Vec3.ZERO;
+    var ctrlPressed = false;
 
-    var lightOverlayColor = {
-        red: 255,
-        green: 153,
-        blue: 0
-    };
-
-    var grabberPropertiesCorner = {
-        position: Vec3.ZERO,
-        size: grabberSizeCorner,
-        color: grabberColorCorner,
-        alpha: 1,
-        solid: grabberSolid,
+    var handlePropertiesTranslateArrowCones = {
+        shape: "Cone",
+        solid: true,
         visible: false,
-        dashed: false,
-        drawInFront: true,
-        borderSize: 1.4
+        ignoreRayIntersection: false,
+        drawInFront: true
     };
-
-    var grabberPropertiesEdge = {
-        position: Vec3.ZERO,
-        size: grabberSizeEdge,
-        color: grabberColorEdge,
-        alpha: 1,
-        solid: grabberSolid,
+    var handlePropertiesTranslateArrowCylinders = {
+        shape: "Cylinder",
+        solid: true,
         visible: false,
-        dashed: false,
-        drawInFront: true,
-        borderSize: 1.4
+        ignoreRayIntersection: false,
+        drawInFront: true
     };
+    var handleTranslateXCone = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCones);
+    var handleTranslateXCylinder = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCylinders);
+    Overlays.editOverlay(handleTranslateXCone, { color : COLOR_RED });
+    Overlays.editOverlay(handleTranslateXCylinder, { color : COLOR_RED });
+    var handleTranslateYCone = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCones);
+    var handleTranslateYCylinder = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCylinders);
+    Overlays.editOverlay(handleTranslateYCone, { color : COLOR_GREEN });
+    Overlays.editOverlay(handleTranslateYCylinder, { color : COLOR_GREEN });
+    var handleTranslateZCone = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCones);
+    var handleTranslateZCylinder = Overlays.addOverlay("shape", handlePropertiesTranslateArrowCylinders);
+    Overlays.editOverlay(handleTranslateZCone, { color : COLOR_BLUE });
+    Overlays.editOverlay(handleTranslateZCylinder, { color : COLOR_BLUE });
 
-    var grabberPropertiesFace = {
-        position: Vec3.ZERO,
-        size: grabberSizeFace,
-        color: grabberColorFace,
+    var handlePropertiesRotateRings = {
         alpha: 1,
-        solid: grabberSolid,
+        solid: true,
+        startAt: 0,
+        endAt: 360,
+        innerRadius: ROTATE_RING_IDLE_INNER_RADIUS,
+        majorTickMarksAngle: ROTATE_DEFAULT_TICK_MARKS_ANGLE,
+        majorTickMarksLength: 0.1,
         visible: false,
-        dashed: false,
-        drawInFront: true,
-        borderSize: 1.4
+        ignoreRayIntersection: false,
+        drawInFront: true
     };
+    var handleRotatePitchRing = Overlays.addOverlay("circle3d", handlePropertiesRotateRings);
+    Overlays.editOverlay(handleRotatePitchRing, { 
+        color : COLOR_RED,
+        majorTickMarksColor: COLOR_RED,
+    });
+    var handleRotateYawRing = Overlays.addOverlay("circle3d", handlePropertiesRotateRings);
+    Overlays.editOverlay(handleRotateYawRing, { 
+        color : COLOR_GREEN,
+        majorTickMarksColor: COLOR_GREEN,
+    });
+    var handleRotateRollRing = Overlays.addOverlay("circle3d", handlePropertiesRotateRings);
+    Overlays.editOverlay(handleRotateRollRing, { 
+        color : COLOR_BLUE,
+        majorTickMarksColor: COLOR_BLUE,
+    });
 
-    var grabberPropertiesCloner = {
-        position: Vec3.ZERO,
-        size: grabberSizeCorner,
-        color: grabberColorCloner,
+    var handleRotateCurrentRing = Overlays.addOverlay("circle3d", {
         alpha: 1,
-        solid: grabberSolid,
+        color: COLOR_ROTATE_CURRENT_RING,
+        solid: true,
+        innerRadius: 0.9,
         visible: false,
-        dashed: false,
-        drawInFront: true,
-        borderSize: 1.4
-    };
-
-    var spotLightLineProperties = {
-        color: lightOverlayColor
-    };
-
-    var highlightBox = Overlays.addOverlay("cube", {
-        position: Vec3.ZERO,
-        size: 1,
-        color: {
-            red: 90,
-            green: 90,
-            blue: 90
-        },
-        alpha: 1,
-        solid: false,
-        visible: false,
-        dashed: true,
-        ignoreRayIntersection: true, // this never ray intersects
+        ignoreRayIntersection: true,
         drawInFront: true
     });
 
-    var selectionBox = Overlays.addOverlay("cube", {
-        position: Vec3.ZERO,
-        size: 1,
-        color: {
-            red: 255,
-            green: 0,
-            blue: 0
-        },
-        alpha: 1,
-        solid: false,
-        visible: false,
-        dashed: false
-    });
-
-    var selectionBoxes = [];
-
     var rotationDegreesDisplay = Overlays.addOverlay("text3d", {
-        position: Vec3.ZERO,
         text: "",
-        color: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        backgroundColor: {
-            red: 255,
-            green: 255,
-            blue: 255
-        },
+        color: { red: 0, green: 0, blue: 0 },
+        backgroundColor: { red: 255, green: 255, blue: 255 },
         alpha: 0.7,
         backgroundAlpha: 0.7,
         visible: false,
         isFacingAvatar: true,
         drawInFront: true,
         ignoreRayIntersection: true,
-        dimensions: {
-            x: 0,
-            y: 0
-        },
+        dimensions: { x: 0, y: 0 },
         lineHeight: 0.0,
         topMargin: 0,
         rightMargin: 0,
@@ -445,461 +416,183 @@ SelectionDisplay = (function() {
         leftMargin: 0
     });
 
-    var grabberMoveUp = Overlays.addOverlay("image3d", {
-        url: HIFI_PUBLIC_BUCKET + "images/up-arrow.svg",
-        position: Vec3.ZERO,
-        color: handleColor,
-        alpha: handleAlpha,
+    var handlePropertiesStretchSpheres = {
+        shape: "Sphere",
+        solid: true,
         visible: false,
-        size: 0.1,
-        scale: 0.1,
-        isFacingAvatar: true,
+        ignoreRayIntersection: false,
         drawInFront: true
-    });
-
-    // var normalLine = Overlays.addOverlay("line3d", {
-    //                 visible: true,
-    //                 start: { x: 0, y: 0, z: 0 },
-    //                 end: { x: 0, y: 0, z: 0 },
-    //                 color: { red: 255, green: 255, blue: 0 },
-    //                 ignoreRayIntersection: true,
-    // });
-
-    var grabberLBN = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberRBN = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberLBF = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberRBF = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberLTN = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberRTN = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberLTF = Overlays.addOverlay("cube", grabberPropertiesCorner);
-    var grabberRTF = Overlays.addOverlay("cube", grabberPropertiesCorner);
-
-    var grabberTOP = Overlays.addOverlay("cube", grabberPropertiesFace);
-    var grabberBOTTOM = Overlays.addOverlay("cube", grabberPropertiesFace);
-    var grabberLEFT = Overlays.addOverlay("cube", grabberPropertiesFace);
-    var grabberRIGHT = Overlays.addOverlay("cube", grabberPropertiesFace);
-    var grabberNEAR = Overlays.addOverlay("cube", grabberPropertiesFace);
-    var grabberFAR = Overlays.addOverlay("cube", grabberPropertiesFace);
-
-    var grabberEdgeTR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeTL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeTF = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeTN = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeBR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeBL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeBF = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeBN = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeNR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeNL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeFR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberEdgeFL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-
-    var grabberSpotLightCircle = Overlays.addOverlay("circle3d", {
-        color: lightOverlayColor,
-        isSolid: false,
-        visible: false
-    });
-    var grabberSpotLightLineT = Overlays.addOverlay("line3d", spotLightLineProperties);
-    var grabberSpotLightLineB = Overlays.addOverlay("line3d", spotLightLineProperties);
-    var grabberSpotLightLineL = Overlays.addOverlay("line3d", spotLightLineProperties);
-    var grabberSpotLightLineR = Overlays.addOverlay("line3d", spotLightLineProperties);
-
-    var grabberSpotLightCenter = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberSpotLightRadius = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberSpotLightL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberSpotLightR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberSpotLightT = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberSpotLightB = Overlays.addOverlay("cube", grabberPropertiesEdge);
-
-    var spotLightGrabberHandles = [
-        grabberSpotLightCircle, grabberSpotLightCenter, grabberSpotLightRadius,
-        grabberSpotLightLineT, grabberSpotLightLineB, grabberSpotLightLineL, grabberSpotLightLineR,
-        grabberSpotLightT, grabberSpotLightB, grabberSpotLightL, grabberSpotLightR
-    ];
-
-    var grabberPointLightCircleX = Overlays.addOverlay("circle3d", {
-        rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
-        color: lightOverlayColor,
-        isSolid: false,
-        visible: false
-    });
-    var grabberPointLightCircleY = Overlays.addOverlay("circle3d", {
-        rotation: Quat.fromPitchYawRollDegrees(90, 0, 0),
-        color: lightOverlayColor,
-        isSolid: false,
-        visible: false
-    });
-    var grabberPointLightCircleZ = Overlays.addOverlay("circle3d", {
-        rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
-        color: lightOverlayColor,
-        isSolid: false,
-        visible: false
-    });
-    var grabberPointLightT = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberPointLightB = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberPointLightL = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberPointLightR = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberPointLightF = Overlays.addOverlay("cube", grabberPropertiesEdge);
-    var grabberPointLightN = Overlays.addOverlay("cube", grabberPropertiesEdge);
-
-    var pointLightGrabberHandles = [
-        grabberPointLightCircleX, grabberPointLightCircleY, grabberPointLightCircleZ,
-        grabberPointLightT, grabberPointLightB, grabberPointLightL,
-        grabberPointLightR, grabberPointLightF, grabberPointLightN
-    ];
-
-    var grabberCloner = Overlays.addOverlay("cube", grabberPropertiesCloner);
-
-    var stretchHandles = [
-        grabberLBN,
-        grabberRBN,
-        grabberLBF,
-        grabberRBF,
-        grabberLTN,
-        grabberRTN,
-        grabberLTF,
-        grabberRTF,
-        grabberTOP,
-        grabberBOTTOM,
-        grabberLEFT,
-        grabberRIGHT,
-        grabberNEAR,
-        grabberFAR,
-        grabberEdgeTR,
-        grabberEdgeTL,
-        grabberEdgeTF,
-        grabberEdgeTN,
-        grabberEdgeBR,
-        grabberEdgeBL,
-        grabberEdgeBF,
-        grabberEdgeBN,
-        grabberEdgeNR,
-        grabberEdgeNL,
-        grabberEdgeFR,
-        grabberEdgeFL,
-
-        grabberSpotLightLineT,
-        grabberSpotLightLineB,
-        grabberSpotLightLineL,
-        grabberSpotLightLineR,
-
-        grabberSpotLightCenter,
-        grabberSpotLightRadius,
-        grabberSpotLightL,
-        grabberSpotLightR,
-        grabberSpotLightT,
-        grabberSpotLightB,
-
-        grabberPointLightT,
-        grabberPointLightB,
-        grabberPointLightL,
-        grabberPointLightR,
-        grabberPointLightF,
-        grabberPointLightN,
-
-        grabberCloner
-    ];
-
-
-    var baseOverlayAngles = {
-        x: 0,
-        y: 0,
-        z: 0
     };
-    var baseOverlayRotation = Quat.fromVec3Degrees(baseOverlayAngles);
-    var baseOfEntityProjectionOverlay = Overlays.addOverlay("rectangle3d", {
-        position: {
-            x: 1,
-            y: 0,
-            z: 0
-        },
-        color: {
-            red: 51,
-            green: 152,
-            blue: 203
-        },
+    var handleStretchXSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres);
+    Overlays.editOverlay(handleStretchXSphere, { color : COLOR_RED });
+    var handleStretchYSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres);
+    Overlays.editOverlay(handleStretchYSphere, { color : COLOR_GREEN });
+    var handleStretchZSphere = Overlays.addOverlay("shape", handlePropertiesStretchSpheres);
+    Overlays.editOverlay(handleStretchZSphere, { color : COLOR_BLUE });
+
+    var handlePropertiesStretchPanel = {
+        shape: "Quad",
         alpha: 0.5,
         solid: true,
         visible: false,
-        width: 300,
-        height: 200,
-        rotation: baseOverlayRotation,
-        ignoreRayIntersection: true // always ignore this
-    });
+        ignoreRayIntersection: true,
+        drawInFront: true,
+    }
+    var handleStretchXPanel = Overlays.addOverlay("shape", handlePropertiesStretchPanel);
+    Overlays.editOverlay(handleStretchXPanel, { color : COLOR_RED });
+    var handleStretchYPanel = Overlays.addOverlay("shape", handlePropertiesStretchPanel);
+    Overlays.editOverlay(handleStretchYPanel, { color : COLOR_GREEN });
+    var handleStretchZPanel = Overlays.addOverlay("shape", handlePropertiesStretchPanel);
+    Overlays.editOverlay(handleStretchZPanel, { color : COLOR_BLUE });
 
-    var yawOverlayAngles = {
-        x: 90,
-        y: 0,
-        z: 0
-    };
-    var yawOverlayRotation = Quat.fromVec3Degrees(yawOverlayAngles);
-    var pitchOverlayAngles = {
-        x: 0,
-        y: 90,
-        z: 0
-    };
-    var pitchOverlayRotation = Quat.fromVec3Degrees(pitchOverlayAngles);
-    var rollOverlayAngles = {
-        x: 0,
-        y: 180,
-        z: 0
-    };
-    var rollOverlayRotation = Quat.fromVec3Degrees(rollOverlayAngles);
-
-    var xRailOverlay = Overlays.addOverlay("line3d", {
-        visible: false,
-        start: Vec3.ZERO,
-        end: Vec3.ZERO,
-        color: {
-            red: 255,
-            green: 0,
-            blue: 0
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
-    var yRailOverlay = Overlays.addOverlay("line3d", {
-        visible: false,
-        start: Vec3.ZERO,
-        end: Vec3.ZERO,
-        color: {
-            red: 0,
-            green: 255,
-            blue: 0
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
-    var zRailOverlay = Overlays.addOverlay("line3d", {
-        visible: false,
-        start: Vec3.ZERO,
-        end: Vec3.ZERO,
-        color: {
-            red: 0,
-            green: 0,
-            blue: 255
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
-
-    var rotateZeroOverlay = Overlays.addOverlay("line3d", {
-        visible: false,
-        start: Vec3.ZERO,
-        end: Vec3.ZERO,
-        color: {
-            red: 255,
-            green: 0,
-            blue: 0
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
-
-    var rotateCurrentOverlay = Overlays.addOverlay("line3d", {
-        visible: false,
-        start: Vec3.ZERO,
-        end: Vec3.ZERO,
-        color: {
-            red: 0,
-            green: 0,
-            blue: 255
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
-
-
-    var rotateOverlayInner = Overlays.addOverlay("circle3d", {
-        position: Vec3.ZERO,
-        size: 1,
-        color: {
-            red: 51,
-            green: 152,
-            blue: 203
-        },
-        alpha: 0.2,
+    var handlePropertiesScaleCubes = {
+        size: 0.025,
+        color: COLOR_SCALE_CUBE,
         solid: true,
         visible: false,
-        rotation: yawOverlayRotation,
-        hasTickMarks: true,
-        majorTickMarksAngle: innerSnapAngle,
-        minorTickMarksAngle: 0,
-        majorTickMarksLength: -0.25,
-        minorTickMarksLength: 0,
-        majorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        minorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        ignoreRayIntersection: true // always ignore this
-    });
+        ignoreRayIntersection: false,
+        drawInFront: true,
+        borderSize: 1.4
+    };
+    var handleScaleLBNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, -y, -z)
+    var handleScaleRBNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, -y,  z)
+    var handleScaleLBFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, -y, -z)
+    var handleScaleRBFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x, -y,  z)
+    var handleScaleLTNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x,  y, -z)
+    var handleScaleRTNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x,  y,  z)
+    var handleScaleLTFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x,  y, -z)
+    var handleScaleRTFCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x,  y,  z)
 
-    var rotateOverlayOuter = Overlays.addOverlay("circle3d", {
-        position: Vec3.ZERO,
-        size: 1,
-        color: {
-            red: 51,
-            green: 152,
-            blue: 203
-        },
-        alpha: 0.2,
+    var handlePropertiesScaleEdge = {
+        color: COLOR_SCALE_EDGE,
+        visible: false,
+        ignoreRayIntersection: true,
+        drawInFront: true,
+        lineWidth: 0.2
+    }
+    var handleScaleTREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleTLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleTFEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleTNEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleBREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleBLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleBFEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleBNEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleNREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleNLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleFREdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+    var handleScaleFLEdge = Overlays.addOverlay("line3d", handlePropertiesScaleEdge);
+
+    var handleCloner = Overlays.addOverlay("cube", {
+        size: 0.05,
+        color: COLOR_GREEN,
         solid: true,
         visible: false,
-        rotation: yawOverlayRotation,
-
-        hasTickMarks: true,
-        majorTickMarksAngle: 45.0,
-        minorTickMarksAngle: 5,
-        majorTickMarksLength: 0.25,
-        minorTickMarksLength: 0.1,
-        majorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        minorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        ignoreRayIntersection: true // always ignore this
+        ignoreRayIntersection: false,
+        drawInFront: true,
+        borderSize: 1.4
     });
 
-    var rotateOverlayCurrent = Overlays.addOverlay("circle3d", {
-        position: Vec3.ZERO,
+    // setting to 0 alpha for now to keep this hidden vs using visible false 
+    // because its used as the translate xz tool handle overlay
+    var selectionBox = Overlays.addOverlay("cube", {
         size: 1,
-        color: {
-            red: 224,
-            green: 67,
-            blue: 36
-        },
-        alpha: 0.8,
-        solid: true,
+        color: COLOR_RED,
+        alpha: 0,
+        solid: false,
         visible: false,
-        rotation: yawOverlayRotation,
-        ignoreRayIntersection: true, // always ignore this
-        hasTickMarks: true,
-        majorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        },
-        minorTickMarksColor: {
-            red: 0,
-            green: 0,
-            blue: 0
-        }
-    });
-
-    var yawHandle = Overlays.addOverlay("image3d", {
-        url: ROTATE_ARROW_WEST_NORTH_URL,
-        position: Vec3.ZERO,
-        color: handleColor,
-        alpha: handleAlpha,
-        visible: false,
-        size: 0.1,
-        scale: 0.1,
-        isFacingAvatar: false,
-        drawInFront: true
-    });
-
-
-    var pitchHandle = Overlays.addOverlay("image3d", {
-        url: ROTATE_ARROW_WEST_NORTH_URL,
-        position: Vec3.ZERO,
-        color: handleColor,
-        alpha: handleAlpha,
-        visible: false,
-        size: 0.1,
-        scale: 0.1,
-        isFacingAvatar: false,
-        drawInFront: true
-    });
-
-
-    var rollHandle = Overlays.addOverlay("image3d", {
-        url: ROTATE_ARROW_WEST_NORTH_URL,
-        position: Vec3.ZERO,
-        color: handleColor,
-        alpha: handleAlpha,
-        visible: false,
-        size: 0.1,
-        scale: 0.1,
-        isFacingAvatar: false,
-        drawInFront: true
+        dashed: false
     });
 
     var allOverlays = [
-        highlightBox,
-        selectionBox,
-        grabberMoveUp,
-        yawHandle,
-        pitchHandle,
-        rollHandle,
-        rotateOverlayInner,
-        rotateOverlayOuter,
-        rotateOverlayCurrent,
-        rotateZeroOverlay,
-        rotateCurrentOverlay,
+        handleTranslateXCone,
+        handleTranslateXCylinder,
+        handleTranslateYCone,
+        handleTranslateYCylinder,
+        handleTranslateZCone,
+        handleTranslateZCylinder,
+        handleRotatePitchRing,
+        handleRotateYawRing,
+        handleRotateRollRing,
+        handleRotateCurrentRing,
         rotationDegreesDisplay,
-        xRailOverlay,
-        yRailOverlay,
-        zRailOverlay,
-        baseOfEntityProjectionOverlay,
-        grabberSpotLightCircle,
-        grabberPointLightCircleX,
-        grabberPointLightCircleY,
-        grabberPointLightCircleZ
+        handleStretchXSphere,
+        handleStretchYSphere,
+        handleStretchZSphere,
+        handleStretchXPanel,
+        handleStretchYPanel,
+        handleStretchZPanel,
+        handleScaleLBNCube,
+        handleScaleRBNCube,
+        handleScaleLBFCube,
+        handleScaleRBFCube,
+        handleScaleLTNCube,
+        handleScaleRTNCube,
+        handleScaleLTFCube,
+        handleScaleRTFCube,
+        handleScaleTREdge,
+        handleScaleTLEdge,
+        handleScaleTFEdge,
+        handleScaleTNEdge,
+        handleScaleBREdge,
+        handleScaleBLEdge,
+        handleScaleBFEdge,
+        handleScaleBNEdge,
+        handleScaleNREdge,
+        handleScaleNLEdge,
+        handleScaleFREdge,
+        handleScaleFLEdge,
+        handleCloner,
+        selectionBox
+    ];
 
-    ].concat(stretchHandles);
+    overlayNames[handleTranslateXCone] = "handleTranslateXCone";
+    overlayNames[handleTranslateXCylinder] = "handleTranslateXCylinder";
+    overlayNames[handleTranslateYCone] = "handleTranslateYCone";
+    overlayNames[handleTranslateYCylinder] = "handleTranslateYCylinder";
+    overlayNames[handleTranslateZCone] = "handleTranslateZCone";
+    overlayNames[handleTranslateZCylinder] = "handleTranslateZCylinder";
 
-    overlayNames[highlightBox] = "highlightBox";
+    overlayNames[handleRotatePitchRing] = "handleRotatePitchRing";
+    overlayNames[handleRotateYawRing] = "handleRotateYawRing";
+    overlayNames[handleRotateRollRing] = "handleRotateRollRing";
+    overlayNames[handleRotateCurrentRing] = "handleRotateCurrentRing";
+    overlayNames[rotationDegreesDisplay] = "rotationDegreesDisplay";
+
+    overlayNames[handleStretchXSphere] = "handleStretchXSphere";
+    overlayNames[handleStretchYSphere] = "handleStretchYSphere";
+    overlayNames[handleStretchZSphere] = "handleStretchZSphere";
+    overlayNames[handleStretchXPanel] = "handleStretchXPanel";
+    overlayNames[handleStretchYPanel] = "handleStretchYPanel";
+    overlayNames[handleStretchZPanel] = "handleStretchZPanel";
+
+    overlayNames[handleScaleLBNCube] = "handleScaleLBNCube";
+    overlayNames[handleScaleRBNCube] = "handleScaleRBNCube";
+    overlayNames[handleScaleLBFCube] = "handleScaleLBFCube";
+    overlayNames[handleScaleRBFCube] = "handleScaleRBFCube";
+    overlayNames[handleScaleLTNCube] = "handleScaleLTNCube";
+    overlayNames[handleScaleRTNCube] = "handleScaleRTNCube";
+    overlayNames[handleScaleLTFCube] = "handleScaleLTFCube";
+    overlayNames[handleScaleRTFCube] = "handleScaleRTFCube";
+
+    overlayNames[handleScaleTREdge] = "handleScaleTREdge";
+    overlayNames[handleScaleTLEdge] = "handleScaleTLEdge";
+    overlayNames[handleScaleTFEdge] = "handleScaleTFEdge";
+    overlayNames[handleScaleTNEdge] = "handleScaleTNEdge";
+    overlayNames[handleScaleBREdge] = "handleScaleBREdge";
+    overlayNames[handleScaleBLEdge] = "handleScaleBLEdge";
+    overlayNames[handleScaleBFEdge] = "handleScaleBFEdge";
+    overlayNames[handleScaleBNEdge] = "handleScaleBNEdge";
+    overlayNames[handleScaleNREdge] = "handleScaleNREdge";
+    overlayNames[handleScaleNLEdge] = "handleScaleNLEdge";
+    overlayNames[handleScaleFREdge] = "handleScaleFREdge";
+    overlayNames[handleScaleFLEdge] = "handleScaleFLEdge";
+
+    overlayNames[handleCloner] = "handleCloner";
     overlayNames[selectionBox] = "selectionBox";
-    overlayNames[baseOfEntityProjectionOverlay] = "baseOfEntityProjectionOverlay";
-    overlayNames[grabberMoveUp] = "grabberMoveUp";
-    overlayNames[grabberLBN] = "grabberLBN";
-    overlayNames[grabberLBF] = "grabberLBF";
-    overlayNames[grabberRBN] = "grabberRBN";
-    overlayNames[grabberRBF] = "grabberRBF";
-    overlayNames[grabberLTN] = "grabberLTN";
-    overlayNames[grabberLTF] = "grabberLTF";
-    overlayNames[grabberRTN] = "grabberRTN";
-    overlayNames[grabberRTF] = "grabberRTF";
 
-    overlayNames[grabberTOP] = "grabberTOP";
-    overlayNames[grabberBOTTOM] = "grabberBOTTOM";
-    overlayNames[grabberLEFT] = "grabberLEFT";
-    overlayNames[grabberRIGHT] = "grabberRIGHT";
-    overlayNames[grabberNEAR] = "grabberNEAR";
-    overlayNames[grabberFAR] = "grabberFAR";
-
-    overlayNames[grabberEdgeTR] = "grabberEdgeTR";
-    overlayNames[grabberEdgeTL] = "grabberEdgeTL";
-    overlayNames[grabberEdgeTF] = "grabberEdgeTF";
-    overlayNames[grabberEdgeTN] = "grabberEdgeTN";
-    overlayNames[grabberEdgeBR] = "grabberEdgeBR";
-    overlayNames[grabberEdgeBL] = "grabberEdgeBL";
-    overlayNames[grabberEdgeBF] = "grabberEdgeBF";
-    overlayNames[grabberEdgeBN] = "grabberEdgeBN";
-    overlayNames[grabberEdgeNR] = "grabberEdgeNR";
-    overlayNames[grabberEdgeNL] = "grabberEdgeNL";
-    overlayNames[grabberEdgeFR] = "grabberEdgeFR";
-    overlayNames[grabberEdgeFL] = "grabberEdgeFL";
-
-    overlayNames[yawHandle] = "yawHandle";
-    overlayNames[pitchHandle] = "pitchHandle";
-    overlayNames[rollHandle] = "rollHandle";
-
-    overlayNames[rotateOverlayInner] = "rotateOverlayInner";
-    overlayNames[rotateOverlayOuter] = "rotateOverlayOuter";
-    overlayNames[rotateOverlayCurrent] = "rotateOverlayCurrent";
-
-    overlayNames[rotateZeroOverlay] = "rotateZeroOverlay";
-    overlayNames[rotateCurrentOverlay] = "rotateCurrentOverlay";
-    overlayNames[grabberCloner] = "grabberCloner";
     var activeTool = null;
-    var grabberTools = {};
+    var handleTools = {};
 
     // We get mouseMoveEvents from the handControllers, via handControllerPointer.
     // But we dont' get mousePressEvents.
@@ -932,6 +625,282 @@ SelectionDisplay = (function() {
     that.triggerMapping.from(Controller.Standard.RT).peek().to(makeTriggerHandler(Controller.Standard.RightHand));
     that.triggerMapping.from(Controller.Standard.LT).peek().to(makeTriggerHandler(Controller.Standard.LeftHand));
 
+    // FUNCTION DEF(s): Intersection Check Helpers
+    function testRayIntersect(queryRay, overlayIncludes, overlayExcludes) {
+        var wantDebug = false;
+        if ((queryRay === undefined) || (queryRay === null)) {
+            if (wantDebug) {
+                print("testRayIntersect - EARLY EXIT -> queryRay is undefined OR null!");
+            }
+            return null;
+        }
+
+        var intersectObj = Overlays.findRayIntersection(queryRay, true, overlayIncludes, overlayExcludes);
+
+        if (wantDebug) {
+            if (!overlayIncludes) {
+                print("testRayIntersect - no overlayIncludes provided.");
+            }
+            if (!overlayExcludes) {
+                print("testRayIntersect - no overlayExcludes provided.");
+            }
+            print("testRayIntersect - Hit: " + intersectObj.intersects);
+            print("    intersectObj.overlayID:" + intersectObj.overlayID + "[" + overlayNames[intersectObj.overlayID] + "]");
+            print("        OverlayName: " + overlayNames[intersectObj.overlayID]);
+            print("    intersectObj.distance:" + intersectObj.distance);
+            print("    intersectObj.face:" + intersectObj.face);
+            Vec3.print("    intersectObj.intersection:", intersectObj.intersection);
+        }
+
+        return intersectObj;
+    }
+
+    // FUNCTION: MOUSE PRESS EVENT
+    that.mousePressEvent = function (event) {
+        var wantDebug = false;
+        if (wantDebug) {
+            print("=============== eST::MousePressEvent BEG =======================");
+        }
+        if (!event.isLeftButton && !that.triggered) {
+            // EARLY EXIT-(if another mouse button than left is pressed ignore it)
+            return false;
+        }
+
+        var pickRay = generalComputePickRay(event.x, event.y);
+        // TODO_Case6491:  Move this out to setup just to make it once
+        var interactiveOverlays = [HMD.tabletID, HMD.tabletScreenID, HMD.homeButtonID];
+        for (var key in handleTools) {
+            if (handleTools.hasOwnProperty(key)) {
+                interactiveOverlays.push(key);
+            }
+        }
+
+        // Start with unknown mode, in case no tool can handle this.
+        activeTool = null;
+
+        var results = testRayIntersect(pickRay, interactiveOverlays);
+        if (results.intersects) {
+            var hitOverlayID = results.overlayID;
+            if ((hitOverlayID === HMD.tabletID) || (hitOverlayID === HMD.tabletScreenID) || 
+                (hitOverlayID === HMD.homeButtonID)) {
+                // EARLY EXIT-(mouse clicks on the tablet should override the edit affordances)
+                return false;
+            }
+
+            entityIconOverlayManager.setIconsSelectable(SelectionManager.selections, true);
+
+            var hitTool = handleTools[ hitOverlayID ];
+            if (hitTool) {
+                activeTool = hitTool;
+                if (activeTool.onBegin) {
+                    activeTool.onBegin(event, pickRay, results);
+                } else {
+                    print("ERROR: entitySelectionTool.mousePressEvent - ActiveTool(" + activeTool.mode + ") missing onBegin");
+                }
+            } else {
+                print("ERROR: entitySelectionTool.mousePressEvent - Hit unexpected object, check interactiveOverlays");
+            }// End_if (hitTool)
+        }// End_If(results.intersects)
+
+        if (wantDebug) {
+            print("    DisplayMode: " + getMode());
+            print("=============== eST::MousePressEvent END =======================");
+        }
+
+        // If mode is known then we successfully handled this;
+        // otherwise, we're missing a tool.
+        return activeTool;
+    };
+
+    that.resetPreviousHandleColor = function() {
+        if (previousHandle != null) {
+            Overlays.editOverlay(previousHandle, { color: previousHandleColor });
+            previousHandle = null;
+        }
+        if (previousHandleHelper != null) {
+            Overlays.editOverlay(previousHandleHelper, { color: previousHandleColor });
+            previousHandleHelper = null;
+        }
+    };
+
+    that.getHandleHelper = function(overlay) {
+        if (overlay === handleTranslateXCone) {
+            return handleTranslateXCylinder;
+        } else if (overlay === handleTranslateXCylinder) {
+            return handleTranslateXCone;
+        } else if (overlay === handleTranslateYCone) {
+            return handleTranslateYCylinder;
+        } else if (overlay === handleTranslateYCylinder) {
+            return handleTranslateYCone;
+        } else if (overlay === handleTranslateZCone) {
+            return handleTranslateZCylinder;
+        } else if (overlay === handleTranslateZCylinder) {
+            return handleTranslateZCone;
+        }
+    };
+
+    // FUNCTION: MOUSE MOVE EVENT
+    that.mouseMoveEvent = function(event) {
+        var wantDebug = false;
+        if (wantDebug) {
+            print("=============== eST::MouseMoveEvent BEG =======================");
+        }
+        if (activeTool) {
+            if (wantDebug) {
+                print("    Trigger ActiveTool(" + activeTool.mode + ")'s onMove");
+            }
+            activeTool.onMove(event);
+
+            if (wantDebug) {
+                print("    Trigger SelectionManager::update");
+            }
+            SelectionManager._update();
+
+            if (wantDebug) {
+                print("=============== eST::MouseMoveEvent END =======================");
+            }
+            // EARLY EXIT--(Move handled via active tool)
+            return true;
+        }
+
+        // if no tool is active, then just look for handles to highlight...
+        var pickRay = generalComputePickRay(event.x, event.y);
+        var result = Overlays.findRayIntersection(pickRay);
+        var pickedColor;
+        var highlightNeeded = false;
+
+        if (result.intersects) {
+            switch (result.overlayID) {
+                case handleTranslateXCone:
+                case handleTranslateXCylinder:
+                case handleRotatePitchRing:
+                case handleStretchXSphere:
+                    pickedColor = COLOR_RED;
+                    highlightNeeded = true;
+                    break;
+                case handleTranslateYCone:
+                case handleTranslateYCylinder:
+                case handleRotateYawRing:
+                case handleStretchYSphere:
+                    pickedColor = COLOR_GREEN;
+                    highlightNeeded = true;
+                    break;
+                case handleTranslateZCone:
+                case handleTranslateZCylinder:
+                case handleRotateRollRing:
+                case handleStretchZSphere:
+                    pickedColor = COLOR_BLUE;
+                    highlightNeeded = true;
+                    break;
+                case handleScaleLBNCube:
+                case handleScaleRBNCube:
+                case handleScaleLBFCube:
+                case handleScaleRBFCube:
+                case handleScaleLTNCube:
+                case handleScaleRTNCube:
+                case handleScaleLTFCube:
+                case handleScaleRTFCube:
+                    pickedColor = COLOR_SCALE_CUBE;
+                    highlightNeeded = true;
+                    break;
+                default:
+                    that.resetPreviousHandleColor();
+                    break;
+            }
+
+            if (highlightNeeded) {
+                that.resetPreviousHandleColor();
+                Overlays.editOverlay(result.overlayID, { color: COLOR_HOVER });
+                previousHandle = result.overlayID;
+                previousHandleHelper = that.getHandleHelper(result.overlayID);
+                if (previousHandleHelper != null) {
+                    Overlays.editOverlay(previousHandleHelper, { color: COLOR_HOVER });
+                }
+                previousHandleColor = pickedColor;
+            }
+
+        } else {
+            that.resetPreviousHandleColor();
+        }
+
+        if (wantDebug) {
+            print("=============== eST::MouseMoveEvent END =======================");
+        }
+        return false;
+    };
+
+    // FUNCTION: MOUSE RELEASE EVENT
+    that.mouseReleaseEvent = function(event) {
+        var wantDebug = false;
+        if (wantDebug) {
+            print("=============== eST::MouseReleaseEvent BEG =======================");
+        }
+        var showHandles = false;
+        if (activeTool) {
+            if (activeTool.onEnd) {
+                if (wantDebug) {
+                    print("    Triggering ActiveTool(" + activeTool.mode + ")'s onEnd");
+                }
+                activeTool.onEnd(event);
+            } else if (wantDebug) {
+                print("    ActiveTool(" + activeTool.mode + ")'s missing onEnd");
+            }
+        }
+
+        showHandles = activeTool; // base on prior tool value
+        activeTool = null;
+
+        // if something is selected, then reset the "original" properties for any potential next click+move operation
+        if (SelectionManager.hasSelection()) {
+            if (showHandles) {
+                if (wantDebug) {
+                    print("    Triggering that.select");
+                }
+                that.select(SelectionManager.selections[0], event);
+            }
+        }
+
+        if (wantDebug) {
+            print("=============== eST::MouseReleaseEvent END =======================");
+        }
+    };
+
+    // Control key remains active only while key is held down
+    that.keyReleaseEvent = function(key) {
+        if (key.key === CTRL_KEY_CODE) {
+            ctrlPressed = false;
+            that.updateActiveRotateRing();
+        }
+    }
+
+    // Triggers notification on specific key driven events
+    that.keyPressEvent = function(key) {
+        if (key.key === CTRL_KEY_CODE) {
+            ctrlPressed = true;
+            that.updateActiveRotateRing();
+        }
+    }
+
+    // NOTE: mousePressEvent and mouseMoveEvent from the main script should call us., so we don't hook these:
+    //       Controller.mousePressEvent.connect(that.mousePressEvent);
+    //       Controller.mouseMoveEvent.connect(that.mouseMoveEvent);
+    Controller.mouseReleaseEvent.connect(that.mouseReleaseEvent);
+    Controller.keyPressEvent.connect(that.keyPressEvent);
+    Controller.keyReleaseEvent.connect(that.keyReleaseEvent);
+
+    that.checkControllerMove = function() {
+        if (SelectionManager.hasSelection()) {
+            var controllerPose = getControllerWorldLocation(activeHand, true);
+            var hand = (activeHand === Controller.Standard.LeftHand) ? 0 : 1;
+            if (controllerPose.valid && lastControllerPoses[hand].valid) {
+                if (!Vec3.equal(controllerPose.position, lastControllerPoses[hand].position) ||
+                    !Vec3.equal(controllerPose.rotation, lastControllerPoses[hand].rotation)) {
+                    that.mouseMoveEvent({});
+                }
+            }
+            lastControllerPoses[hand] = controllerPose;
+        }
+    };
 
     function controllerComputePickRay() {
         var controllerPose = getControllerWorldLocation(activeHand, true);
@@ -942,35 +911,15 @@ SelectionDisplay = (function() {
             return {origin: controllerPosition, direction: controllerDirection};
         }
     }
+
     function generalComputePickRay(x, y) {
         return controllerComputePickRay() || Camera.computePickRay(x, y);
     }
-    function addGrabberTool(overlay, tool) {
-        grabberTools[overlay] = tool;
-        return tool;
-    }
 
-    // @param: toolHandle:  The overlayID associated with the tool
-    //         that correlates to the tool you wish to query.
-    // @note: If toolHandle is null or undefined then activeTool
-    //        will be checked against those values as opposed to
-    //        the tool registered under toolHandle.  Null & Undefined 
-    //        are treated as separate values.
-    // @return: bool - Indicates if the activeTool is that queried.
-    function isActiveTool(toolHandle) {
-        if (!toolHandle) {
-            // Allow isActiveTool(null) and similar to return true if there's
-            // no active tool
-            return (activeTool === toolHandle);
-        }
-
-        if (!grabberTools.hasOwnProperty(toolHandle)) {
-            print("WARNING: entitySelectionTool.isActiveTool - Encountered unknown grabberToolHandle: " + toolHandle + ". Tools should be egistered via addGrabberTool.");
-            // EARLY EXIT
-            return false;
-        }
-
-        return (activeTool === grabberTools[ toolHandle ]);
+    function getDistanceToCamera(position) {
+        var cameraPosition = Camera.getPosition();
+        var toCameraDistance = Vec3.length(Vec3.subtract(cameraPosition, position));
+        return toCameraDistance;
     }
 
     // @return string - The mode of the currently active tool;
@@ -979,30 +928,10 @@ SelectionDisplay = (function() {
         return (activeTool ? activeTool.mode : "UNKNOWN");
     }
 
-
     that.cleanup = function() {
         for (var i = 0; i < allOverlays.length; i++) {
             Overlays.deleteOverlay(allOverlays[i]);
         }
-        for (var j = 0; j < selectionBoxes.length; j++) {
-            Overlays.deleteOverlay(selectionBoxes[j]);
-        }
-    };
-
-    that.highlightSelectable = function(entityID) {
-        var properties = Entities.getEntityProperties(entityID);
-        Overlays.editOverlay(highlightBox, {
-            visible: true,
-            position: properties.boundingBox.center,
-            dimensions: properties.dimensions,
-            rotation: properties.rotation
-        });
-    };
-
-    that.unhighlightSelectable = function(entityID) {
-        Overlays.editOverlay(highlightBox, {
-            visible: false
-        });
     };
 
     that.select = function(entityID, event) {
@@ -1020,262 +949,11 @@ SelectionDisplay = (function() {
                 print("                event.y:" + event.y);
                 Vec3.print("       current position:", properties.position);
             }
-
-
         }
 
-        Overlays.editOverlay(highlightBox, {
-            visible: false
-        });
-
         that.updateHandles();
     };
 
-    // Function: Calculate New Bound Extremes
-    // uses dot product to discover new top and bottom on the new referential (max and min)
-    that.calculateNewBoundExtremes = function(boundPointList, referenceVector) {
-        
-        if (boundPointList.length < 2) {
-            return [null, null];
-        }
-        
-        var refMax = boundPointList[0];
-        var refMin = boundPointList[1];
-        
-        var dotMax = Vec3.dot(boundPointList[0], referenceVector);
-        var dotMin = Vec3.dot(boundPointList[1], referenceVector);
-        
-        if (dotMin > dotMax) {
-            dotMax = dotMin;
-            dotMin = Vec3.dot(boundPointList[0], referenceVector);
-            refMax = boundPointList[1];
-            refMin = boundPointList[0];
-        }
-        
-        for (var i = 2; i < boundPointList.length ; i++) {
-            var dotAux = Vec3.dot(boundPointList[i], referenceVector);
-            if (dotAux > dotMax) {
-                dotMax = dotAux;
-                refMax = boundPointList[i];
-            } else if (dotAux < dotMin) {
-                dotMin = dotAux;
-                refMin = boundPointList[i];
-            }
-        }
-        return [refMin, refMax];
-    }
-
-    // Function: Project Bounding Box Points
-    // Projects all 6 bounding box points: Top, Bottom, Left, Right, Near, Far (assumes center 0,0,0) onto 
-    // one of the basis of the new avatar referencial
-    // dimensions - dimensions of the AABB (axis aligned bounding box) on the standard basis 
-    // [1, 0, 0], [0, 1, 0], [0, 0, 1]
-    // v - projection vector
-    // rotateHandleOffset - offset for the rotation handle gizmo position
-    that.projectBoundingBoxPoints = function(dimensions, v, rotateHandleOffset) {
-        var projT_v = Vec3.dot(Vec3.multiply((dimensions.y / 2) + rotateHandleOffset, Vec3.UNIT_Y), v);
-        projT_v = Vec3.multiply(projT_v, v);
-        
-        var projB_v = Vec3.dot(Vec3.multiply(-(dimensions.y / 2) - rotateHandleOffset, Vec3.UNIT_Y), v);
-        projB_v = Vec3.multiply(projB_v, v);
-        
-        var projL_v = Vec3.dot(Vec3.multiply((dimensions.x / 2) + rotateHandleOffset, Vec3.UNIT_X), v);
-        projL_v = Vec3.multiply(projL_v, v);
-        
-        var projR_v = Vec3.dot(Vec3.multiply(-1.0 * (dimensions.x / 2) - 1.0 * rotateHandleOffset, Vec3.UNIT_X), v);
-        projR_v = Vec3.multiply(projR_v, v);
-        
-        var projN_v = Vec3.dot(Vec3.multiply((dimensions.z / 2) + rotateHandleOffset, Vec3.FRONT), v);
-        projN_v = Vec3.multiply(projN_v, v);
-        
-        var projF_v = Vec3.dot(Vec3.multiply(-1.0 * (dimensions.z / 2) - 1.0 * rotateHandleOffset, Vec3.FRONT), v);
-        projF_v = Vec3.multiply(projF_v, v);
-        
-        var projList = [projT_v, projB_v, projL_v, projR_v, projN_v, projF_v];
-
-        return that.calculateNewBoundExtremes(projList, v);
-    };
-    
-    // FUNCTION: UPDATE ROTATION HANDLES
-    that.updateRotationHandles = function() {
-        var diagonal = (Vec3.length(SelectionManager.worldDimensions) / 2) * 1.1;
-        var halfDimensions = Vec3.multiply(SelectionManager.worldDimensions, 0.5);
-        var innerActive = false;
-        var innerAlpha = 0.2;
-        var outerAlpha = 0.2;
-        if (innerActive) {
-            innerAlpha = 0.5;
-        } else {
-            outerAlpha = 0.5;
-        }
-            // prev 0.05
-        var rotateHandleOffset = 0.05;
-
-        var boundsCenter, objectCenter;
-
-        var dimensions, rotation;
-        if (spaceMode === SPACE_LOCAL) {
-            rotation = SelectionManager.localRotation;
-        } else {
-            rotation = SelectionManager.worldRotation;
-        }
-        objectCenter = SelectionManager.worldPosition;
-        dimensions = SelectionManager.worldDimensions;
-        var position = objectCenter;
-
-        boundsCenter = objectCenter;
-
-        var yawCorner;
-        var pitchCorner;
-        var rollCorner;
-
-        var cameraPosition = Camera.getPosition();
-        var look = Vec3.normalize(Vec3.subtract(cameraPosition, objectCenter));
-
-        // place yaw, pitch and roll rotations on the avatar referential
-        
-        var avatarReferential = Quat.multiply(MyAvatar.orientation, Quat.fromVec3Degrees({
-            x: 0,
-            y: 180,
-            z: 0
-        }));
-        var upVector = Quat.getUp(avatarReferential);
-        var rightVector = Vec3.multiply(-1, Quat.getRight(avatarReferential));
-        var frontVector = Quat.getFront(avatarReferential);
-        
-        // project all 6 bounding box points: Top, Bottom, Left, Right, Near, Far (assumes center 0,0,0) 
-        // onto the new avatar referential
-
-        // UP
-        var projUP = that.projectBoundingBoxPoints(dimensions, upVector, rotateHandleOffset);
-        // RIGHT
-        var projRIGHT = that.projectBoundingBoxPoints(dimensions, rightVector, rotateHandleOffset);
-        // FRONT
-        var projFRONT = that.projectBoundingBoxPoints(dimensions, frontVector, rotateHandleOffset);
-        
-        // YAW
-        yawCenter = Vec3.sum(boundsCenter, projUP[0]); 
-        yawCorner = Vec3.sum(boundsCenter, Vec3.sum(Vec3.sum(projUP[0], projRIGHT[1]), projFRONT[1]));
-        
-        yawHandleRotation = Quat.lookAt(
-            yawCorner, 
-            Vec3.sum(yawCorner, upVector), 
-            Vec3.subtract(yawCenter,yawCorner));
-        yawHandleRotation = Quat.multiply(Quat.angleAxis(45, upVector), yawHandleRotation);
-        
-        // PTCH
-        pitchCorner = Vec3.sum(boundsCenter, Vec3.sum(Vec3.sum(projUP[1], projRIGHT[0]), projFRONT[1]));
-        pitchCenter = Vec3.sum(boundsCenter, projRIGHT[0]); 
-        
-        pitchHandleRotation = Quat.lookAt(
-            pitchCorner, 
-            Vec3.sum(pitchCorner, rightVector), 
-            Vec3.subtract(pitchCenter,pitchCorner));
-        pitchHandleRotation = Quat.multiply(Quat.angleAxis(45, rightVector), pitchHandleRotation);
-        
-        // ROLL
-        rollCorner = Vec3.sum(boundsCenter, Vec3.sum(Vec3.sum(projUP[1], projRIGHT[1]), projFRONT[0]));
-        rollCenter = Vec3.sum(boundsCenter, projFRONT[0]); 
-        
-        rollHandleRotation = Quat.lookAt(
-            rollCorner, 
-            Vec3.sum(rollCorner, frontVector), 
-            Vec3.subtract(rollCenter,rollCorner));
-        rollHandleRotation = Quat.multiply(Quat.angleAxis(45, frontVector), rollHandleRotation);
-        
-
-        var rotateHandlesVisible = true;
-        var rotationOverlaysVisible = false;
-        // note:  Commented out as these are currently unused here; however,
-        //         leaving them around as they document intent of state as it
-        //         relates to modes that may be useful later.
-        // var translateHandlesVisible = true;
-        // var selectionBoxVisible = true;
-        var isPointLight = false;
-        if (SelectionManager.selections.length === 1) {
-            var properties = Entities.getEntityProperties(SelectionManager.selections[0]);
-            isPointLight = (properties.type === "Light") && !properties.isSpotlight;
-        }
-
-        if (isActiveTool(yawHandle) || isActiveTool(pitchHandle) || 
-                isActiveTool(rollHandle) || isActiveTool(selectionBox) || isActiveTool(grabberCloner)) {
-            rotationOverlaysVisible = true;
-            rotateHandlesVisible = false;
-            // translateHandlesVisible = false;
-            // selectionBoxVisible = false;
-        } else if (isActiveTool(grabberMoveUp) || isPointLight) {
-            rotateHandlesVisible = false;
-        } else if (activeTool) {
-            // every other mode is a stretch mode...
-            rotateHandlesVisible = false;
-            // translateHandlesVisible = false;
-        }
-
-        Overlays.editOverlay(rotateZeroOverlay, {
-            visible: rotationOverlaysVisible
-        });
-        Overlays.editOverlay(rotateCurrentOverlay, {
-            visible: rotationOverlaysVisible
-        });
-
-        Overlays.editOverlay(yawHandle, {
-            visible: rotateHandlesVisible,
-            position: yawCorner,
-            rotation: yawHandleRotation
-        });
-        Overlays.editOverlay(pitchHandle, {
-            visible: rotateHandlesVisible,
-            position: pitchCorner,
-            rotation: pitchHandleRotation
-        });
-        Overlays.editOverlay(rollHandle, {
-            visible: rotateHandlesVisible,
-            position: rollCorner,
-            rotation: rollHandleRotation
-        });
-        
-        
-    };
-
-    // FUNCTION: UPDATE HANDLE SIZES
-    that.updateHandleSizes = function() {
-        if (SelectionManager.hasSelection()) {
-            var diff = Vec3.subtract(SelectionManager.worldPosition, Camera.getPosition());
-            var grabberSize = Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO * 5;
-            var dimensions = SelectionManager.worldDimensions;
-            var avgDimension = (dimensions.x + dimensions.y + dimensions.z) / 3;
-            grabberSize = Math.min(grabberSize, avgDimension / 10);
-
-            for (var i = 0; i < stretchHandles.length; i++) {
-                Overlays.editOverlay(stretchHandles[i], {
-                    size: grabberSize
-                });
-            }
-            var handleSize = Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO * 7;
-            handleSize = Math.min(handleSize, avgDimension / 3);
-
-            Overlays.editOverlay(yawHandle, {
-                scale: handleSize
-            });
-            Overlays.editOverlay(pitchHandle, {
-                scale: handleSize
-            });
-            Overlays.editOverlay(rollHandle, {
-                scale: handleSize
-            });
-            var upDiff = Vec3.multiply((
-                Vec3.length(diff) * GRABBER_DISTANCE_TO_SIZE_RATIO * 3), 
-                Quat.getUp(MyAvatar.orientation)
-            );
-            var pos = Vec3.sum(grabberMoveUpPosition, upDiff);
-            Overlays.editOverlay(grabberMoveUp, {
-                position: pos,
-                scale: handleSize / 1.25
-            });
-        }
-    };
-    Script.update.connect(that.updateHandleSizes);
-
     // FUNCTION: SET SPACE MODE
     that.setSpaceMode = function(newSpaceMode) {
         var wantDebug = false;
@@ -1297,32 +975,33 @@ SelectionDisplay = (function() {
         }
     };
 
-    // FUNCTION: TOGGLE SPACE MODE
-    that.toggleSpaceMode = function() {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("========> ToggleSpaceMode called. =========");
-        }
-        if ((spaceMode === SPACE_WORLD) && (SelectionManager.selections.length > 1)) {
-            if (wantDebug) {
-                print("Local space editing is not available with multiple selections");
-            }
-            return;
-        }
-        if (wantDebug) {
-            print("PreToggle: " + spaceMode);
-        }
-        spaceMode = (spaceMode === SPACE_LOCAL) ? SPACE_WORLD : SPACE_LOCAL;
-        that.updateHandles();
-        if (wantDebug) {
-            print("PostToggle: " + spaceMode);        
-            print("======== ToggleSpaceMode called. <=========");
-        }
-    };
+    function addHandleTool(overlay, tool) {
+        handleTools[overlay] = tool;
+        return tool;
+    }
 
-    // FUNCTION: UNSELECT ALL
-    // TODO?: Needs implementation
-    that.unselectAll = function() {};
+    // @param: toolHandle:  The overlayID associated with the tool
+    //         that correlates to the tool you wish to query.
+    // @note: If toolHandle is null or undefined then activeTool
+    //        will be checked against those values as opposed to
+    //        the tool registered under toolHandle.  Null & Undefined 
+    //        are treated as separate values.
+    // @return: bool - Indicates if the activeTool is that queried.
+    function isActiveTool(toolHandle) {
+        if (!toolHandle) {
+            // Allow isActiveTool(null) and similar to return true if there's
+            // no active tool
+            return (activeTool === toolHandle);
+        }
+
+        if (!handleTools.hasOwnProperty(toolHandle)) {
+            print("WARNING: entitySelectionTool.isActiveTool - Encountered unknown grabberToolHandle: " + toolHandle + ". Tools should be registered via addHandleTool.");
+            // EARLY EXIT
+            return false;
+        }
+
+        return (activeTool === handleTools[ toolHandle ]);
+    }
 
     // FUNCTION: UPDATE HANDLES
     that.updateHandles = function() {
@@ -1333,709 +1012,451 @@ SelectionDisplay = (function() {
             print("    SpaceMode: " + spaceMode);
             print("    DisplayMode: " + getMode());
         }
+
         if (SelectionManager.selections.length === 0) {
             that.setOverlaysVisible(false);
             return;
         }
 
-        // print("    Triggering updateRotationHandles");
-        that.updateRotationHandles();
+        if (SelectionManager.hasSelection()) {
+            var position = SelectionManager.worldPosition;
+            var rotation = spaceMode === SPACE_LOCAL ? SelectionManager.localRotation : SelectionManager.worldRotation;
+            var dimensions = spaceMode === SPACE_LOCAL ? SelectionManager.localDimensions : SelectionManager.worldDimensions;
+            var rotationInverse = Quat.inverse(rotation);
+            var toCameraDistance = getDistanceToCamera(position);
 
-        var rotation, dimensions, position, registrationPoint;
+            var localRotationX = Quat.fromPitchYawRollDegrees(0, 0, -90);
+            rotationX = Quat.multiply(rotation, localRotationX);
+            worldRotationX = rotationX;
+            var localRotationY = Quat.fromPitchYawRollDegrees(0, 90, 0);
+            rotationY = Quat.multiply(rotation, localRotationY);
+            worldRotationY = rotationY;
+            var localRotationZ = Quat.fromPitchYawRollDegrees(90, 0, 0);
+            rotationZ = Quat.multiply(rotation, localRotationZ);
+            worldRotationZ = rotationZ;
 
-        if (spaceMode === SPACE_LOCAL) {
-            rotation = SelectionManager.localRotation;
-            dimensions = SelectionManager.localDimensions;
-            position = SelectionManager.localPosition;
-            registrationPoint = SelectionManager.localRegistrationPoint;
-        } else {
-            rotation = Quat.IDENTITY;
-            dimensions = SelectionManager.worldDimensions;
-            position = SelectionManager.worldPosition;
-            registrationPoint = SelectionManager.worldRegistrationPoint;
-        }
-
-        var registrationPointDimensions = {
-            x: dimensions.x * registrationPoint.x,
-            y: dimensions.y * registrationPoint.y,
-            z: dimensions.z * registrationPoint.z
-        };
-
-        // Center of entity, relative to registration point
-        var center = getRelativeCenterPosition(dimensions, registrationPoint);
-
-        // Distances in world coordinates relative to the registration point
-        var left = -registrationPointDimensions.x;
-        var right = dimensions.x - registrationPointDimensions.x;
-        var bottom = -registrationPointDimensions.y;
-        var top = dimensions.y - registrationPointDimensions.y;
-        var near = -registrationPointDimensions.z;
-        var far = dimensions.z - registrationPointDimensions.z;
-        var front = far;
-
-        var worldTop = SelectionManager.worldDimensions.y / 2;
-
-        var LBN = {
-            x: left,
-            y: bottom,
-            z: near
-        };
-        var RBN = {
-            x: right,
-            y: bottom,
-            z: near
-        };
-        var LBF = {
-            x: left,
-            y: bottom,
-            z: far
-        };
-        var RBF = {
-            x: right,
-            y: bottom,
-            z: far
-        };
-        var LTN = {
-            x: left,
-            y: top,
-            z: near
-        };
-        var RTN = {
-            x: right,
-            y: top,
-            z: near
-        };
-        var LTF = {
-            x: left,
-            y: top,
-            z: far
-        };
-        var RTF = {
-            x: right,
-            y: top,
-            z: far
-        };
-
-        var TOP = {
-            x: center.x,
-            y: top,
-            z: center.z
-        };
-        var BOTTOM = {
-            x: center.x,
-            y: bottom,
-            z: center.z
-        };
-        var LEFT = {
-            x: left,
-            y: center.y,
-            z: center.z
-        };
-        var RIGHT = {
-            x: right,
-            y: center.y,
-            z: center.z
-        };
-        var NEAR = {
-            x: center.x,
-            y: center.y,
-            z: near
-        };
-        var FAR = {
-            x: center.x,
-            y: center.y,
-            z: far
-        };
-
-        var EdgeTR = {
-            x: right,
-            y: top,
-            z: center.z
-        };
-        var EdgeTL = {
-            x: left,
-            y: top,
-            z: center.z
-        };
-        var EdgeTF = {
-            x: center.x,
-            y: top,
-            z: front
-        };
-        var EdgeTN = {
-            x: center.x,
-            y: top,
-            z: near
-        };
-        var EdgeBR = {
-            x: right,
-            y: bottom,
-            z: center.z
-        };
-        var EdgeBL = {
-            x: left,
-            y: bottom,
-            z: center.z
-        };
-        var EdgeBF = {
-            x: center.x,
-            y: bottom,
-            z: front
-        };
-        var EdgeBN = {
-            x: center.x,
-            y: bottom,
-            z: near
-        };
-        var EdgeNR = {
-            x: right,
-            y: center.y,
-            z: near
-        };
-        var EdgeNL = {
-            x: left,
-            y: center.y,
-            z: near
-        };
-        var EdgeFR = {
-            x: right,
-            y: center.y,
-            z: front
-        };
-        var EdgeFL = {
-            x: left,
-            y: center.y,
-            z: front
-        };
-
-        LBN = Vec3.multiplyQbyV(rotation, LBN);
-        RBN = Vec3.multiplyQbyV(rotation, RBN);
-        LBF = Vec3.multiplyQbyV(rotation, LBF);
-        RBF = Vec3.multiplyQbyV(rotation, RBF);
-        LTN = Vec3.multiplyQbyV(rotation, LTN);
-        RTN = Vec3.multiplyQbyV(rotation, RTN);
-        LTF = Vec3.multiplyQbyV(rotation, LTF);
-        RTF = Vec3.multiplyQbyV(rotation, RTF);
-
-        TOP = Vec3.multiplyQbyV(rotation, TOP);
-        BOTTOM = Vec3.multiplyQbyV(rotation, BOTTOM);
-        LEFT = Vec3.multiplyQbyV(rotation, LEFT);
-        RIGHT = Vec3.multiplyQbyV(rotation, RIGHT);
-        NEAR = Vec3.multiplyQbyV(rotation, NEAR);
-        FAR = Vec3.multiplyQbyV(rotation, FAR);
-
-        EdgeTR = Vec3.multiplyQbyV(rotation, EdgeTR);
-        EdgeTL = Vec3.multiplyQbyV(rotation, EdgeTL);
-        EdgeTF = Vec3.multiplyQbyV(rotation, EdgeTF);
-        EdgeTN = Vec3.multiplyQbyV(rotation, EdgeTN);
-        EdgeBR = Vec3.multiplyQbyV(rotation, EdgeBR);
-        EdgeBL = Vec3.multiplyQbyV(rotation, EdgeBL);
-        EdgeBF = Vec3.multiplyQbyV(rotation, EdgeBF);
-        EdgeBN = Vec3.multiplyQbyV(rotation, EdgeBN);
-        EdgeNR = Vec3.multiplyQbyV(rotation, EdgeNR);
-        EdgeNL = Vec3.multiplyQbyV(rotation, EdgeNL);
-        EdgeFR = Vec3.multiplyQbyV(rotation, EdgeFR);
-        EdgeFL = Vec3.multiplyQbyV(rotation, EdgeFL);
-
-        LBN = Vec3.sum(position, LBN);
-        RBN = Vec3.sum(position, RBN);
-        LBF = Vec3.sum(position, LBF);
-        RBF = Vec3.sum(position, RBF);
-        LTN = Vec3.sum(position, LTN);
-        RTN = Vec3.sum(position, RTN);
-        LTF = Vec3.sum(position, LTF);
-        RTF = Vec3.sum(position, RTF);
-
-        TOP = Vec3.sum(position, TOP);
-        BOTTOM = Vec3.sum(position, BOTTOM);
-        LEFT = Vec3.sum(position, LEFT);
-        RIGHT = Vec3.sum(position, RIGHT);
-        NEAR = Vec3.sum(position, NEAR);
-        FAR = Vec3.sum(position, FAR);
-
-        EdgeTR = Vec3.sum(position, EdgeTR);
-        EdgeTL = Vec3.sum(position, EdgeTL);
-        EdgeTF = Vec3.sum(position, EdgeTF);
-        EdgeTN = Vec3.sum(position, EdgeTN);
-        EdgeBR = Vec3.sum(position, EdgeBR);
-        EdgeBL = Vec3.sum(position, EdgeBL);
-        EdgeBF = Vec3.sum(position, EdgeBF);
-        EdgeBN = Vec3.sum(position, EdgeBN);
-        EdgeNR = Vec3.sum(position, EdgeNR);
-        EdgeNL = Vec3.sum(position, EdgeNL);
-        EdgeFR = Vec3.sum(position, EdgeFR);
-        EdgeFL = Vec3.sum(position, EdgeFL);
-
-        var inModeRotate = (isActiveTool(yawHandle) || isActiveTool(pitchHandle) || isActiveTool(rollHandle));
-        var inModeTranslate = (isActiveTool(selectionBox) || isActiveTool(grabberCloner) || isActiveTool(grabberMoveUp));
-        var stretchHandlesVisible = !(inModeRotate || inModeTranslate) && (spaceMode === SPACE_LOCAL);
-        var extendedStretchHandlesVisible = (stretchHandlesVisible && showExtendedStretchHandles);
-        var cloneHandleVisible = !(inModeRotate || inModeTranslate);
-        if (wantDebug) {
-            print("    Set Non-Light Grabbers Visible - Norm: " + stretchHandlesVisible + " Ext: " + extendedStretchHandlesVisible);
-        }
-        var isSingleSelection = (SelectionManager.selections.length === 1);
-
-        if (isSingleSelection) {
-            var properties = Entities.getEntityProperties(SelectionManager.selections[0]);
-            var isLightSelection = (properties.type === "Light");
-            if (isLightSelection) {
-                if (wantDebug) {
-                    print("    Light Selection revoking Non-Light Grabbers Visibility!");
-                }
-                stretchHandlesVisible = false;
-                extendedStretchHandlesVisible = false;
-                cloneHandleVisible = false;
-                if (properties.isSpotlight) {
-                    that.setPointLightHandlesVisible(false);
-
-                    var distance = (properties.dimensions.z / 2) * Math.sin(properties.cutoff * (Math.PI / 180));
-                    var showEdgeSpotGrabbers = !(inModeTranslate || inModeRotate);
-                    Overlays.editOverlay(grabberSpotLightCenter, {
-                        position: position,
-                        visible: false
-                    });
-                    Overlays.editOverlay(grabberSpotLightRadius, {
-                        position: NEAR,
-                        rotation: rotation,
-                        visible: showEdgeSpotGrabbers
-                    });
-
-                    Overlays.editOverlay(grabberSpotLightL, {
-                        position: EdgeNL,
-                        rotation: rotation,
-                        visible: showEdgeSpotGrabbers
-                    });
-                    Overlays.editOverlay(grabberSpotLightR, {
-                        position: EdgeNR,
-                        rotation: rotation,
-                        visible: showEdgeSpotGrabbers
-                    });
-                    Overlays.editOverlay(grabberSpotLightT, {
-                        position: EdgeTN,
-                        rotation: rotation,
-                        visible: showEdgeSpotGrabbers
-                    });
-                    Overlays.editOverlay(grabberSpotLightB, {
-                        position: EdgeBN,
-                        rotation: rotation,
-                        visible: showEdgeSpotGrabbers
-                    });
-                    Overlays.editOverlay(grabberSpotLightCircle, {
-                        position: NEAR,
-                        dimensions: {
-                            x: distance,
-                            y: distance,
-                            z: 1
-                        },
-                        rotation: rotation,
-                        visible: true
-                    });
-
-                    Overlays.editOverlay(grabberSpotLightLineT, {
-                        start: position,
-                        end: EdgeTN,
-                        visible: true
-                    });
-                    Overlays.editOverlay(grabberSpotLightLineB, {
-                        start: position,
-                        end: EdgeBN,
-                        visible: true
-                    });
-                    Overlays.editOverlay(grabberSpotLightLineR, {
-                        start: position,
-                        end: EdgeNR,
-                        visible: true
-                    });
-                    Overlays.editOverlay(grabberSpotLightLineL, {
-                        start: position,
-                        end: EdgeNL,
-                        visible: true
-                    });
-
-                } else { // ..it's a PointLight
-                    that.setSpotLightHandlesVisible(false);
-
-                    var showEdgePointGrabbers = !inModeTranslate;
-                    Overlays.editOverlay(grabberPointLightT, {
-                        position: TOP,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightB, {
-                        position: BOTTOM,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightL, {
-                        position: LEFT,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightR, {
-                        position: RIGHT,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightF, {
-                        position: FAR,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightN, {
-                        position: NEAR,
-                        rotation: rotation,
-                        visible: showEdgePointGrabbers
-                    });
-                    Overlays.editOverlay(grabberPointLightCircleX, {
-                        position: position,
-                        rotation: Quat.multiply(rotation, Quat.fromPitchYawRollDegrees(0, 90, 0)),
-                        dimensions: {
-                            x: properties.dimensions.z / 2.0,
-                            y: properties.dimensions.z / 2.0,
-                            z: 1
-                        },
-                        visible: true
-                    });
-                    Overlays.editOverlay(grabberPointLightCircleY, {
-                        position: position,
-                        rotation: Quat.multiply(rotation, Quat.fromPitchYawRollDegrees(90, 0, 0)),
-                        dimensions: {
-                            x: properties.dimensions.z / 2.0,
-                            y: properties.dimensions.z / 2.0,
-                            z: 1
-                        },
-                        visible: true
-                    });
-                    Overlays.editOverlay(grabberPointLightCircleZ, {
-                        position: position,
-                        rotation: rotation,
-                        dimensions: {
-                            x: properties.dimensions.z / 2.0,
-                            y: properties.dimensions.z / 2.0,
-                            z: 1
-                        },
-                        visible: true
-                    });
-                }
-            } else { // ..it's not a light at all
-                that.setSpotLightHandlesVisible(false);
-                that.setPointLightHandlesVisible(false);
+            // in HMD we clamp the overlays to the bounding box for now so lasers can hit them
+            var maxHandleDimension = 0;
+            if (HMD.active) {
+                maxHandleDimension = Math.max(dimensions.x, dimensions.y, dimensions.z);
             }
-        }// end of isSingleSelection
 
-
-        Overlays.editOverlay(grabberLBN, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: LBN
-        });
-        Overlays.editOverlay(grabberRBN, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: RBN
-        });
-        Overlays.editOverlay(grabberLBF, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: LBF
-        });
-        Overlays.editOverlay(grabberRBF, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: RBF
-        });
-
-        Overlays.editOverlay(grabberLTN, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: LTN
-        });
-        Overlays.editOverlay(grabberRTN, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: RTN
-        });
-        Overlays.editOverlay(grabberLTF, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: LTF
-        });
-        Overlays.editOverlay(grabberRTF, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: RTF
-        });
-
-        Overlays.editOverlay(grabberTOP, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: TOP
-        });
-        Overlays.editOverlay(grabberBOTTOM, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: BOTTOM
-        });
-        Overlays.editOverlay(grabberLEFT, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: LEFT
-        });
-        Overlays.editOverlay(grabberRIGHT, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: RIGHT
-        });
-        Overlays.editOverlay(grabberNEAR, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: NEAR
-        });
-        Overlays.editOverlay(grabberFAR, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: FAR
-        });
-
-        Overlays.editOverlay(grabberCloner, {
-            visible: cloneHandleVisible,
-            rotation: rotation,
-            position: EdgeTR
-        });
-
-        var selectionBoxPosition = Vec3.multiplyQbyV(rotation, center);
-        selectionBoxPosition = Vec3.sum(position, selectionBoxPosition);
-        Overlays.editOverlay(selectionBox, {
-            position: selectionBoxPosition,
-            dimensions: dimensions,
-            rotation: rotation,
-            visible: !inModeRotate
-        });
-
-        // Create more selection box overlays if we don't have enough
-        var overlaysNeeded = SelectionManager.selections.length - selectionBoxes.length;
-        for (var i = 0; i < overlaysNeeded; i++) {
-            selectionBoxes.push(
-                Overlays.addOverlay("cube", {
-                    position: {
-                        x: 0,
-                        y: 0,
-                        z: 0
-                    },
-                    size: 1,
-                    color: {
-                        red: 255,
-                        green: 153,
-                        blue: 0
-                    },
-                    alpha: 1,
-                    solid: false,
-                    visible: false,
-                    dashed: false,
-                    ignoreRayIntersection: true
-                }));
-        }
-
-        i = 0;
-        // Only show individual selections boxes if there is more than 1 selection
-        if (SelectionManager.selections.length > 1) {
-            for (; i < SelectionManager.selections.length; i++) {
-                var props = Entities.getEntityProperties(SelectionManager.selections[i]);
-
-                // Adjust overlay position to take registrationPoint into account
-                // centeredRP = registrationPoint with range [-0.5, 0.5]
-                var centeredRP = Vec3.subtract(props.registrationPoint, {
-                    x: 0.5,
-                    y: 0.5,
-                    z: 0.5
-                });
-                var offset = vec3Mult(props.dimensions, centeredRP);
-                offset = Vec3.multiply(-1, offset);
-                offset = Vec3.multiplyQbyV(props.rotation, offset);
-                var curBoxPosition = Vec3.sum(props.position, offset);
-
-                var color = {red: 255, green: 128, blue: 0};
-                if (i >= SelectionManager.selections.length - 1) {
-                    color = {red: 255, green: 255, blue: 64};
-                }
-
-                Overlays.editOverlay(selectionBoxes[i], {
-                    position: curBoxPosition,
-                    color: color,
-                    rotation: props.rotation,
-                    dimensions: props.dimensions,
-                    visible: true
+            // UPDATE ROTATION RINGS
+            // rotateDimension is used as the base dimension for all overlays
+            var rotateDimension = Math.max(maxHandleDimension, toCameraDistance * ROTATE_RING_CAMERA_DISTANCE_MULTIPLE);
+            var rotateDimensions = { x:rotateDimension, y:rotateDimension, z:rotateDimension };
+            if (!isActiveTool(handleRotatePitchRing)) {
+                Overlays.editOverlay(handleRotatePitchRing, { 
+                    position: position, 
+                    rotation: rotationY,
+                    dimensions: rotateDimensions,
+                    majorTickMarksAngle: ROTATE_DEFAULT_TICK_MARKS_ANGLE
                 });
             }
-        }
-        // Hide any remaining selection boxes
-        for (; i < selectionBoxes.length; i++) {
-            Overlays.editOverlay(selectionBoxes[i], {
-                visible: false
+            if (!isActiveTool(handleRotateYawRing)) {
+                Overlays.editOverlay(handleRotateYawRing, { 
+                    position: position, 
+                    rotation: rotationZ,
+                    dimensions: rotateDimensions,
+                    majorTickMarksAngle: ROTATE_DEFAULT_TICK_MARKS_ANGLE
+                });
+            }
+            if (!isActiveTool(handleRotateRollRing)) {
+                Overlays.editOverlay(handleRotateRollRing, { 
+                    position: position, 
+                    rotation: rotationX,
+                    dimensions: rotateDimensions,
+                    majorTickMarksAngle: ROTATE_DEFAULT_TICK_MARKS_ANGLE
+                });
+            }
+            Overlays.editOverlay(handleRotateCurrentRing, { dimensions: rotateDimensions });
+            that.updateActiveRotateRing();
+
+            // UPDATE TRANSLATION ARROWS
+            var arrowCylinderDimension = rotateDimension * TRANSLATE_ARROW_CYLINDER_CAMERA_DISTANCE_MULTIPLE / 
+                                                           ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var arrowCylinderDimensions = { 
+                x:arrowCylinderDimension, 
+                y:arrowCylinderDimension * TRANSLATE_ARROW_CYLINDER_Y_MULTIPLE, 
+                z:arrowCylinderDimension 
+            };
+            var arrowConeDimension = rotateDimension * TRANSLATE_ARROW_CONE_CAMERA_DISTANCE_MULTIPLE / 
+                                                       ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var arrowConeDimensions = { x:arrowConeDimension, y:arrowConeDimension, z:arrowConeDimension };
+            var arrowCylinderOffset = rotateDimension * TRANSLATE_ARROW_CYLINDER_OFFSET / ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var arrowConeOffset = arrowCylinderDimensions.y * TRANSLATE_ARROW_CONE_OFFSET_CYLINDER_DIMENSION_MULTIPLE;
+            var cylinderXPosition = { x:arrowCylinderOffset, y:0, z:0 };
+            cylinderXPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, cylinderXPosition));
+            Overlays.editOverlay(handleTranslateXCylinder, { 
+                position: cylinderXPosition, 
+                rotation: rotationX,
+                dimensions: arrowCylinderDimensions
+            });
+            var cylinderXOffset = Vec3.subtract(cylinderXPosition, position);
+            var coneXPosition = Vec3.sum(cylinderXPosition, Vec3.multiply(Vec3.normalize(cylinderXOffset), arrowConeOffset));
+            Overlays.editOverlay(handleTranslateXCone, { 
+                position: coneXPosition, 
+                rotation: rotationX,
+                dimensions: arrowConeDimensions
+            });
+            var cylinderYPosition = { x:0, y:arrowCylinderOffset, z:0 };
+            cylinderYPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, cylinderYPosition));
+            Overlays.editOverlay(handleTranslateYCylinder, { 
+                position: cylinderYPosition, 
+                rotation: rotationY,
+                dimensions: arrowCylinderDimensions
+            });
+            var cylinderYOffset = Vec3.subtract(cylinderYPosition, position);
+            var coneYPosition = Vec3.sum(cylinderYPosition, Vec3.multiply(Vec3.normalize(cylinderYOffset), arrowConeOffset));
+            Overlays.editOverlay(handleTranslateYCone, { 
+                position: coneYPosition, 
+                rotation: rotationY,
+                dimensions: arrowConeDimensions
+            });
+            var cylinderZPosition = { x:0, y:0, z:arrowCylinderOffset };
+            cylinderZPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, cylinderZPosition));
+            Overlays.editOverlay(handleTranslateZCylinder, { 
+                position: cylinderZPosition, 
+                rotation: rotationZ,
+                dimensions: arrowCylinderDimensions
+            });
+            var cylinderZOffset = Vec3.subtract(cylinderZPosition, position);
+            var coneZPosition = Vec3.sum(cylinderZPosition, Vec3.multiply(Vec3.normalize(cylinderZOffset), arrowConeOffset));
+            Overlays.editOverlay(handleTranslateZCone, { 
+                position: coneZPosition, 
+                rotation: rotationZ,
+                dimensions: arrowConeDimensions
+            });
+
+            // UPDATE SCALE CUBES
+            var scaleCubeOffsetX = SCALE_CUBE_OFFSET * dimensions.x;
+            var scaleCubeOffsetY = SCALE_CUBE_OFFSET * dimensions.y;
+            var scaleCubeOffsetZ = SCALE_CUBE_OFFSET * dimensions.z;
+            var scaleCubeDimension = rotateDimension * SCALE_CUBE_CAMERA_DISTANCE_MULTIPLE / 
+                                                       ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var scaleCubeDimensions = { x:scaleCubeDimension, y:scaleCubeDimension, z:scaleCubeDimension };
+            var scaleCubeRotation = spaceMode === SPACE_LOCAL ? rotation : Quat.IDENTITY;
+            var scaleLBNCubePosition = { x:-scaleCubeOffsetX, y:-scaleCubeOffsetY, z:-scaleCubeOffsetZ };
+            scaleLBNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLBNCubePosition));
+            Overlays.editOverlay(handleScaleLBNCube, { 
+                position: scaleLBNCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleRBNCubePosition = { x:-scaleCubeOffsetX, y:-scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            scaleRBNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRBNCubePosition));
+            Overlays.editOverlay(handleScaleRBNCube, { 
+                position: scaleRBNCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleLBFCubePosition = { x:scaleCubeOffsetX, y:-scaleCubeOffsetY, z:-scaleCubeOffsetZ };
+            scaleLBFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLBFCubePosition));
+            Overlays.editOverlay(handleScaleLBFCube, { 
+                position: scaleLBFCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleRBFCubePosition = { x:scaleCubeOffsetX, y:-scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            scaleRBFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRBFCubePosition));
+            Overlays.editOverlay(handleScaleRBFCube, { 
+                position: scaleRBFCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleLTNCubePosition = { x:-scaleCubeOffsetX, y:scaleCubeOffsetY, z:-scaleCubeOffsetZ };
+            scaleLTNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLTNCubePosition));
+            Overlays.editOverlay(handleScaleLTNCube, { 
+                position: scaleLTNCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleRTNCubePosition = { x:-scaleCubeOffsetX, y:scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            scaleRTNCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRTNCubePosition));
+            Overlays.editOverlay(handleScaleRTNCube, { 
+                position: scaleRTNCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleLTFCubePosition = { x:scaleCubeOffsetX, y:scaleCubeOffsetY, z:-scaleCubeOffsetZ };
+            scaleLTFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLTFCubePosition));
+            Overlays.editOverlay(handleScaleLTFCube, { 
+                position: scaleLTFCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+            var scaleRTFCubePosition = { x:scaleCubeOffsetX, y:scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            scaleRTFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleRTFCubePosition));
+            Overlays.editOverlay(handleScaleRTFCube, { 
+                position: scaleRTFCubePosition, 
+                rotation: scaleCubeRotation,
+                dimensions: scaleCubeDimensions
+            });
+
+            // UPDATE SCALE EDGES
+            Overlays.editOverlay(handleScaleTREdge, { start: scaleRTNCubePosition, end: scaleRTFCubePosition });
+            Overlays.editOverlay(handleScaleTLEdge, { start: scaleLTNCubePosition, end: scaleLTFCubePosition });
+            Overlays.editOverlay(handleScaleTFEdge, { start: scaleLTFCubePosition, end: scaleRTFCubePosition });
+            Overlays.editOverlay(handleScaleTNEdge, { start: scaleLTNCubePosition, end: scaleRTNCubePosition });
+            Overlays.editOverlay(handleScaleBREdge, { start: scaleRBNCubePosition, end: scaleRBFCubePosition });
+            Overlays.editOverlay(handleScaleBLEdge, { start: scaleLBNCubePosition, end: scaleLBFCubePosition });
+            Overlays.editOverlay(handleScaleBFEdge, { start: scaleLBFCubePosition, end: scaleRBFCubePosition });
+            Overlays.editOverlay(handleScaleBNEdge, { start: scaleLBNCubePosition, end: scaleRBNCubePosition });
+            Overlays.editOverlay(handleScaleNREdge, { start: scaleRTNCubePosition, end: scaleRBNCubePosition });
+            Overlays.editOverlay(handleScaleNLEdge, { start: scaleLTNCubePosition, end: scaleLBNCubePosition });
+            Overlays.editOverlay(handleScaleFREdge, { start: scaleRTFCubePosition, end: scaleRBFCubePosition });
+            Overlays.editOverlay(handleScaleFLEdge, { start: scaleLTFCubePosition, end: scaleLBFCubePosition });
+
+            // UPDATE STRETCH SPHERES
+            var stretchSphereDimension = rotateDimension * STRETCH_SPHERE_CAMERA_DISTANCE_MULTIPLE / 
+                                                           ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var stretchSphereDimensions = { x:stretchSphereDimension, y:stretchSphereDimension, z:stretchSphereDimension };
+            var stretchSphereOffset = rotateDimension * STRETCH_SPHERE_OFFSET / ROTATE_RING_CAMERA_DISTANCE_MULTIPLE;
+            var stretchXPosition = { x:stretchSphereOffset, y:0, z:0 };
+            stretchXPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchXPosition));
+            Overlays.editOverlay(handleStretchXSphere, { 
+                position: stretchXPosition, 
+                dimensions: stretchSphereDimensions 
+            });
+            var stretchYPosition = { x:0, y:stretchSphereOffset, z:0 };
+            stretchYPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchYPosition));
+            Overlays.editOverlay(handleStretchYSphere, { 
+                position: stretchYPosition, 
+                dimensions: stretchSphereDimensions 
+            });
+            var stretchZPosition = { x:0, y:0, z:stretchSphereOffset };
+            stretchZPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, stretchZPosition));
+            Overlays.editOverlay(handleStretchZSphere, { 
+                position: stretchZPosition, 
+                dimensions: stretchSphereDimensions 
+            });
+
+            // UPDATE STRETCH HIGHLIGHT PANELS
+            var scaleLTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleLTFCubePosition);
+            var scaleRBFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRBFCubePosition);
+            var stretchPanelXDimensions = Vec3.subtract(scaleLTFCubePositionRotated, scaleRBFCubePositionRotated);
+            var tempY = Math.abs(stretchPanelXDimensions.y);
+            stretchPanelXDimensions.x = STRETCH_PANEL_WIDTH;
+            stretchPanelXDimensions.y = Math.abs(stretchPanelXDimensions.z);
+            stretchPanelXDimensions.z = tempY;
+            var stretchPanelXPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, { x:dimensions.x / 2, y:0, z:0 }));
+            Overlays.editOverlay(handleStretchXPanel, { 
+                position: stretchPanelXPosition, 
+                rotation: rotationZ,
+                dimensions: stretchPanelXDimensions
+            });
+            var scaleLTNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleLTNCubePosition);
+            var scaleRTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTFCubePosition);
+            var stretchPanelYDimensions = Vec3.subtract(scaleLTNCubePositionRotated, scaleRTFCubePositionRotated);
+            var tempX = Math.abs(stretchPanelYDimensions.x);
+            stretchPanelYDimensions.x = Math.abs(stretchPanelYDimensions.z);
+            stretchPanelYDimensions.y = STRETCH_PANEL_WIDTH;
+            stretchPanelYDimensions.z = tempX;
+            var stretchPanelYPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, { x:0, y:dimensions.y / 2, z:0 }));
+            Overlays.editOverlay(handleStretchYPanel, { 
+                position: stretchPanelYPosition, 
+                rotation: rotationY,
+                dimensions: stretchPanelYDimensions
+            });
+            var scaleRTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTFCubePosition);
+            var scaleRBNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRBNCubePosition);
+            var stretchPanelZDimensions = Vec3.subtract(scaleRTFCubePositionRotated, scaleRBNCubePositionRotated);
+            var tempX = Math.abs(stretchPanelZDimensions.x);
+            stretchPanelZDimensions.x = Math.abs(stretchPanelZDimensions.y);
+            stretchPanelZDimensions.y = tempX;
+            stretchPanelZDimensions.z = STRETCH_PANEL_WIDTH;
+            var stretchPanelZPosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, { x:0, y:0, z:dimensions.z / 2 }));
+            Overlays.editOverlay(handleStretchZPanel, { 
+                position: stretchPanelZPosition, 
+                rotation: rotationX,
+                dimensions: stretchPanelZDimensions
+            });
+
+            // UPDATE SELECTION BOX (CURRENTLY INVISIBLE WITH 0 ALPHA FOR TRANSLATE XZ TOOL)
+            var inModeRotate = isActiveTool(handleRotatePitchRing) || 
+                               isActiveTool(handleRotateYawRing) || 
+                               isActiveTool(handleRotateRollRing);
+            Overlays.editOverlay(selectionBox, {
+                position: position,
+                rotation: rotation,
+                dimensions: dimensions,
+                visible: !inModeRotate
+            });
+
+            // UPDATE CLONER (CURRENTLY HIDDEN FOR NOW)
+            var handleClonerOffset =  { 
+                x:CLONER_OFFSET.x * dimensions.x, 
+                y:CLONER_OFFSET.y * dimensions.y, 
+                z:CLONER_OFFSET.z * dimensions.z 
+            };
+            var handleClonerPos = Vec3.sum(position, Vec3.multiplyQbyV(rotation, handleClonerOffset));
+            Overlays.editOverlay(handleCloner, {
+                position: handleClonerPos,
+                rotation: rotation,
+                dimensions: scaleCubeDimensions
             });
         }
 
-        Overlays.editOverlay(grabberEdgeTR, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeTR
-        });
-        Overlays.editOverlay(grabberEdgeTL, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeTL
-        });
-        Overlays.editOverlay(grabberEdgeTF, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeTF
-        });
-        Overlays.editOverlay(grabberEdgeTN, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeTN
-        });
-        Overlays.editOverlay(grabberEdgeBR, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeBR
-        });
-        Overlays.editOverlay(grabberEdgeBL, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeBL
-        });
-        Overlays.editOverlay(grabberEdgeBF, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeBF
-        });
-        Overlays.editOverlay(grabberEdgeBN, {
-            visible: stretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeBN
-        });
-        Overlays.editOverlay(grabberEdgeNR, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeNR
-        });
-        Overlays.editOverlay(grabberEdgeNL, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeNL
-        });
-        Overlays.editOverlay(grabberEdgeFR, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeFR
-        });
-        Overlays.editOverlay(grabberEdgeFL, {
-            visible: extendedStretchHandlesVisible,
-            rotation: rotation,
-            position: EdgeFL
-        });
+        that.setHandleTranslateXVisible(!activeTool || isActiveTool(handleTranslateXCone) || 
+                                                       isActiveTool(handleTranslateXCylinder));
+        that.setHandleTranslateYVisible(!activeTool || isActiveTool(handleTranslateYCone) || 
+                                                       isActiveTool(handleTranslateYCylinder));
+        that.setHandleTranslateZVisible(!activeTool || isActiveTool(handleTranslateZCone) || 
+                                                       isActiveTool(handleTranslateZCylinder));
+        that.setHandleRotatePitchVisible(!activeTool || isActiveTool(handleRotatePitchRing));
+        that.setHandleRotateYawVisible(!activeTool || isActiveTool(handleRotateYawRing));
+        that.setHandleRotateRollVisible(!activeTool || isActiveTool(handleRotateRollRing));
 
-        var grabberMoveUpOffset = 0.1;
-        var upVec = Quat.getUp(MyAvatar.orientation);
-        grabberMoveUpPosition = {
-            x: position.x + (grabberMoveUpOffset + worldTop) * upVec.x ,
-            y: position.y+ (grabberMoveUpOffset + worldTop) * upVec.y,
-            z: position.z + (grabberMoveUpOffset + worldTop) * upVec.z
-        };
-        Overlays.editOverlay(grabberMoveUp, {
-            visible: (!activeTool) || isActiveTool(grabberMoveUp)
-        });
+        var showScaleStretch = !activeTool && SelectionManager.selections.length === 1;
+        that.setHandleStretchXVisible(showScaleStretch || isActiveTool(handleStretchXSphere));
+        that.setHandleStretchYVisible(showScaleStretch || isActiveTool(handleStretchYSphere));
+        that.setHandleStretchZVisible(showScaleStretch || isActiveTool(handleStretchZSphere));
+        that.setHandleScaleCubeVisible(showScaleStretch || isActiveTool(handleScaleLBNCube) || 
+                                       isActiveTool(handleScaleRBNCube) || isActiveTool(handleScaleLBFCube) || 
+                                       isActiveTool(handleScaleRBFCube) || isActiveTool(handleScaleLTNCube) || 
+                                       isActiveTool(handleScaleRTNCube) || isActiveTool(handleScaleLTFCube) || 
+                                       isActiveTool(handleScaleRTFCube) || isActiveTool(handleStretchXSphere) || 
+                                       isActiveTool(handleStretchYSphere) || isActiveTool(handleStretchZSphere));
+        that.setHandleScaleEdgeVisible(!isActiveTool(handleRotatePitchRing) && !isActiveTool(handleRotateYawRing) && 
+                                       !isActiveTool(handleRotateRollRing));
 
-        Overlays.editOverlay(baseOfEntityProjectionOverlay, {
-            visible: !inModeRotate,
-            solid: true,
-            position: {
-                x: SelectionManager.worldPosition.x,
-                y: grid.getOrigin().y,
-                z: SelectionManager.worldPosition.z
-            },
-            dimensions: {
-                x: SelectionManager.worldDimensions.x,
-                y: SelectionManager.worldDimensions.z
-            },
-            rotation: Quat.fromPitchYawRollDegrees(90, 0, 0)
-        });
+        //keep cloner always hidden for now since you can hold Alt to clone while  
+        //translating an entity - we may bring cloner back for HMD only later
+        //that.setHandleClonerVisible(!activeTool || isActiveTool(handleCloner));
 
         if (wantDebug) {
             print("====== Update Handles <=======");
         }
-
     };
+    Script.update.connect(that.updateHandles);
 
-    function helperSetOverlaysVisibility(handleArray, isVisible) {
-        var numHandles = handleArray.length;
-        var visibilityUpdate = { visible: isVisible };
-        for (var handleIndex = 0; handleIndex < numHandles; ++handleIndex) {
-            Overlays.editOverlay(handleArray[ handleIndex ], visibilityUpdate);
+    // FUNCTION: UPDATE ACTIVE ROTATE RING
+    that.updateActiveRotateRing = function() {
+        var activeRotateRing = null;
+        if (isActiveTool(handleRotatePitchRing)) {
+            activeRotateRing = handleRotatePitchRing;
+        } else if (isActiveTool(handleRotateYawRing)) {
+            activeRotateRing = handleRotateYawRing;
+        } else if (isActiveTool(handleRotateRollRing)) {
+            activeRotateRing = handleRotateRollRing;
         }
-    }
+        if (activeRotateRing != null) {
+            var tickMarksAngle =  ctrlPressed ? ROTATE_CTRL_SNAP_ANGLE : ROTATE_DEFAULT_TICK_MARKS_ANGLE;
+            Overlays.editOverlay(activeRotateRing, { majorTickMarksAngle: tickMarksAngle });
+        }
+    };
 
     // FUNCTION: SET OVERLAYS VISIBLE
     that.setOverlaysVisible = function(isVisible) {
-        helperSetOverlaysVisibility(allOverlays, isVisible);
-        helperSetOverlaysVisibility(selectionBoxes, isVisible);
-    };
-
-    // FUNCTION: SET ROTATION HANDLES VISIBLE
-    that.setRotationHandlesVisible = function(isVisible) {
-        var visibilityUpdate = { visible: isVisible };
-        Overlays.editOverlay(yawHandle, visibilityUpdate);
-        Overlays.editOverlay(pitchHandle, visibilityUpdate);
-        Overlays.editOverlay(rollHandle, visibilityUpdate);
-    };
-
-    // FUNCTION: SET STRETCH HANDLES VISIBLE
-    that.setStretchHandlesVisible = function(isVisible) {
-        helperSetOverlaysVisibility(stretchHandles, isVisible);
-    };
-
-    // FUNCTION: SET GRABBER MOVE UP VISIBLE
-    that.setGrabberMoveUpVisible = function(isVisible) {
-        Overlays.editOverlay(grabberMoveUp, { visible: isVisible });
-    };
-
-    // FUNCTION: SET GRABBER TOOLS UP VISIBLE
-    that.setGrabberToolsVisible = function(isVisible) {
-        var visibilityUpdate = { visible: isVisible };
-        for (var toolKey in grabberTools) {
-            if (!grabberTools.hasOwnProperty(toolKey)) {
-                // EARLY ITERATION EXIT--(On to the next one)
-                continue;
-            }
-
-            Overlays.editOverlay(toolKey, visibilityUpdate);
+        for (var i = 0; i < allOverlays.length; i++) {
+            Overlays.editOverlay(allOverlays[i], { visible: isVisible });
         }
     };
 
-    // FUNCTION: SET POINT LIGHT HANDLES VISIBLE
-    that.setPointLightHandlesVisible = function(isVisible) {
-        helperSetOverlaysVisibility(pointLightGrabberHandles, isVisible);
+    // FUNCTION: SET HANDLE TRANSLATE VISIBLE
+    that.setHandleTranslateVisible = function(isVisible) {
+        that.setHandleTranslateXVisible(isVisible);
+        that.setHandleTranslateYVisible(isVisible);
+        that.setHandleTranslateZVisible(isVisible);
     };
 
-    // FUNCTION: SET SPOT LIGHT HANDLES VISIBLE
-    that.setSpotLightHandlesVisible = function(isVisible) {
-        helperSetOverlaysVisibility(spotLightGrabberHandles, isVisible);
+    that.setHandleTranslateXVisible = function(isVisible) {
+        Overlays.editOverlay(handleTranslateXCone, { visible: isVisible });
+        Overlays.editOverlay(handleTranslateXCylinder, { visible: isVisible });
     };
 
-    // FUNCTION: UNSELECT
-    // TODO?: Needs implementation
-    that.unselect = function(entityID) {};
+    that.setHandleTranslateYVisible = function(isVisible) {
+        Overlays.editOverlay(handleTranslateYCone, { visible: isVisible });
+        Overlays.editOverlay(handleTranslateYCylinder, { visible: isVisible });
+    };
 
+    that.setHandleTranslateZVisible = function(isVisible) {
+        Overlays.editOverlay(handleTranslateZCone, { visible: isVisible });
+        Overlays.editOverlay(handleTranslateZCylinder, { visible: isVisible });
+    };
+
+    // FUNCTION: SET HANDLE ROTATE VISIBLE
+    that.setHandleRotateVisible = function(isVisible) {
+        that.setHandleRotatePitchVisible(isVisible);
+        that.setHandleRotateYawVisible(isVisible);
+        that.setHandleRotateRollVisible(isVisible);
+    };
+
+    that.setHandleRotatePitchVisible = function(isVisible) {
+        Overlays.editOverlay(handleRotatePitchRing, { visible: isVisible });
+    };
+
+    that.setHandleRotateYawVisible = function(isVisible) {
+        Overlays.editOverlay(handleRotateYawRing, { visible: isVisible });
+    };
+
+    that.setHandleRotateRollVisible = function(isVisible) {
+        Overlays.editOverlay(handleRotateRollRing, { visible: isVisible });
+    };
+
+    // FUNCTION: SET HANDLE STRETCH VISIBLE
+    that.setHandleStretchVisible = function(isVisible) {
+        that.setHandleStretchXVisible(isVisible);
+        that.setHandleStretchYVisible(isVisible);
+        that.setHandleStretchZVisible(isVisible);
+    };
+
+    that.setHandleStretchXVisible = function(isVisible) {
+        Overlays.editOverlay(handleStretchXSphere, { visible: isVisible });
+    };
+
+    that.setHandleStretchYVisible = function(isVisible) {
+        Overlays.editOverlay(handleStretchYSphere, { visible: isVisible });
+    };
+
+    that.setHandleStretchZVisible = function(isVisible) {
+        Overlays.editOverlay(handleStretchZSphere, { visible: isVisible });
+    };
+    
+    // FUNCTION: SET HANDLE SCALE VISIBLE
+    that.setHandleScaleVisible = function(isVisible) {
+        that.setHandleScaleCubeVisible(isVisible);
+        that.setHandleScaleEdgeVisible(isVisible);
+    };
+
+    that.setHandleScaleCubeVisible = function(isVisible) {
+        Overlays.editOverlay(handleScaleLBNCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleRBNCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleLBFCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleRBFCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleLTNCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleRTNCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleLTFCube, { visible: isVisible });
+        Overlays.editOverlay(handleScaleRTFCube, { visible: isVisible });
+    };
+
+    that.setHandleScaleEdgeVisible = function(isVisible) {
+        Overlays.editOverlay(handleScaleTREdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleTLEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleTFEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleTNEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleBREdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleBLEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleBFEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleBNEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleNREdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleNLEdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleFREdge, { visible: isVisible });
+        Overlays.editOverlay(handleScaleFLEdge, { visible: isVisible });
+    };
+
+    // FUNCTION: SET HANDLE CLONER VISIBLE
+    that.setHandleClonerVisible = function(isVisible) {
+        Overlays.editOverlay(handleCloner, { visible: isVisible });
+    };
+
+    // TOOL DEFINITION: TRANSLATE XZ TOOL
     var initialXZPick = null;
     var isConstrained = false;
     var constrainMajorOnly = false;
     var startPosition = null;
     var duplicatedEntityIDs = null;
-
-    // TOOL DEFINITION: TRANSLATE XZ TOOL
-    var translateXZTool = addGrabberTool(selectionBox,{
+    var translateXZTool = addHandleTool(selectionBox, {
         mode: 'TRANSLATE_XZ',
         pickPlanePosition: { x: 0, y: 0, z: 0 },
         greatestDimension: 0.0,
@@ -2051,14 +1472,20 @@ SelectionDisplay = (function() {
             }
 
             SelectionManager.saveProperties();
-            that.setRotationHandlesVisible(false);
-            that.setStretchHandlesVisible(false);
-            that.setGrabberMoveUpVisible(false);
+            that.resetPreviousHandleColor();
+
+            that.setHandleTranslateVisible(false);
+            that.setHandleRotateVisible(false);
+            that.setHandleScaleCubeVisible(false);
+            that.setHandleStretchVisible(false);
+            that.setHandleClonerVisible(false);
 
             startPosition = SelectionManager.worldPosition;
 
             translateXZTool.pickPlanePosition = pickResult.intersection;
-            translateXZTool.greatestDimension = Math.max(Math.max(SelectionManager.worldDimensions.x, SelectionManager.worldDimensions.y), SelectionManager.worldDimensions.z);
+            translateXZTool.greatestDimension = Math.max(Math.max(SelectionManager.worldDimensions.x, 
+                                                                  SelectionManager.worldDimensions.y), 
+                                                                  SelectionManager.worldDimensions.z);
             translateXZTool.startingDistance = Vec3.distance(pickRay.origin, SelectionManager.position);
             translateXZTool.startingElevation = translateXZTool.elevation(pickRay.origin, translateXZTool.pickPlanePosition);
             if (wantDebug) {
@@ -2099,13 +1526,6 @@ SelectionDisplay = (function() {
         },
         onEnd: function(event, reason) {
             pushCommandForSelections(duplicatedEntityIDs);
-
-            Overlays.editOverlay(xRailOverlay, {
-                visible: false
-            });
-            Overlays.editOverlay(zRailOverlay, {
-                visible: false
-            });
         },
         elevation: function(origin, intersection) {
             return (origin.y - intersection.y) / Vec3.distance(origin, intersection);
@@ -2169,49 +1589,10 @@ SelectionDisplay = (function() {
                     vector.x = 0;
                 }
                 if (!isConstrained) {
-                    Overlays.editOverlay(xRailOverlay, {
-                        visible: true
-                    });
-                    var xStart = Vec3.sum(startPosition, {
-                        x: -10000,
-                        y: 0,
-                        z: 0
-                    });
-                    var xEnd = Vec3.sum(startPosition, {
-                        x: 10000,
-                        y: 0,
-                        z: 0
-                    });
-                    var zStart = Vec3.sum(startPosition, {
-                        x: 0,
-                        y: 0,
-                        z: -10000
-                    });
-                    var zEnd = Vec3.sum(startPosition, {
-                        x: 0,
-                        y: 0,
-                        z: 10000
-                    });
-                    Overlays.editOverlay(xRailOverlay, {
-                        start: xStart,
-                        end: xEnd,
-                        visible: true
-                    });
-                    Overlays.editOverlay(zRailOverlay, {
-                        start: zStart,
-                        end: zEnd,
-                        visible: true
-                    });
                     isConstrained = true;
                 }
             } else {
                 if (isConstrained) {
-                    Overlays.editOverlay(xRailOverlay, {
-                        visible: false
-                    });
-                    Overlays.editOverlay(zRailOverlay, {
-                        visible: false
-                    });
                     isConstrained = false;
                 }
             }
@@ -2222,7 +1603,6 @@ SelectionDisplay = (function() {
                 grid.snapToGrid(Vec3.sum(cornerPosition, vector), constrainMajorOnly),
                 cornerPosition);
 
-
             for (var i = 0; i < SelectionManager.selections.length; i++) {
                 var properties = SelectionManager.savedProperties[SelectionManager.selections[i]];
                 if (!properties) {
@@ -2248,106 +1628,102 @@ SelectionDisplay = (function() {
             SelectionManager._update();
         }
     });
-    
-    // GRABBER TOOL: GRABBER MOVE UP
-    var lastXYPick = null;
-    var upDownPickNormal = null;
-    addGrabberTool(grabberMoveUp, {
-        mode: "TRANSLATE_UP_DOWN",
-        onBegin: function(event, pickRay, pickResult) {
-            upDownPickNormal = Quat.getForward(lastCameraOrientation);
-            lastXYPick = rayPlaneIntersection(pickRay, SelectionManager.worldPosition, upDownPickNormal);
 
-            SelectionManager.saveProperties();
-            that.setGrabberMoveUpVisible(true);
-            that.setStretchHandlesVisible(false);
-            that.setRotationHandlesVisible(false);
-
-            // Duplicate entities if alt is pressed.  This will make a
-            // copy of the selected entities and move the _original_ entities, not
-            // the new ones.
-            if (event.isAlt) {
-                duplicatedEntityIDs = [];
-                for (var otherEntityID in SelectionManager.savedProperties) {
-                    var properties = SelectionManager.savedProperties[otherEntityID];
-                    if (!properties.locked) {
-                        var entityID = Entities.addEntity(properties);
-                        duplicatedEntityIDs.push({
-                            entityID: entityID,
-                            properties: properties
-                        });
-                    }
+    // TOOL DEFINITION: HANDLE TRANSLATE TOOL    
+    function addHandleTranslateTool(overlay, mode, direction) {
+        var pickNormal = null;
+        var lastPick = null;
+        var projectionVector = null;
+        addHandleTool(overlay, {
+            mode: mode,
+            onBegin: function(event, pickRay, pickResult) {
+                if (direction === TRANSLATE_DIRECTION.X) {
+                    pickNormal = { x:0, y:0, z:1 };
+                } else if (direction === TRANSLATE_DIRECTION.Y) {
+                    pickNormal = { x:1, y:0, z:0 };
+                } else if (direction === TRANSLATE_DIRECTION.Z) {
+                    pickNormal = { x:0, y:1, z:0 };
                 }
-            } else {
-                duplicatedEntityIDs = null;
+
+                var rotation = spaceMode === SPACE_LOCAL ? SelectionManager.localRotation : SelectionManager.worldRotation;
+                pickNormal = Vec3.multiplyQbyV(rotation, pickNormal);
+
+                lastPick = rayPlaneIntersection(pickRay, SelectionManager.worldPosition, pickNormal);
+    
+                SelectionManager.saveProperties();
+                that.resetPreviousHandleColor();
+
+                that.setHandleTranslateXVisible(direction === TRANSLATE_DIRECTION.X);
+                that.setHandleTranslateYVisible(direction === TRANSLATE_DIRECTION.Y);
+                that.setHandleTranslateZVisible(direction === TRANSLATE_DIRECTION.Z);
+                that.setHandleRotateVisible(false);
+                that.setHandleStretchVisible(false);
+                that.setHandleScaleCubeVisible(false);
+                that.setHandleClonerVisible(false);
+    
+                // Duplicate entities if alt is pressed.  This will make a
+                // copy of the selected entities and move the _original_ entities, not
+                // the new ones.
+                if (event.isAlt) {
+                    duplicatedEntityIDs = [];
+                    for (var otherEntityID in SelectionManager.savedProperties) {
+                        var properties = SelectionManager.savedProperties[otherEntityID];
+                        if (!properties.locked) {
+                            var entityID = Entities.addEntity(properties);
+                            duplicatedEntityIDs.push({
+                                entityID: entityID,
+                                properties: properties
+                            });
+                        }
+                    }
+                } else {
+                    duplicatedEntityIDs = null;
+                }
+            },
+            onEnd: function(event, reason) {
+                pushCommandForSelections(duplicatedEntityIDs);
+            },
+            onMove: function(event) {
+                pickRay = generalComputePickRay(event.x, event.y);
+    
+                // translate mode left/right based on view toward entity
+                var newIntersection = rayPlaneIntersection(pickRay, SelectionManager.worldPosition, pickNormal);
+                var vector = Vec3.subtract(newIntersection, lastPick);
+                
+                if (direction === TRANSLATE_DIRECTION.X) {
+                    projectionVector = { x:1, y:0, z:0 };
+                } else if (direction === TRANSLATE_DIRECTION.Y) {
+                    projectionVector = { x:0, y:1, z:0 };
+                } else if (direction === TRANSLATE_DIRECTION.Z) {
+                    projectionVector = { x:0, y:0, z:1 };
+                }
+
+                var rotation = spaceMode === SPACE_LOCAL ? SelectionManager.localRotation : SelectionManager.worldRotation;
+                projectionVector = Vec3.multiplyQbyV(rotation, projectionVector);
+
+                var dotVector = Vec3.dot(vector, projectionVector);
+                vector = Vec3.multiply(dotVector, projectionVector);
+                vector = grid.snapToGrid(vector);
+    
+                var wantDebug = false;
+                if (wantDebug) {
+                    print("translateUpDown... ");
+                    print("                event.y:" + event.y);
+                    Vec3.print("        newIntersection:", newIntersection);
+                    Vec3.print("                 vector:", vector);
+                }
+    
+                for (var i = 0; i < SelectionManager.selections.length; i++) {
+                    var id = SelectionManager.selections[i];
+                    var properties = SelectionManager.savedProperties[id];
+                    var newPosition = Vec3.sum(properties.position, vector);
+                    Entities.editEntity(id, { position: newPosition });
+                }
+    
+                SelectionManager._update();
             }
-        },
-        onEnd: function(event, reason) {
-            pushCommandForSelections(duplicatedEntityIDs);
-        },
-        onMove: function(event) {
-            pickRay = generalComputePickRay(event.x, event.y);
-
-            // translate mode left/right based on view toward entity
-            var newIntersection = rayPlaneIntersection(pickRay, SelectionManager.worldPosition, upDownPickNormal);
-
-            var vector = Vec3.subtract(newIntersection, lastXYPick);
-
-            // project vector onto avatar up vector
-            // we want the avatar referential not the camera.
-            var avatarUpVector = Quat.getUp(MyAvatar.orientation);
-            var dotVectorUp = Vec3.dot(vector, avatarUpVector);
-            vector = Vec3.multiply(dotVectorUp, avatarUpVector);
-
-
-            vector = grid.snapToGrid(vector);
-
-            
-
-            var wantDebug = false;
-            if (wantDebug) {
-                print("translateUpDown... ");
-                print("                event.y:" + event.y);
-                Vec3.print("        newIntersection:", newIntersection);
-                Vec3.print("                 vector:", vector);
-                // Vec3.print("            newPosition:", newPosition);
-            }
-            for (var i = 0; i < SelectionManager.selections.length; i++) {
-                var id = SelectionManager.selections[i];
-                var properties = SelectionManager.savedProperties[id];
-
-                var original = properties.position;
-                var newPosition = Vec3.sum(properties.position, vector);
-
-                Entities.editEntity(id, {
-                    position: newPosition
-                });
-            }
-
-            SelectionManager._update();
-        }
-    });
-
-    // GRABBER TOOL: GRABBER CLONER
-    addGrabberTool(grabberCloner, {
-        mode: "CLONE",
-        onBegin: function(event, pickRay, pickResult) {
-            var doClone = true;
-            translateXZTool.onBegin(event,pickRay,pickResult,doClone);
-        },
-        elevation: function (event) {
-            translateXZTool.elevation(event);
-        },
-
-        onEnd: function (event) {
-            translateXZTool.onEnd(event);
-        },
-
-        onMove: function (event) {
-            translateXZTool.onMove(event);
-        }
-    });
-
+        });
+    }
 
     // FUNCTION: VEC 3 MULT
     var vec3Mult = function(v1, v2) {
@@ -2358,36 +1734,24 @@ SelectionDisplay = (function() {
         };
     };
 
-    // FUNCTION: MAKE STRETCH TOOL
-    // stretchMode - name of mode
-    // direction - direction to stretch in
-    // pivot - point to use as a pivot
-    // offset - the position of the overlay tool relative to the selections center position
-    // @return: tool obj
-    var makeStretchTool = function(stretchMode, direction, pivot, offset, customOnMove) {
-        //  directionFor3DStretch - direction and pivot for 3D stretch
-        //  distanceFor3DStretch - distance from the intersection point and the handController 
-        //     used to increase the scale taking into account the distance to the object
-        //    DISTANCE_INFLUENCE_THRESHOLD - constant that holds the minimum distance where the 
-        //     distance to the object will influence the stretch/resize/scale
-        var directionFor3DStretch = getDirectionsFor3DStretch(stretchMode);
+    // TOOL DEFINITION: HANDLE STRETCH TOOL   
+    function makeStretchTool(stretchMode, directionEnum, directionVec, pivot, offset, stretchPanel, scaleHandle) {
+        var directionFor3DStretch = directionVec;
         var distanceFor3DStretch = 0;
         var DISTANCE_INFLUENCE_THRESHOLD = 1.2;
         
-        
         var signs = {
-            x: direction.x < 0 ? -1 : (direction.x > 0 ? 1 : 0),
-            y: direction.y < 0 ? -1 : (direction.y > 0 ? 1 : 0),
-            z: direction.z < 0 ? -1 : (direction.z > 0 ? 1 : 0)
+            x: directionVec.x < 0 ? -1 : (directionVec.x > 0 ? 1 : 0),
+            y: directionVec.y < 0 ? -1 : (directionVec.y > 0 ? 1 : 0),
+            z: directionVec.z < 0 ? -1 : (directionVec.z > 0 ? 1 : 0)
         };
 
         var mask = {
-            x: Math.abs(direction.x) > 0 ? 1 : 0,
-            y: Math.abs(direction.y) > 0 ? 1 : 0,
-            z: Math.abs(direction.z) > 0 ? 1 : 0
+            x: Math.abs(directionVec.x) > 0 ? 1 : 0,
+            y: Math.abs(directionVec.y) > 0 ? 1 : 0,
+            z: Math.abs(directionVec.z) > 0 ? 1 : 0
         };
 
-
         var numDimensions = mask.x + mask.y + mask.z;
 
         var planeNormal = null;
@@ -2467,11 +1831,6 @@ SelectionDisplay = (function() {
                     z: 0
                 });
                 end = Vec3.sum(end, properties.position);
-                Overlays.editOverlay(xRailOverlay, {
-                    start: start,
-                    end: end,
-                    visible: true
-                });
             }
             if ((numDimensions === 1) && mask.y) {
                 start = Vec3.multiplyQbyV(rotation, {
@@ -2486,11 +1845,6 @@ SelectionDisplay = (function() {
                     z: 0
                 });
                 end = Vec3.sum(end, properties.position);
-                Overlays.editOverlay(yRailOverlay, {
-                    start: start,
-                    end: end,
-                    visible: true
-                });
             }
             if ((numDimensions === 1) && mask.z) {
                 start = Vec3.multiplyQbyV(rotation, {
@@ -2505,11 +1859,6 @@ SelectionDisplay = (function() {
                     z: 10000
                 });
                 end = Vec3.sum(end, properties.position);
-                Overlays.editOverlay(zRailOverlay, {
-                    start: start,
-                    end: end,
-                    visible: true
-                });
             }
             if (numDimensions === 1) {
                 if (mask.x === 1) {
@@ -2569,27 +1918,39 @@ SelectionDisplay = (function() {
                     planeNormal3D);
                 distanceFor3DStretch = Vec3.length(Vec3.subtract(pickRayPosition3D, pickRay.origin));
             }
+
+            that.setHandleTranslateVisible(false);
+            that.setHandleRotateVisible(false);
+            that.setHandleScaleCubeVisible(true);
+            that.setHandleStretchXVisible(directionEnum === STRETCH_DIRECTION.X);
+            that.setHandleStretchYVisible(directionEnum === STRETCH_DIRECTION.Y);
+            that.setHandleStretchZVisible(directionEnum === STRETCH_DIRECTION.Z);
+            that.setHandleClonerVisible(false);
         
             SelectionManager.saveProperties();
+            that.resetPreviousHandleColor();
+
+            if (stretchPanel != null) {
+                Overlays.editOverlay(stretchPanel, { visible: true });
+            }
+            if (scaleHandle != null) {
+                Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE_SELECTED });
+            }
         };
 
-        var onEnd = function(event, reason) {
-            Overlays.editOverlay(xRailOverlay, {
-                visible: false
-            });
-            Overlays.editOverlay(yRailOverlay, {
-                visible: false
-            });
-            Overlays.editOverlay(zRailOverlay, {
-                visible: false
-            });
-
+        var onEnd = function(event, reason) {    
+            if (stretchPanel != null) {
+                Overlays.editOverlay(stretchPanel, { visible: false });
+            }
+            if (scaleHandle != null) {
+                Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE });
+            }
             pushCommandForSelections();
         };
 
         var onMove = function(event) {
-            var proportional = (spaceMode === SPACE_WORLD) || event.isShifted || isActiveTool(grabberSpotLightRadius);
-
+            var proportional = (spaceMode === SPACE_WORLD) || event.isShifted || directionEnum === STRETCH_DIRECTION.ALL;
+            
             var position, dimensions, rotation;
             if (spaceMode === SPACE_LOCAL) {
                 position = SelectionManager.localPosition;
@@ -2603,7 +1964,6 @@ SelectionDisplay = (function() {
             
             var localDeltaPivot = deltaPivot;
             var localSigns = signs;
-
             var pickRay = generalComputePickRay(event.x, event.y);
             
             // Are we using handControllers or Mouse - only relevant for 3D tools
@@ -2612,91 +1972,79 @@ SelectionDisplay = (function() {
             if (HMD.isHMDAvailable() && HMD.isHandControllerAvailable() && 
                     controllerPose.valid && that.triggered && directionFor3DStretch) {
                 localDeltaPivot = deltaPivot3D;
-
                 newPick = pickRay.origin;
-            
                 vector = Vec3.subtract(newPick, lastPick3D);
-                
                 vector = Vec3.multiplyQbyV(Quat.inverse(rotation), vector);
-            
                 if (distanceFor3DStretch > DISTANCE_INFLUENCE_THRESHOLD) {
                     // Range of Motion
                     vector = Vec3.multiply(distanceFor3DStretch , vector);
                 }
-                
                 localSigns = directionFor3DStretch;
-                
             } else {
-                newPick = rayPlaneIntersection(pickRay,
-                    pickRayPosition,
-                    planeNormal);
+                newPick = rayPlaneIntersection(pickRay, pickRayPosition, planeNormal);
                 vector = Vec3.subtract(newPick, lastPick);
-
                 vector = Vec3.multiplyQbyV(Quat.inverse(rotation), vector);
-
                 vector = vec3Mult(mask, vector);
-                
             }
             
-            if (customOnMove) {
-                var change = Vec3.multiply(-1, vec3Mult(localSigns, vector));
-                customOnMove(vector, change);
-            } else {
-                vector = grid.snapToSpacing(vector);
-
-                var changeInDimensions = Vec3.multiply(-1, vec3Mult(localSigns, vector));
-                var newDimensions;
-                if (proportional) {
-                    var absX = Math.abs(changeInDimensions.x);
-                    var absY = Math.abs(changeInDimensions.y);
-                    var absZ = Math.abs(changeInDimensions.z);
-                    var pctChange = 0;
-                    if (absX > absY && absX > absZ) {
-                        pctChange = changeInDimensions.x / initialProperties.dimensions.x;
-                        pctChange = changeInDimensions.x / initialDimensions.x;
-                    } else if (absY > absZ) {
-                        pctChange = changeInDimensions.y / initialProperties.dimensions.y;
-                        pctChange = changeInDimensions.y / initialDimensions.y;
-                    } else {
-                        pctChange = changeInDimensions.z / initialProperties.dimensions.z;
-                        pctChange = changeInDimensions.z / initialDimensions.z;
-                    }
-                    pctChange += 1.0;
-                    newDimensions = Vec3.multiply(pctChange, initialDimensions);
-                } else {
-                    newDimensions = Vec3.sum(initialDimensions, changeInDimensions);
-                }
-
-                newDimensions.x = Math.max(newDimensions.x, MINIMUM_DIMENSION);
-                newDimensions.y = Math.max(newDimensions.y, MINIMUM_DIMENSION);
-                newDimensions.z = Math.max(newDimensions.z, MINIMUM_DIMENSION);
-
-                var changeInPosition = Vec3.multiplyQbyV(rotation, vec3Mult(localDeltaPivot, changeInDimensions));
-                var newPosition = Vec3.sum(initialPosition, changeInPosition);
-
-                for (var i = 0; i < SelectionManager.selections.length; i++) {
-                    Entities.editEntity(SelectionManager.selections[i], {
-                        position: newPosition,
-                        dimensions: newDimensions
-                    });
-                }
-                
-
-                var wantDebug = false;
-                if (wantDebug) {
-                    print(stretchMode);
-                    // Vec3.print("        newIntersection:", newIntersection);
-                    Vec3.print("                 vector:", vector);
-                    // Vec3.print("           oldPOS:", oldPOS);
-                    // Vec3.print("                newPOS:", newPOS);
-                    Vec3.print("            changeInDimensions:", changeInDimensions);
-                    Vec3.print("                 newDimensions:", newDimensions);
-
-                    Vec3.print("              changeInPosition:", changeInPosition);
-                    Vec3.print("                   newPosition:", newPosition);
-                }
+            vector = grid.snapToSpacing(vector);
+    
+            var changeInDimensions = Vec3.multiply(NEGATE_VECTOR, vec3Mult(localSigns, vector));
+            if (directionEnum === STRETCH_DIRECTION.ALL) {
+                var toCameraDistance = getDistanceToCamera(position);
+                var dimensionsMultiple = toCameraDistance * STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE;
+                changeInDimensions = Vec3.multiply(changeInDimensions, dimensionsMultiple);
             }
 
+            var newDimensions;
+            if (proportional) {
+                var absoluteX = Math.abs(changeInDimensions.x);
+                var absoluteY = Math.abs(changeInDimensions.y);
+                var absoluteZ = Math.abs(changeInDimensions.z);
+                var percentChange = 0;
+                if (absoluteX > absoluteY && absoluteX > absoluteZ) {
+                    percentChange = changeInDimensions.x / initialProperties.dimensions.x;
+                    percentChange = changeInDimensions.x / initialDimensions.x;
+                } else if (absoluteY > absoluteZ) {
+                    percentChange = changeInDimensions.y / initialProperties.dimensions.y;
+                    percentChange = changeInDimensions.y / initialDimensions.y;
+                } else {
+                    percentChange = changeInDimensions.z / initialProperties.dimensions.z;
+                    percentChange = changeInDimensions.z / initialDimensions.z;
+                }
+                percentChange += 1.0;
+                newDimensions = Vec3.multiply(percentChange, initialDimensions);
+            } else {
+                newDimensions = Vec3.sum(initialDimensions, changeInDimensions);
+            }
+    
+            newDimensions.x = Math.max(newDimensions.x, STRETCH_MINIMUM_DIMENSION);
+            newDimensions.y = Math.max(newDimensions.y, STRETCH_MINIMUM_DIMENSION);
+            newDimensions.z = Math.max(newDimensions.z, STRETCH_MINIMUM_DIMENSION);
+    
+            var changeInPosition = Vec3.multiplyQbyV(rotation, vec3Mult(localDeltaPivot, changeInDimensions));
+            if (directionEnum === STRETCH_DIRECTION.ALL) {
+                changeInPosition = { x:0, y:0, z:0 };
+            }
+            var newPosition = Vec3.sum(initialPosition, changeInPosition);
+    
+            for (var i = 0; i < SelectionManager.selections.length; i++) {
+                Entities.editEntity(SelectionManager.selections[i], {
+                    position: newPosition,
+                    dimensions: newDimensions
+                });
+            }
+                
+            var wantDebug = false;
+            if (wantDebug) {
+                print(stretchMode);
+                Vec3.print("                 vector:", vector);
+                Vec3.print("            changeInDimensions:", changeInDimensions);
+                Vec3.print("                 newDimensions:", newDimensions);
+                Vec3.print("              changeInPosition:", changeInPosition);
+                Vec3.print("                   newPosition:", newPosition);
+            }
+    
             SelectionManager._update();
         };// End of onMove def
 
@@ -2706,600 +2054,85 @@ SelectionDisplay = (function() {
             onMove: onMove,
             onEnd: onEnd
         };
-    };
-    
-    // Direction for the stretch tool when using hand controller
-    var directionsFor3DGrab = {
-        LBN: {
-            x: 1,
-            y: 1,
-            z: 1
-        },
-        RBN: {
-            x: -1,
-            y: 1,
-            z: 1
-        },
-        LBF: {
-            x: 1,
-            y: 1,
-            z: -1
-        },
-        RBF: {
-            x: -1,
-            y: 1,
-            z: -1
-        },
-        LTN: {
-            x: 1,
-            y: -1,
-            z: 1
-        },
-        RTN: {
-            x: -1,
-            y: -1,
-            z: 1
-        },
-        LTF: {
-            x: 1,
-            y: -1,
-            z: -1
-        },
-        RTF: {
-            x: -1,
-            y: -1,
-            z: -1
-        }
-    };
-
-    // FUNCTION: GET DIRECTION FOR 3D STRETCH    
-    // Returns a vector with directions for the stretch tool in 3D using hand controllers
-    function getDirectionsFor3DStretch(mode) {
-        if (mode === "STRETCH_LBN") {
-            return directionsFor3DGrab.LBN;
-        } else if (mode === "STRETCH_RBN") {
-            return directionsFor3DGrab.RBN;
-        } else if (mode === "STRETCH_LBF") {
-            return directionsFor3DGrab.LBF;
-        } else if (mode === "STRETCH_RBF") {
-            return directionsFor3DGrab.RBF;
-        } else if (mode === "STRETCH_LTN") {
-            return directionsFor3DGrab.LTN;
-        } else if (mode === "STRETCH_RTN") {
-            return directionsFor3DGrab.RTN;
-        } else if (mode === "STRETCH_LTF") {
-            return directionsFor3DGrab.LTF;
-        } else if (mode === "STRETCH_RTF") {
-            return directionsFor3DGrab.RTF;
-        } else {
-            return null;
-        }
-    }
-    
-    
-    // FUNCTION: ADD STRETCH TOOL
-    function addStretchTool(overlay, mode, pivot, direction, offset, handleMove) {
-        if (!pivot) {
-            pivot = direction;
-        }
-        var tool = makeStretchTool(mode, direction, pivot, offset, handleMove);
-
-        return addGrabberTool(overlay, tool);
     }
 
-    // FUNCTION: CUTOFF STRETCH FUNC
-    function cutoffStretchFunc(vector, change) {
-        vector = change;
-        var wantDebug = false;
-        if (wantDebug) {
-            Vec3.print("Radius stretch: ", vector);
+    function addHandleStretchTool(overlay, mode, directionEnum) {
+        var directionVector, offset, stretchPanel;
+        if (directionEnum === STRETCH_DIRECTION.X) {
+            stretchPanel = handleStretchXPanel;
+            directionVector = { x:-1, y:0, z:0 };
+        } else if (directionEnum === STRETCH_DIRECTION.Y) {
+            stretchPanel = handleStretchYPanel;
+            directionVector = { x:0, y:-1, z:0 };
+        } else if (directionEnum === STRETCH_DIRECTION.Z) {
+            stretchPanel = handleStretchZPanel
+            directionVector = { x:0, y:0, z:-1 };
         }
-        var length = vector.x + vector.y + vector.z;
-        var props = SelectionManager.savedProperties[SelectionManager.selections[0]];
-
-        var radius = props.dimensions.z / 2;
-        var originalCutoff = props.cutoff;
-
-        var originalSize = radius * Math.tan(originalCutoff * (Math.PI / 180));
-        var newSize = originalSize + length;
-        var cutoff = Math.atan2(newSize, radius) * 180 / Math.PI;
-
-        Entities.editEntity(SelectionManager.selections[0], {
-            cutoff: cutoff
-        });
-
-        SelectionManager._update();
+        offset = Vec3.multiply(directionVector, NEGATE_VECTOR);
+        var tool = makeStretchTool(mode, directionEnum, directionVector, directionVector, offset, stretchPanel, null);
+        return addHandleTool(overlay, tool);
     }
 
-    // FUNCTION: RADIUS STRETCH FUNC
-    function radiusStretchFunc(vector, change) {
-        var props = SelectionManager.savedProperties[SelectionManager.selections[0]];
-
-        // Find the axis being adjusted
-        var size;
-        if (Math.abs(change.x) > 0) {
-            size = props.dimensions.x + change.x;
-        } else if (Math.abs(change.y) > 0) {
-            size = props.dimensions.y + change.y;
-        } else if (Math.abs(change.z) > 0) {
-            size = props.dimensions.z + change.z;
+    // TOOL DEFINITION: HANDLE SCALE TOOL   
+    function addHandleScaleTool(overlay, mode, directionEnum) {
+        var directionVector, offset, selectedHandle;
+        if (directionEnum === SCALE_DIRECTION.LBN) {
+            directionVector = { x:1, y:1, z:1 };
+            selectedHandle = handleScaleLBNCube;
+        } else if (directionEnum === SCALE_DIRECTION.RBN) {
+            directionVector = { x:1, y:1, z:-1 };
+            selectedHandle = handleScaleRBNCube;
+        } else if (directionEnum === SCALE_DIRECTION.LBF) {
+            directionVector = { x:-1, y:1, z:1 };
+            selectedHandle = handleScaleLBFCube;
+        } else if (directionEnum === SCALE_DIRECTION.RBF) {
+            directionVector = { x:-1, y:1, z:-1 };
+            selectedHandle = handleScaleRBFCube;
+        } else if (directionEnum === SCALE_DIRECTION.LTN) { 
+            directionVector = { x:1, y:-1, z:1 };
+            selectedHandle = handleScaleLTNCube;
+        } else if (directionEnum === SCALE_DIRECTION.RTN) {
+            directionVector = { x:1, y:-1, z:-1 };
+            selectedHandle = handleScaleRTNCube;
+        } else if (directionEnum === SCALE_DIRECTION.LTF) {
+            directionVector = { x:-1, y:-1, z:1 };
+            selectedHandle = handleScaleLTFCube;
+        } else if (directionEnum === SCALE_DIRECTION.RTF) {
+            directionVector = { x:-1, y:-1, z:-1 };
+            selectedHandle = handleScaleRTFCube;
         }
-
-        var newDimensions = {
-            x: size,
-            y: size,
-            z: size
-        };
-
-        Entities.editEntity(SelectionManager.selections[0], {
-            dimensions: newDimensions
-        });
-
-        SelectionManager._update();
+        offset = Vec3.multiply(directionVector, NEGATE_VECTOR);
+        var tool = makeStretchTool(mode, STRETCH_DIRECTION.ALL, directionVector, 
+                                   directionVector, offset, null, selectedHandle);
+        return addHandleTool(overlay, tool);
     }
 
-    // STRETCH TOOL DEF SECTION
-    addStretchTool(grabberNEAR, "STRETCH_NEAR", {
-        x: 0,
-        y: 0,
-        z: 1
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, {
-        x: 0,
-        y: 0,
-        z: -1
-    });
-    addStretchTool(grabberFAR, "STRETCH_FAR", {
-        x: 0,
-        y: 0,
-        z: -1
-    }, {
-        x: 0,
-        y: 0,
-        z: -1
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    });
-    addStretchTool(grabberTOP, "STRETCH_TOP", {
-        x: 0,
-        y: -1,
-        z: 0
-    }, {
-        x: 0,
-        y: -1,
-        z: 0
-    }, {
-        x: 0,
-        y: 1,
-        z: 0
-    });
-    addStretchTool(grabberBOTTOM, "STRETCH_BOTTOM", {
-        x: 0,
-        y: 1,
-        z: 0
-    }, {
-        x: 0,
-        y: 1,
-        z: 0
-    }, {
-        x: 0,
-        y: -1,
-        z: 0
-    });
-    addStretchTool(grabberRIGHT, "STRETCH_RIGHT", {
-        x: -1,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: 0,
-        z: 0
-    });
-    addStretchTool(grabberLEFT, "STRETCH_LEFT", {
-        x: 1,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: 0,
-        z: 0
-    });
-
-    addStretchTool(grabberSpotLightRadius, "STRETCH_RADIUS", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, {
-        x: 0,
-        y: 0,
-        z: -1
-    });
-    addStretchTool(grabberSpotLightT, "STRETCH_CUTOFF_T", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: -1,
-        z: 0
-    }, {
-        x: 0,
-        y: 1,
-        z: 0
-    }, cutoffStretchFunc);
-    addStretchTool(grabberSpotLightB, "STRETCH_CUTOFF_B", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 1,
-        z: 0
-    }, {
-        x: 0,
-        y: -1,
-        z: 0
-    }, cutoffStretchFunc);
-    addStretchTool(grabberSpotLightL, "STRETCH_CUTOFF_L", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: 0,
-        z: 0
-    }, cutoffStretchFunc);
-    addStretchTool(grabberSpotLightR, "STRETCH_CUTOFF_R", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: 0,
-        z: 0
-    }, cutoffStretchFunc);
-
-    addStretchTool(grabberPointLightT, "STRETCH_RADIUS_T", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: -1,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, radiusStretchFunc);
-    addStretchTool(grabberPointLightB, "STRETCH_RADIUS_B", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 1,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, radiusStretchFunc);
-    addStretchTool(grabberPointLightL, "STRETCH_RADIUS_L", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, radiusStretchFunc);
-    addStretchTool(grabberPointLightR, "STRETCH_RADIUS_R", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, radiusStretchFunc);
-    addStretchTool(grabberPointLightF, "STRETCH_RADIUS_F", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: -1
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, radiusStretchFunc);
-    addStretchTool(grabberPointLightN, "STRETCH_RADIUS_N", {
-        x: 0,
-        y: 0,
-        z: 0
-    }, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, {
-        x: 0,
-        y: 0,
-        z: -1
-    }, radiusStretchFunc);
-
-    addStretchTool(grabberLBN, "STRETCH_LBN", null, {
-        x: 1,
-        y: 0,
-        z: 1
-    }, {
-        x: -1,
-        y: -1,
-        z: -1
-    });
-    addStretchTool(grabberRBN, "STRETCH_RBN", null, {
-        x: -1,
-        y: 0,
-        z: 1
-    }, {
-        x: 1,
-        y: -1,
-        z: -1
-    });
-    addStretchTool(grabberLBF, "STRETCH_LBF", null, {
-        x: 1,
-        y: 0,
-        z: -1
-    }, {
-        x: -1,
-        y: -1,
-        z: 1
-    });
-    addStretchTool(grabberRBF, "STRETCH_RBF", null, {
-        x: -1,
-        y: 0,
-        z: -1
-    }, {
-        x: 1,
-        y: -1,
-        z: 1
-    });
-    addStretchTool(grabberLTN, "STRETCH_LTN", null, {
-        x: 1,
-        y: 0,
-        z: 1
-    }, {
-        x: -1,
-        y: 1,
-        z: -1
-    });
-    addStretchTool(grabberRTN, "STRETCH_RTN", null, {
-        x: -1,
-        y: 0,
-        z: 1
-    }, {
-        x: 1,
-        y: 1,
-        z: -1
-    });
-    addStretchTool(grabberLTF, "STRETCH_LTF", null, {
-        x: 1,
-        y: 0,
-        z: -1
-    }, {
-        x: -1,
-        y: 1,
-        z: 1
-    });
-    addStretchTool(grabberRTF, "STRETCH_RTF", null, {
-        x: -1,
-        y: 0,
-        z: -1
-    }, {
-        x: 1,
-        y: 1,
-        z: 1
-    });
-
-    addStretchTool(grabberEdgeTR, "STRETCH_EdgeTR", null, {
-        x: 1,
-        y: 1,
-        z: 0
-    }, {
-        x: 1,
-        y: 1,
-        z: 0
-    });
-    addStretchTool(grabberEdgeTL, "STRETCH_EdgeTL", null, {
-        x: -1,
-        y: 1,
-        z: 0
-    }, {
-        x: -1,
-        y: 1,
-        z: 0
-    });
-    addStretchTool(grabberEdgeTF, "STRETCH_EdgeTF", null, {
-        x: 0,
-        y: 1,
-        z: -1
-    }, {
-        x: 0,
-        y: 1,
-        z: -1
-    });
-    addStretchTool(grabberEdgeTN, "STRETCH_EdgeTN", null, {
-        x: 0,
-        y: 1,
-        z: 1
-    }, {
-        x: 0,
-        y: 1,
-        z: 1
-    });
-    addStretchTool(grabberEdgeBR, "STRETCH_EdgeBR", null, {
-        x: -1,
-        y: 0,
-        z: 0
-    }, {
-        x: 1,
-        y: -1,
-        z: 0
-    });
-    addStretchTool(grabberEdgeBL, "STRETCH_EdgeBL", null, {
-        x: 1,
-        y: 0,
-        z: 0
-    }, {
-        x: -1,
-        y: -1,
-        z: 0
-    });
-    addStretchTool(grabberEdgeBF, "STRETCH_EdgeBF", null, {
-        x: 0,
-        y: 0,
-        z: -1
-    }, {
-        x: 0,
-        y: -1,
-        z: -1
-    });
-    addStretchTool(grabberEdgeBN, "STRETCH_EdgeBN", null, {
-        x: 0,
-        y: 0,
-        z: 1
-    }, {
-        x: 0,
-        y: -1,
-        z: 1
-    });
-    addStretchTool(grabberEdgeNR, "STRETCH_EdgeNR", null, {
-        x: -1,
-        y: 0,
-        z: 1
-    }, {
-        x: 1,
-        y: 0,
-        z: -1
-    });
-    addStretchTool(grabberEdgeNL, "STRETCH_EdgeNL", null, {
-        x: 1,
-        y: 0,
-        z: 1
-    }, {
-        x: -1,
-        y: 0,
-        z: -1
-    });
-    addStretchTool(grabberEdgeFR, "STRETCH_EdgeFR", null, {
-        x: -1,
-        y: 0,
-        z: -1
-    }, {
-        x: 1,
-        y: 0,
-        z: 1
-    });
-    addStretchTool(grabberEdgeFL, "STRETCH_EdgeFL", null, {
-        x: 1,
-        y: 0,
-        z: -1
-    }, {
-        x: -1,
-        y: 0,
-        z: 1
-    });
-
     // FUNCTION: UPDATE ROTATION DEGREES OVERLAY
-    function updateRotationDegreesOverlay(angleFromZero, handleRotation, centerPosition) {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("---> updateRotationDegreesOverlay ---");
-            print("    AngleFromZero: " + angleFromZero);
-            print("    HandleRotation - X: " + handleRotation.x + " Y: " + handleRotation.y + " Z: " + handleRotation.z);
-            print("    CenterPos - " + centerPosition.x + " Y: " + centerPosition.y + " Z: " + centerPosition.z);
-        }
-
+    function updateRotationDegreesOverlay(angleFromZero, position) {
         var angle = angleFromZero * (Math.PI / 180);
-        var position = {
-            x: Math.cos(angle) * outerRadius * ROTATION_DISPLAY_DISTANCE_MULTIPLIER,
-            y: Math.sin(angle) * outerRadius * ROTATION_DISPLAY_DISTANCE_MULTIPLIER,
-            z: 0
-        };
-        if (wantDebug) {
-            print("    Angle: " + angle);
-            print("    InitialPos: " + position.x + ", " + position.y + ", " + position.z);
-        }
-        
-        position = Vec3.multiplyQbyV(handleRotation, position);
-        position = Vec3.sum(centerPosition, position);
+        var toCameraDistance = getDistanceToCamera(position);
         var overlayProps = {
             position: position,
             dimensions: {
-                x: innerRadius * ROTATION_DISPLAY_SIZE_X_MULTIPLIER,
-                y: innerRadius * ROTATION_DISPLAY_SIZE_Y_MULTIPLIER
+                x: toCameraDistance * ROTATE_DISPLAY_SIZE_X_MULTIPLIER,
+                y: toCameraDistance * ROTATE_DISPLAY_SIZE_Y_MULTIPLIER
             },
-            lineHeight: innerRadius * ROTATION_DISPLAY_LINE_HEIGHT_MULTIPLIER,
+            lineHeight: toCameraDistance * ROTATE_DISPLAY_LINE_HEIGHT_MULTIPLIER,
             text: normalizeDegrees(-angleFromZero) + "°"
         };
-        if (wantDebug) {
-            print("    TranslatedPos: " + position.x + ", " + position.y + ", " + position.z);
-            print("    OverlayDim - X: " + overlayProps.dimensions.x + " Y: " + overlayProps.dimensions.y + " Z: " + overlayProps.dimensions.z);
-            print("    OverlayLineHeight: " + overlayProps.lineHeight);
-            print("    OverlayText: " + overlayProps.text);
-        }
-
         Overlays.editOverlay(rotationDegreesDisplay, overlayProps);
-        if (wantDebug) {
-            print("<--- updateRotationDegreesOverlay ---");
-        }
     }
 
     // FUNCTION DEF: updateSelectionsRotation
-    //    Helper func used by rotation grabber tools 
-    function updateSelectionsRotation(rotationChange) {
+    //    Helper func used by rotation handle tools 
+    function updateSelectionsRotation(rotationChange, initialPosition) {
         if (!rotationChange) {
             print("ERROR: entitySelectionTool.updateSelectionsRotation - Invalid arg specified!!");
 
             // EARLY EXIT
             return;
         }
-        
+
         // Entities should only reposition if we are rotating multiple selections around
         // the selections center point.  Otherwise, the rotation will be around the entities
         // registration point which does not need repositioning.
@@ -3322,585 +2155,211 @@ SelectionDisplay = (function() {
         }
     }
 
-    function helperRotationHandleOnBegin(event, pickRay, rotAroundAxis, rotCenter, handleRotation) {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("================== " + getMode() + "(rotation helper onBegin) -> =======================");
-        }
+    // TOOL DEFINITION: HANDLE ROTATION TOOL   
+    function addHandleRotateTool(overlay, mode, direction) {
+        var selectedHandle = null;
+        var worldRotation = null;
+        var rotationCenter = null;
+        var initialRotation = null;
+        addHandleTool(overlay, {
+            mode: mode,
+            onBegin: function(event, pickRay, pickResult) {
+                var wantDebug = false;
+                if (wantDebug) {
+                    print("================== " + getMode() + "(addHandleRotateTool onBegin) -> =======================");
+                }
 
-        SelectionManager.saveProperties();
-        that.setRotationHandlesVisible(false);
-        that.setStretchHandlesVisible(false);
-        that.setGrabberMoveUpVisible(false);
+                SelectionManager.saveProperties();
+                that.resetPreviousHandleColor();
+    
+                that.setHandleTranslateVisible(false);
+                that.setHandleRotatePitchVisible(direction === ROTATE_DIRECTION.PITCH);
+                that.setHandleRotateYawVisible(direction === ROTATE_DIRECTION.YAW);
+                that.setHandleRotateRollVisible(direction === ROTATE_DIRECTION.ROLL);
+                that.setHandleStretchVisible(false);
+                that.setHandleScaleCubeVisible(false);
+                that.setHandleClonerVisible(false);
 
-        initialPosition = SelectionManager.worldPosition;
-        rotationNormal = { x: 0, y: 0, z: 0 };
-        rotationNormal[rotAroundAxis] = 1;
-        //get the correct axis according to the avatar referencial
-        var avatarReferential = Quat.multiply(MyAvatar.orientation, Quat.fromVec3Degrees({
-            x: 0,
-            y: 0,
-            z: 0
-        }));
-        rotationNormal = Vec3.multiplyQbyV(avatarReferential, rotationNormal);
+                if (direction === ROTATE_DIRECTION.PITCH) {
+                    rotationNormal = { x: 1, y: 0, z: 0 };
+                    worldRotation = worldRotationY;
+                    selectedHandle = handleRotatePitchRing;
+                } else if (direction === ROTATE_DIRECTION.YAW) {
+                    rotationNormal = { x: 0, y: 1, z: 0 };
+                    worldRotation = worldRotationZ;
+                    selectedHandle = handleRotateYawRing;
+                } else if (direction === ROTATE_DIRECTION.ROLL) {
+                    rotationNormal = { x: 0, y: 0, z: 1 };
+                    worldRotation = worldRotationX;
+                    selectedHandle = handleRotateRollRing;
+                }
 
-        // Size the overlays to the current selection size
-        var diagonal = (Vec3.length(SelectionManager.worldDimensions) / 2) * 1.1;
-        var halfDimensions = Vec3.multiply(SelectionManager.worldDimensions, 0.5);
-        innerRadius = diagonal;
-        outerRadius = diagonal * 1.15;
-        var innerAlpha = 0.2;
-        var outerAlpha = 0.2;
-        Overlays.editOverlay(rotateOverlayInner, {
-            visible: true,
-            rotation: handleRotation,
-            position: rotCenter,
-            size: innerRadius,
-            innerRadius: 0.9,
-            startAt: 0,
-            endAt: 360,
-            alpha: innerAlpha
-        });
+                Overlays.editOverlay(selectedHandle, { 
+                    hasTickMarks: true,
+                    solid: false,
+                    innerRadius: ROTATE_RING_SELECTED_INNER_RADIUS
+                });
 
-        Overlays.editOverlay(rotateOverlayOuter, {
-            visible: true,
-            rotation: handleRotation,
-            position: rotCenter,
-            size: outerRadius,
-            innerRadius: 0.9,
-            startAt: 0,
-            endAt: 360,
-            alpha: outerAlpha
-        });
+                initialRotation = spaceMode === SPACE_LOCAL ? SelectionManager.localRotation : SelectionManager.worldRotation;
+                rotationNormal = Vec3.multiplyQbyV(initialRotation, rotationNormal);
 
-        Overlays.editOverlay(rotateOverlayCurrent, {
-            visible: true,
-            rotation: handleRotation,
-            position: rotCenter,
-            size: outerRadius,
-            startAt: 0,
-            endAt: 0,
-            innerRadius: 0.9
-        });
+                rotationCenter = SelectionManager.worldPosition;
 
-        Overlays.editOverlay(rotationDegreesDisplay, {
-            visible: true
-        });
-
-        updateRotationDegreesOverlay(0, handleRotation, rotCenter);
-        
-        // editOverlays may not have committed rotation changes.
-        // Compute zero position based on where the overlay will be eventually.
-        var result = rayPlaneIntersection(pickRay, rotCenter, rotationNormal);
-        // In case of a parallel ray, this will be null, which will cause early-out
-        // in the onMove helper.
-        rotZero = result;
-        
-        if (wantDebug) {
-            print("================== " + getMode() + "(rotation helper onBegin) <- =======================");
-        }
-    }// End_Function(helperRotationHandleOnBegin)
-
-    function helperRotationHandleOnMove(event, rotAroundAxis, rotCenter, handleRotation) {
-
-        if (!rotZero) {
-            print("ERROR: entitySelectionTool.handleRotationHandleOnMove - Invalid RotationZero Specified (missed rotation target plane?)");
-
-            // EARLY EXIT
-            return;
-        }
-
-        var wantDebug = false;
-        if (wantDebug) {
-            print("================== "+ getMode() + "(rotation helper onMove) -> =======================");
-            Vec3.print("    rotZero: ", rotZero);
-        }
-        var pickRay = generalComputePickRay(event.x, event.y);
-        Overlays.editOverlay(selectionBox, {
-            visible: false
-        });
-        Overlays.editOverlay(baseOfEntityProjectionOverlay, {
-            visible: false
-        });
-
-        var result = rayPlaneIntersection(pickRay, rotCenter, rotationNormal);
-        if (result) {
-            var centerToZero = Vec3.subtract(rotZero, rotCenter);
-            var centerToIntersect = Vec3.subtract(result, rotCenter);
-            if (wantDebug) {
-                Vec3.print("    RotationNormal:    ", rotationNormal);
-                Vec3.print("    rotZero:           ", rotZero);
-                Vec3.print("    rotCenter:         ", rotCenter);
-                Vec3.print("    intersect:         ", result);
-                Vec3.print("    centerToZero:      ", centerToZero);
-                Vec3.print("    centerToIntersect: ", centerToIntersect);
-            }
-            // Note: orientedAngle which wants normalized centerToZero and centerToIntersect
-            //             handles that internally, so it's to pass unnormalized vectors here.
-            var angleFromZero = Vec3.orientedAngle(centerToZero, centerToIntersect, rotationNormal);
-
-            var distanceFromCenter = Vec3.length(centerToIntersect);
-            var snapToInner = distanceFromCenter < innerRadius;
-            var snapAngle = snapToInner ? innerSnapAngle : 1.0;
-            angleFromZero = Math.floor(angleFromZero / snapAngle) * snapAngle;
-
-            
-            var rotChange = Quat.angleAxis(angleFromZero, rotationNormal);
-            updateSelectionsRotation(rotChange);
-            //present angle in avatar referencial
-            angleFromZero = -angleFromZero;
-            updateRotationDegreesOverlay(angleFromZero, handleRotation, rotCenter);
-
-            // update the rotation display accordingly...
-            var startAtCurrent = 0;
-            var endAtCurrent = angleFromZero;
-            var startAtRemainder = angleFromZero;
-            var endAtRemainder = 360;
-            if (angleFromZero < 0) {
-                startAtCurrent = 360 + angleFromZero;
-                endAtCurrent = 360;
-                startAtRemainder = 0;
-                endAtRemainder = startAtCurrent;
-            }
-            if (snapToInner) {
-                Overlays.editOverlay(rotateOverlayOuter, {
+                Overlays.editOverlay(rotationDegreesDisplay, { visible: true });
+                Overlays.editOverlay(handleRotateCurrentRing, {
+                    position: rotationCenter,
+                    rotation: worldRotation,
                     startAt: 0,
-                    endAt: 360
+                    endAt: 0,
+                    visible: true
                 });
-                Overlays.editOverlay(rotateOverlayInner, {
-                    startAt: startAtRemainder,
-                    endAt: endAtRemainder
+
+                // editOverlays may not have committed rotation changes.
+                // Compute zero position based on where the overlay will be eventually.
+                var result = rayPlaneIntersection(pickRay, rotationCenter, rotationNormal);
+                // In case of a parallel ray, this will be null, which will cause early-out
+                // in the onMove helper.
+                rotationZero = result;
+
+                var rotationCenterToZero = Vec3.subtract(rotationZero, rotationCenter);
+                var rotationCenterToZeroLength = Vec3.length(rotationCenterToZero);
+                rotationDegreesPosition = Vec3.sum(rotationCenter, Vec3.multiply(Vec3.normalize(rotationCenterToZero), 
+                                                   rotationCenterToZeroLength * ROTATE_DISPLAY_DISTANCE_MULTIPLIER));
+                updateRotationDegreesOverlay(0, rotationDegreesPosition);
+
+                if (wantDebug) {
+                    print("================== " + getMode() + "(addHandleRotateTool onBegin) <- =======================");
+                }
+            },
+            onEnd: function(event, reason) {
+                var wantDebug = false;
+                if (wantDebug) {
+                    print("================== " + getMode() + "(addHandleRotateTool onEnd) -> =======================");
+                }
+                Overlays.editOverlay(rotationDegreesDisplay, { visible: false });
+                Overlays.editOverlay(selectedHandle, { 
+                    hasTickMarks: false,
+                    solid: true,
+                    innerRadius: ROTATE_RING_IDLE_INNER_RADIUS
                 });
-                Overlays.editOverlay(rotateOverlayCurrent, {
-                    startAt: startAtCurrent,
-                    endAt: endAtCurrent,
-                    size: innerRadius,
-                    majorTickMarksAngle: innerSnapAngle,
-                    minorTickMarksAngle: 0,
-                    majorTickMarksLength: -0.25,
-                    minorTickMarksLength: 0
-                });
-            } else {
-                Overlays.editOverlay(rotateOverlayInner, {
-                    startAt: 0,
-                    endAt: 360
-                });
-                Overlays.editOverlay(rotateOverlayOuter, {
-                    startAt: startAtRemainder,
-                    endAt: endAtRemainder
-                });
-                Overlays.editOverlay(rotateOverlayCurrent, {
-                    startAt: startAtCurrent,
-                    endAt: endAtCurrent,
-                    size: outerRadius,
-                    majorTickMarksAngle: 45.0,
-                    minorTickMarksAngle: 5,
-                    majorTickMarksLength: 0.25,
-                    minorTickMarksLength: 0.1
-                });
-            }
-        }// End_If(results.intersects)
+                Overlays.editOverlay(handleRotateCurrentRing, { visible: false });
+                pushCommandForSelections();
+                if (wantDebug) {
+                    print("================== " + getMode() + "(addHandleRotateTool onEnd) <- =======================");
+                }
+            },
+            onMove: function(event) {
+                if (!rotationZero) {
+                    print("ERROR: entitySelectionTool.addHandleRotateTool.onMove - " +
+                          "Invalid RotationZero Specified (missed rotation target plane?)");
 
-        if (wantDebug) {
-            print("================== "+ getMode() + "(rotation helper onMove) <- =======================");
-        }
-    }// End_Function(helperRotationHandleOnMove)
+                    // EARLY EXIT
+                    return;
+                }
+                
+                var wantDebug = false;
+                if (wantDebug) {
+                    print("================== "+ getMode() + "(addHandleRotateTool onMove) -> =======================");
+                    Vec3.print("    rotationZero: ", rotationZero);
+                }
 
-    function helperRotationHandleOnEnd() {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("================== " + getMode() + "(onEnd) -> =======================");
-        }
-        Overlays.editOverlay(rotateOverlayInner, {
-            visible: false
-        });
-        Overlays.editOverlay(rotateOverlayOuter, {
-            visible: false
-        });
-        Overlays.editOverlay(rotateOverlayCurrent, {
-            visible: false
-        });
-        Overlays.editOverlay(rotationDegreesDisplay, {
-            visible: false
-        });
+                var pickRay = generalComputePickRay(event.x, event.y);
+                var result = rayPlaneIntersection(pickRay, rotationCenter, rotationNormal);
+                if (result) {
+                    var centerToZero = Vec3.subtract(rotationZero, rotationCenter);
+                    var centerToIntersect = Vec3.subtract(result, rotationCenter);
 
-        pushCommandForSelections();
+                    if (wantDebug) {
+                        Vec3.print("    RotationNormal:    ", rotationNormal);
+                        Vec3.print("    rotationZero:           ", rotationZero);
+                        Vec3.print("    rotationCenter:         ", rotationCenter);
+                        Vec3.print("    intersect:         ", result);
+                        Vec3.print("    centerToZero:      ", centerToZero);
+                        Vec3.print("    centerToIntersect: ", centerToIntersect);
+                    }
 
-        if (wantDebug) {
-            print("================== " + getMode() + "(onEnd) <- =======================");
-        }
-    }// End_Function(helperRotationHandleOnEnd)
+                    // Note: orientedAngle which wants normalized centerToZero and centerToIntersect
+                    //             handles that internally, so it's to pass unnormalized vectors here.
+                    var angleFromZero = Vec3.orientedAngle(centerToZero, centerToIntersect, rotationNormal);        
+                    var snapAngle = ctrlPressed ? ROTATE_CTRL_SNAP_ANGLE : ROTATE_DEFAULT_SNAP_ANGLE;
+                    angleFromZero = Math.floor(angleFromZero / snapAngle) * snapAngle;
+                    var rotationChange = Quat.angleAxis(angleFromZero, rotationNormal);
+                    updateSelectionsRotation(rotationChange, rotationCenter);
+                    updateRotationDegreesOverlay(-angleFromZero, rotationDegreesPosition);
 
+                    var startAtCurrent = 0;
+                    var endAtCurrent = angleFromZero;
+                    if (angleFromZero < 0) {
+                        startAtCurrent = 360 + angleFromZero;
+                        endAtCurrent = 360;
+                    }
+                    Overlays.editOverlay(handleRotateCurrentRing, {
+                        startAt: startAtCurrent,
+                        endAt: endAtCurrent
+                    });
 
-    // YAW GRABBER TOOL DEFINITION
-    var initialPosition = SelectionManager.worldPosition;
-    addGrabberTool(yawHandle, {
-        mode: "ROTATE_YAW",
-        onBegin: function(event, pickRay, pickResult) {
-            helperRotationHandleOnBegin(event, pickRay, "y", yawCenter, yawHandleRotation);
-        },
-        onEnd: function(event, reason) {
-            helperRotationHandleOnEnd();
-        },
-        onMove: function(event) {
-            helperRotationHandleOnMove(event, "y", yawCenter, yawHandleRotation);
-        }
-    });
+                    // not sure why but this seems to be needed to fix an reverse rotation for yaw ring only
+                    if (direction === ROTATE_DIRECTION.YAW) {
+                        if (spaceMode === SPACE_LOCAL) {
+                            Overlays.editOverlay(handleRotateCurrentRing, { rotation: worldRotationZ });
+                        } else {
+                            Overlays.editOverlay(handleRotateCurrentRing, { 
+                                rotation: Quat.fromPitchYawRollDegrees(-90, 0, 0) 
+                            });
+                        }
+                    }
+                }
 
-
-    // PITCH GRABBER TOOL DEFINITION
-    addGrabberTool(pitchHandle, {
-        mode: "ROTATE_PITCH",
-        onBegin: function(event, pickRay, pickResult) {
-            helperRotationHandleOnBegin(event, pickRay, "x", pitchCenter, pitchHandleRotation);
-        },
-        onEnd: function(event, reason) {
-            helperRotationHandleOnEnd();
-        },
-        onMove: function (event) {
-            helperRotationHandleOnMove(event, "x", pitchCenter, pitchHandleRotation);
-        }
-    });
-
-
-    // ROLL GRABBER TOOL DEFINITION
-    addGrabberTool(rollHandle, {
-        mode: "ROTATE_ROLL",
-        onBegin: function(event, pickRay, pickResult) {
-            helperRotationHandleOnBegin(event, pickRay, "z", rollCenter, rollHandleRotation);
-        },
-        onEnd: function (event, reason) {
-            helperRotationHandleOnEnd();
-        },
-        onMove: function(event) {
-            helperRotationHandleOnMove(event, "z", rollCenter, rollHandleRotation);
-        }
-    });
-
-    // FUNCTION: CHECK MOVE
-    that.checkMove = function() {
-        if (SelectionManager.hasSelection()) {
-
-            // FIXME - this cause problems with editing in the entity properties window
-            // SelectionManager._update();
-
-            if (!Vec3.equal(Camera.getPosition(), lastCameraPosition) ||
-                !Quat.equal(Camera.getOrientation(), lastCameraOrientation)) {
-
-                that.updateRotationHandles();
-            }
-        }
-    };
-
-    that.checkControllerMove = function() {
-        if (SelectionManager.hasSelection()) {
-            var controllerPose = getControllerWorldLocation(activeHand, true);
-            var hand = (activeHand === Controller.Standard.LeftHand) ? 0 : 1;
-            if (controllerPose.valid && lastControllerPoses[hand].valid) {
-                if (!Vec3.equal(controllerPose.position, lastControllerPoses[hand].position) ||
-                    !Vec3.equal(controllerPose.rotation, lastControllerPoses[hand].rotation)) {
-                    that.mouseMoveEvent({});
+                if (wantDebug) {
+                    print("================== "+ getMode() + "(addHandleRotateTool onMove) <- =======================");
                 }
             }
-            lastControllerPoses[hand] = controllerPose;
-        }
-    };
-
-
-    // FUNCTION DEF(s): Intersection Check Helpers
-    function testRayIntersect(queryRay, overlayIncludes, overlayExcludes) {
-        var wantDebug = false;
-        if ((queryRay === undefined) || (queryRay === null)) {
-            if (wantDebug) {
-                print("testRayIntersect - EARLY EXIT -> queryRay is undefined OR null!");
-            }
-            return null;
-        }
-
-        var intersectObj = Overlays.findRayIntersection(queryRay, true, overlayIncludes, overlayExcludes);
-
-        if (wantDebug) {
-            if (!overlayIncludes) {
-                print("testRayIntersect - no overlayIncludes provided.");
-            }
-            if (!overlayExcludes) {
-                print("testRayIntersect - no overlayExcludes provided.");
-            }
-            print("testRayIntersect - Hit: " + intersectObj.intersects);
-            print("    intersectObj.overlayID:" + intersectObj.overlayID + "[" + overlayNames[intersectObj.overlayID] + "]");
-            print("        OverlayName: " + overlayNames[intersectObj.overlayID]);
-            print("    intersectObj.distance:" + intersectObj.distance);
-            print("    intersectObj.face:" + intersectObj.face);
-            Vec3.print("    intersectObj.intersection:", intersectObj.intersection);
-        }
-
-        return intersectObj;
+        });
     }
 
-    // FUNCTION: MOUSE PRESS EVENT
-    that.mousePressEvent = function (event) {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("=============== eST::MousePressEvent BEG =======================");
-        }
-        if (!event.isLeftButton && !that.triggered) {
-            // EARLY EXIT-(if another mouse button than left is pressed ignore it)
-            return false;
+    // TOOL DEFINITION: HANDLE CLONER
+    addHandleTool(handleCloner, {
+        mode: "CLONE",
+        onBegin: function(event, pickRay, pickResult) {
+            var doClone = true;
+            translateXZTool.onBegin(event,pickRay,pickResult,doClone);
+        },
+        elevation: function (event) {
+            translateXZTool.elevation(event);
+        },
+    
+        onEnd: function (event) {
+            translateXZTool.onEnd(event);
+        },
+    
+        onMove: function (event) {
+            translateXZTool.onMove(event);
         }
+    });
 
-        var pickRay = generalComputePickRay(event.x, event.y);
-        // TODO_Case6491:  Move this out to setup just to make it once
-        var interactiveOverlays = [HMD.tabletID, HMD.tabletScreenID, HMD.homeButtonID, selectionBox];
-        for (var key in grabberTools) {
-            if (grabberTools.hasOwnProperty(key)) {
-                interactiveOverlays.push(key);
-            }
-        }
+    addHandleTranslateTool(handleTranslateXCone, "TRANSLATE_X", TRANSLATE_DIRECTION.X);
+    addHandleTranslateTool(handleTranslateXCylinder, "TRANSLATE_X", TRANSLATE_DIRECTION.X);
+    addHandleTranslateTool(handleTranslateYCone, "TRANSLATE_Y", TRANSLATE_DIRECTION.Y);
+    addHandleTranslateTool(handleTranslateYCylinder, "TRANSLATE_Y", TRANSLATE_DIRECTION.Y);
+    addHandleTranslateTool(handleTranslateZCone, "TRANSLATE_Z", TRANSLATE_DIRECTION.Z);
+    addHandleTranslateTool(handleTranslateZCylinder, "TRANSLATE_Z", TRANSLATE_DIRECTION.Z);
 
-        // Start with unknown mode, in case no tool can handle this.
-        activeTool = null;
+    addHandleRotateTool(handleRotatePitchRing, "ROTATE_PITCH", ROTATE_DIRECTION.PITCH);
+    addHandleRotateTool(handleRotateYawRing, "ROTATE_YAW", ROTATE_DIRECTION.YAW);
+    addHandleRotateTool(handleRotateRollRing, "ROTATE_ROLL", ROTATE_DIRECTION.ROLL);
 
-        var results = testRayIntersect(pickRay, interactiveOverlays);
-        if (results.intersects) {
-            var hitOverlayID = results.overlayID;
-            if ((hitOverlayID === HMD.tabletID) || (hitOverlayID === HMD.tabletScreenID) || (hitOverlayID === HMD.homeButtonID)) {
-                // EARLY EXIT-(mouse clicks on the tablet should override the edit affordances)
-                return false;
-            }
-
-            entityIconOverlayManager.setIconsSelectable(SelectionManager.selections, true);
-
-            var hitTool = grabberTools[ hitOverlayID ];
-            if (hitTool) {
-                activeTool = hitTool;
-                if (activeTool.onBegin) {
-                    activeTool.onBegin(event, pickRay, results);
-                } else {
-                    print("ERROR: entitySelectionTool.mousePressEvent - ActiveTool(" + activeTool.mode + ") missing onBegin");
-                }
-            } else {
-                print("ERROR: entitySelectionTool.mousePressEvent - Hit unexpected object, check interactiveOverlays");
-            }// End_if (hitTool)
-        }// End_If(results.intersects)
-
-        if (wantDebug) {
-            print("    DisplayMode: " + getMode());
-            print("=============== eST::MousePressEvent END =======================");
-        }
-
-        // If mode is known then we successfully handled this;
-        // otherwise, we're missing a tool.
-        return activeTool;
-    };
-
-    // FUNCTION: MOUSE MOVE EVENT
-    that.mouseMoveEvent = function(event) {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("=============== eST::MouseMoveEvent BEG =======================");
-        }
-        if (activeTool) {
-            if (wantDebug) {
-                print("    Trigger ActiveTool(" + activeTool.mode + ")'s onMove");
-            }
-            activeTool.onMove(event);
-
-            if (wantDebug) {
-                print("    Trigger SelectionManager::update");
-            }
-            SelectionManager._update();
-
-            if (wantDebug) {
-                print("=============== eST::MouseMoveEvent END =======================");
-            }
-            // EARLY EXIT--(Move handled via active tool)
-            return true;
-        }
-
-        // if no tool is active, then just look for handles to highlight...
-        var pickRay = generalComputePickRay(event.x, event.y);
-        var result = Overlays.findRayIntersection(pickRay);
-        var pickedColor;
-        var pickedAlpha;
-        var highlightNeeded = false;
-
-        if (result.intersects) {
-            switch (result.overlayID) {
-                case yawHandle:
-                case pitchHandle:
-                case rollHandle:
-                    pickedColor = handleColor;
-                    pickedAlpha = handleAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                case grabberMoveUp:
-                    pickedColor = handleColor;
-                    pickedAlpha = handleAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                case grabberLBN:
-                case grabberLBF:
-                case grabberRBN:
-                case grabberRBF:
-                case grabberLTN:
-                case grabberLTF:
-                case grabberRTN:
-                case grabberRTF:
-                    pickedColor = grabberColorCorner;
-                    pickedAlpha = grabberAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                case grabberTOP:
-                case grabberBOTTOM:
-                case grabberLEFT:
-                case grabberRIGHT:
-                case grabberNEAR:
-                case grabberFAR:
-                    pickedColor = grabberColorFace;
-                    pickedAlpha = grabberAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                case grabberEdgeTR:
-                case grabberEdgeTL:
-                case grabberEdgeTF:
-                case grabberEdgeTN:
-                case grabberEdgeBR:
-                case grabberEdgeBL:
-                case grabberEdgeBF:
-                case grabberEdgeBN:
-                case grabberEdgeNR:
-                case grabberEdgeNL:
-                case grabberEdgeFR:
-                case grabberEdgeFL:
-                case grabberSpotLightRadius:
-                case grabberSpotLightT:
-                case grabberSpotLightB:
-                case grabberSpotLightL:
-                case grabberSpotLightR:
-                case grabberPointLightT:
-                case grabberPointLightB:
-                case grabberPointLightR:
-                case grabberPointLightL:
-                case grabberPointLightN:
-                case grabberPointLightF:
-                    pickedColor = grabberColorEdge;
-                    pickedAlpha = grabberAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                case grabberCloner:
-                    pickedColor = grabberColorCloner;
-                    pickedAlpha = grabberAlpha;
-                    highlightNeeded = true;
-                    break;
-
-                default:
-                    if (previousHandle) {
-                        Overlays.editOverlay(previousHandle, {
-                            color: previousHandleColor,
-                            alpha: previousHandleAlpha
-                        });
-                        previousHandle = false;
-                    }
-                    break;
-            }
-
-            if (highlightNeeded) {
-                if (previousHandle) {
-                    Overlays.editOverlay(previousHandle, {
-                        color: previousHandleColor,
-                        alpha: previousHandleAlpha
-                    });
-                    previousHandle = false;
-                }
-                Overlays.editOverlay(result.overlayID, {
-                    color: highlightedHandleColor,
-                    alpha: highlightedHandleAlpha
-                });
-                previousHandle = result.overlayID;
-                previousHandleColor = pickedColor;
-                previousHandleAlpha = pickedAlpha;
-            }
-
-        } else {
-            if (previousHandle) {
-                Overlays.editOverlay(previousHandle, {
-                    color: previousHandleColor,
-                    alpha: previousHandleAlpha
-                });
-                previousHandle = false;
-            }
-        }
-
-        if (wantDebug) {
-            print("=============== eST::MouseMoveEvent END =======================");
-        }
-        return false;
-    };
-
-    // FUNCTION: MOUSE RELEASE EVENT
-    that.mouseReleaseEvent = function(event) {
-        var wantDebug = false;
-        if (wantDebug) {
-            print("=============== eST::MouseReleaseEvent BEG =======================");
-        }
-        var showHandles = false;
-        if (activeTool) {
-            if (activeTool.onEnd) {
-                if (wantDebug) {
-                    print("    Triggering ActiveTool(" + activeTool.mode + ")'s onEnd");
-                }
-                activeTool.onEnd(event);
-            } else if (wantDebug) {
-                print("    ActiveTool(" + activeTool.mode + ")'s missing onEnd");
-            }
-        }
-        
-        // hide our rotation overlays..., and show our handles
-        if (isActiveTool(yawHandle) || isActiveTool(pitchHandle) || isActiveTool(rollHandle)) {
-            if (wantDebug) {
-                print("    Triggering hide of RotateOverlays");
-            }
-            Overlays.editOverlay(rotateOverlayInner, {
-                visible: false
-            });
-            Overlays.editOverlay(rotateOverlayOuter, {
-                visible: false
-            });
-            Overlays.editOverlay(rotateOverlayCurrent, {
-                visible: false
-            });
-            
-        }
-
-        showHandles = activeTool; // base on prior tool value
-        activeTool = null;
-
-        // if something is selected, then reset the "original" properties for any potential next click+move operation
-        if (SelectionManager.hasSelection()) {
-            if (showHandles) {
-                if (wantDebug) {
-                    print("    Triggering that.select");
-                }
-                that.select(SelectionManager.selections[0], event);
-            }
-        }
-
-        if (wantDebug) {
-            print("=============== eST::MouseReleaseEvent END =======================");
-        }
-    };
-
-    // NOTE: mousePressEvent and mouseMoveEvent from the main script should call us., so we don't hook these:
-    //       Controller.mousePressEvent.connect(that.mousePressEvent);
-    //       Controller.mouseMoveEvent.connect(that.mouseMoveEvent);
-    Controller.mouseReleaseEvent.connect(that.mouseReleaseEvent);
+    addHandleStretchTool(handleStretchXSphere, "STRETCH_X", STRETCH_DIRECTION.X);
+    addHandleStretchTool(handleStretchYSphere, "STRETCH_Y", STRETCH_DIRECTION.Y);
+    addHandleStretchTool(handleStretchZSphere, "STRETCH_Z", STRETCH_DIRECTION.Z);
 
+    addHandleScaleTool(handleScaleLBNCube, "SCALE_LBN", SCALE_DIRECTION.LBN);
+    addHandleScaleTool(handleScaleRBNCube, "SCALE_RBN", SCALE_DIRECTION.RBN);
+    addHandleScaleTool(handleScaleLBFCube, "SCALE_LBF", SCALE_DIRECTION.LBF);
+    addHandleScaleTool(handleScaleRBFCube, "SCALE_RBF", SCALE_DIRECTION.RBF);
+    addHandleScaleTool(handleScaleLTNCube, "SCALE_LTN", SCALE_DIRECTION.LTN);
+    addHandleScaleTool(handleScaleRTNCube, "SCALE_RTN", SCALE_DIRECTION.RTN);
+    addHandleScaleTool(handleScaleLTFCube, "SCALE_LTF", SCALE_DIRECTION.LTF);
+    addHandleScaleTool(handleScaleRTFCube, "SCALE_RTF", SCALE_DIRECTION.RTF);
 
     return that;
-
 }());
diff --git a/scripts/system/libraries/pointersUtils.js b/scripts/system/libraries/pointersUtils.js
index 2af563f8d4..53959b91f8 100644
--- a/scripts/system/libraries/pointersUtils.js
+++ b/scripts/system/libraries/pointersUtils.js
@@ -30,7 +30,6 @@ Pointer = function(hudLayer, pickType, pointerData) {
         ignoreRayIntersection: true, // always ignore this
         drawInFront: !hudLayer, // Even when burried inside of something, show it.
         drawHUDLayer: hudLayer,
-        parentID: MyAvatar.SELF_ID
     };
     this.halfEnd = {
         type: "sphere",
@@ -53,7 +52,6 @@ Pointer = function(hudLayer, pickType, pointerData) {
         ignoreRayIntersection: true, // always ignore this
         drawInFront: !hudLayer, // Even when burried inside of something, show it.
         drawHUDLayer: hudLayer,
-        parentID: MyAvatar.SELF_ID
     };
     this.fullEnd = {
         type: "sphere",
@@ -76,7 +74,6 @@ Pointer = function(hudLayer, pickType, pointerData) {
         ignoreRayIntersection: true, // always ignore this
         drawInFront: !hudLayer, // Even when burried inside of something, show it.
         drawHUDLayer: hudLayer,
-        parentID: MyAvatar.SELF_ID
     };
 
     this.renderStates = [
diff --git a/scripts/system/marketplaces/marketplaces.js b/scripts/system/marketplaces/marketplaces.js
index edcd488a01..fd1275a251 100644
--- a/scripts/system/marketplaces/marketplaces.js
+++ b/scripts/system/marketplaces/marketplaces.js
@@ -163,6 +163,7 @@ var selectionDisplay = null; // for gridTool.js to ignore
         var certificateId = itemCertificateId || (Entities.getEntityProperties(currentEntityWithContextOverlay, ['certificateID']).certificateID);
         tablet.sendToQml({
             method: 'inspectionCertificate_setCertificateId',
+            entityId: currentEntityWithContextOverlay,
             certificateId: certificateId
         });
     }
@@ -583,6 +584,9 @@ var selectionDisplay = null; // for gridTool.js to ignore
             case 'inspectionCertificate_closeClicked':
                 tablet.gotoHomeScreen();
                 break;
+            case 'inspectionCertificate_requestOwnershipVerification':
+                ContextOverlay.requestOwnershipVerification(message.entity);
+                break;
             case 'inspectionCertificate_showInMarketplaceClicked':
                 tablet.gotoWebScreen(message.marketplaceUrl, MARKETPLACES_INJECT_SCRIPT_URL);
                 break;
diff --git a/tests/shared/src/BitVectorHelperTests.cpp b/tests/shared/src/BitVectorHelperTests.cpp
index 070e90eec7..618a86cad1 100644
--- a/tests/shared/src/BitVectorHelperTests.cpp
+++ b/tests/shared/src/BitVectorHelperTests.cpp
@@ -20,8 +20,6 @@
 
 QTEST_MAIN(BitVectorHelperTests)
 
-const int BITS_IN_BYTE = 8;
-
 void BitVectorHelperTests::sizeTest() {
     std::vector<int> sizes = {0, 6, 7, 8, 30, 31, 32, 33, 87, 88, 89, 90, 90, 91, 92, 93};
     for (auto& size : sizes) {
diff --git a/tests/shared/src/FileCacheTests.cpp b/tests/shared/src/FileCacheTests.cpp
index 3f1c5e1a01..b7c2103817 100644
--- a/tests/shared/src/FileCacheTests.cpp
+++ b/tests/shared/src/FileCacheTests.cpp
@@ -33,7 +33,7 @@ size_t FileCacheTests::getCacheDirectorySize() const {
     return result;
 }
 
-FileCachePointer makeFileCache(QString& location) {
+FileCachePointer makeFileCache(QString location) {
     auto result = std::make_shared<FileCache>(location.toStdString(), "tmp");
     result->initialize();
     result->setMaxSize(MAX_UNUSED_SIZE);
@@ -53,7 +53,7 @@ void FileCacheTests::testUnusedFiles() {
             auto file = cache->writeFile(TEST_DATA.data(), FileCache::Metadata(key, TEST_DATA.size()));
             QVERIFY(file->_locked);
             inUseFiles.push_back(file);
-            
+
             QThread::msleep(10);
         }
         QCOMPARE(cache->getNumCachedFiles(), (size_t)0);
@@ -100,13 +100,13 @@ void FileCacheTests::testUnusedFiles() {
             inUseFiles.push_back(file);
 
             if (i == 94) {
-                // Each access touches the file, so we need to sleep here to ensure that the the last 5 files 
+                // Each access touches the file, so we need to sleep here to ensure that the the last 5 files
                 // have later times for cache ejection priority, otherwise the test runs too fast to reliably
-                // differentiate 
+                // differentiate
                 QThread::msleep(1000);
             }
         }
-        
+
         QCOMPARE(cache->getNumCachedFiles(), (size_t)0);
         QCOMPARE(cache->getNumTotalFiles(), (size_t)10);
         inUseFiles.clear();
@@ -119,7 +119,7 @@ size_t FileCacheTests::getFreeSpace() const {
     return QStorageInfo(_testDir.path()).bytesFree();
 }
 
-// FIXME if something else is changing the amount of free space on the target drive concurrently with this test 
+// FIXME if something else is changing the amount of free space on the target drive concurrently with this test
 // running, then it may fail
 void FileCacheTests::testFreeSpacePreservation() {
     QCOMPARE(getCacheDirectorySize(), MAX_UNUSED_SIZE);
diff --git a/tests/shared/src/GeometryUtilTests.cpp b/tests/shared/src/GeometryUtilTests.cpp
index ccb3dc8a0e..eb9be4987f 100644
--- a/tests/shared/src/GeometryUtilTests.cpp
+++ b/tests/shared/src/GeometryUtilTests.cpp
@@ -31,20 +31,20 @@ static void testSphereVsCone(const glm::vec3 coneNormal, const glm::vec3 coneBiN
     glm::vec3 coneCenter = glm::vec3(0.0f, 0.0f, 0.0f);
     glm::vec3 sphereCenter = coneCenter + coneEdge * sphereDistance;
     float result = coneSphereAngle(coneCenter, u, sphereCenter, sphereRadius);
-    QCOMPARE(isnan(result), false);
+    QCOMPARE(glm::isnan(result), false);
     QCOMPARE(result < coneAngle, true);
 
     // push sphere outward from edge so it is tangent to the cone.
     glm::vec3 sphereOffset = glm::angleAxis(PI / 2.0f, w) * coneEdge;
     sphereCenter += sphereOffset * sphereRadius;
     result = coneSphereAngle(coneCenter, u, sphereCenter, sphereRadius);
-    QCOMPARE(isnan(result), false);
+    QCOMPARE(glm::isnan(result), false);
     QCOMPARE_WITH_ABS_ERROR(result, coneAngle, 0.001f);
 
     // push sphere outward from edge a bit further, so it is outside of the cone.
     sphereCenter += 0.1f * sphereOffset;
     result = coneSphereAngle(coneCenter, u, sphereCenter, sphereRadius);
-    QCOMPARE(isnan(result), false);
+    QCOMPARE(glm::isnan(result), false);
     QCOMPARE(result > coneAngle, true);
 }
 
diff --git a/tests/shared/src/PathUtilsTests.cpp b/tests/shared/src/PathUtilsTests.cpp
index 1c445908f7..3aec4fa5f9 100644
--- a/tests/shared/src/PathUtilsTests.cpp
+++ b/tests/shared/src/PathUtilsTests.cpp
@@ -16,12 +16,8 @@
 QTEST_MAIN(PathUtilsTests)
 
 void PathUtilsTests::testPathUtils() {
-    QString result = PathUtils::qmlBasePath();
-#if DEV_BUILD
-    QVERIFY(result.startsWith("file:///"));
-#else
+    QString result = PathUtils::qmlBaseUrl();
     QVERIFY(result.startsWith("qrc:///"));
-#endif
     QVERIFY(result.endsWith("/"));
 }