Geenz/texture loading speed (#5985)

* Add more controls for texture loading budgets.  Should yield much faster loading within a given FPS target - should generally self regulate depending on your framerate.

* Harden texture pipeline against stalls and OOM.  Generally makes texture loading faster, at the expense of some budgeting (which we weren't doing a great job at anyways).

Author: Geenz

indra/llrender/llgl.cpp

@@ -2370,6 +2370,12 @@ void clear_glerror()
     glGetError();
 }
 
+void drain_glerror()
+{
+    // bounded: a lost/reset context can return errors indefinitely
+    for (S32 i = 0; i < 16 && glGetError() != GL_NO_ERROR; ++i) {}
+}
+
 ///////////////////////////////////////////////////////////////
 //
 // LLGLState

indra/llrender/llgl.h

@@ -159,6 +159,7 @@ void log_glerror();
 void assert_glerror();
 
 void clear_glerror();
+void drain_glerror(); // pops ALL pending GL error flags (bounded so a lost/reset context that returns errors forever cannot hang the caller); use before an attributable glGetError check.
 
 
 # define stop_glerror() assert_glerror()

indra/llrender/llimagegl.cpp

@@ -1507,7 +1507,7 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt
         // Drain stale GL errors so an OOM detected below belongs to this alloc.
         // Otherwise a failed glTexImage2D is swallowed in release while
         // alloc_tex_image still counts the bytes, inflating the used-VRAM figure.
-        while (glGetError() != GL_NO_ERROR) {}
+        drain_glerror();
 
         const bool use_sub_image = should_stagger_image_set(compress);
         if (!use_sub_image)
@@ -1919,7 +1919,8 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
 
     //-----------------------------------------------------------------------------------------------
     GLenum error ;
-    while((error = glGetError()) != GL_NO_ERROR)
+    S32 error_count = 0 ;
+    while((error = glGetError()) != GL_NO_ERROR && ++error_count <= 16)
     {
         LL_WARNS() << "GL Error happens before reading back texture. Error code: " << error << LL_ENDL ;
     }
@@ -1979,7 +1980,8 @@ bool LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
         LL_WARNS() << "GL Error happens after reading back texture. Error code: " << error << LL_ENDL ;
         imageraw->deleteData() ;
 
-        while((error = glGetError()) != GL_NO_ERROR)
+        error_count = 0 ;
+        while((error = glGetError()) != GL_NO_ERROR && ++error_count <= 16)
         {
             LL_WARNS() << "GL Error happens after reading back texture. Error code: " << error << LL_ENDL ;
         }
@@ -2548,8 +2550,10 @@ bool LLImageGL::scaleDown(S32 desired_discard)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 
-    // Don't let eviction re-arm visibility: the glGenerateMipmap re-bind below
-    // would otherwise stamp mLastBindFrame and keep the texture fetch-eligible.
+    // Don't let eviction re-arm the GC: the glGenerateMipmap re-bind below would
+    // otherwise stamp mLastBindFrame, so the next computeDesiredDiscard treats the
+    // just-evicted texture as freshly drawn, un-floors it, and re-fetches - the
+    // evict/refetch oscillation.
     LLImageGLStampBypass no_stamp;
 
     if (mTarget != GL_TEXTURE_2D

indra/newview/app_settings/settings.xml

@@ -11992,16 +11992,49 @@
       <key>Value</key>
       <integer>1</integer>
     </map>
-    <key>TextureFetchVisibilityFrames</key>
+    <key>TextureLoadTargetFPS</key>
     <map>
       <key>Comment</key>
-      <string>Only fetch a texture if it was drawn within this many rendered frames; out-of-view content isn't fetched. Minimum 1 (0 is clamped up). Boosted/UI textures, avatar bakes, and callback textures are exempt.</string>
+      <string>Frame rate the viewer is willing to drop to while loading textures. The texture pipeline's per-frame budget is the headroom between this and the actual frame cost, so fast machines load aggressively and slow ones hold their frame rate.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>30.0</real>
+    </map>
+    <key>TextureLoadBudgetMaxMS</key>
+    <map>
+      <key>Comment</key>
+      <string>Hard cap, in milliseconds per frame, on the adaptive texture-pipeline budget.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>10.0</real>
+    </map>
+    <key>TextureFetchStepMips</key>
+    <map>
+      <key>Comment</key>
+      <string>Fetch refinement step, in mip levels: a texture whose resident data is coarser than desired by more than this fetches in steps of this size instead of jumping straight to the final resolution, so it sharpens progressively instead of sitting blurry then popping. 0 = jump directly. Boosted/pinned textures always jump.</string>
       <key>Persist</key>
       <integer>1</integer>
       <key>Type</key>
       <string>U32</string>
       <key>Value</key>
+      <integer>2</integer>
+    </map>
+    <key>TextureFrustumAllowance</key>
+    <map>
+      <key>Comment</key>
+      <string>Falloff width for out-of-frustum texture resolution, as a fraction of screen size. Content grazing the screen edge keeps full resolution; content this far past the edge reaches the deepest mip, lerped between. Keeps barely-out-of-view textures resident so panning back doesn't refetch them.</string>
+      <key>Persist</key>
       <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>0.5</real>
     </map>
     <key>TextureDecodeDisabled</key>
     <map>

indra/newview/llface.cpp

@@ -2297,6 +2297,8 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
     // don't update every frame
     if (gFrameTimeSeconds - mLastPixelAreaUpdate < PIXEL_AREA_UPDATE_PERIOD)
     {
+        cos_angle_to_view_dir = mLastCosAngleToViewDir;
+        radius = mLastRadius;
         return true;
     }
 
@@ -2368,6 +2370,7 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
             // no rigged extents, zero out bounding box and skip update
             mRiggedExtents[0] = mRiggedExtents[1] = LLVector4a(0.f, 0.f, 0.f);
 
+            mInFrustum = false;
             return false;
         }
 
@@ -2422,6 +2425,7 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
         if(!camera->AABBInFrustum(center, size))
         {
             mImportanceToCamera = 0.f ;
+            mInFrustum = false;
             return false ;
         }
         if(cos_angle_to_view_dir > camera->getCosHalfFov()) //the center is within the view frustum
@@ -2450,6 +2454,24 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
         mImportanceToCamera = LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist) ;
     }
 
+    // On-screen test: does the face's projected disc overlap the screen disc?
+    // (Same construction as adjustPartialOverlapPixelArea.) Behind-camera faces
+    // get acos(cos) near pi and fall out; the generous screen radius errs toward
+    // "on screen" so fetch admission never starves edge content. mFrustumOverflow
+    // is how far past the boundary the disc sits, as a fraction of screen size -
+    // 0 on screen, 0.1 = 10% of a screen out - and feeds the frustum allowance
+    // falloff in computeDesiredDiscard.
+    {
+        F32 center_px = acosf(llclamp(cos_angle_to_view_dir, -1.f, 1.f)) * LLDrawable::sCurPixelAngle;
+        F32 screen_radius = (F32)llmax(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw());
+        F32 past_edge = center_px - radius - screen_radius;
+        mInFrustum = past_edge <= 5.f;
+        mFrustumOverflow = llmax(past_edge - 5.f, 0.f) / screen_radius;
+    }
+
+    mLastCosAngleToViewDir = cos_angle_to_view_dir;
+    mLastRadius = radius;
+
     return true ;
 }
 

indra/newview/llface.h

@@ -269,10 +269,21 @@ class alignas(16) LLFace
     // return mSkinInfo->mHash or 0 if mSkinInfo is null
     U64 getSkinHash();
 
-    // true if face was recently in the main camera frustum according to LLViewerTextureList updates
+    // True if this face's projected bounding disc overlaps the screen - maintained
+    // by calcPixelArea() (sticky between its throttled updates). Drives per-texture
+    // fetch admission (LLViewerTextureList::updateImageDecodePriority -> mOnScreen).
     bool mInFrustum = false;
+    // How far past the screen boundary the projected disc sits, as a fraction of
+    // screen size (0 = on screen). Feeds the frustum-allowance falloff so barely
+    // out-of-view content keeps its resolution. Maintained with mInFrustum.
+    F32 mFrustumOverflow = 0.f;
     // value of gFrameCount the last time the face was touched by LLViewerTextureList::updateImageDecodePriority
     U32 mLastTextureUpdate = 0;
+    // Cached per-channel streaming coverage (repeat-adjusted screen pixels),
+    // refreshed at the mLastTextureUpdate cadence and shared by every texture
+    // on this face. 0 = degenerate / not yet measured. See
+    // update_face_stream_vsize in llviewertexturelist.cpp.
+    F32 mStreamVSize[LLRender::NUM_TEXTURE_CHANNELS] = {};
 
 private:
     LLPointer<LLVertexBuffer> mVertexBuffer;
@@ -309,6 +320,11 @@ class alignas(16) LLFace
     // gFrameTimeSeconds when mPixelArea was last updated
     F32         mLastPixelAreaUpdate = 0.f;
 
+    // Last cos-angle-to-view-dir and projected radius computed by calcPixelArea;
+    // reused by its throttled early-return so the overlap test gets real values.
+    F32         mLastCosAngleToViewDir = 1.f;
+    F32         mLastRadius = 0.f;
+
     // virtual size of face in texture area  (mPixelArea adjusted by texture repeats)
     // used to determine desired resolution of texture
     F32         mVSize;

indra/newview/llviewerdisplay.cpp

@@ -140,6 +140,27 @@ void render_disconnected_background();
 void getProfileStatsContext(boost::json::object& stats);
 std::string getProfileStatsFilename();
 
+// Adaptive texture-pipeline budget: spend the frame-time headroom between the
+// frame we're rendering and TextureLoadTargetFPS, clamped [2ms, max]. Headroom
+// is measured (smoothed frame interval minus the pipeline's own last spend),
+// so fast machines get big budgets and machines already at target hold the
+// floor. Only consumed while queues have work - drain loops exit when empty.
+static F32 sTexturePipelineSpent = 0.f;
+static F32 texture_pipeline_budget()
+{
+    static LLCachedControl<F32> target_fps(gSavedSettings, "TextureLoadTargetFPS", 60.f);
+    static LLCachedControl<F32> max_ms(gSavedSettings, "TextureLoadBudgetMaxMS", 10.f);
+    static F32 smoothed_other = 0.008f;
+    F32 other = llmax(gFrameIntervalSeconds.value() - sTexturePipelineSpent, 0.f);
+    // A single multi-second hitch must not crater the budget for the following
+    // frames, so cap the sample before it enters the EMA.
+    other = llmin(other, 0.1f);
+    smoothed_other = smoothed_other * 0.9f + other * 0.1f;
+    F32 target_interval = 1.f / llclamp((F32)target_fps, 15.f, 240.f);
+    F32 headroom = target_interval - smoothed_other;
+    return llclamp(headroom, 0.002f, llclamp((F32)max_ms, 2.f, 50.f) * 0.001f);
+}
+
 void display_startup()
 {
     if (   !gViewerWindow
@@ -500,9 +521,10 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot)
 
             {
                 LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("List");
-                F32 max_image_decode_time = 0.050f * gFrameIntervalSeconds.value();          // 50 ms/second decode time
-                max_image_decode_time     = llclamp(max_image_decode_time, 0.002f, 0.005f);  // min 2ms/frame, max 5ms/frame)
+                F32 max_image_decode_time = texture_pipeline_budget();
+                LLTimer tex_timer;
                 gTextureList.updateImages(max_image_decode_time);
+                sTexturePipelineSpent = tex_timer.getElapsedTimeF32();
             }
 
             {
@@ -862,9 +884,10 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot)
 
             {
                 LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("List");
-                F32 max_image_decode_time = 0.050f*gFrameIntervalSeconds.value(); // 50 ms/second decode time
-                max_image_decode_time = llclamp(max_image_decode_time, 0.002f, 0.005f ); // min 2ms/frame, max 5ms/frame)
+                F32 max_image_decode_time = texture_pipeline_budget();
+                LLTimer tex_timer;
                 gTextureList.updateImages(max_image_decode_time);
+                sTexturePipelineSpent = tex_timer.getElapsedTimeF32();
             }
 
             {