tweaks to the LOD Tools UI

interface/src/Application.cpp

@@ -1969,7 +1969,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();

interface/src/LODManager.cpp

@@ -17,15 +17,34 @@
 
 #include "LODManager.h"
 
-Setting::Handle<bool> automaticAvatarLOD("automaticAvatarLOD", true);
+Setting::Handle<bool> automaticLODAdjust("automaticLODAdjust", true);
-Setting::Handle<float> avatarLODDecreaseFPS("avatarLODDecreaseFPS", DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
+Setting::Handle<float> desktopLODDecreaseFPS("desktopLODDecreaseFPS", DEFAULT_DESKTOP_LOD_DOWN_FPS);
-Setting::Handle<float> avatarLODIncreaseFPS("avatarLODIncreaseFPS",  ADJUST_LOD_UP_FPS);
+Setting::Handle<float> desktopLODIncreaseFPS("desktopLODIncreaseFPS",  DEFAULT_DESKTOP_LOD_UP_FPS);
+Setting::Handle<float> hmdLODDecreaseFPS("hmdLODDecreaseFPS", DEFAULT_HMD_LOD_DOWN_FPS);
+Setting::Handle<float> hmdLODIncreaseFPS("hmdLODIncreaseFPS",  DEFAULT_HMD_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);
 
 
+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) {
     // NOTE: our first ~100 samples at app startup are completely all over the place, and we don't
     // really want to count them in our average, so we will ignore the real frame rates and stuff
@@ -39,66 +58,93 @@ 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();
+            // Avatars... attempt to lower the detail in proportion to the fps difference
-    }
+            float targetFps = (getLODDecreaseFPS() + getLODIncreaseFPS()) * 0.5f;
+            float averageFps = _fastFPSAverage.getAverage();
+            const float MAXIMUM_MULTIPLIER_SCALE = 2.0f;
+            float oldAvatarLODDistanceMultiplier = _avatarLODDistanceMultiplier;
+            _avatarLODDistanceMultiplier = qMin(MAXIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER, _avatarLODDistanceMultiplier *
+                                                (averageFps < EPSILON ? MAXIMUM_MULTIPLIER_SCALE :
+                                                 qMin(MAXIMUM_MULTIPLIER_SCALE, targetFps / averageFps)));
+        
+            if (oldAvatarLODDistanceMultiplier != _avatarLODDistanceMultiplier) {
+                qDebug() << "adjusting LOD down... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
+                            << "_avatarLODDistanceMultiplier=" << _avatarLODDistanceMultiplier;
+                changed = true;
+            }
+
+            // 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) {
+            // Avatars... let the detail level creep slowly upwards
-            lodToolsDialog->reloadSliders();
+            if (_avatarLODDistanceMultiplier < MAXIMUM_AUTO_ADJUST_AVATAR_LOD_DISTANCE_MULTIPLIER) {
+                const float DISTANCE_DECREASE_RATE = 0.05f;
+                float oldAvatarLODDistanceMultiplier = _avatarLODDistanceMultiplier;
+                _avatarLODDistanceMultiplier = qMax(MINIMUM_AVATAR_LOD_DISTANCE_MULTIPLIER,
+                                                    _avatarLODDistanceMultiplier - DISTANCE_DECREASE_RATE);
+                                                    
+                if (oldAvatarLODDistanceMultiplier != _avatarLODDistanceMultiplier) {
+                    qDebug() << "adjusting LOD up... average fps for last approximately 5 seconds=" << _fpsAverage.getAverage()
+                                << "_avatarLODDistanceMultiplier=" << _avatarLODDistanceMultiplier;
+                    changed = true;
+                }
+            }
+
+            // 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) {
+            _shouldRenderTableNeedsRebuilding = true;
+            auto lodToolsDialog = DependencyManager::get<DialogsManager>()->getLodToolsDialog();
+            if (lodToolsDialog) {
+                lodToolsDialog->reloadSliders();
+            }
         }
     }
 }
@@ -106,7 +152,7 @@ void LODManager::autoAdjustLOD(float currentFPS) {
 void LODManager::resetLODAdjust() {
     _fpsAverage.reset();
     _fastFPSAverage.reset();
-    _lastAvatarDetailDrop = _lastAdjust = usecTimestampNow();
+    _lastAdjust = usecTimestampNow();
 }
 
 QString LODManager::getLODFeedbackText() {
@@ -116,29 +162,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;
 }
@@ -194,18 +244,24 @@ void LODManager::setBoundaryLevelAdjust(int boundaryLevelAdjust) {
 
 
 void LODManager::loadSettings() {
-    setAutomaticAvatarLOD(automaticAvatarLOD.get());
+    setAutomaticLODAdjust(automaticLODAdjust.get());
-    setAvatarLODDecreaseFPS(avatarLODDecreaseFPS.get());
+    setDesktopLODDecreaseFPS(desktopLODDecreaseFPS.get());
-    setAvatarLODIncreaseFPS(avatarLODIncreaseFPS.get());
+    setDesktopLODIncreaseFPS(desktopLODIncreaseFPS.get());
+    setHMDLODDecreaseFPS(hmdLODDecreaseFPS.get());
+    setHMDLODIncreaseFPS(hmdLODIncreaseFPS.get());
+
     setAvatarLODDistanceMultiplier(avatarLODDistanceMultiplier.get());
     setBoundaryLevelAdjust(boundaryLevelAdjust.get());
     setOctreeSizeScale(octreeSizeScale.get());
 }
 
 void LODManager::saveSettings() {
-    automaticAvatarLOD.set(getAutomaticAvatarLOD());
+    automaticLODAdjust.set(getAutomaticLODAdjust());
-    avatarLODDecreaseFPS.set(getAvatarLODDecreaseFPS());
+    desktopLODDecreaseFPS.set(getDesktopLODDecreaseFPS());
-    avatarLODIncreaseFPS.set(getAvatarLODIncreaseFPS());
+    desktopLODIncreaseFPS.set(getDesktopLODIncreaseFPS());
+    hmdLODDecreaseFPS.set(getHMDLODDecreaseFPS());
+    hmdLODIncreaseFPS.set(getHMDLODIncreaseFPS());
+
     avatarLODDistanceMultiplier.set(getAvatarLODDistanceMultiplier());
     boundaryLevelAdjust.set(getBoundaryLevelAdjust());
     octreeSizeScale.set(getOctreeSizeScale());

interface/src/LODManager.h

@@ -17,9 +17,10 @@
 #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_DESKTOP_LOD_UP_FPS = 50.0;
-const float DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS = 30.0f;
+const float DEFAULT_HMD_LOD_DOWN_FPS = 60.0;
+const float DEFAULT_HMD_LOD_UP_FPS = 65.0;
 
 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;
@@ -36,6 +37,7 @@ 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;
+const float MAXIMUM_AUTO_ADJUST_AVATAR_LOD_DISTANCE_MULTIPLIER = DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER;
 
 const int ONE_SECOND_OF_FRAMES = 60;
 const int FIVE_SECONDS_OF_FRAMES = 5 * ONE_SECOND_OF_FRAMES;
@@ -46,14 +48,21 @@ 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 void setDesktopLODIncreaseFPS(float value) { _desktopLODIncreaseFPS = value; }
-    void setAvatarLODDistanceMultiplier(float multiplier) { _avatarLODDistanceMultiplier = multiplier; }
+    Q_INVOKABLE float getDesktopLODIncreaseFPS() const { return _desktopLODIncreaseFPS; }
-    float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
+
+    Q_INVOKABLE void setHMDLODDecreaseFPS(float value) { _hmdLODDecreaseFPS = value; }
+    Q_INVOKABLE float getHMDLODDecreaseFPS() const { return _hmdLODDecreaseFPS; }
+    Q_INVOKABLE void setHMDLODIncreaseFPS(float value) { _hmdLODIncreaseFPS = value; }
+    Q_INVOKABLE float getHMDLODIncreaseFPS() const { return _hmdLODIncreaseFPS; }
+
+    Q_INVOKABLE void setAvatarLODDistanceMultiplier(float multiplier) { _avatarLODDistanceMultiplier = multiplier; }
+    Q_INVOKABLE float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
     
     // User Tweakable LOD Items
     Q_INVOKABLE QString getLODFeedbackText();
@@ -63,12 +72,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();
@@ -80,16 +92,18 @@ signals:
 private:
     LODManager() {}
     
-    bool _automaticAvatarLOD = true;
+    bool _automaticLODAdjust = true;
-    float _avatarLODDecreaseFPS = DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS;
+    float _desktopLODDecreaseFPS = DEFAULT_DESKTOP_LOD_DOWN_FPS;
-    float _avatarLODIncreaseFPS = ADJUST_LOD_UP_FPS;
+    float _desktopLODIncreaseFPS = DEFAULT_DESKTOP_LOD_UP_FPS;
+    float _hmdLODDecreaseFPS = DEFAULT_HMD_LOD_DOWN_FPS;
+    float _hmdLODIncreaseFPS = DEFAULT_HMD_LOD_UP_FPS;
+
     float _avatarLODDistanceMultiplier = DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER;
     
     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,51 @@ 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("Automatic LOD Adjustment:", _automaticLODAdjust = new QCheckBox(this));
+    _automaticLODAdjust->setChecked(lodManager->getAutomaticLODAdjust());
+    connect(_automaticLODAdjust, SIGNAL(toggled(bool)), SLOT(updateAutomaticLODAdjust()));
+    
+    form->addRow("Desktop Decrease LOD Below FPS:", _desktopLODDecreaseFPS = new QDoubleSpinBox(this));
+    _desktopLODDecreaseFPS->setValue(lodManager->getDesktopLODDecreaseFPS());
+    _desktopLODDecreaseFPS->setDecimals(0);
+    connect(_desktopLODDecreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateLODValues()));
+    
+    form->addRow("Desktop Increase LOD Above FPS:", _desktopLODIncreaseFPS = new QDoubleSpinBox(this));
+    _desktopLODIncreaseFPS->setValue(lodManager->getDesktopLODIncreaseFPS());
+    _desktopLODIncreaseFPS->setDecimals(0);
+    connect(_desktopLODIncreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateLODValues()));
+
+    form->addRow("HMD Decrease LOD Below FPS:", _hmdLODDecreaseFPS = new QDoubleSpinBox(this));
+    _hmdLODDecreaseFPS->setValue(lodManager->getHMDLODDecreaseFPS());
+    _hmdLODDecreaseFPS->setDecimals(0);
+    connect(_hmdLODDecreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateLODValues()));
+    
+    form->addRow("HMD Increase LOD Above FPS:", _hmdLODIncreaseFPS = new QDoubleSpinBox(this));
+    _hmdLODIncreaseFPS->setValue(lodManager->getHMDLODIncreaseFPS());
+    _hmdLODIncreaseFPS->setDecimals(0);
+    connect(_hmdLODIncreaseFPS, SIGNAL(valueChanged(double)), SLOT(updateLODValues()));
+    
+    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()));
+
     _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 +92,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("Non-Avatar Content LOD:", _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 +102,34 @@ 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());
+
+    _avatarLOD->setValue(1.0 / lodManager->getAvatarLODDistanceMultiplier());
+
 }
 
-void LodToolsDialog::updateAvatarLODControls() {
+void LodToolsDialog::updateAutomaticLODAdjust() {
-    QFormLayout* form = static_cast<QFormLayout*>(layout());
-    
     auto lodManager = DependencyManager::get<LODManager>();
-    lodManager->setAutomaticAvatarLOD(_automaticAvatarLOD->isChecked());
+    lodManager->setAutomaticLODAdjust(_automaticLODAdjust->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() {
+void LodToolsDialog::updateLODValues() {
     auto lodManager = DependencyManager::get<LODManager>();
-    if (_automaticAvatarLOD->isChecked()) {
+
-        lodManager->setAvatarLODDecreaseFPS(_avatarLODDecreaseFPS->value());
+    lodManager->setAutomaticLODAdjust(_automaticLODAdjust->isChecked());
-        lodManager->setAvatarLODIncreaseFPS(_avatarLODIncreaseFPS->value());
+
-        
+    lodManager->setDesktopLODDecreaseFPS(_desktopLODDecreaseFPS->value());
-    } else {
+    lodManager->setDesktopLODIncreaseFPS(_desktopLODIncreaseFPS->value());
-        lodManager->setAvatarLODDistanceMultiplier(1.0 / _avatarLOD->value());
+    lodManager->setHMDLODDecreaseFPS(_hmdLODDecreaseFPS->value());
-    }
+    lodManager->setHMDLODIncreaseFPS(_hmdLODIncreaseFPS->value());
+
+    lodManager->setAvatarLODDistanceMultiplier(1.0 / _avatarLOD->value());
 }
 
 void LodToolsDialog::sizeScaleValueChanged(int value) {
@@ -160,20 +140,19 @@ 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);
+    _automaticLODAdjust->setChecked(true);
-    _automaticAvatarLOD->setChecked(true);
+    _desktopLODDecreaseFPS->setValue(DEFAULT_DESKTOP_LOD_DOWN_FPS);
-    _avatarLODDecreaseFPS->setValue(DEFAULT_ADJUST_AVATAR_LOD_DOWN_FPS);
+    _desktopLODIncreaseFPS->setValue(DEFAULT_DESKTOP_LOD_UP_FPS);
-    _avatarLODIncreaseFPS->setValue(ADJUST_LOD_UP_FPS);
+    _hmdLODDecreaseFPS->setValue(DEFAULT_HMD_LOD_DOWN_FPS);
+    _hmdLODIncreaseFPS->setValue(DEFAULT_HMD_LOD_UP_FPS);
+
+    _avatarLOD->setValue(1.0 / DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER);
+    
+    updateLODValues(); // tell our LOD manager about the reset
 }
 
 void LodToolsDialog::reject() {

interface/src/ui/LodToolsDialog.h

@@ -31,11 +31,10 @@ 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();
+    void updateLODValues();
 
 protected:
 
@@ -44,10 +43,16 @@ protected:
 
 private:
     QSlider* _lodSize;
-    QSlider* _boundaryLevelAdjust;
+
-    QCheckBox* _automaticAvatarLOD;
+    QCheckBox* _automaticLODAdjust;
-    QDoubleSpinBox* _avatarLODDecreaseFPS;
+
-    QDoubleSpinBox* _avatarLODIncreaseFPS;
+    QDoubleSpinBox* _desktopLODDecreaseFPS;
+    QDoubleSpinBox* _desktopLODIncreaseFPS;
+
+    QDoubleSpinBox* _hmdLODDecreaseFPS;
+    QDoubleSpinBox* _hmdLODIncreaseFPS;
+
+
     QDoubleSpinBox* _avatarLOD;
     QLabel* _feedback;
 };