snapshot. It works.

interface/src/Application.cpp

@@ -1106,7 +1106,7 @@ void Application::paintGL() {
     // This is not the same as update(deltaTime), because the latter attempts to throttle to 60hz and also clamps to 1/4 second.
     const float actualPeriod = diff / (float)USECS_PER_SECOND; // same as 1/instantaneousFps but easier for compiler to optimize
     // Note that _lastPaintWait (stored at end of last call) is for the same paint cycle.
-    float deducedNonVSyncPeriod = actualPeriod - _lastPaintWait; // plus a some non-zero time for machinery we can't measure
+    float deducedNonVSyncPeriod = actualPeriod - _lastPaintWait + 0.002f; // plus a some non-zero time for machinery we can't measure
     // We don't know how much time to allow for that, but if we went over the target period, we know it's at least the portion
     // of paintWait up to the next vSync. This gives us enough of a penalty so that when actualPeriod crosses two cycles,
     // the key part (and not an exagerated part) of _lastPaintWait is accounted for.

interface/src/Application.h

@@ -163,6 +163,7 @@ public:
     float getLastInstanteousFps() const { return _lastInstantaneousFps; }
     float getLastPaintWait() const { return _lastPaintWait; };
     float getLastDeducedNonVSyncFps() const { return _lastDeducedNonVSyncFps; }
+    void setMarginForDeducedFramePeriod(float newValue) { _marginForDeducedFramePeriod = newValue; }
 
     float getFieldOfView() { return _fieldOfView.get(); }
     void setFieldOfView(float fov);
@@ -437,6 +438,7 @@ private:
     float _lastInstantaneousFps { 0.0f };
     float _lastPaintWait { 0.0f };
     float _lastDeducedNonVSyncFps { 0.0f };
+    float _marginForDeducedFramePeriod { 1.0f };
 
     ShapeManager _shapeManager;
     PhysicalEntitySimulation _entitySimulation;

interface/src/avatar/AvatarManager.cpp

@@ -101,9 +101,9 @@ void AvatarManager::init() {
     // 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.0005f); // Usually about 0.6 of largest that doesn't oscillate when other parameters 0.
-    _renderDistanceController.setKI(0.0004f); // Big enough to bring us to target with the above KP.
-    _renderDistanceController.setKD(0.00001f); // A touch of kd increases the speed by which we get there.
+    _renderDistanceController.setKP(0.0006f); // Usually about 0.6 of largest that doesn't oscillate when other parameters 0.
+    _renderDistanceController.setKI(0.0005f); // 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.
 
 }
 
@@ -140,7 +140,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     // 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->getLastDeducedNonVSyncFps();
+    const float deduced = qApp->getLastDeducedNonVSyncFps() - _renderPresentationAllowance;
     const float distance = 1.0f / _renderDistanceController.update(deduced, deltaTime, false, fps, paintWait);
     _renderDistanceAverage.updateAverage(distance);
     _renderDistance = _renderDistanceAverage.getAverage();

interface/src/avatar/AvatarManager.h

@@ -73,11 +73,12 @@ public:
     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 f) { _renderDistanceController.setKP(f); }
-    Q_INVOKABLE void setRenderDistanceKI(float f) { _renderDistanceController.setKI(f); }
-    Q_INVOKABLE void setRenderDistanceKD(float f) { _renderDistanceController.setKD(f); }
-    Q_INVOKABLE void setRenderDistanceLowLimit(float f) { _renderDistanceController.setControlledValueLowLimit(f); }
-    Q_INVOKABLE void setRenderDistanceHighLimit(float f) { _renderDistanceController.setControlledValueHighLimit(f); }
+    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 setRenderDistanceLowLimit(float newValue) { _renderDistanceController.setControlledValueLowLimit(newValue); }
+    Q_INVOKABLE void setRenderDistanceHighLimit(float newValue) { _renderDistanceController.setControlledValueHighLimit(newValue); }
+   // Q_INVOKABLE void setRenderPresentationAllowance(float newValue) { qApp->setMarginForDeducedFramePeriod(newValue); }
    
 public slots:
     void setShouldShowReceiveStats(bool shouldShowReceiveStats) { _shouldShowReceiveStats = shouldShowReceiveStats; }
@@ -103,9 +104,10 @@ private:
 
     bool _shouldShowReceiveStats = false;
     float _renderDistance { (float) TREE_SCALE };
-    int _renderedAvatarCount {0};
-    PIDController _renderDistanceController {};
-    SimpleMovingAverage _renderDistanceAverage {10};
+    int _renderedAvatarCount { 0 };
+    float _renderPresentationAllowance { 0.0f };
+    PIDController _renderDistanceController { };
+    SimpleMovingAverage _renderDistanceAverage { 10 };