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

2025-08-05 19:17:43 +02:00 · 2015-03-25 10:16:43 -07:00 · 2015-03-25 10:16:43 -07:00 · 8938a6297f
commit 8938a6297f
parent c9377d0811 e6ac502fb5
19 changed files with 2666 additions and 2391 deletions
--- a/examples/defaultScripts.js
+++ b/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");
--- a/examples/example/entities/makeHouses.js
+++ b/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);
+})();
--- a/examples/hmdDefaults.js
+++ b/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
--- a/examples/notifications.js
+++ b/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);
--- a/examples/utilities/LODWarning.js
+++ b/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);
-});
--- a/interface/resources/html/edit-commands.html
+++ b/interface/resources/html/edit-commands.html
--- a/interface/resources/html/edit-entities-commands.html
+++ b/interface/resources/html/edit-entities-commands.html
--- a/interface/src/Application.cpp
+++ b/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;
    }
 }
--- a/interface/src/Application.h
+++ b/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 = 
--- a/interface/src/LODManager.cpp
+++ b/interface/src/LODManager.cpp
@ -17,13 +17,26 @@

 #include "LODManager.h"

-Setting::Handle<bool> automaticAvatarLOD("automaticAvatarLOD", true);
-Setting::Handle<float> avatarLODDecreaseFPS("avatarLODDecreaseFPS", DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
-Setting::Handle<float> avatarLODIncreaseFPS("avatarLODIncreaseFPS",  ADJUST_LOD_UP_FPS);
-Setting::Handle<float> avatarLODDistanceMultiplier("avatarLODDistanceMultiplier",
-                                                           DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER);
-Setting::Handle<int> boundaryLevelAdjust("boundaryLevelAdjust", 0);
-Setting::Handle<float> octreeSizeScale("octreeSizeScale", DEFAULT_OCTREE_SIZE_SCALE);
+Setting::Handle<float> desktopLODDecreaseFPS("desktopLODDecreaseFPS", DEFAULT_DESKTOP_LOD_DOWN_FPS);
+Setting::Handle<float> hmdLODDecreaseFPS("hmdLODDecreaseFPS", DEFAULT_HMD_LOD_DOWN_FPS);
+
+LODManager::LODManager() {
+    calculateAvatarLODDistanceMultiplier();
+}
+
+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
-        && _octreeSizeScale > ADJUST_LOD_MIN_SIZE_SCALE) {
-        
-        _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;
+    if (_automaticLODAdjust) {
+        // LOD Downward adjustment    
+        if (elapsed > ADJUST_LOD_DOWN_DELAY && _fpsAverage.getAverage() < getLODDecreaseFPS()) {

-        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) {
-        _shouldRenderTableNeedsRebuilding = true;
-        auto lodToolsDialog = DependencyManager::get<DialogsManager>()->getLodToolsDialog();
-        if (lodToolsDialog) {
-            lodToolsDialog->reloadSliders();
+        // LOD Upward adjustment
+        if (elapsed > ADJUST_LOD_UP_DELAY && _fpsAverage.getAverage() > getLODIncreaseFPS()) {
+
+            // Octee items... stepwise adjustment
+            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());
-    setAvatarLODDecreaseFPS(avatarLODDecreaseFPS.get());
-    setAvatarLODIncreaseFPS(avatarLODIncreaseFPS.get());
-    setAvatarLODDistanceMultiplier(avatarLODDistanceMultiplier.get());
-    setBoundaryLevelAdjust(boundaryLevelAdjust.get());
-    setOctreeSizeScale(octreeSizeScale.get());
+    setDesktopLODDecreaseFPS(desktopLODDecreaseFPS.get());
+    setHMDLODDecreaseFPS(hmdLODDecreaseFPS.get());
 }

 void LODManager::saveSettings() {
-    automaticAvatarLOD.set(getAutomaticAvatarLOD());
-    avatarLODDecreaseFPS.set(getAvatarLODDecreaseFPS());
-    avatarLODIncreaseFPS.set(getAvatarLODIncreaseFPS());
-    avatarLODDistanceMultiplier.set(getAvatarLODDistanceMultiplier());
-    boundaryLevelAdjust.set(getBoundaryLevelAdjust());
-    octreeSizeScale.set(getOctreeSizeScale());
+    desktopLODDecreaseFPS.set(getDesktopLODDecreaseFPS());
+    hmdLODDecreaseFPS.set(getHMDLODDecreaseFPS());
 }


--- a/interface/src/LODManager.h
+++ b/interface/src/LODManager.h
@ -17,9 +17,9 @@
 #include <SharedUtil.h>
 #include <SimpleMovingAverage.h>

-const float ADJUST_LOD_DOWN_FPS = 40.0;
-const float ADJUST_LOD_UP_FPS = 55.0;
-const float DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS = 30.0f;
+const float DEFAULT_DESKTOP_LOD_DOWN_FPS = 30.0;
+const float DEFAULT_HMD_LOD_DOWN_FPS = 60.0;
+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;
-const float MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER = 15.0f;
-const float DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER = 1.0f;
+// The ratio of "visibility" of avatars to other content. A value larger than 1 will mean Avatars "cull" later than entities
+// do. But both are still culled using the same angular size logic.
+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; }
-    bool getAutomaticAvatarLOD() const { return _automaticAvatarLOD; }
-    void setAvatarLODDecreaseFPS(float avatarLODDecreaseFPS) { _avatarLODDecreaseFPS = avatarLODDecreaseFPS; }
-    float getAvatarLODDecreaseFPS() const { return _avatarLODDecreaseFPS; }
-    void setAvatarLODIncreaseFPS(float avatarLODIncreaseFPS) { _avatarLODIncreaseFPS = avatarLODIncreaseFPS; }
-    float getAvatarLODIncreaseFPS() const { return _avatarLODIncreaseFPS; }
-    void setAvatarLODDistanceMultiplier(float multiplier) { _avatarLODDistanceMultiplier = multiplier; }
-    float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
+    Q_INVOKABLE void setAutomaticLODAdjust(bool value) { _automaticLODAdjust = value; }
+    Q_INVOKABLE bool getAutomaticLODAdjust() const { return _automaticLODAdjust; }
+
+    Q_INVOKABLE void setDesktopLODDecreaseFPS(float value) { _desktopLODDecreaseFPS = value; }
+    Q_INVOKABLE float getDesktopLODDecreaseFPS() const { return _desktopLODDecreaseFPS; }
+    Q_INVOKABLE float getDesktopLODIncreaseFPS() const { return _desktopLODDecreaseFPS + INCREASE_LOD_GAP; }
+
+    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() {}
-    
-    bool _automaticAvatarLOD = true;
-    float _avatarLODDecreaseFPS = DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS;
-    float _avatarLODIncreaseFPS = ADJUST_LOD_UP_FPS;
-    float _avatarLODDistanceMultiplier = DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER;
+    LODManager();
+    void calculateAvatarLODDistanceMultiplier();
    
+    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;
    
--- a/interface/src/Menu.cpp
+++ b/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);
--- a/interface/src/Menu.h
+++ b/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";
--- a/interface/src/ui/LodToolsDialog.cpp
+++ b/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() {
-    QFormLayout* form = static_cast<QFormLayout*>(layout());
-    
+void LodToolsDialog::updateAutomaticLODAdjust() {
    auto lodManager = DependencyManager::get<LODManager>();
-    lodManager->setAutomaticAvatarLOD(_automaticAvatarLOD->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());
-    }
+    lodManager->setAutomaticLODAdjust(!_manualLODAdjust->isChecked());
+    _lodSize->setEnabled(_manualLODAdjust->isChecked());
 }

 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);
-    _automaticAvatarLOD->setChecked(true);
-    _avatarLODDecreaseFPS->setValue(DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
-    _avatarLODIncreaseFPS->setValue(ADJUST_LOD_UP_FPS);
+    _manualLODAdjust->setChecked(false);
+    
+    updateAutomaticLODAdjust(); // tell our LOD manager about the reset
 }

 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);
+    }
 }


--- a/interface/src/ui/LodToolsDialog.h
+++ b/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 updateAvatarLODValues();
+    void updateAutomaticLODAdjust();

 protected:

@ -44,11 +42,13 @@ protected:

 private:
    QSlider* _lodSize;
-    QSlider* _boundaryLevelAdjust;
-    QCheckBox* _automaticAvatarLOD;
-    QDoubleSpinBox* _avatarLODDecreaseFPS;
-    QDoubleSpinBox* _avatarLODIncreaseFPS;
-    QDoubleSpinBox* _avatarLOD;
+
+    QCheckBox* _manualLODAdjust;
+
+    QDoubleSpinBox* _desktopLODDecreaseFPS;
+
+    QDoubleSpinBox* _hmdLODDecreaseFPS;
+
    QLabel* _feedback;
 };

--- a/interface/src/ui/PreferencesDialog.cpp
+++ b/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());
 }
--- a/interface/ui/preferencesDialog.ui
+++ b/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">
--- a/libraries/octree/src/OctreeConstants.h
+++ b/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;

--- a/libraries/render-utils/src/Model.cpp
+++ b/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, true, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, false, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, true, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, false, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, true, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args);
-    translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, 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, true);
+    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, true);
+    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, true);
+    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, 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, true, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, false, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, true, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, false, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, true, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, false, args);
-        translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, true, 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, true);
+        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, true);
+        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, true);
+        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, true);
    }

    GLBATCH(glDepthMask)(true);