Merge pull request #12609 from Atlante45/new-master

Merge RC65 back into master

interface/resources/qml/hifi/commerce/checkout/Checkout.qml

@@ -147,8 +147,7 @@ Rectangle {
         } else if (root.itemHref.indexOf('.json') > -1) {
             root.itemType = "entity"; // "wearable" type handled later
         } else {
-            console.log("WARNING - Item type is UNKNOWN!");
+            root.itemType = "unknown";
-            root.itemType = "entity";
         }
     }
 

interface/src/Application.cpp

@@ -6636,17 +6636,17 @@ void Application::addAssetToWorld(QString path, QString zipFile, bool isZip, boo
 
     addAssetToWorldInfo(filename, "Adding " + mapping.mid(1) + " to the Asset Server.");
 
-    addAssetToWorldWithNewMapping(path, mapping, 0);
+    addAssetToWorldWithNewMapping(path, mapping, 0, isZip, isBlocks);
 }
 
-void Application::addAssetToWorldWithNewMapping(QString filePath, QString mapping, int copy) {
+void Application::addAssetToWorldWithNewMapping(QString filePath, QString mapping, int copy, bool isZip, bool isBlocks) {
     auto request = DependencyManager::get<AssetClient>()->createGetMappingRequest(mapping);
 
     QObject::connect(request, &GetMappingRequest::finished, this, [=](GetMappingRequest* request) mutable {
         const int MAX_COPY_COUNT = 100;  // Limit number of duplicate assets; recursion guard.
         auto result = request->getError();
         if (result == GetMappingRequest::NotFound) {
-            addAssetToWorldUpload(filePath, mapping);
+            addAssetToWorldUpload(filePath, mapping, isZip, isBlocks);
         } else if (result != GetMappingRequest::NoError) {
             QString errorInfo = "Could not map asset name: "
                 + mapping.left(mapping.length() - QString::number(copy).length() - 1);
@@ -6658,7 +6658,7 @@ void Application::addAssetToWorldWithNewMapping(QString filePath, QString mappin
             }
             copy++;
             mapping = mapping.insert(mapping.lastIndexOf("."), "-" + QString::number(copy));
-            addAssetToWorldWithNewMapping(filePath, mapping, copy);
+            addAssetToWorldWithNewMapping(filePath, mapping, copy, isZip, isBlocks);
         } else {
             QString errorInfo = "Too many copies of asset name: "
                 + mapping.left(mapping.length() - QString::number(copy).length() - 1);
@@ -6671,7 +6671,7 @@ void Application::addAssetToWorldWithNewMapping(QString filePath, QString mappin
     request->start();
 }
 
-void Application::addAssetToWorldUpload(QString filePath, QString mapping) {
+void Application::addAssetToWorldUpload(QString filePath, QString mapping, bool isZip, bool isBlocks) {
     qInfo(interfaceapp) << "Uploading" << filePath << "to Asset Server as" << mapping;
     auto upload = DependencyManager::get<AssetClient>()->createUpload(filePath);
     QObject::connect(upload, &AssetUpload::finished, this, [=](AssetUpload* upload, const QString& hash) mutable {
@@ -6680,7 +6680,7 @@ void Application::addAssetToWorldUpload(QString filePath, QString mapping) {
             qWarning(interfaceapp) << "Error downloading model: " + errorInfo;
             addAssetToWorldError(filenameFromPath(filePath), errorInfo);
         } else {
-            addAssetToWorldSetMapping(filePath, mapping, hash);
+            addAssetToWorldSetMapping(filePath, mapping, hash, isZip, isBlocks);
         }
 
         // Remove temporary directory created by Clara.io market place download.
@@ -6697,7 +6697,7 @@ void Application::addAssetToWorldUpload(QString filePath, QString mapping) {
     upload->start();
 }
 
-void Application::addAssetToWorldSetMapping(QString filePath, QString mapping, QString hash) {
+void Application::addAssetToWorldSetMapping(QString filePath, QString mapping, QString hash, bool isZip, bool isBlocks) {
     auto request = DependencyManager::get<AssetClient>()->createSetMappingRequest(mapping, hash);
     connect(request, &SetMappingRequest::finished, this, [=](SetMappingRequest* request) mutable {
         if (request->getError() != SetMappingRequest::NoError) {
@@ -6705,9 +6705,10 @@ void Application::addAssetToWorldSetMapping(QString filePath, QString mapping, Q
             qWarning(interfaceapp) << "Error downloading model: " + errorInfo;
             addAssetToWorldError(filenameFromPath(filePath), errorInfo);
         } else {
-            // to prevent files that aren't models from being loaded into world automatically
+            // to prevent files that aren't models or texture files from being loaded into world automatically
-            if (filePath.toLower().endsWith(OBJ_EXTENSION) || filePath.toLower().endsWith(FBX_EXTENSION) || 
+            if ((filePath.toLower().endsWith(OBJ_EXTENSION) || filePath.toLower().endsWith(FBX_EXTENSION)) || 
-                filePath.toLower().endsWith(JPG_EXTENSION) || filePath.toLower().endsWith(PNG_EXTENSION)) {
+                ((filePath.toLower().endsWith(JPG_EXTENSION) || filePath.toLower().endsWith(PNG_EXTENSION)) &&
+                ((!isBlocks) && (!isZip)))) {
                 addAssetToWorldAddEntity(filePath, mapping);
             } else {
                 qCDebug(interfaceapp) << "Zipped contents are not supported entity files";

interface/src/Application.h

@@ -321,11 +321,11 @@ public slots:
     // FIXME: Move addAssetToWorld* methods to own class?
     void addAssetToWorldFromURL(QString url);
     void addAssetToWorldFromURLRequestFinished();
-    void addAssetToWorld(QString filePath, QString zipFile, bool isZip, bool isBlocks);
+    void addAssetToWorld(QString filePath, QString zipFile, bool isZip = false, bool isBlocks = false);
     void addAssetToWorldUnzipFailure(QString filePath);
-    void addAssetToWorldWithNewMapping(QString filePath, QString mapping, int copy);
+    void addAssetToWorldWithNewMapping(QString filePath, QString mapping, int copy, bool isZip = false, bool isBlocks = false);
-    void addAssetToWorldUpload(QString filePath, QString mapping);
+    void addAssetToWorldUpload(QString filePath, QString mapping, bool isZip = false, bool isBlocks = false);
-    void addAssetToWorldSetMapping(QString filePath, QString mapping, QString hash);
+    void addAssetToWorldSetMapping(QString filePath, QString mapping, QString hash, bool isZip = false, bool isBlocks = false);
     void addAssetToWorldAddEntity(QString filePath, QString mapping);
 
     void handleUnzip(QString sourceFile, QStringList destinationFile, bool autoAdd, bool isZip, bool isBlocks);

interface/src/commerce/Ledger.cpp

@@ -80,9 +80,13 @@ void Ledger::signedSend(const QString& propertyName, const QByteArray& text, con
 
 void Ledger::keysQuery(const QString& endpoint, const QString& success, const QString& fail, QJsonObject& requestParams) {
     auto wallet = DependencyManager::get<Wallet>();
-    requestParams["public_keys"] = QJsonArray::fromStringList(wallet->listPublicKeys());
+    QStringList cachedPublicKeys = wallet->listPublicKeys();
-
+    if (!cachedPublicKeys.isEmpty()) {
-    send(endpoint, success, fail, QNetworkAccessManager::PostOperation, AccountManagerAuth::Required, requestParams);
+        requestParams["public_keys"] = QJsonArray::fromStringList(cachedPublicKeys);
+        send(endpoint, success, fail, QNetworkAccessManager::PostOperation, AccountManagerAuth::Required, requestParams);
+    } else {
+        qDebug(commerce) << "User attempted to call keysQuery, but cachedPublicKeys was empty!";
+    }
 }
 
 void Ledger::keysQuery(const QString& endpoint, const QString& success, const QString& fail) {
@@ -296,14 +300,18 @@ void Ledger::updateLocation(const QString& asset_id, const QString location, con
         emit walletScriptingInterface->walletNotSetup();
         qDebug(commerce) << "User attempted to update the location of a certificate, but their wallet wasn't ready. Status:" << walletStatus;
     } else {
-        QStringList keys = wallet->listPublicKeys();
+        QStringList cachedPublicKeys = wallet->listPublicKeys();
-        QString key = keys[0];
+        if (!cachedPublicKeys.isEmpty()) {
-        QJsonObject transaction;
+            QString key = cachedPublicKeys[0];
-        transaction["certificate_id"] = asset_id;
+            QJsonObject transaction;
-        transaction["place_name"] = location;
+            transaction["certificate_id"] = asset_id;
-        QJsonDocument transactionDoc{ transaction };
+            transaction["place_name"] = location;
-        auto transactionString = transactionDoc.toJson(QJsonDocument::Compact);
+            QJsonDocument transactionDoc{ transaction };
-        signedSend("transaction", transactionString, key, "location", "updateLocationSuccess", "updateLocationFailure", controlledFailure);
+            auto transactionString = transactionDoc.toJson(QJsonDocument::Compact);
+            signedSend("transaction", transactionString, key, "location", "updateLocationSuccess", "updateLocationFailure", controlledFailure);
+        } else {
+            qDebug(commerce) << "User attempted to update the location of a certificate, but cachedPublicKeys was empty!";
+        }
     }
 }
 
@@ -359,7 +367,12 @@ void Ledger::alreadyOwned(const QString& marketplaceId) {
     auto wallet = DependencyManager::get<Wallet>();
     QString endpoint = "already_owned";
     QJsonObject request;
-    request["public_keys"] = QJsonArray::fromStringList(wallet->listPublicKeys());
+    QStringList cachedPublicKeys = wallet->listPublicKeys();
-    request["marketplace_item_id"] = marketplaceId;
+    if (!cachedPublicKeys.isEmpty()) {
-    send(endpoint, "alreadyOwnedSuccess", "alreadyOwnedFailure", QNetworkAccessManager::PutOperation, AccountManagerAuth::Required, request);
+        request["public_keys"] = QJsonArray::fromStringList(wallet->listPublicKeys());
+        request["marketplace_item_id"] = marketplaceId;
+        send(endpoint, "alreadyOwnedSuccess", "alreadyOwnedFailure", QNetworkAccessManager::PutOperation, AccountManagerAuth::Required, request);
+    } else {
+        qDebug(commerce) << "User attempted to use the alreadyOwned endpoint, but cachedPublicKeys was empty!";
+    }
 }

libraries/script-engine/src/FileScriptingInterface.cpp

@@ -68,6 +68,10 @@ void FileScriptingInterface::runUnzip(QString path, QUrl url, bool autoAdd, bool
     if (path.contains("vr.google.com/downloads")) {
         isZip = true;
     }
+    if (!hasModel(fileList)) {
+        isZip = false;
+    }
+
     emit unzipResult(path, fileList, autoAdd, isZip, isBlocks);
 
 }
@@ -107,6 +111,15 @@ bool FileScriptingInterface::isTempDir(QString tempDir) {
     return (testContainer == tempContainer);
 }
 
+bool FileScriptingInterface::hasModel(QStringList fileList) {
+    for (int i = 0; i < fileList.size(); i++) {
+        if (fileList.at(i).toLower().contains(".fbx") || fileList.at(i).toLower().contains(".obj")) {
+            return true;
+        }
+    }
+    return false;
+}
+
 QString FileScriptingInterface::getTempDir() {
     QTemporaryDir dir;
     dir.setAutoRemove(false);

libraries/script-engine/src/FileScriptingInterface.h

@@ -32,6 +32,7 @@ signals:
 
 private:
     bool isTempDir(QString tempDir);
+    bool hasModel(QStringList fileList);
     QStringList unzipFile(QString path, QString tempDir);
     void recursiveFileScan(QFileInfo file, QString* dirName);
     void downloadZip(QString path, const QString link);

scripts/system/libraries/entitySelectionTool.js

@@ -272,17 +272,19 @@ SelectionDisplay = (function() {
     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_ALL_MINIMUM_DIMENSION = 0.01;
+    var STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE = 6;
     var STRETCH_PANEL_WIDTH = 0.01;
 
     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 AVATAR_COLLISIONS_OPTION = "Enable Avatar Collisions";
+
     var TRANSLATE_DIRECTION = {
         X : 0,
         Y : 1,
@@ -336,6 +338,8 @@ SelectionDisplay = (function() {
 
     var ctrlPressed = false;
 
+    var handleStretchCollisionOverride = false;
+
     var handlePropertiesTranslateArrowCones = {
         shape: "Cone",
         solid: true,
@@ -458,12 +462,12 @@ SelectionDisplay = (function() {
         borderSize: 1.4
     };
     var handleScaleLBNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // (-x, -y, -z)
-    var handleScaleRBNCube = 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 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 handleScaleRTNCube = Overlays.addOverlay("cube", handlePropertiesScaleCubes); // ( x,  y, -z)
-    var handleScaleLTFCube = 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 handlePropertiesScaleEdge = {
@@ -597,6 +601,11 @@ SelectionDisplay = (function() {
     var activeTool = null;
     var handleTools = {};
 
+    that.shutdown = function() {
+        that.restoreAvatarCollisionsFromStretch();
+    }
+    Script.scriptEnding.connect(that.shutdown);
+
     // We get mouseMoveEvents from the handControllers, via handControllerPointer.
     // But we dont' get mousePressEvents.
     that.triggerMapping = Controller.newMapping(Script.resolvePath('') + '-click');
@@ -1021,7 +1030,6 @@ SelectionDisplay = (function() {
             return;
         }
 
-
         if (SelectionManager.hasSelection()) {
             var position = SelectionManager.worldPosition;
             var rotation = spaceMode === SPACE_LOCAL ? SelectionManager.localRotation : SelectionManager.worldRotation;
@@ -1147,14 +1155,14 @@ SelectionDisplay = (function() {
                 rotation: scaleCubeRotation,
                 dimensions: scaleCubeDimensions
             });
-            var scaleRBNCubePosition = { x:-scaleCubeOffsetX, y:-scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            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 };
+            var scaleLBFCubePosition = { x:-scaleCubeOffsetX, y:-scaleCubeOffsetY, z:scaleCubeOffsetZ };
             scaleLBFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLBFCubePosition));
             Overlays.editOverlay(handleScaleLBFCube, { 
                 position: scaleLBFCubePosition, 
@@ -1175,14 +1183,14 @@ SelectionDisplay = (function() {
                 rotation: scaleCubeRotation,
                 dimensions: scaleCubeDimensions
             });
-            var scaleRTNCubePosition = { x:-scaleCubeOffsetX, y:scaleCubeOffsetY, z:scaleCubeOffsetZ };
+            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 };
+            var scaleLTFCubePosition = { x:-scaleCubeOffsetX, y:scaleCubeOffsetY, z:scaleCubeOffsetZ };
             scaleLTFCubePosition = Vec3.sum(position, Vec3.multiplyQbyV(rotation, scaleLTFCubePosition));
             Overlays.editOverlay(handleScaleLTFCube, { 
                 position: scaleLTFCubePosition, 
@@ -1236,9 +1244,11 @@ SelectionDisplay = (function() {
             });
 
             // UPDATE STRETCH HIGHLIGHT PANELS
-            var scaleLTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleLTFCubePosition);
             var scaleRBFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRBFCubePosition);
-            var stretchPanelXDimensions = Vec3.subtract(scaleLTFCubePositionRotated, scaleRBFCubePositionRotated);
+            var scaleRTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTFCubePosition);
+            var scaleLTNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleLTNCubePosition);
+            var scaleRTNCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTNCubePosition);
+            var stretchPanelXDimensions = Vec3.subtract(scaleRTNCubePositionRotated, scaleRBFCubePositionRotated);
             var tempY = Math.abs(stretchPanelXDimensions.y);
             stretchPanelXDimensions.x = STRETCH_PANEL_WIDTH;
             stretchPanelXDimensions.y = Math.abs(stretchPanelXDimensions.z);
@@ -1249,8 +1259,6 @@ SelectionDisplay = (function() {
                 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);
@@ -1262,9 +1270,7 @@ SelectionDisplay = (function() {
                 rotation: rotationY,
                 dimensions: stretchPanelYDimensions
             });
-            var scaleRTFCubePositionRotated = Vec3.multiplyQbyV(rotationInverse, scaleRTFCubePosition);
+            var stretchPanelZDimensions = Vec3.subtract(scaleLTNCubePositionRotated, scaleRBFCubePositionRotated);
-            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;
@@ -1743,6 +1749,13 @@ SelectionDisplay = (function() {
         };
     };
 
+    that.restoreAvatarCollisionsFromStretch = function() {
+        if (handleStretchCollisionOverride) {
+            Menu.setIsOptionChecked(AVATAR_COLLISIONS_OPTION, true);
+            handleStretchCollisionOverride = false;
+        }
+    }
+
     // TOOL DEFINITION: HANDLE STRETCH TOOL   
     function makeStretchTool(stretchMode, directionEnum, directionVec, pivot, offset, stretchPanel, scaleHandle) {
         var directionFor3DStretch = directionVec;
@@ -1945,6 +1958,10 @@ SelectionDisplay = (function() {
             if (scaleHandle != null) {
                 Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE_SELECTED });
             }
+            if (Menu.isOptionChecked(AVATAR_COLLISIONS_OPTION)) {
+                Menu.setIsOptionChecked(AVATAR_COLLISIONS_OPTION, false);
+                handleStretchCollisionOverride = true;
+            }
         };
 
         var onEnd = function(event, reason) {    
@@ -1954,11 +1971,12 @@ SelectionDisplay = (function() {
             if (scaleHandle != null) {
                 Overlays.editOverlay(scaleHandle, { color: COLOR_SCALE_CUBE });
             }
+            that.restoreAvatarCollisionsFromStretch();
             pushCommandForSelections();
         };
 
         var onMove = function(event) {
-            var proportional = (spaceMode === SPACE_WORLD) || event.isShifted || directionEnum === STRETCH_DIRECTION.ALL;
+            var proportional = (spaceMode === SPACE_WORLD) || directionEnum === STRETCH_DIRECTION.ALL;
             
             var position, dimensions, rotation;
             if (spaceMode === SPACE_LOCAL) {
@@ -1999,10 +2017,10 @@ SelectionDisplay = (function() {
             vector = grid.snapToSpacing(vector);
     
             var changeInDimensions = Vec3.multiply(NEGATE_VECTOR, vec3Mult(localSigns, vector));
-            if (directionEnum === STRETCH_DIRECTION.ALL) {
+            if (directionEnum === STRETCH_DIRECTION.ALL) {	
-                var toCameraDistance = getDistanceToCamera(position);
+                var toCameraDistance = getDistanceToCamera(position);	
-                var dimensionsMultiple = toCameraDistance * STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE;
+                var dimensionsMultiple = toCameraDistance * STRETCH_DIRECTION_ALL_CAMERA_DISTANCE_MULTIPLE;	
-                changeInDimensions = Vec3.multiply(changeInDimensions, dimensionsMultiple);
+                changeInDimensions = Vec3.multiply(changeInDimensions, dimensionsMultiple);	
             }
 
             var newDimensions;
@@ -2027,9 +2045,11 @@ SelectionDisplay = (function() {
                 newDimensions = Vec3.sum(initialDimensions, changeInDimensions);
             }
     
-            newDimensions.x = Math.max(newDimensions.x, STRETCH_MINIMUM_DIMENSION);
+            var minimumDimension = directionEnum === STRETCH_DIRECTION.ALL ? STRETCH_ALL_MINIMUM_DIMENSION : 
-            newDimensions.y = Math.max(newDimensions.y, STRETCH_MINIMUM_DIMENSION);
+                                                                             STRETCH_MINIMUM_DIMENSION;
-            newDimensions.z = Math.max(newDimensions.z, STRETCH_MINIMUM_DIMENSION);
+            newDimensions.x = Math.max(newDimensions.x, minimumDimension);
+            newDimensions.y = Math.max(newDimensions.y, minimumDimension);
+            newDimensions.z = Math.max(newDimensions.z, minimumDimension);
     
             var changeInPosition = Vec3.multiplyQbyV(rotation, vec3Mult(localDeltaPivot, changeInDimensions));
             if (directionEnum === STRETCH_DIRECTION.ALL) {
@@ -2089,10 +2109,10 @@ SelectionDisplay = (function() {
             directionVector = { x:1, y:1, z:1 };
             selectedHandle = handleScaleLBNCube;
         } else if (directionEnum === SCALE_DIRECTION.RBN) {
-            directionVector = { x:1, y:1, z:-1 };
+            directionVector = { x:-1, y:1, z:1 };
             selectedHandle = handleScaleRBNCube;
         } else if (directionEnum === SCALE_DIRECTION.LBF) {
-            directionVector = { x:-1, y:1, z:1 };
+            directionVector = { x:1, y:1, z:-1 };
             selectedHandle = handleScaleLBFCube;
         } else if (directionEnum === SCALE_DIRECTION.RBF) {
             directionVector = { x:-1, y:1, z:-1 };
@@ -2101,10 +2121,10 @@ SelectionDisplay = (function() {
             directionVector = { x:1, y:-1, z:1 };
             selectedHandle = handleScaleLTNCube;
         } else if (directionEnum === SCALE_DIRECTION.RTN) {
-            directionVector = { x:1, y:-1, z:-1 };
+            directionVector = { x:-1, y:-1, z:1 };
             selectedHandle = handleScaleRTNCube;
         } else if (directionEnum === SCALE_DIRECTION.LTF) {
-            directionVector = { x:-1, y:-1, z:1 };
+            directionVector = { x:1, y:-1, z:-1 };
             selectedHandle = handleScaleLTFCube;
         } else if (directionEnum === SCALE_DIRECTION.RTF) {
             directionVector = { x:-1, y:-1, z:-1 };