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

examples/defaultScripts.js

@@ -18,4 +18,3 @@ Script.load("lobby.js");
 Script.load("notifications.js");
 Script.load("look.js");
 Script.load("users.js");
-Script.load("utilities/LODWarning.js");

examples/example/entities/makeHouses.js

@@ -0,0 +1,157 @@
+//
+// makeHouses.js
+//
+//
+// Created by Stojce Slavkovski on March 14, 2015
+// Copyright 2015 High Fidelity, Inc.
+//
+// This sample script that creates house entities based on parameters.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+(function () {
+
+    /** options **/
+    var numHouses = 100;
+    var xRange = 300;
+    var yRange = 300;
+
+    var sizeOfTheHouse = {
+        x: 10,
+        y: 15,
+        z: 10
+    };
+    
+    var randomizeModels = false;
+    /**/
+ 
+    var modelUrlPrefix = "http://public.highfidelity.io/load_testing/3-Buildings-2-SanFranciscoHouse-";
+    var modelurlExt = ".fbx";
+    var modelVariations = 100;
+
+    var houses = [];
+
+    function addHouseAt(position, rotation) {
+        // get house model
+        var modelNumber = randomizeModels ?
+            1 + Math.floor(Math.random() * (modelVariations - 1)) :
+            (houses.length + 1) % modelVariations;
+        
+        if (modelNumber == 0) {
+            modelNumber = modelVariations;
+        }
+        
+        var modelUrl = modelUrlPrefix + (modelNumber + "") + modelurlExt;
+        print("Model ID:" + modelNumber);
+        print("Model URL:" + modelUrl);
+        
+        var properties = {
+            type: "Model",
+            position: position,
+            rotation: rotation,
+            dimensions: sizeOfTheHouse,
+            modelURL: modelUrl
+        };
+
+        return Entities.addEntity(properties);
+    }
+
+    // calculate initial position
+    var posX = MyAvatar.position.x - (xRange / 2);
+    var measures = calculateParcels(numHouses, xRange, yRange);
+    var dd = 0;
+
+    // avatar facing rotation
+    var rotEven = Quat.fromPitchYawRollDegrees(0, 270.0 + MyAvatar.bodyYaw, 0.0);
+
+    // avatar opposite rotation
+    var rotOdd = Quat.fromPitchYawRollDegrees(0, 90.0 + MyAvatar.bodyYaw, 0.0);
+    var housePos = Vec3.sum(MyAvatar.position, Quat.getFront(Camera.getOrientation()));
+
+    for (var j = 0; j < measures.rows; j++) {
+
+        var posX1 = 0 - (xRange / 2);
+        dd += measures.parcelLength;
+
+        for (var i = 0; i < measures.cols; i++) {
+
+            // skip reminder of houses
+            if (houses.length > numHouses) {
+                break;
+            }
+
+            var posShift = {
+                x: posX1,
+                y: 0,
+                z: dd
+            };
+
+            print("House nr.:" + (houses.length + 1));
+            houses.push(
+                addHouseAt(Vec3.sum(housePos, posShift), (j % 2 == 0) ? rotEven : rotOdd)
+            );
+            posX1 += measures.parcelWidth;
+        }
+    }
+
+    // calculate rows and columns in area, and dimension of single parcel
+    function calculateParcels(items, areaWidth, areaLength) {
+
+        var idealSize = Math.min(Math.sqrt(areaWidth * areaLength / items), areaWidth, areaLength);
+
+        var baseWidth = Math.min(Math.floor(areaWidth / idealSize), items);
+        var baseLength = Math.min(Math.floor(areaLength / idealSize), items);
+
+        var sirRows = baseWidth;
+        var sirCols = Math.ceil(items / sirRows);
+        var sirW = areaWidth / sirRows;
+        var sirL = areaLength / sirCols;
+
+        var visCols = baseLength;
+        var visRows = Math.ceil(items / visCols);
+        var visW = areaWidth / visRows;
+        var visL = areaLength / visCols;
+
+        var rows = 0;
+        var cols = 0;
+        var parcelWidth = 0;
+        var parcelLength = 0;
+
+        if (Math.min(sirW, sirL) > Math.min(visW, visL)) {
+            rows = sirRows;
+            cols = sirCols;
+            parcelWidth = sirW;
+            parcelLength = sirL;
+        } else {
+            rows = visRows;
+            cols = visCols;
+            parcelWidth = visW;
+            parcelLength = visL;
+        }
+
+        print("rows:" + rows);
+        print("cols:" + cols);
+        print("parcelWidth:" + parcelWidth);
+        print("parcelLength:" + parcelLength);
+
+        return {
+            rows: rows,
+            cols: cols,
+            parcelWidth: parcelWidth,
+            parcelLength: parcelLength
+        };
+    }
+
+    function cleanup() {
+        while (houses.length > 0) {
+            if (!houses[0].isKnownID) {
+                houses[0] = Entities.identifyEntity(houses[0]);
+            }
+            Entities.deleteEntity(houses.shift());
+        }
+    }
+
+    Script.scriptEnding.connect(cleanup);
+})();

examples/hmdDefaults.js

@@ -13,5 +13,4 @@ Script.load("progress.js");
 Script.load("lobby.js");
 Script.load("notifications.js");
 Script.load("controllers/oculus/goTo.js");
-Script.load("utilities/LODWarning.js");
 //Script.load("scripts.js");  // Not created yet

examples/notifications.js

@@ -43,7 +43,6 @@
 //  after that we will send it to createNotification(text).
 //  If the message is 42 chars or less you should bypass wordWrap() and call createNotification() directly.
 
-
 //  To add a keypress driven notification:
 //
 //  1. Add a key to the keyPressEvent(key).
@@ -85,16 +84,19 @@ var PLAY_NOTIFICATION_SOUNDS_MENU_ITEM = "Play Notification Sounds";
 var NOTIFICATION_MENU_ITEM_POST = " Notifications";
 var PLAY_NOTIFICATION_SOUNDS_SETTING = "play_notification_sounds";
 var PLAY_NOTIFICATION_SOUNDS_TYPE_SETTING_PRE = "play_notification_sounds_type_";
+var lodTextID = false;
 
 var NotificationType = {
     UNKNOWN: 0,
     MUTE_TOGGLE: 1,
     SNAPSHOT: 2,
     WINDOW_RESIZE: 3,
+    LOD_WARNING: 4,
     properties: [
         { text: "Mute Toggle" },
         { text: "Snapshot" },
-        { text: "Window Resize" }
+        { text: "Window Resize" },
+        { text: "Level of Detail" }
     ],
     getTypeFromMenuItem: function(menuItemName) {
         if (menuItemName.substr(menuItemName.length - NOTIFICATION_MENU_ITEM_POST.length) !== NOTIFICATION_MENU_ITEM_POST) {
@@ -143,6 +145,10 @@ function createArrays(notice, button, createTime, height, myAlpha) {
 
 //  This handles the final dismissal of a notification after fading
 function dismiss(firstNoteOut, firstButOut, firstOut) {
+    if (firstNoteOut == lodTextID) {
+        lodTextID = false;
+    }
+
     Overlays.deleteOverlay(firstNoteOut);
     Overlays.deleteOverlay(firstButOut);
     notifications.splice(firstOut, 1);
@@ -261,7 +267,8 @@ function notify(notice, button, height) {
             height: noticeHeight
         });
     } else {
-        notifications.push((Overlays.addOverlay("text", notice)));
+        var notificationText = Overlays.addOverlay("text", notice);
+        notifications.push((notificationText));
         buttons.push((Overlays.addOverlay("image", button)));
     }
 
@@ -272,6 +279,7 @@ function notify(notice, button, height) {
     last = notifications.length - 1;
     createArrays(notifications[last], buttons[last], times[last], heights[last], myAlpha[last]);
     fadeIn(notifications[last], buttons[last]);
+    return notificationText;
 }
 
 //  This function creates and sizes the overlays
@@ -331,11 +339,15 @@ function createNotification(text, notificationType) {
         randomSounds.playRandom();
     }
 
-    notify(noticeProperties, buttonProperties, height);
+    return notify(noticeProperties, buttonProperties, height);
 }
 
 function deleteNotification(index) {
-    Overlays.deleteOverlay(notifications[index]);
+    var notificationTextID = notifications[index];
+    if (notificationTextID == lodTextID) {
+        lodTextID = false;
+    }
+    Overlays.deleteOverlay(notificationTextID);
     Overlays.deleteOverlay(buttons[index]);
     notifications.splice(index, 1);
     buttons.splice(index, 1);
@@ -575,6 +587,20 @@ function menuItemEvent(menuItem) {
     }
 }
 
+LODManager.LODDecreased.connect(function() {
+    var warningText = "\n"
+            + "Due to the complexity of the content, the \n"
+            + "level of detail has been decreased."
+            + "You can now see: \n" 
+            + LODManager.getLODFeedbackText();
+
+    if (lodTextID == false) {
+        lodTextID = createNotification(warningText, NotificationType.LOD_WARNING);
+    } else {
+        Overlays.editOverlay(lodTextID, { text: warningText });
+    }
+});
+
 AudioDevice.muteToggled.connect(onMuteStateChanged);
 Controller.keyPressEvent.connect(keyPressEvent);
 Controller.mousePressEvent.connect(mousePressEvent);

examples/utilities/LODWarning.js

@@ -1,115 +0,0 @@
-//  LODWarning.js
-//  examples
-//
-//  Created by Brad Hefta-Gaub on 3/17/15.
-//  Copyright 2015 High Fidelity, Inc.
-//
-//  This script will display a warning when the LOD is adjusted to do scene complexity.
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-var DISPLAY_WARNING_FOR = 3; // in seconds
-var DISTANCE_FROM_CAMERA = 2;
-var SHOW_LOD_UP_MESSAGE = false; // By default we only display the LOD message when reducing LOD
-
-
-var warningIsVisible = false; // initially the warning is hidden
-var warningShownAt = 0;
-var billboardPosition = Vec3.sum(Camera.getPosition(), 
-                                    Vec3.multiply(DISTANCE_FROM_CAMERA, Quat.getFront(Camera.getOrientation())));
-                                    
-var warningOverlay = Overlays.addOverlay("text3d", {
-                    position: billboardPosition,
-                    dimensions: { x: 2, y: 1.25 },
-                    width: 2,
-                    height: 1.25,
-                    backgroundColor: { red: 0, green: 0, blue: 0 },
-                    color: { red: 255, green: 255, blue: 255},
-                    topMargin: 0.1,
-                    leftMargin: 0.1,
-                    lineHeight: 0.07,
-                    text: "",
-                    alpha: 0.5,
-                    backgroundAlpha: 0.7,
-                    isFacingAvatar: true,
-                    visible: warningIsVisible,
-                });
-
-// Handle moving the billboard to remain in front of the camera
-var billboardNeedsMoving = false;
-Script.update.connect(function() {
-
-    if (warningIsVisible) {
-        var bestBillboardPosition = Vec3.sum(Camera.getPosition(), 
-                                                Vec3.multiply(DISTANCE_FROM_CAMERA, Quat.getFront(Camera.getOrientation())));
-    
-        var MAX_DISTANCE = 0.5;
-        var CLOSE_ENOUGH = 0.01;
-        if (!billboardNeedsMoving && Vec3.distance(bestBillboardPosition, billboardPosition) > MAX_DISTANCE) {
-            billboardNeedsMoving = true;
-        }
-
-        if (billboardNeedsMoving && Vec3.distance(bestBillboardPosition, billboardPosition) <= CLOSE_ENOUGH) {
-            billboardNeedsMoving = false;
-        }
-    
-        if (billboardNeedsMoving) {
-            // slurp the billboard to the best location
-            moveVector = Vec3.multiply(0.05, Vec3.subtract(bestBillboardPosition, billboardPosition));
-            billboardPosition = Vec3.sum(billboardPosition, moveVector);
-            Overlays.editOverlay(warningOverlay, { position: billboardPosition });
-        }
-
-        var now = new Date();
-        var sinceWarningShown = now - warningShownAt;
-        if (sinceWarningShown > 1000 * DISPLAY_WARNING_FOR) {
-            warningIsVisible = false;
-            Overlays.editOverlay(warningOverlay, { visible: warningIsVisible });
-        }
-    }
-});
-
-LODManager.LODIncreased.connect(function() {
-    if (SHOW_LOD_UP_MESSAGE) {
-        // if the warning wasn't visible, then move it before showing it.
-        if (!warningIsVisible) {
-            billboardPosition = Vec3.sum(Camera.getPosition(), 
-                                                    Vec3.multiply(DISTANCE_FROM_CAMERA, Quat.getFront(Camera.getOrientation())));
-            Overlays.editOverlay(warningOverlay, { position: billboardPosition });
-        }
-
-        warningShownAt = new Date();
-        warningIsVisible = true;
-        warningText = "Level of detail has been increased. \n"
-                + "You can now see: \n" 
-                + LODManager.getLODFeedbackText();
-
-        Overlays.editOverlay(warningOverlay, { visible: warningIsVisible, text: warningText });
-    }
-});
-
-LODManager.LODDecreased.connect(function() {
-    // if the warning wasn't visible, then move it before showing it.
-    if (!warningIsVisible) {
-        billboardPosition = Vec3.sum(Camera.getPosition(), 
-                                                Vec3.multiply(DISTANCE_FROM_CAMERA, Quat.getFront(Camera.getOrientation())));
-        Overlays.editOverlay(warningOverlay, { position: billboardPosition });
-    }
-
-    warningShownAt = new Date();
-    warningIsVisible = true;
-    warningText = "\n"
-            + "Due to the complexity of the content, the \n"
-            + "level of detail has been decreased. \n"
-            + "You can now see: \n" 
-            + LODManager.getLODFeedbackText();
-
-    Overlays.editOverlay(warningOverlay, { visible: warningIsVisible, text: warningText });
-});
-
-
-Script.scriptEnding.connect(function() {
-    Overlays.deleteOverlay(warningOverlay);
-});

interface/src/Application.cpp

@@ -382,6 +382,10 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
     auto discoverabilityManager = DependencyManager::get<DiscoverabilityManager>();
     connect(locationUpdateTimer, &QTimer::timeout, discoverabilityManager.data(), &DiscoverabilityManager::updateLocation);
     locationUpdateTimer->start(DATA_SERVER_LOCATION_CHANGE_UPDATE_MSECS);
+    
+    // if we get a domain change, immediately attempt update location in metaverse server
+    connect(&nodeList->getDomainHandler(), &DomainHandler::connectedToDomain,
+            discoverabilityManager.data(), &DiscoverabilityManager::updateLocation);
 
     connect(nodeList.data(), &NodeList::nodeAdded, this, &Application::nodeAdded);
     connect(nodeList.data(), &NodeList::nodeKilled, this, &Application::nodeKilled);
@@ -1786,6 +1790,7 @@ bool Application::exportEntities(const QString& filename, float x, float y, floa
 void Application::loadSettings() {
 
     DependencyManager::get<AudioClient>()->loadSettings();
+    DependencyManager::get<LODManager>()->loadSettings();
 
     Menu::getInstance()->loadSettings();
     _myAvatar->loadData();
@@ -1793,6 +1798,7 @@ void Application::loadSettings() {
 
 void Application::saveSettings() {
     DependencyManager::get<AudioClient>()->saveSettings();
+    DependencyManager::get<LODManager>()->saveSettings();
 
     Menu::getInstance()->saveSettings();
     _myAvatar->saveData();
@@ -1969,7 +1975,7 @@ bool Application::isLookingAtMyAvatar(Avatar* avatar) {
 void Application::updateLOD() {
     PerformanceTimer perfTimer("LOD");
     // adjust it unless we were asked to disable this feature, or if we're currently in throttleRendering mode
-    if (!Menu::getInstance()->isOptionChecked(MenuOption::DisableAutoAdjustLOD) && !isThrottleRendering()) {
+    if (!isThrottleRendering()) {
         DependencyManager::get<LODManager>()->autoAdjustLOD(_fps);
     } else {
         DependencyManager::get<LODManager>()->resetLODAdjust();
@@ -3295,11 +3301,6 @@ void Application::connectedToDomain(const QString& hostname) {
     const QUuid& domainID = DependencyManager::get<NodeList>()->getDomainHandler().getUUID();
     
     if (accountManager.isLoggedIn() && !domainID.isNull()) {
-        // update our data-server with the domain-server we're logged in with
-        QString domainPutJsonString = "{\"location\":{\"domain_id\":\"" + uuidStringWithoutCurlyBraces(domainID) + "\"}}";
-        accountManager.authenticatedRequest("/api/v1/user/location", QNetworkAccessManager::PutOperation,
-                                            JSONCallbackParameters(), domainPutJsonString.toUtf8());
-
         _notifiedPacketVersionMismatchThisDomain = false;
     }
 }

interface/src/Application.h

@@ -113,7 +113,7 @@ static const float MIRROR_FIELD_OF_VIEW = 30.0f;
 static const quint64 TOO_LONG_SINCE_LAST_SEND_DOWNSTREAM_AUDIO_STATS = 1 * USECS_PER_SECOND;
 
 static const QString INFO_HELP_PATH = "html/interface-welcome.html";
-static const QString INFO_EDIT_ENTITIES_PATH = "html/edit-entities-commands.html";
+static const QString INFO_EDIT_ENTITIES_PATH = "html/edit-commands.html";
 
 #ifdef Q_OS_WIN
 static const UINT UWM_IDENTIFY_INSTANCES = 

interface/src/LODManager.cpp

@@ -17,13 +17,26 @@
 
 #include "LODManager.h"
 
-Setting::Handle<bool> automaticAvatarLOD("automaticAvatarLOD", true);
+Setting::Handle<float> desktopLODDecreaseFPS("desktopLODDecreaseFPS", DEFAULT_DESKTOP_LOD_DOWN_FPS);
-Setting::Handle<float> avatarLODDecreaseFPS("avatarLODDecreaseFPS", DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
+Setting::Handle<float> hmdLODDecreaseFPS("hmdLODDecreaseFPS", DEFAULT_HMD_LOD_DOWN_FPS);
-Setting::Handle<float> avatarLODIncreaseFPS("avatarLODIncreaseFPS",  ADJUST_LOD_UP_FPS);
+
-Setting::Handle<float> avatarLODDistanceMultiplier("avatarLODDistanceMultiplier",
+LODManager::LODManager() {
-                                                           DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER);
+    calculateAvatarLODDistanceMultiplier();
-Setting::Handle<int> boundaryLevelAdjust("boundaryLevelAdjust", 0);
+}
-Setting::Handle<float> octreeSizeScale("octreeSizeScale", DEFAULT_OCTREE_SIZE_SCALE);
+
+float LODManager::getLODDecreaseFPS() {
+    if (Application::getInstance()->isHMDMode()) {
+        return getHMDLODDecreaseFPS();
+    }
+    return getDesktopLODDecreaseFPS();
+}
+
+float LODManager::getLODIncreaseFPS() {
+    if (Application::getInstance()->isHMDMode()) {
+        return getHMDLODIncreaseFPS();
+    }
+    return getDesktopLODIncreaseFPS();
+}
 
 
 void LODManager::autoAdjustLOD(float currentFPS) {
@@ -39,66 +52,65 @@ void LODManager::autoAdjustLOD(float currentFPS) {
     _fastFPSAverage.updateAverage(currentFPS);
     
     quint64 now = usecTimestampNow();
-    
+
-    const quint64 ADJUST_AVATAR_LOD_DOWN_DELAY = 1000 * 1000;
-    if (_automaticAvatarLOD) {
-        if (_fastFPSAverage.getAverage() < _avatarLODDecreaseFPS) {
-            if (now - _lastAvatarDetailDrop > ADJUST_AVATAR_LOD_DOWN_DELAY) {
-                // attempt to lower the detail in proportion to the fps difference
-                float targetFps = (_avatarLODDecreaseFPS + _avatarLODIncreaseFPS) * 0.5f;
-                float averageFps = _fastFPSAverage.getAverage();
-                const float MAXIMUM_MULTIPLIER_SCALE = 2.0f;
-                _avatarLODDistanceMultiplier = qMin(MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER, _avatarLODDistanceMultiplier *
-                                                    (averageFps < EPSILON ? MAXIMUM_MULTIPLIER_SCALE :
-                                                     qMin(MAXIMUM_MULTIPLIER_SCALE, targetFps / averageFps)));
-                _lastAvatarDetailDrop = now;
-            }
-        } else if (_fastFPSAverage.getAverage() > _avatarLODIncreaseFPS) {
-            // let the detail level creep slowly upwards
-            const float DISTANCE_DECREASE_RATE = 0.05f;
-            _avatarLODDistanceMultiplier = qMax(MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER,
-                                                _avatarLODDistanceMultiplier - DISTANCE_DECREASE_RATE);
-        }
-    }
-    
     bool changed = false;
+    bool octreeChanged = false;
     quint64 elapsed = now - _lastAdjust;
     
-    if (elapsed > ADJUST_LOD_DOWN_DELAY && _fpsAverage.getAverage() < ADJUST_LOD_DOWN_FPS
+    if (_automaticLODAdjust) {
-        && _octreeSizeScale > ADJUST_LOD_MIN_SIZE_SCALE) {
+        // LOD Downward adjustment    
-        
+        if (elapsed > ADJUST_LOD_DOWN_DELAY && _fpsAverage.getAverage() < getLODDecreaseFPS()) {
-        _octreeSizeScale *= ADJUST_LOD_DOWN_BY;
-        
-        if (_octreeSizeScale < ADJUST_LOD_MIN_SIZE_SCALE) {
-            _octreeSizeScale = ADJUST_LOD_MIN_SIZE_SCALE;
-        }
-        changed = true;
-        _lastAdjust = now;
-        qDebug() << "adjusting LOD down... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
-                    << "_octreeSizeScale=" << _octreeSizeScale;
-        
-        emit LODDecreased();
-    }
-    
-    if (elapsed > ADJUST_LOD_UP_DELAY && _fpsAverage.getAverage() > ADJUST_LOD_UP_FPS
-        && _octreeSizeScale < ADJUST_LOD_MAX_SIZE_SCALE) {
-        _octreeSizeScale *= ADJUST_LOD_UP_BY;
-        if (_octreeSizeScale > ADJUST_LOD_MAX_SIZE_SCALE) {
-            _octreeSizeScale = ADJUST_LOD_MAX_SIZE_SCALE;
-        }
-        changed = true;
-        _lastAdjust = now;
-        qDebug() << "adjusting LOD up... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
-                    << "_octreeSizeScale=" << _octreeSizeScale;
 
-        emit LODIncreased();
+            // Octree items... stepwise adjustment
-    }
+            if (_octreeSizeScale > ADJUST_LOD_MIN_SIZE_SCALE) {
+                _octreeSizeScale *= ADJUST_LOD_DOWN_BY;
+                if (_octreeSizeScale < ADJUST_LOD_MIN_SIZE_SCALE) {
+                    _octreeSizeScale = ADJUST_LOD_MIN_SIZE_SCALE;
+                }
+                octreeChanged = changed = true;
+            }
+
+            if (changed) {        
+                _lastAdjust = now;
+                qDebug() << "adjusting LOD down... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
+                            << "_octreeSizeScale=" << _octreeSizeScale;
+        
+                emit LODDecreased();
+            }
+        }
     
-    if (changed) {
+        // LOD Upward adjustment
-        _shouldRenderTableNeedsRebuilding = true;
+        if (elapsed > ADJUST_LOD_UP_DELAY && _fpsAverage.getAverage() > getLODIncreaseFPS()) {
-        auto lodToolsDialog = DependencyManager::get<DialogsManager>()->getLodToolsDialog();
+
-        if (lodToolsDialog) {
+            // Octee items... stepwise adjustment
-            lodToolsDialog->reloadSliders();
+            if (_octreeSizeScale < ADJUST_LOD_MAX_SIZE_SCALE) {
+                if (_octreeSizeScale < ADJUST_LOD_MIN_SIZE_SCALE) {
+                    _octreeSizeScale = ADJUST_LOD_MIN_SIZE_SCALE;
+                } else {
+                    _octreeSizeScale *= ADJUST_LOD_UP_BY;
+                }
+                if (_octreeSizeScale > ADJUST_LOD_MAX_SIZE_SCALE) {
+                    _octreeSizeScale = ADJUST_LOD_MAX_SIZE_SCALE;
+                }
+                octreeChanged = changed = true;
+            }
+        
+            if (changed) {
+                _lastAdjust = now;
+                qDebug() << "adjusting LOD up... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
+                            << "_octreeSizeScale=" << _octreeSizeScale;
+
+                emit LODIncreased();
+            }
+        }
+    
+        if (changed) {
+            calculateAvatarLODDistanceMultiplier();
+            _shouldRenderTableNeedsRebuilding = true;
+            auto lodToolsDialog = DependencyManager::get<DialogsManager>()->getLodToolsDialog();
+            if (lodToolsDialog) {
+                lodToolsDialog->reloadSliders();
+            }
         }
     }
 }
@@ -106,7 +118,7 @@ void LODManager::autoAdjustLOD(float currentFPS) {
 void LODManager::resetLODAdjust() {
     _fpsAverage.reset();
     _fastFPSAverage.reset();
-    _lastAvatarDetailDrop = _lastAdjust = usecTimestampNow();
+    _lastAdjust = usecTimestampNow();
 }
 
 QString LODManager::getLODFeedbackText() {
@@ -116,29 +128,33 @@ QString LODManager::getLODFeedbackText() {
     
     switch (boundaryLevelAdjust) {
         case 0: {
-            granularityFeedback = QString("at standard granularity.");
+            granularityFeedback = QString(".");
         } break;
         case 1: {
-            granularityFeedback = QString("at half of standard granularity.");
+            granularityFeedback = QString(" at half of standard granularity.");
         } break;
         case 2: {
-            granularityFeedback = QString("at a third of standard granularity.");
+            granularityFeedback = QString(" at a third of standard granularity.");
         } break;
         default: {
-            granularityFeedback = QString("at 1/%1th of standard granularity.").arg(boundaryLevelAdjust + 1);
+            granularityFeedback = QString(" at 1/%1th of standard granularity.").arg(boundaryLevelAdjust + 1);
         } break;
     }
     
     // distance feedback
     float octreeSizeScale = getOctreeSizeScale();
     float relativeToDefault = octreeSizeScale / DEFAULT_OCTREE_SIZE_SCALE;
+    int relativeToTwentyTwenty = 20 / relativeToDefault;
+
     QString result;
     if (relativeToDefault > 1.01) {
-        result = QString("%1 further %2").arg(relativeToDefault,8,'f',2).arg(granularityFeedback);
+        result = QString("20:%1 or %2 times further than average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',2).arg(granularityFeedback);
     } else if (relativeToDefault > 0.99) {
-        result = QString("the default distance %1").arg(granularityFeedback);
+        result = QString("20:20 or the default distance for average vision%1").arg(granularityFeedback);
+    } else if (relativeToDefault > 0.01) {
+        result = QString("20:%1 or %2 of default distance for average vision%3").arg(relativeToTwentyTwenty).arg(relativeToDefault,0,'f',3).arg(granularityFeedback);
     } else {
-        result = QString("%1 of default %2").arg(relativeToDefault,8,'f',3).arg(granularityFeedback);
+        result = QString("%2 of default distance for average vision%3").arg(relativeToDefault,0,'f',3).arg(granularityFeedback);
     }
     return result;
 }
@@ -184,9 +200,14 @@ bool LODManager::shouldRenderMesh(float largestDimension, float distanceToCamera
 
 void LODManager::setOctreeSizeScale(float sizeScale) {
     _octreeSizeScale = sizeScale;
+    calculateAvatarLODDistanceMultiplier();
     _shouldRenderTableNeedsRebuilding = true;
 }
 
+void LODManager::calculateAvatarLODDistanceMultiplier() {
+    _avatarLODDistanceMultiplier = AVATAR_TO_ENTITY_RATIO / (_octreeSizeScale / DEFAULT_OCTREE_SIZE_SCALE);
+}
+
 void LODManager::setBoundaryLevelAdjust(int boundaryLevelAdjust) {
     _boundaryLevelAdjust = boundaryLevelAdjust;
     _shouldRenderTableNeedsRebuilding = true;
@@ -194,21 +215,13 @@ void LODManager::setBoundaryLevelAdjust(int boundaryLevelAdjust) {
 
 
 void LODManager::loadSettings() {
-    setAutomaticAvatarLOD(automaticAvatarLOD.get());
+    setDesktopLODDecreaseFPS(desktopLODDecreaseFPS.get());
-    setAvatarLODDecreaseFPS(avatarLODDecreaseFPS.get());
+    setHMDLODDecreaseFPS(hmdLODDecreaseFPS.get());
-    setAvatarLODIncreaseFPS(avatarLODIncreaseFPS.get());
-    setAvatarLODDistanceMultiplier(avatarLODDistanceMultiplier.get());
-    setBoundaryLevelAdjust(boundaryLevelAdjust.get());
-    setOctreeSizeScale(octreeSizeScale.get());
 }
 
 void LODManager::saveSettings() {
-    automaticAvatarLOD.set(getAutomaticAvatarLOD());
+    desktopLODDecreaseFPS.set(getDesktopLODDecreaseFPS());
-    avatarLODDecreaseFPS.set(getAvatarLODDecreaseFPS());
+    hmdLODDecreaseFPS.set(getHMDLODDecreaseFPS());
-    avatarLODIncreaseFPS.set(getAvatarLODIncreaseFPS());
-    avatarLODDistanceMultiplier.set(getAvatarLODDistanceMultiplier());
-    boundaryLevelAdjust.set(getBoundaryLevelAdjust());
-    octreeSizeScale.set(getOctreeSizeScale());
 }
 
 

interface/src/LODManager.h

@@ -17,9 +17,9 @@
 #include <SharedUtil.h>
 #include <SimpleMovingAverage.h>
 
-const float ADJUST_LOD_DOWN_FPS = 40.0;
+const float DEFAULT_DESKTOP_LOD_DOWN_FPS = 30.0;
-const float ADJUST_LOD_UP_FPS = 55.0;
+const float DEFAULT_HMD_LOD_DOWN_FPS = 60.0;
-const float DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS = 30.0f;
+const float INCREASE_LOD_GAP = 5.0f;
 
 const quint64 ADJUST_LOD_DOWN_DELAY = 1000 * 1000 * 0.5; // Consider adjusting LOD down after half a second
 const quint64 ADJUST_LOD_UP_DELAY = ADJUST_LOD_DOWN_DELAY * 2;
@@ -33,9 +33,9 @@ const float ADJUST_LOD_UP_BY = 1.1f;
 const float ADJUST_LOD_MIN_SIZE_SCALE = 1.0f;
 const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
 
-const float MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER = 0.1f;
+// The ratio of "visibility" of avatars to other content. A value larger than 1 will mean Avatars "cull" later than entities
-const float MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER = 15.0f;
+// do. But both are still culled using the same angular size logic.
-const float DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER = 1.0f;
+const float AVATAR_TO_ENTITY_RATIO = 2.0f;
 
 const int ONE_SECOND_OF_FRAMES = 60;
 const int FIVE_SECONDS_OF_FRAMES = 5 * ONE_SECOND_OF_FRAMES;
@@ -46,14 +46,18 @@ class LODManager : public QObject, public Dependency {
     SINGLETON_DEPENDENCY
     
 public:
-    void setAutomaticAvatarLOD(bool automaticAvatarLOD) { _automaticAvatarLOD = automaticAvatarLOD; }
+    Q_INVOKABLE void setAutomaticLODAdjust(bool value) { _automaticLODAdjust = value; }
-    bool getAutomaticAvatarLOD() const { return _automaticAvatarLOD; }
+    Q_INVOKABLE bool getAutomaticLODAdjust() const { return _automaticLODAdjust; }
-    void setAvatarLODDecreaseFPS(float avatarLODDecreaseFPS) { _avatarLODDecreaseFPS = avatarLODDecreaseFPS; }
+
-    float getAvatarLODDecreaseFPS() const { return _avatarLODDecreaseFPS; }
+    Q_INVOKABLE void setDesktopLODDecreaseFPS(float value) { _desktopLODDecreaseFPS = value; }
-    void setAvatarLODIncreaseFPS(float avatarLODIncreaseFPS) { _avatarLODIncreaseFPS = avatarLODIncreaseFPS; }
+    Q_INVOKABLE float getDesktopLODDecreaseFPS() const { return _desktopLODDecreaseFPS; }
-    float getAvatarLODIncreaseFPS() const { return _avatarLODIncreaseFPS; }
+    Q_INVOKABLE float getDesktopLODIncreaseFPS() const { return _desktopLODDecreaseFPS + INCREASE_LOD_GAP; }
-    void setAvatarLODDistanceMultiplier(float multiplier) { _avatarLODDistanceMultiplier = multiplier; }
+
-    float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
+    Q_INVOKABLE void setHMDLODDecreaseFPS(float value) { _hmdLODDecreaseFPS = value; }
+    Q_INVOKABLE float getHMDLODDecreaseFPS() const { return _hmdLODDecreaseFPS; }
+    Q_INVOKABLE float getHMDLODIncreaseFPS() const { return _hmdLODDecreaseFPS + INCREASE_LOD_GAP; }
+
+    Q_INVOKABLE float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
     
     // User Tweakable LOD Items
     Q_INVOKABLE QString getLODFeedbackText();
@@ -63,12 +67,15 @@ public:
     Q_INVOKABLE void setBoundaryLevelAdjust(int boundaryLevelAdjust);
     Q_INVOKABLE int getBoundaryLevelAdjust() const { return _boundaryLevelAdjust; }
     
-    void autoAdjustLOD(float currentFPS);
     Q_INVOKABLE void resetLODAdjust();
     Q_INVOKABLE float getFPSAverage() const { return _fpsAverage.getAverage(); }
     Q_INVOKABLE float getFastFPSAverage() const { return _fastFPSAverage.getAverage(); }
     
+    Q_INVOKABLE float getLODDecreaseFPS();
+    Q_INVOKABLE float getLODIncreaseFPS();
+    
     bool shouldRenderMesh(float largestDimension, float distanceToCamera);
+    void autoAdjustLOD(float currentFPS);
     
     void loadSettings();
     void saveSettings();
@@ -78,18 +85,18 @@ signals:
     void LODDecreased();
     
 private:
-    LODManager() {}
+    LODManager();
-    
+    void calculateAvatarLODDistanceMultiplier();
-    bool _automaticAvatarLOD = true;
-    float _avatarLODDecreaseFPS = DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS;
-    float _avatarLODIncreaseFPS = ADJUST_LOD_UP_FPS;
-    float _avatarLODDistanceMultiplier = DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER;
     
+    bool _automaticLODAdjust = true;
+    float _desktopLODDecreaseFPS = DEFAULT_DESKTOP_LOD_DOWN_FPS;
+    float _hmdLODDecreaseFPS = DEFAULT_HMD_LOD_DOWN_FPS;
+
+    float _avatarLODDistanceMultiplier;
     float _octreeSizeScale = DEFAULT_OCTREE_SIZE_SCALE;
     int _boundaryLevelAdjust = 0;
     
     quint64 _lastAdjust = 0;
-    quint64 _lastAvatarDetailDrop = 0;
     SimpleMovingAverage _fpsAverage = FIVE_SECONDS_OF_FRAMES;
     SimpleMovingAverage _fastFPSAverage = ONE_SECOND_OF_FRAMES;
     

interface/src/Menu.cpp

@@ -276,7 +276,6 @@ Menu::Menu() {
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Entities, 0, true);
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AmbientOcclusion);
     addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DontFadeOnOctreeServerChanges);
-    addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DisableAutoAdjustLOD);
 
     QMenu* ambientLightMenu = renderOptionsMenu->addMenu(MenuOption::RenderAmbientLight);
     QActionGroup* ambientLightGroup = new QActionGroup(ambientLightMenu);

interface/src/Menu.h

@@ -136,7 +136,6 @@ namespace MenuOption {
     const QString DecreaseAvatarSize = "Decrease Avatar Size";
     const QString DeleteBookmark = "Delete Bookmark...";
     const QString DisableActivityLogger = "Disable Activity Logger";
-    const QString DisableAutoAdjustLOD = "Disable Automatically Adjusting LOD";
     const QString DisableLightEntities = "Disable Light Entities";
     const QString DisableNackPackets = "Disable NACK Packets";
     const QString DiskCacheEditor = "Disk Cache Editor";

interface/src/ui/LodToolsDialog.cpp

@@ -35,9 +35,24 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
     // Create layouter
     QFormLayout* form = new QFormLayout(this);
 
+    // Create a label with feedback...
+    _feedback = new QLabel(this);
+    QPalette palette = _feedback->palette();
+    const unsigned redish  = 0xfff00000;
+    palette.setColor(QPalette::WindowText, QColor::fromRgb(redish));
+    _feedback->setPalette(palette);
+    _feedback->setText(lodManager->getLODFeedbackText());
+    const int FEEDBACK_WIDTH = 350;
+    _feedback->setFixedWidth(FEEDBACK_WIDTH);
+    form->addRow("You can see... ", _feedback);
+
+    form->addRow("Manually Adjust Level of Detail:", _manualLODAdjust = new QCheckBox(this));
+    _manualLODAdjust->setChecked(!lodManager->getAutomaticLODAdjust());
+    connect(_manualLODAdjust, SIGNAL(toggled(bool)), SLOT(updateAutomaticLODAdjust()));
+    
     _lodSize = new QSlider(Qt::Horizontal, this);
     const int MAX_LOD_SIZE = MAX_LOD_SIZE_MULTIPLIER;
-    const int MIN_LOD_SIZE = 0;
+    const int MIN_LOD_SIZE = ADJUST_LOD_MIN_SIZE_SCALE;
     const int STEP_LOD_SIZE = 1;
     const int PAGE_STEP_LOD_SIZE = 100;
     const int SLIDER_WIDTH = 300;
@@ -50,55 +65,8 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
     _lodSize->setPageStep(PAGE_STEP_LOD_SIZE);
     int sliderValue = lodManager->getOctreeSizeScale() / TREE_SCALE;
     _lodSize->setValue(sliderValue);
-    form->addRow("LOD Size Scale:", _lodSize);
+    form->addRow("Level of Detail:", _lodSize);
     connect(_lodSize,SIGNAL(valueChanged(int)),this,SLOT(sizeScaleValueChanged(int)));
-
-    _boundaryLevelAdjust = new QSlider(Qt::Horizontal, this);
-    const int MAX_ADJUST = 10;
-    const int MIN_ADJUST = 0;
-    const int STEP_ADJUST = 1;
-    _boundaryLevelAdjust->setMaximum(MAX_ADJUST);
-    _boundaryLevelAdjust->setMinimum(MIN_ADJUST);
-    _boundaryLevelAdjust->setSingleStep(STEP_ADJUST);
-    _boundaryLevelAdjust->setTickInterval(STEP_ADJUST);
-    _boundaryLevelAdjust->setTickPosition(QSlider::TicksBelow);
-    _boundaryLevelAdjust->setFixedWidth(SLIDER_WIDTH);
-    sliderValue = lodManager->getBoundaryLevelAdjust();
-    _boundaryLevelAdjust->setValue(sliderValue);
-    form->addRow("Boundary Level Adjust:", _boundaryLevelAdjust);
-    connect(_boundaryLevelAdjust,SIGNAL(valueChanged(int)),this,SLOT(boundaryLevelValueChanged(int)));
-
-    // Create a label with feedback...
-    _feedback = new QLabel(this);
-    QPalette palette = _feedback->palette();
-    const unsigned redish  = 0xfff00000;
-    palette.setColor(QPalette::WindowText, QColor::fromRgb(redish));
-    _feedback->setPalette(palette);
-    _feedback->setText(lodManager->getLODFeedbackText());
-    const int FEEDBACK_WIDTH = 350;
-    _feedback->setFixedWidth(FEEDBACK_WIDTH);
-    form->addRow("You can see... ", _feedback);
-    
-    form->addRow("Automatic Avatar LOD Adjustment:", _automaticAvatarLOD = new QCheckBox(this));
-    _automaticAvatarLOD->setChecked(lodManager->getAutomaticAvatarLOD());
-    connect(_automaticAvatarLOD, SIGNAL(toggled(bool)), SLOT(updateAvatarLODControls()));
-    
-    form->addRow("Decrease Avatar LOD Below FPS:", _avatarLODDecreaseFPS = new QDoubleSpinBox(this));
-    _avatarLODDecreaseFPS->setValue(lodManager->getAvatarLODDecreaseFPS());
-    _avatarLODDecreaseFPS->setDecimals(0);
-    connect(_avatarLODDecreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
-    
-    form->addRow("Increase Avatar LOD Above FPS:", _avatarLODIncreaseFPS = new QDoubleSpinBox(this));
-    _avatarLODIncreaseFPS->setValue(lodManager->getAvatarLODIncreaseFPS());
-    _avatarLODIncreaseFPS->setDecimals(0);
-    connect(_avatarLODIncreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
-    
-    form->addRow("Avatar LOD:", _avatarLOD = new QDoubleSpinBox(this));
-    _avatarLOD->setDecimals(3);
-    _avatarLOD->setRange(1.0 / MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER, 1.0 / MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER);
-    _avatarLOD->setSingleStep(0.001);
-    _avatarLOD->setValue(1.0 / lodManager->getAvatarLODDistanceMultiplier());
-    connect(_avatarLOD, SIGNAL(valueChanged(double)), SLOT(updateAvatarLODValues()));
     
     // Add a button to reset
     QPushButton* resetButton = new QPushButton("Reset", this);
@@ -107,49 +75,19 @@ LodToolsDialog::LodToolsDialog(QWidget* parent) :
 
     this->QDialog::setLayout(form);
     
-    updateAvatarLODControls();
+    updateAutomaticLODAdjust();
 }
 
 void LodToolsDialog::reloadSliders() {
     auto lodManager = DependencyManager::get<LODManager>();
     _lodSize->setValue(lodManager->getOctreeSizeScale() / TREE_SCALE);
-    _boundaryLevelAdjust->setValue(lodManager->getBoundaryLevelAdjust());
     _feedback->setText(lodManager->getLODFeedbackText());
 }
 
-void LodToolsDialog::updateAvatarLODControls() {
+void LodToolsDialog::updateAutomaticLODAdjust() {
-    QFormLayout* form = static_cast<QFormLayout*>(layout());
-    
     auto lodManager = DependencyManager::get<LODManager>();
-    lodManager->setAutomaticAvatarLOD(_automaticAvatarLOD->isChecked());
+    lodManager->setAutomaticLODAdjust(!_manualLODAdjust->isChecked());
-    
+    _lodSize->setEnabled(_manualLODAdjust->isChecked());
-    _avatarLODDecreaseFPS->setVisible(_automaticAvatarLOD->isChecked());
-    form->labelForField(_avatarLODDecreaseFPS)->setVisible(_automaticAvatarLOD->isChecked());
-    
-    _avatarLODIncreaseFPS->setVisible(_automaticAvatarLOD->isChecked());
-    form->labelForField(_avatarLODIncreaseFPS)->setVisible(_automaticAvatarLOD->isChecked());
-    
-    _avatarLOD->setVisible(!_automaticAvatarLOD->isChecked());
-    form->labelForField(_avatarLOD)->setVisible(!_automaticAvatarLOD->isChecked());
-    
-    if (!_automaticAvatarLOD->isChecked()) {
-        _avatarLOD->setValue(1.0 / lodManager->getAvatarLODDistanceMultiplier());
-    }
-    
-    if (isVisible()) {
-        adjustSize();
-    }
-}
-
-void LodToolsDialog::updateAvatarLODValues() {
-    auto lodManager = DependencyManager::get<LODManager>();
-    if (_automaticAvatarLOD->isChecked()) {
-        lodManager->setAvatarLODDecreaseFPS(_avatarLODDecreaseFPS->value());
-        lodManager->setAvatarLODIncreaseFPS(_avatarLODIncreaseFPS->value());
-        
-    } else {
-        lodManager->setAvatarLODDistanceMultiplier(1.0 / _avatarLOD->value());
-    }
 }
 
 void LodToolsDialog::sizeScaleValueChanged(int value) {
@@ -160,20 +98,13 @@ void LodToolsDialog::sizeScaleValueChanged(int value) {
     _feedback->setText(lodManager->getLODFeedbackText());
 }
 
-void LodToolsDialog::boundaryLevelValueChanged(int value) {
-    auto lodManager = DependencyManager::get<LODManager>();
-    lodManager->setBoundaryLevelAdjust(value);
-    _feedback->setText(lodManager->getLODFeedbackText());
-}
-
 void LodToolsDialog::resetClicked(bool checked) {
+
     int sliderValue = DEFAULT_OCTREE_SIZE_SCALE / TREE_SCALE;
-    //sizeScaleValueChanged(sliderValue);
     _lodSize->setValue(sliderValue);
-    _boundaryLevelAdjust->setValue(0);
+    _manualLODAdjust->setChecked(false);
-    _automaticAvatarLOD->setChecked(true);
+    
-    _avatarLODDecreaseFPS->setValue(DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
+    updateAutomaticLODAdjust(); // tell our LOD manager about the reset
-    _avatarLODIncreaseFPS->setValue(ADJUST_LOD_UP_FPS);
 }
 
 void LodToolsDialog::reject() {
@@ -184,6 +115,15 @@ void LodToolsDialog::reject() {
 void LodToolsDialog::closeEvent(QCloseEvent* event) {
     this->QDialog::closeEvent(event);
     emit closed();
+    auto lodManager = DependencyManager::get<LODManager>();
+    
+    // always revert back to automatic LOD adjustment when closed
+    lodManager->setAutomaticLODAdjust(true); 
+
+    // if the user adjusted the LOD above "normal" then always revert back to default
+    if (lodManager->getOctreeSizeScale() > DEFAULT_OCTREE_SIZE_SCALE) {
+        lodManager->setOctreeSizeScale(DEFAULT_OCTREE_SIZE_SCALE);
+    }
 }
 
 

interface/src/ui/LodToolsDialog.h

@@ -31,11 +31,9 @@ signals:
 public slots:
     void reject();
     void sizeScaleValueChanged(int value);
-    void boundaryLevelValueChanged(int value);
     void resetClicked(bool checked);
     void reloadSliders();
-    void updateAvatarLODControls();
+    void updateAutomaticLODAdjust();
-    void updateAvatarLODValues();
 
 protected:
 
@@ -44,11 +42,13 @@ protected:
 
 private:
     QSlider* _lodSize;
-    QSlider* _boundaryLevelAdjust;
+
-    QCheckBox* _automaticAvatarLOD;
+    QCheckBox* _manualLODAdjust;
-    QDoubleSpinBox* _avatarLODDecreaseFPS;
+
-    QDoubleSpinBox* _avatarLODIncreaseFPS;
+    QDoubleSpinBox* _desktopLODDecreaseFPS;
-    QDoubleSpinBox* _avatarLOD;
+
+    QDoubleSpinBox* _hmdLODDecreaseFPS;
+
     QLabel* _feedback;
 };
 

interface/src/ui/PreferencesDialog.cpp

@@ -19,6 +19,7 @@
 
 #include "Application.h"
 #include "MainWindow.h"
+#include "LODManager.h"
 #include "Menu.h"
 #include "ModelsBrowser.h"
 #include "PreferencesDialog.h"
@@ -174,6 +175,10 @@ void PreferencesDialog::loadPreferences() {
     ui.sixenseReticleMoveSpeedSpin->setValue(sixense.getReticleMoveSpeed());
     ui.invertSixenseButtonsCheckBox->setChecked(sixense.getInvertButtons());
 
+    // LOD items
+    auto lodManager = DependencyManager::get<LODManager>();
+    ui.desktopMinimumFPSSpin->setValue(lodManager->getDesktopLODDecreaseFPS());
+    ui.hmdMinimumFPSSpin->setValue(lodManager->getHMDLODDecreaseFPS());
 }
 
 void PreferencesDialog::savePreferences() {
@@ -275,4 +280,9 @@ void PreferencesDialog::savePreferences() {
     audio->setOutputStarveDetectionPeriod(ui.outputStarveDetectionPeriodSpinner->value());
 
     Application::getInstance()->resizeGL(glCanvas->width(), glCanvas->height());
+
+    // LOD items
+    auto lodManager = DependencyManager::get<LODManager>();
+    lodManager->setDesktopLODDecreaseFPS(ui.desktopMinimumFPSSpin->value());
+    lodManager->setHMDLODDecreaseFPS(ui.hmdMinimumFPSSpin->value());
 }

interface/ui/preferencesDialog.ui

@@ -701,6 +701,219 @@
          </property>
         </widget>
        </item>
+
+
+
+       <item>
+        <spacer name="verticalSpacer_10">
+         <property name="orientation">
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeType">
+          <enum>QSizePolicy::Fixed</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>20</width>
+           <height>20</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+
+       <item>
+        <widget class="QLabel" name="levelOfDetailTitleLabel">
+         <property name="font">
+          <font>
+           <family>Arial</family>
+           <pointsize>18</pointsize>
+           <weight>75</weight>
+           <bold>true</bold>
+          </font>
+         </property>
+         <property name="styleSheet">
+          <string notr="true">color:#29967e</string>
+         </property>
+         <property name="text">
+          <string>Level of Detail Tuning</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignBottom|Qt::AlignLeading|Qt::AlignLeft</set>
+         </property>
+        </widget>
+       </item>
+
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_111x">
+         <property name="spacing">
+          <number>0</number>
+         </property>
+         <property name="topMargin">
+          <number>7</number>
+         </property>
+         <property name="rightMargin">
+          <number>0</number>
+         </property>
+         <property name="bottomMargin">
+          <number>7</number>
+         </property>
+         <item>
+          <widget class="QLabel" name="label_9x">
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="styleSheet">
+            <string notr="true"/>
+           </property>
+           <property name="text">
+            <string>Minimum Desktop FPS</string>
+           </property>
+           <property name="indent">
+            <number>0</number>
+           </property>
+           <!--
+           <property name="buddy">
+            <cstring>fieldOfViewSpin</cstring>
+           </property>
+           -->
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer_111x">
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>0</width>
+             <height>0</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="desktopMinimumFPSSpin">
+           <property name="minimumSize">
+            <size>
+             <width>100</width>
+             <height>0</height>
+            </size>
+           </property>
+           <property name="maximumSize">
+            <size>
+             <width>95</width>
+             <height>36</height>
+            </size>
+           </property>
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="minimum">
+            <number>0</number>
+           </property>
+           <property name="maximum">
+            <number>120</number>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_111y">
+         <property name="spacing">
+          <number>0</number>
+         </property>
+         <property name="topMargin">
+          <number>7</number>
+         </property>
+         <property name="rightMargin">
+          <number>0</number>
+         </property>
+         <property name="bottomMargin">
+          <number>7</number>
+         </property>
+         <item>
+          <widget class="QLabel" name="label_9y">
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="styleSheet">
+            <string notr="true"/>
+           </property>
+           <property name="text">
+            <string>Minimum HMD FPS</string>
+           </property>
+           <property name="indent">
+            <number>0</number>
+           </property>
+           <!--
+           <property name="buddy">
+            <cstring>fieldOfViewSpin</cstring>
+           </property>
+           -->
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer_111y">
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>0</width>
+             <height>0</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="hmdMinimumFPSSpin">
+           <property name="minimumSize">
+            <size>
+             <width>100</width>
+             <height>0</height>
+            </size>
+           </property>
+           <property name="maximumSize">
+            <size>
+             <width>95</width>
+             <height>36</height>
+            </size>
+           </property>
+           <property name="font">
+            <font>
+             <family>Arial</family>
+            </font>
+           </property>
+           <property name="minimum">
+            <number>0</number>
+           </property>
+           <property name="maximum">
+            <number>120</number>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+
+
        <item>
         <spacer name="verticalSpacer_8">
          <property name="orientation">
@@ -717,6 +930,7 @@
          </property>
         </spacer>
        </item>
+
        <item>
         <widget class="QLabel" name="avatarTitleLabel">
          <property name="font">
@@ -738,6 +952,7 @@
          </property>
         </widget>
        </item>
+
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_111">
          <property name="spacing">
@@ -820,6 +1035,9 @@
          </item>
         </layout>
        </item>
+       
+       
+       
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <property name="spacing">

libraries/octree/src/OctreeConstants.h

@@ -23,7 +23,7 @@ const int   TREE_SCALE = 16384; // ~10 miles.. This is the number of meters of t
 const float DEFAULT_OCTREE_SIZE_SCALE = TREE_SCALE * 400.0f; 
 
 // This is used in the LOD Tools to translate between the size scale slider and the values used to set the OctreeSizeScale
-const float MAX_LOD_SIZE_MULTIPLIER = 2000.0f;
+const float MAX_LOD_SIZE_MULTIPLIER = 800.0f;
 
 const int NUMBER_OF_CHILDREN = 8;
 

libraries/render-utils/src/Model.cpp

@@ -721,7 +721,7 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
     const float DEFAULT_ALPHA_THRESHOLD = 0.5f;
     
 
-    //renderMeshes(RenderMode mode, bool translucent, float alphaThreshold, bool hasTangents, bool hasSpecular, book isSkinned, args);
+    //renderMeshes(batch, mode, translucent, alphaThreshold, hasTangents, hasSpecular, isSkinned, args, forceRenderMeshes);
     int opaqueMeshPartsRendered = 0;
     opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, false, false, args, true);
     opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, false, true, args, true);
@@ -749,14 +749,14 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
 
     int translucentMeshPartsRendered = 0;
     const float MOSTLY_OPAQUE_THRESHOLD = 0.75f;
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, false, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, false, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, true, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, true, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, false, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, false, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, true, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, true, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, false, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, false, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, true, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, true, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args, true);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args);
+    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args, true);
 
     GLBATCH(glDisable)(GL_ALPHA_TEST);
   /*  GLBATCH(glEnable)(GL_BLEND);
@@ -773,14 +773,14 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
 
     if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) {
         const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f;
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, false, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, false, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, true, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, true, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, false, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, false, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, true, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, true, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, false, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, false, args, true);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, true, args);
+        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, true, args, true);
     }
 
     GLBATCH(glDepthMask)(true);