big sweep

interface/src/LODManager.cpp

@@ -31,7 +31,6 @@ Setting::Handle<float> renderDistanceInverseHighLimit("renderDistanceInverseHigh
 void LODManager::setRenderDistanceInverseHighLimit(float newValue) {
     renderDistanceInverseHighLimit.set(newValue); // persist it, and tell all the controllers that use it
     _renderDistanceController.setControlledValueHighLimit(newValue);
-   DependencyManager::get<AvatarManager>()->setRenderDistanceInverseHighLimit(newValue);
 }
 
 LODManager::LODManager() {
@@ -252,12 +251,8 @@ int LODManager::getRenderedCount() {
     return lastRenderedCount;
 }
 QString LODManager::getLODStatsRenderText() {
-    if (getUseAcuity()) {
-        auto avatarManager = DependencyManager::get<AvatarManager>();
-        return QString("Renderable avatars: ") + QString::number(avatarManager->getNumberInRenderRange()) + " w/in " + QString::number((int)avatarManager->getRenderDistance()) + "m";
-    } else {
-        return QString("Rendered objects: ") + QString::number(getRenderedCount()) + " w/in " + QString::number((int)getRenderDistance()) + "m";
-    }
+    QString label = getUseAcuity() ? "Renderable avatars: " : "Rendered objects: ";
+    return label + QString::number(getRenderedCount()) + " w/in " + QString::number((int)getRenderDistance()) + "m";
 }
 // compare audoAdjustLOD()
 void LODManager::updatePIDRenderDistance(float targetFps, float measuredFps, float deltaTime, bool isThrottled) {

interface/src/Menu.h

@@ -64,6 +64,7 @@ public:
     void saveSettings();
 
     MenuWrapper* getMenu(const QString& menuName);
+    MenuWrapper* getSubMenuFromName(const QString& menuName, MenuWrapper* menu);
 
     void triggerOption(const QString& menuOption);
     QAction* getActionForOption(const QString& menuOption);
@@ -128,7 +129,6 @@ private:
                                        const QString& grouping = QString());
 
     QAction* getActionFromName(const QString& menuName, MenuWrapper* menu);
-    MenuWrapper* getSubMenuFromName(const QString& menuName, MenuWrapper* menu);
     MenuWrapper* getMenuParent(const QString& menuName, QString& finalMenuPart);
 
     QAction* getMenuAction(const QString& menuName);

interface/src/avatar/Avatar.cpp

@@ -164,26 +164,6 @@ void Avatar::simulate(float deltaTime) {
         _shouldRenderBillboard = true;
         qCDebug(interfaceapp) << "Billboarding" << (isMyAvatar() ? "myself" : getSessionUUID()) << "for LOD" << getLODDistance();
     }
-    
-    const bool isControllerLogging = DependencyManager::get<AvatarManager>()->getRenderDistanceControllerIsLogging();
-    float renderDistance = DependencyManager::get<AvatarManager>()->getRenderDistance();
-    const float SKIP_HYSTERESIS_PROPORTION = isControllerLogging ? 0.0f : BILLBOARD_HYSTERESIS_PROPORTION;
-    float distance = glm::distance(qApp->getCamera()->getPosition(), getPosition());
-    if (_shouldSkipRender) {
-        if (distance < renderDistance * (1.0f - SKIP_HYSTERESIS_PROPORTION)) {
-            _shouldSkipRender = false;
-            _skeletonModel.setVisibleInScene(true, qApp->getMain3DScene());
-            if (!isControllerLogging) {  // Test for isMyAvatar is prophylactic. Never occurs in current code.
-                qCDebug(interfaceapp) << "Rerendering" << (isMyAvatar() ? "myself" : getSessionUUID()) << "for distance" << renderDistance;
-            }
-        }
-    } else if (distance > renderDistance * (1.0f + SKIP_HYSTERESIS_PROPORTION)) {
-        _shouldSkipRender = true;
-        _skeletonModel.setVisibleInScene(false, qApp->getMain3DScene());
-        if (!isControllerLogging) {
-            qCDebug(interfaceapp) << "Unrendering" << (isMyAvatar() ? "myself" : getSessionUUID()) << "for distance" << renderDistance;
-        }
-    }
 
     // simple frustum check
     float boundingRadius = getBillboardSize();

interface/src/avatar/AvatarManager.cpp

@@ -92,19 +92,6 @@ void AvatarManager::init() {
         _myAvatar->addToScene(_myAvatar, scene, pendingChanges);
     }
     scene->enqueuePendingChanges(pendingChanges);
-
-    const float target_fps = qApp->getTargetFrameRate();
-    _renderDistanceController.setMeasuredValueSetpoint(target_fps / 2.0f);
-    _renderDistanceController.setControlledValueHighLimit(DependencyManager::get<LODManager>()->getRenderDistanceInverseHighLimit());
-    _renderDistanceController.setControlledValueLowLimit(1.0f / (float) TREE_SCALE);
-    // Advice for tuning parameters:
-    // See PIDController.h. There's a section on tuning in the reference.
-    // Turn on logging with the following (or from js with AvatarList.setRenderDistanceControllerHistory("avatar render", 300))
-    //_renderDistanceController.setHistorySize("avatar render", target_fps * 4);
-    // Note that extra logging/hysteresis is turned off in Avatar.cpp when the above logging is on.
-    _renderDistanceController.setKP(0.0008f); // Usually about 0.6 of largest that doesn't oscillate when other parameters 0.
-    _renderDistanceController.setKI(0.0006f); // Big enough to bring us to target with the above KP.
-    _renderDistanceController.setKD(0.000001f); // A touch of kd increases the speed by which we get there.
 }
 
 void AvatarManager::updateMyAvatar(float deltaTime) {
@@ -139,23 +126,6 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
 
     PerformanceTimer perfTimer("otherAvatars");
     
-    float distance;
-    if (!qApp->isThrottleRendering()) {
-        _renderDistanceController.setMeasuredValueSetpoint(qApp->getTargetFrameRate()); // No problem updating in flight.
-        // The PID controller raises the controlled value when the measured value goes up.
-        // The measured value is frame rate. When the controlled value (1 / render cutoff distance)
-        // goes up, the render cutoff distance gets closer, the number of rendered avatars is less, and frame rate
-        // goes up.
-        const float deduced = qApp->getLastUnsynchronizedFps();
-        distance = 1.0f / _renderDistanceController.update(deduced, deltaTime);
-    } else {
-        // Here we choose to just use the maximum render cutoff distance if throttled.
-        distance = 1.0f / _renderDistanceController.getControlledValueLowLimit();
-    }
-    _renderDistanceAverage.updateAverage(distance);
-    _renderDistance = _renderDistanceAverage.getAverage();
-    int renderableCount = 0;
-
     // simulate avatars
     auto hashCopy = getHashCopy();
     
@@ -173,14 +143,10 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
         } else {
             avatar->startUpdate();
             avatar->simulate(deltaTime);
-            if (avatar->getShouldRender()) {
-                renderableCount++;
-            }
             avatar->endUpdate();
             ++avatarIterator;
         }
     }
-    _renderedAvatarCount = renderableCount;
 
     // simulate avatar fades
     simulateAvatarFades(deltaTime);

interface/src/avatar/AvatarManager.h

@@ -45,7 +45,6 @@ public:
     void clearOtherAvatars();
    
     bool shouldShowReceiveStats() const { return _shouldShowReceiveStats; }
-    PIDController& getRenderDistanceController()  { return _renderDistanceController; }
 
     class LocalLight {
     public:
@@ -67,20 +66,7 @@ public:
     void handleCollisionEvents(const CollisionEvents& collisionEvents);
 
     void updateAvatarPhysicsShape(Avatar* avatar);
-    
-    // Expose results and parameter-tuning operations to other systems, such as stats and javascript.
-    Q_INVOKABLE float getRenderDistance() { return _renderDistance; }
-    Q_INVOKABLE float getRenderDistanceInverseLowLimit() { return _renderDistanceController.getControlledValueLowLimit(); }
-    Q_INVOKABLE float getRenderDistanceInverseHighLimit() { return _renderDistanceController.getControlledValueHighLimit(); }
-    Q_INVOKABLE int getNumberInRenderRange() { return _renderedAvatarCount; }
-    Q_INVOKABLE bool getRenderDistanceControllerIsLogging() { return _renderDistanceController.getIsLogging(); }
-    Q_INVOKABLE void setRenderDistanceControllerHistory(QString label, int size) { return _renderDistanceController.setHistorySize(label, size); }
-    Q_INVOKABLE void setRenderDistanceKP(float newValue) { _renderDistanceController.setKP(newValue); }
-    Q_INVOKABLE void setRenderDistanceKI(float newValue) { _renderDistanceController.setKI(newValue); }
-    Q_INVOKABLE void setRenderDistanceKD(float newValue) { _renderDistanceController.setKD(newValue); }
-    Q_INVOKABLE void setRenderDistanceInverseLowLimit(float newValue) { _renderDistanceController.setControlledValueLowLimit(newValue); }
-    Q_INVOKABLE void setRenderDistanceInverseHighLimit(float newValue) { _renderDistanceController.setControlledValueHighLimit(newValue); }
-   
+       
 public slots:
     void setShouldShowReceiveStats(bool shouldShowReceiveStats) { _shouldShowReceiveStats = shouldShowReceiveStats; }
     void updateAvatarRenderStatus(bool shouldRenderAvatars);
@@ -106,10 +92,6 @@ private:
     QVector<AvatarManager::LocalLight> _localLights;
 
     bool _shouldShowReceiveStats = false;
-    float _renderDistance { (float) TREE_SCALE };
-    int _renderedAvatarCount { 0 };
-    PIDController _renderDistanceController { };
-    SimpleMovingAverage _renderDistanceAverage { 10 };
 
     SetOfAvatarMotionStates _avatarMotionStates;
     SetOfMotionStates _motionStatesToAdd;

interface/src/ui/PreferencesDialog.cpp

@@ -67,6 +67,7 @@ void PreferencesDialog::changeUseAcuity() {
     ui.hmdMinimumFPSSpin->setEnabled(useAcuity);
     ui.label_smallestReasonableRenderHorizon->setText(useAcuity ? "Minimum Avatar Display Distance (@half speed)" : "Minimum Display Distance (@half speed)");
     Menu::getInstance()->getActionForOption(MenuOption::LodTools)->setEnabled(useAcuity);
+    Menu::getInstance()->getSubMenuFromName(MenuOption::RenderResolution, Menu::getInstance()->getSubMenuFromName("Render", Menu::getInstance()->getMenu("Developer")))->setEnabled(useAcuity);
 }
 void PreferencesDialog::changeFullAvatarURL() {
     DependencyManager::get<AvatarManager>()->getMyAvatar()->useFullAvatarURL(ui.appearanceDescription->text(), "");