From ce139f26e0542e3ab4c2334c10044a2af9085049 Mon Sep 17 00:00:00 2001 From: Andrey Kleshchev <117672381+akleshchev@users.noreply.github.com> Date: Wed, 4 Mar 2026 22:39:47 +0200 Subject: #5486 Fix potential unpackBinaryData buffer issues --- indra/newview/llviewerobject.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'indra/newview/llviewerobject.cpp') diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp index db1ef54ffa..521c6731e0 100644 --- a/indra/newview/llviewerobject.cpp +++ b/indra/newview/llviewerobject.cpp @@ -1529,7 +1529,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys, U16 param_type; S32 param_size; dp.unpackU16(param_type, "param_type"); - dp.unpackBinaryData(param_block, param_size, "param_data"); + dp.unpackBinaryData(param_block, MAX_OBJECT_PARAMS_SIZE, param_size, "param_data"); //LL_INFOS() << "Param type: " << param_type << ", Size: " << param_size << LL_ENDL; LLDataPackerBinaryBuffer dp2(param_block, param_size); unpackParameterEntry(param_type, &dp2); @@ -1786,7 +1786,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys, dp->unpackU32(size, "ScratchPadSize"); delete [] mData; mData = new U8[size]; - dp->unpackBinaryData((U8 *)mData, sp_size, "PartData"); + dp->unpackBinaryData((U8 *)mData, size, sp_size, "PartData"); } else { @@ -1859,7 +1859,7 @@ U32 LLViewerObject::processUpdateMessage(LLMessageSystem *mesgsys, U16 param_type; S32 param_size; dp->unpackU16(param_type, "param_type"); - dp->unpackBinaryData(param_block, param_size, "param_data"); + dp->unpackBinaryData(param_block, MAX_OBJECT_PARAMS_SIZE, param_size, "param_data"); //LL_INFOS() << "Param type: " << param_type << ", Size: " << param_size << LL_ENDL; LLDataPackerBinaryBuffer dp2(param_block, param_size); unpackParameterEntry(param_type, &dp2); -- cgit v1.3 From 5b485bdc6046867e8b03906e8bdd0f02471f9fa8 Mon Sep 17 00:00:00 2001 From: Andrey Kleshchev <117672381+akleshchev@users.noreply.github.com> Date: Fri, 3 Apr 2026 02:11:15 +0300 Subject: #5612 Improve profiling coverage --- indra/llmessage/llassetstorage.cpp | 3 ++- indra/newview/llfloaterinspect.cpp | 1 + indra/newview/llremoteparcelrequest.cpp | 1 + indra/newview/llviewergenericmessage.cpp | 3 +++ indra/newview/llviewermessage.cpp | 8 ++++++++ indra/newview/llviewerobject.cpp | 1 + indra/newview/llvoavatar.cpp | 1 + indra/newview/llworld.cpp | 1 + indra/newview/llworldmapmessage.cpp | 2 ++ 9 files changed, 20 insertions(+), 1 deletion(-) (limited to 'indra/newview/llviewerobject.cpp') diff --git a/indra/llmessage/llassetstorage.cpp b/indra/llmessage/llassetstorage.cpp index 4c3acb27f4..b6a98575f9 100644 --- a/indra/llmessage/llassetstorage.cpp +++ b/indra/llmessage/llassetstorage.cpp @@ -453,6 +453,7 @@ bool LLAssetStorage::findInCacheAndInvokeCallback(const LLUUID& uuid, LLAssetTyp bool exists = LLFileSystem::getExists(uuid, type); if (exists) { + LL_PROFILE_ZONE_SCOPED; LLFileSystem file(uuid, type); U32 size = file.getSize(); if (size > 0) @@ -562,7 +563,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid, if (callback == tmp->mDownCallback && user_data == tmp->mUserData) { // this is a duplicate from the same subsystem - throw it away - LL_WARNS("AssetStorage") << "Discarding duplicate request for asset " << uuid + LL_DEBUGS("AssetStorage") << "Discarding duplicate request for asset " << uuid << "." << LLAssetType::lookup(type) << LL_ENDL; return; } diff --git a/indra/newview/llfloaterinspect.cpp b/indra/newview/llfloaterinspect.cpp index c0fe7ad896..163edf0426 100644 --- a/indra/newview/llfloaterinspect.cpp +++ b/indra/newview/llfloaterinspect.cpp @@ -100,6 +100,7 @@ void LLFloaterInspect::onOpen(const LLSD& key) LLSelectMgr::getInstance()->setForceSelection(forcesel); // restore previouis value mObjectSelection = LLSelectMgr::getInstance()->getSelection(); refresh(); + mDirty = false; } void LLFloaterInspect::onClickCreatorProfile() { diff --git a/indra/newview/llremoteparcelrequest.cpp b/indra/newview/llremoteparcelrequest.cpp index f89afd38ab..c1b33f313b 100644 --- a/indra/newview/llremoteparcelrequest.cpp +++ b/indra/newview/llremoteparcelrequest.cpp @@ -84,6 +84,7 @@ void LLRemoteParcelInfoProcessor::removeObserver(const LLUUID& parcel_id, LLRemo //static void LLRemoteParcelInfoProcessor::processParcelInfoReply(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLParcelData parcel_data; msg->getUUID ("Data", "ParcelID", parcel_data.parcel_id); diff --git a/indra/newview/llviewergenericmessage.cpp b/indra/newview/llviewergenericmessage.cpp index fd894a5997..f3a0f026b8 100644 --- a/indra/newview/llviewergenericmessage.cpp +++ b/indra/newview/llviewergenericmessage.cpp @@ -73,6 +73,7 @@ void send_generic_message(const std::string& method, void process_generic_message(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID agent_id; msg->getUUID("AgentData", "AgentID", agent_id); if (agent_id != gAgent.getID()) @@ -95,6 +96,7 @@ void process_generic_message(LLMessageSystem* msg, void**) void process_generic_streaming_message(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLGenericStreamingMessage data; data.unpack(msg); switch (data.mMethod) @@ -110,6 +112,7 @@ void process_generic_streaming_message(LLMessageSystem* msg, void**) void process_large_generic_message(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID agent_id; msg->getUUID("AgentData", "AgentID", agent_id); if (agent_id != gAgent.getID()) diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp index 5d8bd45218..812ba76551 100644 --- a/indra/newview/llviewermessage.cpp +++ b/indra/newview/llviewermessage.cpp @@ -3554,6 +3554,7 @@ extern U32Bits gObjectData; void process_object_update(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; // Update the data counters if (mesgsys->getReceiveCompressedSize()) { @@ -3575,6 +3576,7 @@ void process_object_update(LLMessageSystem *mesgsys, void **user_data) void process_compressed_object_update(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; // Update the data counters if (mesgsys->getReceiveCompressedSize()) { @@ -3596,6 +3598,7 @@ void process_compressed_object_update(LLMessageSystem *mesgsys, void **user_data void process_cached_object_update(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; // Update the data counters if (mesgsys->getReceiveCompressedSize()) { @@ -3613,6 +3616,7 @@ void process_cached_object_update(LLMessageSystem *mesgsys, void **user_data) void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; if (mesgsys->getReceiveCompressedSize()) { gObjectData += (U32Bytes)mesgsys->getReceiveCompressedSize(); @@ -3972,6 +3976,7 @@ void process_sim_stats(LLMessageSystem *msg, void **user_data) void process_avatar_animation(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID animation_id; LLUUID uuid; S32 anim_sequence_id; @@ -4083,6 +4088,7 @@ void process_avatar_animation(LLMessageSystem *mesgsys, void **user_data) void process_object_animation(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID animation_id; LLUUID uuid; S32 anim_sequence_id; @@ -4148,6 +4154,7 @@ void process_object_animation(LLMessageSystem *mesgsys, void **user_data) void process_avatar_appearance(LLMessageSystem *mesgsys, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID uuid; mesgsys->getUUIDFast(_PREHASH_Sender, _PREHASH_ID, uuid); @@ -5679,6 +5686,7 @@ void process_script_experience_details(const LLSD& experience_details, LLSD args void process_script_question(LLMessageSystem *msg, void **user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; // *TODO: Translate owner name -> [FIRST] [LAST] LLHost sender = msg->getSender(); diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp index 521c6731e0..7c26cb3c9f 100644 --- a/indra/newview/llviewerobject.cpp +++ b/indra/newview/llviewerobject.cpp @@ -3210,6 +3210,7 @@ S32 LLFilenameAndTask::sCount = 0; // static void LLViewerObject::processTaskInv(LLMessageSystem* msg, void** user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLUUID task_id; msg->getUUIDFast(_PREHASH_InventoryData, _PREHASH_TaskID, task_id); LLViewerObject* object = gObjectList.findObject(task_id); diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp index bb152ced40..2f39a76156 100644 --- a/indra/newview/llvoavatar.cpp +++ b/indra/newview/llvoavatar.cpp @@ -5984,6 +5984,7 @@ const LLUUID& LLVOAvatar::getStepSound() const //----------------------------------------------------------------------------- void LLVOAvatar::processAnimationStateChanges() { + LL_PROFILE_ZONE_SCOPED_CATEGORY_AVATAR; if ( isAnyAnimationSignaled(AGENT_WALK_ANIMS, NUM_AGENT_WALK_ANIMS) ) { startMotion(ANIM_AGENT_WALK_ADJUST); diff --git a/indra/newview/llworld.cpp b/indra/newview/llworld.cpp index 47e1815bc2..d02694de7d 100644 --- a/indra/newview/llworld.cpp +++ b/indra/newview/llworld.cpp @@ -1217,6 +1217,7 @@ void process_disable_simulator(LLMessageSystem *mesgsys, void **user_data) void process_region_handshake(LLMessageSystem* msg, void** user_data) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; LLHost host = msg->getSender(); LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(host); if (!regionp) diff --git a/indra/newview/llworldmapmessage.cpp b/indra/newview/llworldmapmessage.cpp index 3264f8ae8b..c039f9de3f 100644 --- a/indra/newview/llworldmapmessage.cpp +++ b/indra/newview/llworldmapmessage.cpp @@ -154,6 +154,7 @@ void LLWorldMapMessage::sendMapBlockRequest(U16 min_x, U16 min_y, U16 max_x, U16 // public static void LLWorldMapMessage::processMapBlockReply(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; if (gNonInteractive) { return; @@ -248,6 +249,7 @@ void LLWorldMapMessage::processMapBlockReply(LLMessageSystem* msg, void**) // public static void LLWorldMapMessage::processMapItemReply(LLMessageSystem* msg, void**) { + LL_PROFILE_ZONE_SCOPED_CATEGORY_NETWORK; //LL_INFOS("WorldMap") << LL_ENDL; U32 type; msg->getU32Fast(_PREHASH_RequestData, _PREHASH_ItemType, type); -- cgit v1.3 From 845fe1f83c4967fe1d49715d5f17b61a4adc68ee Mon Sep 17 00:00:00 2001 From: "Jonathan \"Geenz\" Goodman" Date: Mon, 6 Jul 2026 19:01:48 -0400 Subject: Get things working a little more consistently between BP and PBR. Also add some bias controls for the texel-to-pixel ratio based streaming. --- indra/llprimitive/lltextureentry.cpp | 13 -- indra/llprimitive/lltextureentry.h | 14 -- indra/newview/app_settings/settings.xml | 17 +-- indra/newview/llfetchedgltfmaterial.cpp | 39 +++++- indra/newview/llviewerobject.cpp | 18 ++- indra/newview/llviewertexture.cpp | 18 +++ indra/newview/llviewertexture.h | 13 +- indra/newview/llviewertexturelist.cpp | 228 ++++++++++++++++++++++++++++---- indra/newview/llvovolume.cpp | 63 ++++++++- 9 files changed, 347 insertions(+), 76 deletions(-) (limited to 'indra/newview/llviewerobject.cpp') diff --git a/indra/llprimitive/lltextureentry.cpp b/indra/llprimitive/lltextureentry.cpp index 5296e86a69..2b0f989701 100644 --- a/indra/llprimitive/lltextureentry.cpp +++ b/indra/llprimitive/lltextureentry.cpp @@ -356,7 +356,6 @@ S32 LLTextureEntry::setScale(F32 s, F32 t) { mScaleS = s; mScaleT = t; - mMinScaleSq = -1.f; // invalidate cache for getMinScaleSq() retval = TEM_CHANGE_TEXTURE; } @@ -369,7 +368,6 @@ S32 LLTextureEntry::setScaleS(F32 s) if (mScaleS != s) { mScaleS = s; - mMinScaleSq = -1.f; // invalidate cache for getMinScaleSq() retval = TEM_CHANGE_TEXTURE; } return retval; @@ -381,22 +379,11 @@ S32 LLTextureEntry::setScaleT(F32 t) if (mScaleT != t) { mScaleT = t; - mMinScaleSq = -1.f; // invalidate cache for getMinScaleSq() retval = TEM_CHANGE_TEXTURE; } return retval; } -F32 LLTextureEntry::getMinScaleSq() const -{ - if (mMinScaleSq < 0.f) - { - F32 m = llmin(fabsf(mScaleS), fabsf(mScaleT)); - mMinScaleSq = m * m; - } - return mMinScaleSq; -} - S32 LLTextureEntry::setColor(const LLColor4 &color) { if (mColor != color) diff --git a/indra/llprimitive/lltextureentry.h b/indra/llprimitive/lltextureentry.h index 765a5f5fdc..78c61b4d65 100644 --- a/indra/llprimitive/lltextureentry.h +++ b/indra/llprimitive/lltextureentry.h @@ -143,13 +143,6 @@ public: F32 getScaleS() const { return mScaleS; } F32 getScaleT() const { return mScaleT; } - // Cached min(|mScaleS|, |mScaleT|)^2, lazily computed and invalidated - // in setScale/setScaleS/setScaleT. Used by the texture streaming face - // loop (updateImageDecodePriority) to avoid the per-face per-frame - // sqrt/abs/min/multiply chain. Returns the raw (unclamped) value; - // callers still apply TextureScaleMin/MaxAreaFactor clamps. - F32 getMinScaleSq() const; - void getOffset(F32 *s, F32 *t) const { *s = mOffsetS; *t = mOffsetT; } F32 getOffsetS() const { return mOffsetS; } F32 getOffsetT() const { return mOffsetT; } @@ -225,13 +218,6 @@ public: F32 mOffsetT; // S, T offset F32 mRotation; // anti-clockwise rotation in rad about the bottom left corner -private: - // Cache for getMinScaleSq(). -1.f sentinel = stale. Invalidated by - // setScale/setScaleS/setScaleT. Mutable so getMinScaleSq() can fill it - // on first read without breaking const correctness for read-only callers. - mutable F32 mMinScaleSq = -1.f; -public: - static const LLTextureEntry null; // LLSD key defines diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index cfd92e03ca..2fec0b53d4 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -12124,27 +12124,16 @@ Value - TextureScaleMinAreaFactor + TextureDownrezCoverageBias Comment - Limits how texture scale affects area calculation. + Which end of a texture's texels-per-pixel spread sizes it. Each texture tracks the screen coverage of its most demanding use (lowest texels per pixel) and least demanding use (highest texels per pixel, most oversampled). 0 = size to the most demanding use (best quality); 1 = size to the least demanding use (frees the most memory). Interpolation is geometric (log-space), so the resulting discard level moves linearly with this value - 0.5 sits halfway between the two ends in mip levels. Default 0.25 is the best universal balance. Persist 1 Type F32 Value - 0.0095 - - TextureScaleMaxAreaFactor - - Comment - Limits how texture scale affects area calculation. - Persist - 1 - Type - F32 - Value - 25.0 + 0.25 ThreadPoolSizes diff --git a/indra/newview/llfetchedgltfmaterial.cpp b/indra/newview/llfetchedgltfmaterial.cpp index a05f725673..306067d2cf 100644 --- a/indra/newview/llfetchedgltfmaterial.cpp +++ b/indra/newview/llfetchedgltfmaterial.cpp @@ -73,6 +73,23 @@ void LLFetchedGLTFMaterial::bind(LLViewerTexture* media_tex) LLViewerTexture* baseColorTex = media_tex ? media_tex : mBaseColorTexture; LLViewerTexture* emissiveTex = media_tex ? media_tex : mEmissiveTexture; + if (media_tex) + { + // The real basecolor/emissive stay registered for coverage while + // media hides them - stamp them so the streaming cooldown doesn't + // fight that coverage (coarsen -> refetch tug-of-war) the whole + // time media is playing. Blinn has no hidden-texture-under-media + // state, so without this the two systems diverge on media faces. + if (mBaseColorTexture.notNull()) + { + if (LLImageGL* gl_tex = mBaseColorTexture->getGLTexture()) { gl_tex->stampBound(); } + } + if (mEmissiveTexture.notNull()) + { + if (LLImageGL* gl_tex = mEmissiveTexture->getGLTexture()) { gl_tex->stampBound(); } + } + } + if (!LLPipeline::sShadowRender || (mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK)) { if (mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK) @@ -97,13 +114,33 @@ void LLFetchedGLTFMaterial::bind(LLViewerTexture* media_tex) if (!LLPipeline::sShadowRender) { - if (mNormalTexture.notNull() && mNormalTexture->getDiscardLevel() <= 4) + // Bind the normal map at whatever resolution is resident - matching + // how Blinn-Phong normal maps degrade (soft, never absent). The old + // "getDiscardLevel() <= 4" gate made PBR normals a cliff instead of + // a gradient: any material the streamer legitimately sized past + // discard 4 (distant / tiled) rendered with NO normal map while the + // equivalent Blinn content rendered a soft one, making PBR look + // categorically flatter. The flat-normal fallback remains only for + // the genuinely-not-yet-loaded window, where it is the correct + // normal-shaped default. + if (mNormalTexture.notNull() && mNormalTexture->hasGLTexture()) { shader->bindTexture(LLShaderMgr::BUMP_MAP, mNormalTexture); } else { shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep); + if (mNormalTexture.notNull()) + { + // In active use, just not loaded yet - stamp it so the + // streaming last-bound cooldown doesn't read "unbound" as + // "unseen" and pin it at the deepest mip before its first + // real bind. + if (LLImageGL* gl_tex = mNormalTexture->getGLTexture()) + { + gl_tex->stampBound(); + } + } } if (mMetallicRoughnessTexture.notNull()) diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp index 7c26cb3c9f..4e4282a8ca 100644 --- a/indra/newview/llviewerobject.cpp +++ b/indra/newview/llviewerobject.cpp @@ -5229,7 +5229,20 @@ void LLViewerObject::setTE(const U8 te, const LLTextureEntry& texture_entry) const LLUUID& image_id = getTE(te)->getID(); LLViewerTexture* bakedTexture = getBakedTextureForMagicId(image_id); - mTEImages[te] = bakedTexture ? bakedTexture : LLViewerTextureManager::getFetchedTexture(image_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + if (bakedTexture) + { + mTEImages[te] = bakedTexture; + } + else + { + LLViewerFetchedTexture* img = LLViewerTextureManager::getFetchedTexture(image_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + // Same creation seed the PBR path applies in updateTEMaterialTextures' + // fetch_texture - without it a Blinn texture has decode_priority 0 and + // cannot even fetch headers until its first coverage measurement, + // while the equivalent PBR texture starts fetching immediately. + img->addTextureStats(64.f * 64.f, true); + mTEImages[te] = img; + } updateAvatarMeshVisibility(image_id, old_image_id); @@ -5240,11 +5253,14 @@ void LLViewerObject::updateTEMaterialTextures(U8 te) { if (getTE(te)->getMaterialParams().notNull()) { + // Same creation seed as the PBR fetch_texture below - see setTE. const LLUUID& norm_id = getTE(te)->getMaterialParams()->getNormalID(); mTENormalMaps[te] = LLViewerTextureManager::getFetchedTexture(norm_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + mTENormalMaps[te]->addTextureStats(64.f * 64.f, true); const LLUUID& spec_id = getTE(te)->getMaterialParams()->getSpecularID(); mTESpecularMaps[te] = LLViewerTextureManager::getFetchedTexture(spec_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + mTESpecularMaps[te]->addTextureStats(64.f * 64.f, true); } LLFetchedGLTFMaterial* mat = (LLFetchedGLTFMaterial*) getTE(te)->getGLTFRenderMaterial(); diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp index ef49e0e67f..baf5874507 100644 --- a/indra/newview/llviewertexture.cpp +++ b/indra/newview/llviewertexture.cpp @@ -3070,6 +3070,13 @@ S32 LLViewerLODTexture::computeDesiredDiscard(S32 dim_max_i, bool avatar_bake) c static LLCachedControl ch_emissive (gSavedSettings, "TextureChannelRatioEmissive", 0.5f); const F32 channel_ratio[4] = { (F32)ch_normal, (F32)ch_basecolor, (F32)ch_specular, (F32)ch_emissive }; + // Downrez bias: 0 sizes each bucket to its most demanding use (the lowest + // texels-per-pixel variant - the quality bound); 1 sizes to its least + // demanding use (the most oversampled variant - frees the most memory). + // Values between lerp across the texture's measured coverage spread. + static LLCachedControl downrez_bias(gSavedSettings, "TextureDownrezCoverageBias", 0.25f); + const F32 cov_bias = llclampf((F32)downrez_bias); + // Continuous ideal discard = sharpest (smallest) requirement across the // channels this texture is actually used in. F32 ideal = (F32)dim_max_i; // default: coarsest, until a measurement arrives @@ -3081,6 +3088,17 @@ S32 LLViewerLODTexture::computeDesiredDiscard(S32 dim_max_i, bool avatar_bake) c { continue; } + if (cov_bias > 0.f && mChannelCoverageMin[b] > 0.f && mChannelCoverageMin[b] < coverage) + { + // Geometric (log-space) lerp between the coverage bounds. The + // consumer below is log4(coverage), and min/max are routinely + // orders of magnitude apart - a linear pixel-area lerp barely + // moves the resulting discard until bias approaches 1, then + // plunges (reads as binary). Interpolating the RATIO instead + // moves the discard linearly with bias: 0.5 = halfway between + // the two ends in mip levels. + coverage *= powf(mChannelCoverageMin[b] / coverage, cov_bias); + } measured = true; F32 allowed_texels = coverage * r_global * llmax(channel_ratio[b], 0.01f); F32 d; diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h index 6fc6ad72f9..28d896eff5 100644 --- a/indra/newview/llviewertexture.h +++ b/indra/newview/llviewertexture.h @@ -150,6 +150,11 @@ public: virtual F32 getMaxVirtualSize() ; + // Read-only debug access to the per-bucket coverage bounds (see + // mChannelCoverage) - used by the RENDER_DEBUG_TEXTURE_PRIORITY overlay. + F32 getChannelCoverage(S32 bucket) const { return (bucket >= 0 && bucket < 4) ? mChannelCoverage[bucket] : 0.f; } + F32 getChannelCoverageMin(S32 bucket) const { return (bucket >= 0 && bucket < 4) ? mChannelCoverageMin[bucket] : 0.f; } + LLFrameTimer* getLastReferencedTimer() { return &mLastReferencedTimer; } S32 getFullWidth() const { return mFullWidth; } @@ -205,13 +210,17 @@ protected: mutable S32 mMaxVirtualSizeResetInterval; LLFrameTimer mLastReferencedTimer; - // Largest screen-space pixel coverage among the texture's faces, per + // Screen-space pixel coverage bounds among the texture's faces, per // priority bucket (0=Normal, 1=BaseColor, 2=Specular, 3=Emissive). 0 = the // texture is not used in that channel (or hasn't been measured yet). // Populated by LLViewerTextureList::updateImageDecodePriority; consumed by // LLViewerLODTexture::computeDesiredDiscard. This is the only view-dependent - // streaming signal - distance, size, and channel role all collapse into it. + // streaming signal - distance, size, tiling, and channel role all collapse + // into it. Max = the most demanding use (lowest texels-per-pixel variant, + // the quality bound); Min = the least demanding positive use (highest + // texels-per-pixel, most oversampled - the downrez-bias end). F32 mChannelCoverage[4] = { 0.f, 0.f, 0.f, 0.f }; + F32 mChannelCoverageMin[4] = { 0.f, 0.f, 0.f, 0.f }; ll_face_list_t mFaceList[LLRender::NUM_TEXTURE_CHANNELS]; //reverse pointer pointing to the faces using this image as texture U32 mNumFaces[LLRender::NUM_TEXTURE_CHANNELS]; diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp index 16a3418bc7..e503bbc466 100644 --- a/indra/newview/llviewertexturelist.cpp +++ b/indra/newview/llviewertexturelist.cpp @@ -64,6 +64,8 @@ #include "llviewerwindow.h" #include "llsurface.h" #include "llvoavatarself.h" +#include "llvovolume.h" +#include "llviewertextureanim.h" #include "llprogressview.h" //////////////////////////////////////////////////////////////////////////// @@ -916,18 +918,35 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag { llassert(!gCubeSnapshot); - if (imagep->getBoostLevel() < LLViewerFetchedTexture::BOOST_HIGH) // don't bother checking face list for boosted textures + // Refresh spotlight priorities first: light projector textures register as + // LIGHT_TEX volumes (no faces), and both their fetch priority + // (addTextureStats inside updateSpotLightPriority) and their coverage + // (folded into the block below) derive from mSpotLightPriority. + for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) { - static LLCachedControl texture_scale_min(gSavedSettings, "TextureScaleMinAreaFactor", 0.0095f); - static LLCachedControl texture_scale_max(gSavedSettings, "TextureScaleMaxAreaFactor", 25.f); + LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; + volume->updateSpotLightPriority(); + } - // Largest screen-space pixel coverage per priority bucket - // (0=Normal, 1=BaseColor, 2=Specular, 3=Emissive), plus the overall max. - // The per-bucket maxima drive desired discard with per-channel ratios; - // the overall max is the fetch priority (raw - no bias). A bucket with - // faces but zero coverage (all off-screen) publishes 0, which + if (imagep->getBoostLevel() < LLViewerFetchedTexture::BOOST_HIGH) // don't bother checking face list for boosted textures + { + // Bounds on the per-face UV repeat-area divisor (mined from the old + // getTextureVirtualSize texel_area clamp [1/64, 128]): atlas/crop boost + // capped at 64x (3 mips finer), tiling penalty at 128x (3.5 mips + // coarser) so pathological UV scales can't explode either direction. + constexpr F32 MIN_REPEAT_AREA = 1.f / 64.f; + constexpr F32 MAX_REPEAT_AREA = 128.f; + + // Per priority bucket (0=Normal, 1=BaseColor, 2=Specular, 3=Emissive): + // the HIGHEST per-face effective coverage (= the lowest texels-per-pixel + // use, the most demanding variant - drives desired discard) and the + // LOWEST positive coverage (= the highest texels-per-pixel use, the most + // oversampled variant - available for downrez-bias policy). The overall + // max is the fetch priority (raw - no bias). A bucket with faces but + // zero coverage (all off-screen) publishes 0, which // computeDesiredDiscard reads as "coarsest mip". F32 channel_coverage[4] = { 0.f, 0.f, 0.f, 0.f }; + F32 channel_coverage_min[4] = { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX }; bool bucket_used[4] = { false, false, false, false }; F32 max_coverage = 0.f; @@ -952,7 +971,13 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag // Used in so many places that scanning the face list isn't worth it // (and isn't time-sliced) - treat as full-screen so it loads sharp. for (S32 b = 0; b < 4; ++b) - if (bucket_used[b]) channel_coverage[b] = (F32)MAX_IMAGE_AREA; + { + if (bucket_used[b]) + { + channel_coverage[b] = (F32)MAX_IMAGE_AREA; + channel_coverage_min[b] = (F32)MAX_IMAGE_AREA; + } + } max_coverage = (F32)MAX_IMAGE_AREA; } else @@ -980,20 +1005,163 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag face->mLastTextureUpdate = gFrameCount; } - F32 vsize = face->getPixelArea(); + // Most-demanding-point measurement: the spec is that the + // LOWEST pixel:texel ratio governs, so pixel density is + // evaluated at the face's NEAREST point and applied to the + // face's true world area. The previous whole-face average + // (bounding-disc pixel area) under-resolved perspective + // surfaces: on a floor, the tile at your feet covers far + // more screen than the average tile, and the GPU samples + // fine mips right there - tiled (PBR-heavy) content went + // soft while untiled content looked fine. + const LLVector4a* ext = face->isState(LLFace::RIGGED) ? face->mRiggedExtents : face->mExtents; + LLVector4a diag; + diag.setSub(ext[1], ext[0]); + // World area of the face ~ product of the two largest AABB + // dims (max pairwise product; robust for flat faces). + F32 dx = diag[0], dy = diag[1], dz = diag[2]; + F32 area_world = llmax(dx * dy, llmax(dx * dz, dy * dz)); + // Pixels per meter at the nearest point. Distance floored: + // nearer than this the screen clamp below governs anyway. + F32 dist = llmax(face->mDistanceToCamera, 0.5f); + F32 ppm = LLDrawable::sCurPixelAngle / dist; + F32 face_px = area_world * ppm * ppm; + if (face_px <= 0.f) + { + // Degenerate extents: the face hasn't been through a + // geometry build yet (or a rigged face has no rigged + // extents) - it isn't renderable, so it must not be + // measured. Skipping matters especially for the + // per-bucket MIN bound: any invented placeholder + // value (the old fallback hit LLFace::init's 16px + // default) becomes the texture's least-demanding + // "use" and, under TextureDownrezCoverageBias, drags + // the whole texture to its deepest mip - and it + // poisoned BP and PBR asymmetrically since the two + // systems register faces at different points in the + // geometry lifecycle. + continue; + } - // Scale coverage by texture repeat: a texture shown at a - // fraction of a face (atlas) needs only that fraction of - // texels; a tiled texture needs more. getMinScaleSq() is the - // cached min(|scaleS|,|scaleT|)^2, invalidated by setScale*. + // Effective UV repeat AREA across this face: the tiling + // term of texels-drawn-per-screen-pixel. More tiling => + // each tile is smaller on screen => coarser mips suffice + // (penalty). Repeats < 1 (atlas/crop) => only a sub-rect + // of the image is shown, but discard levels are whole- + // image, so the full image must be resident at 1/repeats + // times the crop's pixel count (boost). S32 te_offset = face->getTEOffset(); // offset is -1 if not inited LLViewerObject* objp = face->getViewerObject(); const LLTextureEntry* te = (te_offset < 0 || te_offset >= objp->getNumTEs()) ? nullptr : objp->getTE(te_offset); - F32 min_scale = te ? llclamp(te->getMinScaleSq(), texture_scale_min(), texture_scale_max()) : 1.f; - vsize /= min_scale; + + F32 repeats = 1.f; + if (te) + { + // UV scale source: every channel reads the repeat + // values ITS renderer actually applies, then flows + // through the identical pipeline below. Sources: + // diffuse -> TE scale + // Blinn normal/spec -> LLMaterial per-map repeats + // PBR channels -> KHR texture_transform scale + // Fallback for any missing material is the TE scale - + // never a silent hardcoded 1. + F32 scale_s = te->getScaleS(); + F32 scale_t = te->getScaleT(); + if (i >= LLRender::BASECOLOR_MAP) + { + // LLRender channel -> LLGLTFMaterial::TextureInfo + static const S32 gltf_info[4] = { + LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR, // BASECOLOR_MAP (3) + LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS, // METALLIC_ROUGHNESS_MAP (4) + LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL, // GLTF_NORMAL_MAP (5) + LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE, // EMISSIVE_MAP (6) + }; + if (const LLGLTFMaterial* gltf_mat = te->getGLTFRenderMaterial()) + { + const LLVector2& s = gltf_mat->mTextureTransform[gltf_info[i - LLRender::BASECOLOR_MAP]].mScale; + scale_s = s.mV[0]; + scale_t = s.mV[1]; + } + } + else if (i == LLRender::NORMAL_MAP || i == LLRender::SPECULAR_MAP) + { + // Blinn-Phong normal/specular maps carry their own + // repeats in LLMaterial - the renderer builds their + // texture matrices from these, NOT from the TE's + // diffuse scale. Reading the diffuse scale here made + // Blinn normals scale differently than PBR normals + // (whose per-channel transform IS read above). + if (const LLMaterial* mat = te->getMaterialParams().get()) + { + if (i == LLRender::NORMAL_MAP) + { + mat->getNormalRepeat(scale_s, scale_t); + } + else + { + mat->getSpecularRepeat(scale_s, scale_t); + } + } + } + + // Continuously-animated scale (llSetTextureAnim SCALE) + // bypasses both static sources via mTextureMatrix - + // the live animated values win on either path. + if (LLVOVolume* vvo = face->getDrawable() ? face->getDrawable()->getVOVolume() : nullptr) + { + LLViewerTextureAnim* anim = vvo->mTextureAnimp; + if (anim && (anim->mMode & LLTextureAnim::ON) && (anim->mMode & LLTextureAnim::SCALE) + && (anim->mFace < 0 || anim->mFace == te_offset)) + { + scale_s = anim->mScaleS; + scale_t = anim->mScaleT; + } + } + + repeats = fabsf(scale_s * scale_t); + + // Mesh atlas sub-rect: a face whose intrinsic UVs span + // only part of [0,1]^2 shows that fraction of the + // image. Applies identically to both paths - the + // transforms above stack on the raw face UVs. + if (LLVolume* vol = objp->getVolume()) + { + if (te_offset >= 0 && te_offset < vol->getNumVolumeFaces()) + { + const LLVolumeFace& vf = vol->getVolumeFace(te_offset); + F32 span = fabsf((vf.mTexCoordExtents[1].mV[0] - vf.mTexCoordExtents[0].mV[0]) + * (vf.mTexCoordExtents[1].mV[1] - vf.mTexCoordExtents[0].mV[1])); + if (span > 0.f) + { + repeats *= span; + } + } + } + } + + repeats = llclamp(repeats, MIN_REPEAT_AREA, MAX_REPEAT_AREA); + + // Apply the two sides of the repeat term in the right + // order relative to the screen clamp: + // - tiling (repeats > 1): the per-tile footprint at the + // nearest point, THEN clamped - one tile can't draw + // more pixels than the screen. (Clamping the whole + // face first and then dividing crushed near tiles.) + // - atlas/crop (repeats < 1): boost AFTER the clamp - + // whole-image residency for a crop legitimately + // demands more than its screen coverage. + F32 tiling = llmax(repeats, 1.f); + F32 crop = llmin(repeats, 1.f); + F32 vsize = llmin(face_px / tiling, LLViewerTexture::sWindowPixelArea) / crop; if (bucket >= 0 && bucket < 4) + { channel_coverage[bucket] = llmax(channel_coverage[bucket], vsize); + if (vsize > 0.f) + { + channel_coverage_min[bucket] = llmin(channel_coverage_min[bucket], vsize); + } + } max_coverage = llmax(max_coverage, vsize); } } @@ -1010,15 +1178,34 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag // Floor so terrain never collapses to nothing at draw distance. F32 cov = LLViewerTexture::sWindowPixelArea * llmax(near_frac, 0.05f); channel_coverage[1] = cov; // terrain detail maps are diffuse / base color + channel_coverage_min[1] = cov; max_coverage = cov; } + // Light projector textures register as LIGHT_TEX volumes, not faces. + // mSpotLightPriority (refreshed above) is already a screen-pixel-area + // estimate of the lit radius - fold it in as BaseColor coverage so + // projectors stream view-dependently like everything else. + for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) + { + LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; + F32 cov = llmin(volume->getSpotLightPriority(), LLViewerTexture::sWindowPixelArea); + if (cov > 0.f) + { + channel_coverage[1] = llmax(channel_coverage[1], cov); + channel_coverage_min[1] = llmin(channel_coverage_min[1], cov); + max_coverage = llmax(max_coverage, cov); + } + } + imagep->addTextureStats(max_coverage); - // Publish per-bucket coverage for LLViewerLODTexture::computeDesiredDiscard. + // Publish per-bucket coverage bounds for + // LLViewerLODTexture::computeDesiredDiscard. for (S32 b = 0; b < 4; ++b) { imagep->mChannelCoverage[b] = channel_coverage[b]; + imagep->mChannelCoverageMin[b] = (channel_coverage_min[b] == FLT_MAX) ? 0.f : channel_coverage_min[b]; } } @@ -1030,13 +1217,6 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag imagep->getFullWidth())); #endif - // make sure to addTextureStats for any spotlights that are using this texture - for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) - { - LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; - volume->updateSpotLightPriority(); - } - F32 max_inactive_time = 20.f; // inactive time before deleting saved raw image S32 min_refs = 3; // 1 for mImageList, 1 for mUUIDMap, and 1 for "entries" in updateImagesFetchTextures diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp index 3b41ccb6fc..d57456aa5a 100644 --- a/indra/newview/llvovolume.cpp +++ b/indra/newview/llvovolume.cpp @@ -878,11 +878,15 @@ void LLVOVolume::updateTextureVirtualSize(bool forced) LLViewerFetchedTexture* img = LLViewerTextureManager::staticCastToFetchedTexture(imagep) ; if(img) { - debug_text << img->getDiscardLevel() << ":" << img->getDesiredDiscardLevel() << ":" << img->getWidth() << ":" << (S32) sqrtf(vsize) << ":" << (S32) sqrtf(img->getMaxVirtualSize()) << "\n"; - /*F32 pri = img->getDecodePriority(); - pri = llmax(pri, 0.0f); - if (pri < min_vsize) min_vsize = pri; - if (pri > max_vsize) max_vsize = pri;*/ + // cur:desired:width then per-bucket coverage bounds + // (N/BC/S/E, sqrt so values read as pixel dimensions, + // max~min) - the exact inputs computeDesiredDiscard sees. + debug_text << img->getDiscardLevel() << ":" << img->getDesiredDiscardLevel() << ":" << img->getWidth() + << " N" << (S32)sqrtf(img->getChannelCoverage(0)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(0)) + << " BC" << (S32)sqrtf(img->getChannelCoverage(1)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(1)) + << " S" << (S32)sqrtf(img->getChannelCoverage(2)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(2)) + << " E" << (S32)sqrtf(img->getChannelCoverage(3)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(3)) + << "\n"; } } else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA)) @@ -928,7 +932,7 @@ void LLVOVolume::updateTextureVirtualSize(bool forced) { LLLightImageParams* params = getLightImageParams(); LLUUID id = params->getLightTexture(); - mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE); + mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); if (mLightTexture.notNull()) { F32 rad = getLightRadius(); @@ -1797,6 +1801,41 @@ void LLVOVolume::regenFaces() facep->setNormalMap(getTENormalMap(i)); facep->setSpecularMap(getTESpecularMap(i)); } + + // Register PBR channel textures HERE, at geometry build, exactly when + // the Blinn textures above register - mirrored from rebuildGeom + // (which still re-runs this when the material resolves later). + // Without this, PBR textures had zero registered faces until the + // spatial group's budget-throttled rebuildGeom ran, so the streaming + // math read "not measured -> deepest mip" for PBR content while + // identical Blinn content on the same geometry measured immediately. + { + const LLTextureEntry* te = facep->getTextureEntry(); + LLFetchedGLTFMaterial* gltf_mat = te ? (LLFetchedGLTFMaterial*)te->getGLTFRenderMaterial() : nullptr; + if (gltf_mat) + { + if (!facep->hasMedia()) + { + facep->setTexture(LLRender::DIFFUSE_MAP, nullptr); + } + facep->setTexture(LLRender::NORMAL_MAP, nullptr); + facep->setTexture(LLRender::SPECULAR_MAP, nullptr); + facep->setTexture(LLRender::BASECOLOR_MAP, gltf_mat->mBaseColorTexture); + facep->setTexture(LLRender::GLTF_NORMAL_MAP, gltf_mat->mNormalTexture); + facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, gltf_mat->mMetallicRoughnessTexture); + facep->setTexture(LLRender::EMISSIVE_MAP, gltf_mat->mEmissiveTexture); + } + else + { + // No (or no longer a) PBR material: clear any stale GLTF + // channel registrations so a removed material's textures + // stop accruing phantom coverage from this face. + facep->setTexture(LLRender::BASECOLOR_MAP, nullptr); + facep->setTexture(LLRender::GLTF_NORMAL_MAP, nullptr); + facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, nullptr); + facep->setTexture(LLRender::EMISSIVE_MAP, nullptr); + } + } facep->setViewerObject(this); // If the face had media on it, this will have broken the link between the LLViewerMediaTexture and the face. @@ -3367,7 +3406,7 @@ LLViewerTexture* LLVOVolume::getLightTexture() { if (mLightTexture.isNull() || id != mLightTexture->getID()) { - mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE); + mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); } } else @@ -5851,6 +5890,16 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group) facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, gltf_mat->mMetallicRoughnessTexture); facep->setTexture(LLRender::EMISSIVE_MAP, gltf_mat->mEmissiveTexture); } + else + { + // Face is not (or no longer) PBR: clear any stale GLTF + // channel registrations, or a removed material's textures + // keep accruing phantom coverage from this face forever. + facep->setTexture(LLRender::BASECOLOR_MAP, nullptr); + facep->setTexture(LLRender::GLTF_NORMAL_MAP, nullptr); + facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, nullptr); + facep->setTexture(LLRender::EMISSIVE_MAP, nullptr); + } //ALWAYS null out vertex buffer on rebuild -- if the face lands in a render // batch, it will recover its vertex buffer reference from the spatial group -- cgit v1.3 From 6b9f0f0bf43250f984631032a3f3b41d245907a9 Mon Sep 17 00:00:00 2001 From: "Jonathan \"Geenz\" Goodman" Date: Wed, 22 Jul 2026 00:38:54 -0400 Subject: Revert "Merge pull request #5982 from secondlife/geenz/texture-streaming-tweaks" This reverts commit 3d465f6c966f0a2fcfd5d3c9effb6ce20c2754c8, reversing changes made to f2c356fc7130ce5e38b994dcfa1e210609b458b9. --- indra/llprimitive/lltextureentry.cpp | 2 +- indra/llrender/llimagegl.cpp | 64 +-- indra/llrender/llimagegl.h | 33 +- indra/llrender/llrender.cpp | 7 - indra/newview/app_settings/settings.xml | 300 ++++++++++--- indra/newview/featuretable.txt | 1 + indra/newview/featuretable_linux.txt | 2 + indra/newview/featuretable_mac.txt | 1 + indra/newview/llfetchedgltfmaterial.cpp | 29 +- indra/newview/lltextureview.cpp | 13 +- indra/newview/llviewercontrol.cpp | 88 ++-- indra/newview/llviewermessage.cpp | 7 + indra/newview/llviewerobject.cpp | 18 +- indra/newview/llviewershadermgr.cpp | 6 + indra/newview/llviewertexture.cpp | 765 ++++++++++++++++++++++---------- indra/newview/llviewertexture.h | 102 +++-- indra/newview/llviewertexturelist.cpp | 495 +++++++++------------ indra/newview/llviewertexturelist.h | 4 + indra/newview/llviewerwindow.cpp | 8 +- indra/newview/llvovolume.cpp | 63 +-- indra/newview/pipeline.cpp | 6 - 21 files changed, 1160 insertions(+), 854 deletions(-) (limited to 'indra/newview/llviewerobject.cpp') diff --git a/indra/llprimitive/lltextureentry.cpp b/indra/llprimitive/lltextureentry.cpp index 2b0f989701..ac482ffbf9 100644 --- a/indra/llprimitive/lltextureentry.cpp +++ b/indra/llprimitive/lltextureentry.cpp @@ -600,7 +600,7 @@ LLGLTFMaterial* LLTextureEntry::getGLTFRenderMaterial() const return mGLTFRenderMaterial; } - //llassert(getGLTFMaterialOverride() == nullptr || getGLTFMaterialOverride()->isClearedForBaseMaterial()); + llassert(getGLTFMaterialOverride() == nullptr || getGLTFMaterialOverride()->isClearedForBaseMaterial()); return getGLTFMaterial(); } diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp index c8a23d873e..6bcc34938c 100644 --- a/indra/llrender/llimagegl.cpp +++ b/indra/llrender/llimagegl.cpp @@ -166,8 +166,6 @@ U64 LLImageGL::getTextureBytesAllocated() //statics U32 LLImageGL::sUniqueCount = 0; -std::atomic LLImageGL::sOOMErrorCount(0); -thread_local bool LLImageGL::sStampBindFrame = true; U32 LLImageGL::sBindCount = 0; S32 LLImageGL::sCount = 0; @@ -493,7 +491,7 @@ bool LLImageGL::create(LLPointer& dest, const LLImageRaw* imageraw, b //---------------------------------------------------------------------------- LLImageGL::LLImageGL(bool usemipmaps/* = true*/, bool allow_compression/* = true*/) -: mExternalTexture(false) +: mSaveData(0), mExternalTexture(false) { init(usemipmaps, allow_compression); setSize(0, 0, 0); @@ -502,7 +500,7 @@ LLImageGL::LLImageGL(bool usemipmaps/* = true*/, bool allow_compression/* = true } LLImageGL::LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps/* = true*/, bool allow_compression/* = true*/) -: mExternalTexture(false) +: mSaveData(0), mExternalTexture(false) { llassert( components <= 4 ); init(usemipmaps, allow_compression); @@ -512,7 +510,7 @@ LLImageGL::LLImageGL(U32 width, U32 height, U8 components, bool usemipmaps/* = t } LLImageGL::LLImageGL(const LLImageRaw* imageraw, bool usemipmaps/* = true*/, bool allow_compression/* = true*/) -: mExternalTexture(false) +: mSaveData(0), mExternalTexture(false) { init(usemipmaps, allow_compression); setSize(0, 0, 0); @@ -621,6 +619,8 @@ void LLImageGL::cleanup() destroyGLTexture(); } freePickMask(); + + mSaveData = NULL; // deletes data } //---------------------------------------------------------------------------- @@ -777,7 +777,6 @@ void LLImageGL::setImage(const LLImageRaw* imageraw) bool LLImageGL::setImage(const U8* data_in, bool data_hasmips /* = false */, S32 usename /* = 0 */) { LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE; - LLImageGLStampBypass no_stamp; // upload binds are not visibility const bool is_compressed = isCompressed(); @@ -1503,12 +1502,6 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt { free_cur_tex_image(); } - - // 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) {} - const bool use_sub_image = should_stagger_image_set(compress); if (!use_sub_image) { @@ -1518,30 +1511,19 @@ void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 widt else { // break up calls to a manageable size for the GL command buffer - LL_PROFILE_ZONE_NAMED("glTexImage2D alloc"); - glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, nullptr); - } + { + LL_PROFILE_ZONE_NAMED("glTexImage2D alloc"); + glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, nullptr); + } - if (glGetError() == GL_OUT_OF_MEMORY) - { - ++sOOMErrorCount; - LL_WARNS_ONCE("Texture") << "glTexImage2D failed with GL_OUT_OF_MEMORY (" - << width << "x" << height << " mip " << miplevel - << ") - not counting bytes" << LL_ENDL; - } - else - { - if (use_sub_image) + U8* src = (U8*)(pixels); + if (src) { - U8* src = (U8*)(pixels); - if (src) - { - LL_PROFILE_ZONE_NAMED("glTexImage2D copy"); - sub_image_lines(target, miplevel, 0, 0, width, height, pixformat, pixtype, src, width); - } + LL_PROFILE_ZONE_NAMED("glTexImage2D copy"); + sub_image_lines(target, miplevel, 0, 0, width, height, pixformat, pixtype, src, width); } - alloc_tex_image(width, height, intformat, 1); } + alloc_tex_image(width, height, intformat, 1); } stop_glerror(); } @@ -1686,7 +1668,6 @@ bool LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, bool data_ LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE; LL_PROFILE_GPU_ZONE("createGLTexture"); checkActiveThread(); - LLImageGLStampBypass no_stamp; // creation binds are not visibility bool main_thread = on_main_thread(); @@ -2109,21 +2090,12 @@ S32 LLImageGL::dimDerivedMaxDiscard(S32 width, S32 height) void LLImageGL::stampBound() const { - // Both stamps skip same-frame re-binds (bindFast runs per draw). They dedupe - // separately, so a non-camera pass touching the time stamp first doesn't stop - // a real camera bind from setting the frame stamp later the same frame. + // Skip the store on same-frame re-binds - bindFast is per-draw and + // would dirty this cache line per bind per texture otherwise. if (mLastBindTime != sLastFrameTime) { mLastBindTime = sLastFrameTime; } - if (sStampBindFrame) - { - const U32 frame = LLFrameTimer::getFrameCount(); - if (mLastBindFrame != frame) - { - mLastBindFrame = frame; - } - } } S64 LLImageGL::getBytes(S32 discard_level) const @@ -2548,10 +2520,6 @@ 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. - LLImageGLStampBypass no_stamp; - if (mTarget != GL_TEXTURE_2D || mFormatInternal == -1 // not initialized ) diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h index ca75b543c0..0c85446b84 100644 --- a/indra/llrender/llimagegl.h +++ b/indra/llrender/llimagegl.h @@ -39,7 +39,6 @@ #include "llrender.h" #include "threadpool.h" #include "workqueue.h" -#include #include #define LL_IMAGEGL_THREAD_CHECK 0 //set to 1 to enable thread debugging for ImageGL @@ -239,23 +238,15 @@ public: public: // Various GL/Rendering options S64Bytes mTextureMemory; - mutable F32 mLastBindTime = 0.f; // wall-clock time at last stampBound (bind or bind-attempt) - mutable U32 mLastBindFrame = 0; // frame index (LLFrameTimer::getFrameCount) at last CAMERA-pass - // stampBound; 0 = never. Drives visibility GC + fetch gating. - F32 mGLCreateTime = 0.f; // wall-clock time the GL texture was created - - // When false, stampBound skips the mLastBindFrame stamp (mLastBindTime still - // updates). Set false around non-camera passes (probes, shadows, impostors) - // and administrative binds (upload, scaleDown - via LLImageGLStampBypass) so - // those binds don't count as camera visibility. Thread-local so a GL upload - // thread can't flip it on the render thread mid-frame. - static thread_local bool sStampBindFrame; + mutable F32 mLastBindTime = 0.f; // wall-clock time at last stampBound; drives streaming staleness + F32 mGLCreateTime = 0.f; // wall-clock time the GL texture was created; staleness fallback for never-bound textures private: U32 createPickMask(S32 pWidth, S32 pHeight); void freePickMask(); bool isCompressed(); + LLPointer mSaveData; // used for destroyGL/restoreGL LL::WorkQueue::weak_t mMainQueue; U8* mPickMask; //downsampled bitmap approximation of alpha channel. NULL if no alpha channel U16 mPickMaskWidth; @@ -309,11 +300,6 @@ public: // Global memory statistics static U32 sBindCount; // Tracks number of texture binds for current frame static U32 sUniqueCount; // Tracks number of unique texture binds for current frame - // glTexImage2D GL_OUT_OF_MEMORY failures detected (bytes NOT counted for - // these). Written from whichever thread runs texture creation; read by - // the streaming 1Hz pressure log. Nonzero = the driver is refusing - // allocations and the VRAM budget is unreliable. - static std::atomic sOOMErrorCount; static bool sGlobalUseAnisotropic; static LLImageGL* sDefaultGLTexture ; static bool sAutomatedTest; @@ -369,19 +355,6 @@ public: }; -// RAII: suppress the mLastBindFrame stamp for the current scope. Use around -// administrative binds (upload, create, scaleDown) so they don't count as -// camera visibility - otherwise the GC's own scaleDown re-stamps what it just -// aged out and oscillates. Saves/restores, so it nests correctly. -class LLImageGLStampBypass -{ -public: - LLImageGLStampBypass() : mPrev(LLImageGL::sStampBindFrame) { LLImageGL::sStampBindFrame = false; } - ~LLImageGLStampBypass() { LLImageGL::sStampBindFrame = mPrev; } -private: - bool mPrev; -}; - class LLImageGLThread : public LLSimpleton, LL::ThreadPool { public: diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp index f0a1c44507..5e845fbcce 100644 --- a/indra/llrender/llrender.cpp +++ b/indra/llrender/llrender.cpp @@ -245,11 +245,6 @@ bool LLTexUnit::bind(LLTexture* texture, bool for_rendering, bool forceBind) texture->setActive() ; texture->updateBindStatsForTester() ; } - // updateBindStats only stamps time; the GC and fetch gate use - // the frame stamp, so stamp it here too or bind()-drawn faces - // (bump/material/media) oscillate. Admin/non-camera binds are - // already suppressed via LLImageGLStampBypass / sStampBindFrame. - gl_tex->stampBound(); mHasMipMaps = gl_tex->mHasMipMaps; if (gl_tex->mTexOptionsDirty) { @@ -330,8 +325,6 @@ bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind, S32 glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture); stop_glerror(); texture->updateBindStats(); - // Frame-stamp fresh binds too - see bind(LLTexture*) above. - texture->stampBound(); mHasMipMaps = texture->mHasMipMaps; if (texture->mTexOptionsDirty) { diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index 45a7dced5c..81299a5b71 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -8002,6 +8002,17 @@ Value 1 + RenderMinFreeMainMemoryThreshold + + Comment + If available free physical memory is below this value textures get agresively scaled down + Persist + 0 + Type + U32 + Value + 512 + RenderLowMemMinDiscardIncrement Comment @@ -8024,6 +8035,17 @@ Value 0.1 + RenderMaxTextureIndex + + Comment + Maximum texture index to use for indexed texture rendering. + Persist + 1 + Type + U32 + Value + 16 + RenderMaxTextureResolution Comment @@ -8038,7 +8060,7 @@ RenderTextureQuality Comment - Texture quality preset: 0=Low, 1=Medium, 2=High, 3=Ultra. Drives RenderMaxTextureResolution, TexturePixelToTexelRatio, TexturePressureTightenRate, TexturePressureRelaxRate, and TextureChannelRatio* (Normal/BaseColor/Specular/Emissive). The pressure water marks (TexturePressureHighWater/LowWater) are constant across tiers. + Texture quality preset: 0=Low, 1=Medium, 2=High, 3=Ultra. Drives RenderMaxTextureResolution, the four TextureChannel* exponents, and TextureDistanceDiscardPower. Persist 1 Type @@ -8057,6 +8079,17 @@ Value 0 + RenderDebugTextureBind + + Comment + Enable texture bind performance test. + Persist + 1 + Type + Boolean + Value + 0 + RenderDelayCreation Comment @@ -9373,6 +9406,17 @@ Value 64 + RenderReservedTextureIndices + + Comment + Count of texture indices to reserve for shadow and reflection maps when using indexed texture rendering. Probably only want to set from the login screen. + Persist + 1 + Type + S32 + Value + 14 + RenderResolutionDivisor Comment @@ -11827,10 +11871,10 @@ Value 20.0 - TextureChannelRatioNormal + TextureChannelNormal Comment - Per-channel pixel:texel ratio multiplier for normal maps (texels per pixel, applied on top of the global TexturePixelToTexelRatio). 1.0 = full quality; lower = coarser. Driven by the RenderTextureQuality preset. + Per-channel discard exponent for normal maps. 1.0 = baseline; lower = more aggressive. Driven by the RenderTextureQuality preset. Persist 1 Type @@ -11838,21 +11882,21 @@ Value 1.0 - TextureChannelRatioBaseColor + TextureChannelBaseColor Comment - Per-channel pixel:texel ratio multiplier for base color / diffuse (texels per pixel, applied on top of the global TexturePixelToTexelRatio). 1.0 = full quality. Driven by the RenderTextureQuality preset. + Per-channel discard exponent for base color / diffuse. 1.0 = baseline; lower = more aggressive. Driven by the RenderTextureQuality preset. Persist 1 Type F32 Value - 1.0 + 0.75 - TextureChannelRatioSpecular + TextureChannelSpecular Comment - Per-channel pixel:texel ratio multiplier for specular / metallic-roughness (texels per pixel, applied on top of the global TexturePixelToTexelRatio). 0.5 = half resolution (specular detail is usually less perceptible than diffuse). Driven by the RenderTextureQuality preset. + Per-channel discard exponent for specular / metallic-roughness. 1.0 = baseline; lower = more aggressive. Driven by the RenderTextureQuality preset. Persist 1 Type @@ -11860,16 +11904,16 @@ Value 0.5 - TextureChannelRatioEmissive + TextureChannelEmissive Comment - Per-channel pixel:texel ratio multiplier for emissive (texels per pixel, applied on top of the global TexturePixelToTexelRatio). 0.5 = half resolution. Driven by the RenderTextureQuality preset. + Per-channel discard exponent for emissive. 1.0 = baseline; lower = more aggressive. Driven by the RenderTextureQuality preset. Persist 1 Type F32 Value - 0.5 + 0.75 TextureMaxDiscardOverride @@ -11882,87 +11926,165 @@ Value 0 - TexturePixelToTexelRatio + TextureMemoryHighWaterMark Comment - Max texels per screen pixel the streamer will allocate (the "R" in a 1:R pixel:texel ratio). 1.0 = one texel per pixel. VRAM pressure walks the effective ratio down from here. + Fraction of budget (0..1) at which the pressure controller bypasses smoothing and slams to cap. Last-ditch min-discard also creeps without waiting for mult_progress. Persist 1 Type F32 Value - 1.0 + 0.8 - TextureBackgroundMinRatio + TextureMemoryPressureBackoffStart Comment - Lowest pixel:texel ratio the streamer decays to while the viewer is backgrounded, to free VRAM for other apps. Lower frees more but re-rezzes slower on return. Restored when focus comes back. + Fraction of the VRAM target at which the pressure ramp starts (0..1). Lower = earlier headroom-building; 1.0 disables backoff (ramp only above target). Persist 1 Type F32 Value - 0.001 + 0.85 - TexturePressureHighWater + TextureMemoryPressureMaxMultiplier Comment - High water mark as a fraction of the VRAM budget. When used VRAM crosses this, the global pixel:texel ratio tightens (backs off detail) at TexturePressureTightenRate. Held at 0.90 - it's a physical "crossed the budget" threshold, not a tier preference. + Upper bound on the VRAM-pressure distance multiplier (>= 1). Mostly defensive -- at mult=64 the streaming ramp collapses to ~ramp_range/64, already extreme. Higher allows even more aggressive compression in tight-budget scenes. Persist 1 Type F32 Value - 0.90 + 64.0 - TexturePressureLowWater + TextureLastDitchEngageProgress Comment - Low water mark as a fraction of the VRAM budget. When used VRAM drops below this, the global pixel:texel ratio relaxes (restores detail) at TexturePressureRelaxRate. The band between low and high is the hysteresis zone where the ratio holds steady - wide enough to prevent sawtooth. + mult_progress (0..1) at which the last-ditch floor starts creeping up. The floor only advances when mult is at or above this fraction of its cap AND prediction is still over budget. Decays back toward 0 whenever prediction is under budget. Persist 1 Type F32 Value - 0.70 + 0.95 - TexturePressureTightenRate + TextureLastDitchRampRate Comment - Rate (ratio units/sec) at which the global pixel:texel ratio drops while used VRAM is above the high watermark. Deliberately slow so eviction (scaleDown draining) frees bytes before the next step - prevents over-shoot / thrash. + Rate (discard levels/sec) at which sLastDitchMinDiscard creeps up while engaged. 0.5 = takes ~2 sec to add one discard level. Mirrors sDesiredDiscardBias ramp shape. Persist 1 Type F32 Value - 0.30 + 0.5 - TexturePressureRelaxRate + TextureLastDitchDecayRate Comment - Rate (ratio units/sec) at which the global pixel:texel ratio climbs back toward TexturePixelToTexelRatio while used VRAM is below the low watermark. Typically slower than the tighten rate so detail returns gradually as headroom appears. + Rate (discard levels/sec) at which sLastDitchMinDiscard decays back to 0 when prediction is under budget. Persist 1 Type F32 Value - 0.10 + 0.5 - TextureUpRezMargin + TextureLastDitchMinDiscardMax Comment - Hysteresis dead-band (in mip levels) around a texture's current discard. A texture only fetches a finer mip when its ideal discard falls more than this below the current level, and only evicts when it rises more than this above - prevents fetch/scaleDown thrash at mip boundaries when an object slowly recedes. + Hard ceiling on sLastDitchMinDiscard. At 13 the floor can climb all the way to the deepest meaningful mip; lower values cap how aggressive the last-ditch escalation can get before we are simply out of discards. Persist 1 Type F32 Value - 0.2 + 13.0 - TextureCooldownStepSeconds + TextureMemoryPressurePredictionGain Comment - While backgrounded, the pixel:texel ratio drops one mip toward TextureBackgroundMinRatio every this many seconds. + Power exponent mapping predicted-over-budget ratio to target multiplier. target_mult = pred_over^gain. Higher gain saturates faster. + Persist + 1 + Type + F32 + Value + 10.0 + + TextureMemoryPressureSmoothingRate + + Comment + Lerp rate (1/sec) at which the pressure multiplier converges to its prediction-driven target. Higher = faster response, lower = smoother. Default 4 reaches ~63% in 0.25s. + Persist + 1 + Type + F32 + Value + 4.0 + + TextureTerrainDistanceFloor + + Comment + Minimum distance factor for BOOST_TERRAIN textures. Keeps combined > 0 so VRAM pressure can evict terrain. Lower = higher idle quality, less pressure response. + Persist + 1 + Type + F32 + Value + 0.01 + + TextureTerrainCoverageFraction + + Comment + Synthetic on-screen coverage fraction for BOOST_TERRAIN textures (no faces are registered). Higher = higher idle quality, less pressure response. + Persist + 1 + Type + F32 + Value + 0.99 + + TextureAgentAvatarBoost + + Comment + Quality boost (0..1) for textures on the agent's avatar (rigged mesh / animated objects). Lower = higher quality. Preference, not exemption - pressure can still evict. + Persist + 1 + Type + F32 + Value + 0.5 + + TextureBackgroundFactorRatePerSec + + Comment + Per-second ramp rate of the background-window discard floor (0..1). Snaps to 0 in foreground. Default 0.011 ~ 90s to saturate. + Persist + 1 + Type + F32 + Value + 0.011 + + TextureBackgroundDiscardOffset + + Comment + Backgrounded textures will only discard up to (dim_max - offset). e.g. a 2048 texture (dim_max 11) with offset 2 caps the background floor at discard 9. 0 disables the cap (background can drive to max discard). + Persist + 1 + Type + S32 + Value + 2 + + + TextureCloseBubbleMeters + + Comment + Close-camera bubble (meters). Faces inside this distance get dist_factor = 0 (no discard contribution); the ramp to 1 spans (bubble, draw_distance]. Shrinks toward TextureCloseBubbleMinMeters as VRAM pressure ramps the multiplier toward its cap. Persist 1 Type @@ -11970,39 +12092,95 @@ Value 5.0 - TextureGCStepFrames + TextureCloseBubbleMinMeters Comment - Foreground GC cooldown, in rendered frames. For every this many frames a texture goes without being drawn, its mip drops by TextureGCStepMips. Resets when the texture is drawn again. + Floor (meters) for the close-camera bubble under maximum VRAM pressure. At sMemoryPressureMultiplier = TextureMemoryPressureMaxMultiplier the bubble collapses to this value, allowing eviction of even close textures when nothing else fits. Persist 1 Type - U32 + F32 Value - 5 + 3.0 - TextureGCStepMips + TextureCloseBubbleShrinkThreshold Comment - Mip levels dropped each time a TextureGCStepFrames cooldown elapses. 1 is gentlest; higher sheds VRAM faster in coarser jumps. + Bubble stays at full size until mult_progress exceeds this fraction (0..1) of its range to the cap. Above that, bubble lerps from full to TextureCloseBubbleMinMeters. Keeps the bubble out of the normal feedback loop. Persist 1 Type - U32 + F32 Value + 0.8 + + TextureCloseBubbleTrackRate + + Comment + Rate (1/sec) at which the actual bubble tracks its target. Lower = smoother, slower to react. Damps short-term multiplier swings so close textures don't yo-yo. + Persist 1 + Type + F32 + Value + 0.5 - TextureFetchVisibilityFrames + TextureDistanceDiscardPower Comment - 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. + Exponent on the distance factor (face_distance / draw_distance). 1.0 = linear; lower = textures hit max discard sooner with distance. Default 0.5 = sqrt. Persist 1 Type - U32 + F32 + Value + 0.5 + + TextureSizeDiscardPower + + Comment + Exponent on the on-screen size factor (1 - coverage). 1.0 = linear; lower = small-on-screen textures attenuate sooner. + Persist + 1 + Type + F32 + Value + 1.0 + + TextureStalenessIntervalSeconds + + Comment + Seconds per staleness step. Per-interval increment is 1/max_discard so any texture saturates after interval * max_discard seconds idle. + Persist + 1 + Type + F32 + Value + 5.0 + + TextureBindDecaySeconds + + Comment + Grace seconds after a bind during which the staleness factor stays at 0. Prevents intermittently-bound textures from ramping. 0 disables the grace period. + Persist + 1 + Type + F32 Value + 5.0 + + TextureFetchPressureScale + + Comment + Pending-fetch divisor for the bias floor: bias floor = 1 + clamp(pending / scale, 0, 3). Lower = bias rises sooner under load floods. + Persist 1 + Type + F32 + Value + 1000.0 + TextureDecodeDisabled Comment @@ -12036,6 +12214,28 @@ Value 0 + TextureDiscardBackgroundedTime + + Comment + Specify how long to wait before discarding texture data after viewer is backgrounded. (zero or negative to disable) + Persist + 1 + Type + F32 + Value + 60.0 + + TextureDiscardMinimizedTime + + Comment + Specify how long to wait before discarding texture data after viewer is minimized. (zero or negative to disable) + Persist + 1 + Type + F32 + Value + 1.0 + TextureFetchConcurrency Comment @@ -12124,27 +12324,27 @@ Value - TextureAvatarBoost + TextureScaleMinAreaFactor Comment - Coverage multiplier for avatar textures: worn attachments (rigged extents make their measurement unreliable) and baked system-avatar textures. 4.0 = one mip finer than measured. A bonus, not a pin - nearby avatars gain headroom while distant avatars still downrez with their measured coverage. 1.0 disables. + Limits how texture scale affects area calculation. Persist 1 Type F32 Value - 4.0 + 0.0095 - TextureDownrezCoverageBias + TextureScaleMaxAreaFactor Comment - Which end of a texture's texels-per-pixel spread sizes it. Each texture tracks the screen coverage of its most demanding use (lowest texels per pixel) and least demanding use (highest texels per pixel, most oversampled). 0 = size to the most demanding use (best quality); 1 = size to the least demanding use (frees the most memory). Interpolation is geometric (log-space), so the resulting discard level moves linearly with this value - 0.5 sits halfway between the two ends in mip levels. Default 0.25 is the best universal balance. + Limits how texture scale affects area calculation. Persist 1 Type F32 Value - 0.25 + 25.0 ThreadPoolSizes diff --git a/indra/newview/featuretable.txt b/indra/newview/featuretable.txt index 72e0f43c0e..f05f77c222 100644 --- a/indra/newview/featuretable.txt +++ b/indra/newview/featuretable.txt @@ -68,6 +68,7 @@ RenderShadowDetail 1 2 RenderUseStreamVBO 1 1 RenderFSAAType 1 2 RenderFSAASamples 1 3 +RenderMaxTextureIndex 1 16 RenderGLContextCoreProfile 1 1 RenderGLMultiThreadedTextures 1 0 RenderGLMultiThreadedMedia 1 1 diff --git a/indra/newview/featuretable_linux.txt b/indra/newview/featuretable_linux.txt index a39c64510f..d8d4f08429 100644 --- a/indra/newview/featuretable_linux.txt +++ b/indra/newview/featuretable_linux.txt @@ -66,6 +66,7 @@ RenderDeferredSSAO 1 1 RenderUseAdvancedAtmospherics 1 0 RenderShadowDetail 1 2 RenderFSAASamples 1 16 +RenderMaxTextureIndex 1 16 RenderMirrors 1 1 // @@ -490,6 +491,7 @@ RenderVBOEnable 1 0 list OpenGLPre30 RenderDeferred 0 0 +RenderMaxTextureIndex 1 1 list Intel RenderAnisotropic 1 0 diff --git a/indra/newview/featuretable_mac.txt b/indra/newview/featuretable_mac.txt index ebfe45d9ea..b11fa28c48 100644 --- a/indra/newview/featuretable_mac.txt +++ b/indra/newview/featuretable_mac.txt @@ -65,6 +65,7 @@ RenderShadowDetail 1 2 RenderUseStreamVBO 1 1 RenderFSAAType 1 2 RenderFSAASamples 1 3 +RenderMaxTextureIndex 1 16 RenderGLContextCoreProfile 1 1 RenderGLMultiThreadedTextures 1 1 RenderGLMultiThreadedMedia 1 1 diff --git a/indra/newview/llfetchedgltfmaterial.cpp b/indra/newview/llfetchedgltfmaterial.cpp index d71f0c1bd4..a05f725673 100644 --- a/indra/newview/llfetchedgltfmaterial.cpp +++ b/indra/newview/llfetchedgltfmaterial.cpp @@ -73,20 +73,6 @@ void LLFetchedGLTFMaterial::bind(LLViewerTexture* media_tex) LLViewerTexture* baseColorTex = media_tex ? media_tex : mBaseColorTexture; LLViewerTexture* emissiveTex = media_tex ? media_tex : mEmissiveTexture; - if (media_tex) - { - // Media hides these but they stay registered for coverage. Stamp them so - // the GC doesn't coarsen/refetch them while the media is playing. - if (mBaseColorTexture.notNull()) - { - if (LLImageGL* gl_tex = mBaseColorTexture->getGLTexture()) { gl_tex->stampBound(); } - } - if (mEmissiveTexture.notNull()) - { - if (LLImageGL* gl_tex = mEmissiveTexture->getGLTexture()) { gl_tex->stampBound(); } - } - } - if (!LLPipeline::sShadowRender || (mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK)) { if (mAlphaMode == LLGLTFMaterial::ALPHA_MODE_MASK) @@ -111,26 +97,13 @@ void LLFetchedGLTFMaterial::bind(LLViewerTexture* media_tex) if (!LLPipeline::sShadowRender) { - // Bind the normal map at whatever resolution is resident, like Blinn-Phong - // (soft, never absent). Only fall back to the flat normal when it's not - // loaded yet. (The old discard<=4 gate dropped distant/tiled PBR normals - // entirely, making PBR look flatter than equivalent Blinn content.) - if (mNormalTexture.notNull() && mNormalTexture->hasGLTexture()) + if (mNormalTexture.notNull() && mNormalTexture->getDiscardLevel() <= 4) { shader->bindTexture(LLShaderMgr::BUMP_MAP, mNormalTexture); } else { shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep); - if (mNormalTexture.notNull()) - { - // In use, just not loaded yet - stamp it so the GC doesn't treat - // it as unseen and pin it deep before its first real bind. - if (LLImageGL* gl_tex = mNormalTexture->getGLTexture()) - { - gl_tex->stampBound(); - } - } } if (mMetallicRoughnessTexture.notNull()) diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp index 10b57f47da..470a133fa7 100644 --- a/indra/newview/lltextureview.cpp +++ b/indra/newview/lltextureview.cpp @@ -476,7 +476,7 @@ private: void LLGLTexMemBar::draw() { - F32 pixel_to_texel_ratio = LLViewerTexture::sPixelToTexelRatio; + F32 discard_bias = LLViewerTexture::sDesiredDiscardBias; F32 cache_usage = (F32)LLAppViewer::getTextureCache()->getUsage().valueInUnits(); F32 cache_max_usage = (F32)LLAppViewer::getTextureCache()->getMaxUsage().valueInUnits(); S32 line_height = LLFontGL::getFontMonospace()->getLineHeight(); @@ -560,22 +560,25 @@ void LLGLTexMemBar::draw() gGL.color4f(0.f, 0.f, 0.f, 0.25f); gl_rect_2d(-10, getRect().getHeight() + line_height*2 + 1, getRect().getWidth()+2, getRect().getHeight()+2); - text = llformat("Est. Free: %d MB Sys Free: %d MB FBO: %d MB Probe#: %d Probe Mem: %d MB Px:Texel 1:%.2f Cache: %.1f/%.1f MB", + text = llformat("Est. Free: %d MB Sys Free: %d MB FBO: %d MB Probe#: %d Probe Mem: %d MB Bias: %.2f Cache: %.1f/%.1f MB", (S32)LLViewerTexture::sFreeVRAMMegabytes, LLMemory::getAvailableMemKB()/1024, LLRenderTarget::sBytesAllocated/(1024*1024), gPipeline.mReflectionMapManager.probeCount(), gPipeline.mReflectionMapManager.probeMemory(), - pixel_to_texel_ratio, + discard_bias, cache_usage, cache_max_usage); LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*8, text_color, LLFontGL::LEFT, LLFontGL::TOP); - text = llformat("Images: %d Raw: %d (%.2f MB) Saved: %d (%.2f MB) Aux: %d (%.2f MB)", + text = llformat("Images: %d Raw: %d (%.2f MB) Saved: %d (%.2f MB) Aux: %d (%.2f MB) Bubble: %.1fm PressMult: %.1fx LDMin: %.1f", image_count, raw_image_count, raw_image_bytes_MB, saved_raw_image_count, saved_raw_image_bytes_MB, - aux_raw_image_count, aux_raw_image_bytes_MB); + aux_raw_image_count, aux_raw_image_bytes_MB, + LLViewerTextureList::sCurrentBubbleMeters, + LLViewerTexture::sMemoryPressureMultiplier, + LLViewerTexture::sLastDitchMinDiscard); LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height * 7, text_color, LLFontGL::LEFT, LLFontGL::TOP); diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp index dd2357ae8f..a4a7f1fd20 100644 --- a/indra/newview/llviewercontrol.cpp +++ b/indra/newview/llviewercontrol.cpp @@ -112,60 +112,45 @@ static bool handleRenderAvatarMouselookChanged(const LLSD& newvalue) return true; } -// Per-tier texture quality preset. Data-driven so adding a setting is -// "add a column", and the tier values are visible side-by-side. Index is -// RenderTextureQuality: 0=Low, 1=Medium, 2=High, 3=Ultra. -namespace -{ - struct TexturePreset - { - const char* name; - U32 max_resolution; - F32 pixel_to_texel_ratio; // TexturePixelToTexelRatio (R_max, texels per pixel) - F32 pressure_tighten_rate; // TexturePressureTightenRate (ratio units/sec) - F32 pressure_relax_rate; // TexturePressureRelaxRate (ratio units/sec) - F32 channel_ratio_normal; // TextureChannelRatioNormal - F32 channel_ratio_basecolor; // TextureChannelRatioBaseColor - F32 channel_ratio_specular; // TextureChannelRatioSpecular - F32 channel_ratio_emissive; // TextureChannelRatioEmissive - }; - - // Tier values: Low (2-4GB), Medium (4-8GB), High (8-16GB), Ultra (16+GB). - // Quality ladder, expressed in pixel:texel (texels per pixel): - // - pixel_to_texel_ratio is the baseline quality: how many texels per - // screen pixel the tier allocates when VRAM is comfortable (1.0 = 1:1). - // Under pressure the runtime drives the global ratio below this with no - // floor (down to 0 = deepest mips), so there is no per-tier minimum. - // - the channel ratios coarsen specular/emissive/normal relative to base - // color (each is a multiplier on the global ratio). - // The pressure water marks (TexturePressureHighWater/LowWater) are NOT tiered - they're a - // physical "crossed the budget" threshold (0.90 / 0.70), constant across - // tiers. Lower tiers start blurrier (lower R_max) and tighten faster. - // max_res Rmax tight relax N BC S E - static constexpr TexturePreset TEXTURE_PRESETS[4] = { - /* 0 Low */ { "Low", 1024, 0.10f, 0.50f, 0.05f, 0.50f, 1.00f, 0.25f, 0.25f }, - /* 1 Medium */ { "Medium", 2048, 0.40f, 0.35f, 0.08f, 1.00f, 1.00f, 0.50f, 0.50f }, - /* 2 High */ { "High", 2048, 0.80f, 0.25f, 0.10f, 1.00f, 1.00f, 0.50f, 1.00f }, - /* 3 Ultra */ { "Ultra", 2048, 1.00f, 0.15f, 0.12f, 1.00f, 1.00f, 1.00f, 1.00f }, - }; -} - static bool handleRenderTextureQualityChanged(const LLSD& newvalue) { + // 0=Low, 1=Medium, 2=High, 3=Ultra. Drives RenderMaxTextureResolution, + // the four TextureChannel* exponents (Normal/BaseColor/Spec/Emissive), + // and TextureDistanceDiscardPower. U32 quality = (U32)newvalue.asInteger(); - if (quality > 3) quality = 3; - const TexturePreset& p = TEXTURE_PRESETS[quality]; - - gSavedSettings.setU32("RenderMaxTextureResolution", p.max_resolution); - gSavedSettings.setF32("TexturePixelToTexelRatio", p.pixel_to_texel_ratio); - gSavedSettings.setF32("TexturePressureTightenRate", p.pressure_tighten_rate); - gSavedSettings.setF32("TexturePressureRelaxRate", p.pressure_relax_rate); - gSavedSettings.setF32("TextureChannelRatioNormal", p.channel_ratio_normal); - gSavedSettings.setF32("TextureChannelRatioBaseColor", p.channel_ratio_basecolor); - gSavedSettings.setF32("TextureChannelRatioSpecular", p.channel_ratio_specular); - gSavedSettings.setF32("TextureChannelRatioEmissive", p.channel_ratio_emissive); - - LL_INFOS("TextureStream") << "Applied texture quality preset: " << p.name << LL_ENDL; + U32 max_res = 2048; + F32 ch_normal = 1.0f; + F32 ch_basecolor = 0.75f; + F32 ch_specular = 0.5f; + F32 ch_emissive = 0.75f; + F32 distance_power = 0.5f; + switch (quality) + { + case 0: // Low + max_res = 1024; + ch_normal = 0.5f; ch_basecolor = 0.75f; ch_specular = 0.1f; ch_emissive = 0.5f; + distance_power = 0.15f; + break; + case 1: // Medium + ch_normal = 0.75f; ch_basecolor = 0.75f; ch_specular = 0.3f; ch_emissive = 0.75f; + distance_power = 0.25f; + break; + case 2: // High + // channel defaults above + distance_power = 0.35f; + break; + case 3: // Ultra + default: + ch_normal = 1.f; ch_basecolor = 1.f; ch_specular = 1.f; ch_emissive = 1.f; + distance_power = 0.5f; + break; + } + gSavedSettings.setU32("RenderMaxTextureResolution", max_res); + gSavedSettings.setF32("TextureChannelNormal", ch_normal); + gSavedSettings.setF32("TextureChannelBaseColor", ch_basecolor); + gSavedSettings.setF32("TextureChannelSpecular", ch_specular); + gSavedSettings.setF32("TextureChannelEmissive", ch_emissive); + gSavedSettings.setF32("TextureDistanceDiscardPower", distance_power); return true; } @@ -884,6 +869,7 @@ void settings_setup_listeners() setting_setup_signal_listener(gSavedSettings, "OctreeMaxNodeCapacity", handleRepartition); setting_setup_signal_listener(gSavedSettings, "OctreeAlphaDistanceFactor", handleRepartition); setting_setup_signal_listener(gSavedSettings, "OctreeAttachmentSizeFactor", handleRepartition); + setting_setup_signal_listener(gSavedSettings, "RenderMaxTextureIndex", handleSetShaderChanged); setting_setup_signal_listener(gSavedSettings, "RenderUIBuffer", handleWindowResized); setting_setup_signal_listener(gSavedSettings, "RenderDepthOfField", handleReleaseGLBufferChanged); setting_setup_signal_listener(gSavedSettings, "RenderFSAAType", handleReleaseGLBufferChanged); diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp index 8863dfb501..7e671ef9a2 100644 --- a/indra/newview/llviewermessage.cpp +++ b/indra/newview/llviewermessage.cpp @@ -3380,6 +3380,13 @@ void send_agent_update(bool force_send, bool send_reliable) memory_limited_draw_distance = llmax(gAgentCamera.mDrawDistance / mem_factor, gAgentCamera.mDrawDistance / 2.f); } + if (LLViewerTexture::getSystemMemoryBudgetFactor() > 1.f) + { + // We are critcally low on memory or recovering, + // limit requested draw distance + memory_limited_draw_distance = llmax(gAgentCamera.mDrawDistance / LLViewerTexture::getSystemMemoryBudgetFactor(), gAgentCamera.mDrawDistance / 2.f); + } + if (tp_state == LLAgent::TELEPORT_ARRIVING || LLStartUp::getStartupState() < STATE_MISC) { // Inform interest list, prioritize closer area. diff --git a/indra/newview/llviewerobject.cpp b/indra/newview/llviewerobject.cpp index 4e4282a8ca..7c26cb3c9f 100644 --- a/indra/newview/llviewerobject.cpp +++ b/indra/newview/llviewerobject.cpp @@ -5229,20 +5229,7 @@ void LLViewerObject::setTE(const U8 te, const LLTextureEntry& texture_entry) const LLUUID& image_id = getTE(te)->getID(); LLViewerTexture* bakedTexture = getBakedTextureForMagicId(image_id); - if (bakedTexture) - { - mTEImages[te] = bakedTexture; - } - else - { - LLViewerFetchedTexture* img = LLViewerTextureManager::getFetchedTexture(image_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); - // Same creation seed the PBR path applies in updateTEMaterialTextures' - // fetch_texture - without it a Blinn texture has decode_priority 0 and - // cannot even fetch headers until its first coverage measurement, - // while the equivalent PBR texture starts fetching immediately. - img->addTextureStats(64.f * 64.f, true); - mTEImages[te] = img; - } + mTEImages[te] = bakedTexture ? bakedTexture : LLViewerTextureManager::getFetchedTexture(image_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); updateAvatarMeshVisibility(image_id, old_image_id); @@ -5253,14 +5240,11 @@ void LLViewerObject::updateTEMaterialTextures(U8 te) { if (getTE(te)->getMaterialParams().notNull()) { - // Same creation seed as the PBR fetch_texture below - see setTE. const LLUUID& norm_id = getTE(te)->getMaterialParams()->getNormalID(); mTENormalMaps[te] = LLViewerTextureManager::getFetchedTexture(norm_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); - mTENormalMaps[te]->addTextureStats(64.f * 64.f, true); const LLUUID& spec_id = getTE(te)->getMaterialParams()->getSpecularID(); mTESpecularMaps[te] = LLViewerTextureManager::getFetchedTexture(spec_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); - mTESpecularMaps[te]->addTextureStats(64.f * 64.f, true); } LLFetchedGLTFMaterial* mat = (LLFetchedGLTFMaterial*) getTE(te)->getGLTFRenderMaterial(); diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp index 255317ce80..27865f7598 100644 --- a/indra/newview/llviewershadermgr.cpp +++ b/indra/newview/llviewershadermgr.cpp @@ -561,7 +561,13 @@ void LLViewerShaderMgr::setShaders() LLAppViewer::instance()->isSecondInstance()); } + static LLCachedControl max_texture_index(gSavedSettings, "RenderMaxTextureIndex", 16); + + // when using indexed texture rendering, leave some texture units available for shadow and reflection maps + static LLCachedControl reserved_texture_units(gSavedSettings, "RenderReservedTextureIndices", 14); + LLGLSLShader::sIndexedTextureChannels = 4; + //llclamp(max_texture_index, 1, gGLManager.mNumTextureImageUnits-reserved_texture_units); reentrance = true; diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp index 80daffdbf3..ac8bb1d0c5 100644 --- a/indra/newview/llviewertexture.cpp +++ b/indra/newview/llviewertexture.cpp @@ -60,7 +60,6 @@ #include "llmediaentry.h" #include "llvovolume.h" #include "llviewermedia.h" -#include "lldrawable.h" #include "lltexturecache.h" #include "llviewerwindow.h" #include "llwindow.h" @@ -87,8 +86,19 @@ S32 LLViewerTexture::sImageCount = 0; S32 LLViewerTexture::sRawCount = 0; S32 LLViewerTexture::sAuxCount = 0; LLFrameTimer LLViewerTexture::sEvaluationTimer; -F32 LLViewerTexture::sPixelToTexelRatio = 1.f; -U32 LLViewerTexture::sGCSuspendedFrame = 0; +F32 LLViewerTexture::sDesiredDiscardBias = 0.f; +F32 LLViewerTexture::sBackgroundFactor = 0.f; +F32 LLViewerTexture::sMemoryPressureMultiplier = 1.f; +F32 LLViewerTexture::sLastDitchMinDiscard = 0.f; + +//static +F32 LLViewerTexture::getMemoryPressureProgress() +{ + static LLCachedControl max_mult(gSavedSettings, "TextureMemoryPressureMaxMultiplier", 64.f); + F32 cap = llmax((F32)max_mult, 1.0001f); + return llclampf((sMemoryPressureMultiplier - 1.f) / (cap - 1.f)); +} +U32 LLViewerTexture::sBiasTexturesUpdated = 0; S32 LLViewerTexture::sMaxSculptRez = 128; //max sculpt image size constexpr S32 MAX_CACHED_RAW_IMAGE_AREA = 64 * 64; @@ -100,9 +110,11 @@ U32 LLViewerTexture::sMinLargeImageSize = 65536; //256 * 256. U32 LLViewerTexture::sMaxSmallImageSize = MAX_CACHED_RAW_IMAGE_AREA; F32 LLViewerTexture::sCurrentTime = 0.0f; +constexpr F32 MEMORY_CHECK_WAIT_TIME = 1.0f; constexpr F32 MIN_VRAM_BUDGET = 768.f; F32 LLViewerTexture::sFreeVRAMMegabytes = MIN_VRAM_BUDGET; F32 LLViewerTexture::sWindowPixelArea = 1.f; +F32 LLViewerTexture::sSysMemoryFactor = 1.f; LLViewerTexture::EDebugTexels LLViewerTexture::sDebugTexelsMode = LLViewerTexture::DEBUG_TEXELS_OFF; @@ -479,6 +491,13 @@ void LLViewerTexture::initClass() LLImageGL::sDefaultGLTexture = LLViewerFetchedTexture::sDefaultImagep->getGLTexture(); } +S32Megabytes get_render_free_main_memory_treshold() +{ + static LLCachedControl min_free_main_memory(gSavedSettings, "RenderMinFreeMainMemoryThreshold", 512); + const U32Megabytes MIN_FREE_MAIN_MEMORY(min_free_main_memory); + return MIN_FREE_MAIN_MEMORY; +} + //static void LLViewerTexture::updateClass() { @@ -527,60 +546,375 @@ void LLViewerTexture::updateClass() // 'bias' calculation to kick in. F32 vram_target = llmax(llmin(vram_budget - 512.f, vram_budget * 0.8f), MIN_VRAM_BUDGET); sFreeVRAMMegabytes = vram_target - vram_used; + const S32Megabytes free_sys_mem = getFreeSystemMemory(); + + F32 over_pct = (vram_used - vram_target) / vram_target; + + // Predicted-VRAM pressure controller. Eviction is fast, refetch is slow, + // so feedback on instantaneous `used` sawtooths; feeding `used + + // in_flight_delta` lets mult converge to equilibrium instead of cycling. + { + static LLCachedControl backoff_start(gSavedSettings, "TextureMemoryPressureBackoffStart", 0.85f); + static LLCachedControl max_mult(gSavedSettings, "TextureMemoryPressureMaxMultiplier", 64.f); + static LLCachedControl prediction_gain(gSavedSettings, "TextureMemoryPressurePredictionGain", 10.f); + static LLCachedControl smoothing_rate(gSavedSettings, "TextureMemoryPressureSmoothingRate", 4.f); + + F32 backoff_target = vram_target * llclamp((F32)backoff_start, 0.05f, 1.f); + F32 cap = llmax((F32)max_mult, 1.0001f); + F32 dt = (F32)gFrameIntervalSeconds; + + // Skip the full-list iteration when there is no pressure to react to: + // mult already at baseline, last-ditch at zero, and used well clear of + // the backoff target. Worst case the controller picks up the spike one + // frame later, from `used` alone. + bool need_predict = sMemoryPressureMultiplier > 1.001f + || sLastDitchMinDiscard > 0.f + || vram_used > backoff_target * 0.5f; + + S64 pending_bytes_increase = 0; + S64 pending_bytes_decrease = 0; + if (need_predict) + { + LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vt - in-flight predict"); + for (auto& imagep : gTextureList) + { + if (imagep.isNull()) continue; + // Cheap inline checks first so the virtual getDiscardLevel() + // call only fires when there is a real chance of contribution. + S32 desired = imagep->getDesiredDiscardLevel(); + if (desired < 0) continue; + S32 fw = imagep->getFullWidth(); + S32 fh = imagep->getFullHeight(); + if (fw <= 0 || fh <= 0) continue; + S32 current = imagep->getDiscardLevel(); + if (current < 0 || desired == current) continue; + + S32 wd = llmax(1, fw >> desired); + S32 hd = llmax(1, fh >> desired); + S32 wc = llmax(1, fw >> current); + S32 hc = llmax(1, fh >> current); + // bpp=4, mip pyramid overhead 4/3 + S64 size_d = (S64)wd * hd * 4 * 4 / 3; + S64 size_c = (S64)wc * hc * 4 * 4 / 3; + + if (desired < current) + pending_bytes_increase += (size_d - size_c); + else + pending_bytes_decrease += (size_c - size_d); + } + } - // VRAM pressure controller for the global pixel:texel ratio. Tightens above - // the high watermark, relaxes below the low one, holds in the band (the band - // stops sawtooth). Rates are slow so eviction frees bytes before the next step. - { - static LLCachedControl ratio_max(gSavedSettings, "TexturePixelToTexelRatio", 1.0f); - static LLCachedControl bg_min_ratio(gSavedSettings, "TextureBackgroundMinRatio", 0.001f); - static LLCachedControl wm_high(gSavedSettings, "TexturePressureHighWater", 0.90f); - static LLCachedControl wm_low(gSavedSettings, "TexturePressureLowWater", 0.70f); - static LLCachedControl tighten_rate(gSavedSettings, "TexturePressureTightenRate", 0.30f); - static LLCachedControl relax_rate(gSavedSettings, "TexturePressureRelaxRate", 0.10f); - static LLCachedControl cooldown_step(gSavedSettings, "TextureCooldownStepSeconds", 5.f); + // 1024 * 512 = 524288: matches the unit reduction at line 513. + constexpr F32 BYTES_TO_USED_UNITS = 1.f / 524288.f; + F32 predicted_used = vram_used + + (F32)pending_bytes_increase * BYTES_TO_USED_UNITS + - (F32)pending_bytes_decrease * BYTES_TO_USED_UNITS; + F32 predicted_over = predicted_used / llmax(backoff_target, 1.f); + + // High water mark: when used crosses budget * high_water, skip the + // smoothed convergence and slam the controller into hard-cap state. + // Recovers the historical 90% behavior - immediate aggressive + // response instead of waiting for the lerp to chase the target. + static LLCachedControl high_water(gSavedSettings, "TextureMemoryHighWaterMark", 0.8f); + bool above_high_water = vram_used >= vram_budget * llclamp((F32)high_water, 0.5f, 1.f); + + F32 target_mult = llclamp(powf(llmax(predicted_over, 1.f), llmax((F32)prediction_gain, 0.0001f)), 1.f, cap); + if (above_high_water) + { + target_mult = cap; + sMemoryPressureMultiplier = cap; + } + else + { + // ~63% convergence in 1/smoothing_rate seconds (default 0.25s). + F32 alpha = 1.f - expf(-llmax(dt, 0.f) * llmax((F32)smoothing_rate, 0.f)); + sMemoryPressureMultiplier += (target_mult - sMemoryPressureMultiplier) * alpha; + } + sMemoryPressureMultiplier = llclamp(sMemoryPressureMultiplier, 1.f, cap); - // No lower bound: pressure can drive the ratio to 0 (deepest mip for - // everything). Only the top is capped, by the configured max. - F32 r_max = llmax((F32)ratio_max, 0.f); - F32 high_frac = llclamp((F32)wm_high, 0.1f, 1.f); - F32 high = vram_budget * high_frac; - F32 low = vram_budget * llclamp((F32)wm_low, 0.05f, high_frac); - F32 dt = (F32)gFrameIntervalSeconds; + F32 progress = getMemoryPressureProgress(); - bool in_background = (gViewerWindow && !gViewerWindow->getWindow()->getVisible()) || !gFocusMgr.getAppHasFocus(); + { + static LLCachedControl ld_engage(gSavedSettings, "TextureLastDitchEngageProgress", 0.95f); + static LLCachedControl ld_ramp(gSavedSettings, "TextureLastDitchRampRate", 0.5f); + static LLCachedControl ld_decay(gSavedSettings, "TextureLastDitchDecayRate", 0.5f); + static LLCachedControl ld_max(gSavedSettings, "TextureLastDitchMinDiscardMax", 13.f); + // Above the high water mark, last-ditch creeps regardless of + // mult_progress: by definition we are out of normal headroom. + bool engage = above_high_water || progress >= llclampf((F32)ld_engage); + if (engage && predicted_over > 1.f) + { + sLastDitchMinDiscard += llmax((F32)ld_ramp, 0.f) * dt; + } + else if (!above_high_water && predicted_over < 1.f) + { + sLastDitchMinDiscard -= llmax((F32)ld_decay, 0.f) * dt; + } + sLastDitchMinDiscard = llclamp(sLastDitchMinDiscard, 0.f, llmax((F32)ld_max, 0.f)); + } - if (in_background) + // 1 Hz pressure log. + static LLFrameTimer s_pressure_log_timer; + if (s_pressure_log_timer.getElapsedTimeF32() > 1.f) + { + s_pressure_log_timer.reset(); + F32 over = vram_used / llmax(backoff_target, 1.f); + LL_INFOS("TextureStream") << "pressure" + << " mult=" << sMemoryPressureMultiplier + << " target_mult=" << target_mult + << " progress=" << progress + << " used=" << vram_used + << " predicted=" << predicted_used + << " target=" << vram_target + << " over=" << over + << " pred_over=" << predicted_over + << " in+=" << (S32)(pending_bytes_increase / 1024 / 1024) + << "MB in-=" << (S32)(pending_bytes_decrease / 1024 / 1024) + << "MB bias=" << sDesiredDiscardBias + << " ldmin=" << sLastDitchMinDiscard + << " dsq=" << (S32)gTextureList.mDownScaleQueue.size() + << LL_ENDL; + } + } + + bool is_sys_low = isSystemMemoryLow(); + bool is_sys_critically_low = isSystemMemoryCritical(); + bool is_low = is_sys_low || over_pct > 0.f; + + static bool was_low = false; + static bool sys_was_low = false; + + // System memory factor + // sSysMemoryFactor affects draw distance + // + // We only decrement when more than 406MB is free, but increment + // when below 256MB free. This should provide a stable value + // in the 256-406MB range to avoid draw range fluctuations. + // + // Draw range reduction is a last resort, texture bias is supposed + // to free at least some memory before we get here. + // Note: textures were mostly moved to vram, we might want to + // detach texture bias from system memory. + if (is_sys_critically_low) + { + const S32Megabytes MIN_FREE_MAIN_MEMORY(get_render_free_main_memory_treshold() / 2); + // debt is a negative value since MIN_FREE_MAIN_MEMORY > free memory. + S32 sys_budget_debt = free_sys_mem - MIN_FREE_MAIN_MEMORY; + + // Leave some padding, otherwise we will crash out of memory before hitting factor 2. + const S32Megabytes PAD_BUFFER(32); + S32Megabytes budget_target = MIN_FREE_MAIN_MEMORY - PAD_BUFFER; + if (!sys_was_low) + { + // Result should range from 1 at 0 debt to 2 at -224 debt, 2.14 at -256MB + F32 new_factor = 1.f - (F32)sys_budget_debt / (F32)budget_target; + sSysMemoryFactor = llmax(sSysMemoryFactor, new_factor); + } + else { - // Backgrounded: decay toward bg_min to free VRAM for other apps, one - // mip per cooldown_step seconds (multiplicative). Don't relax back up - // until we're focused again. Pressure can still push below bg_min. - F32 bg_min = llclamp((F32)bg_min_ratio, 0.f, r_max); - if (sPixelToTexelRatio > bg_min) + // Slowly ramp up factor to free memory (increasing factor decreases draw range) + constexpr F32 MAX_INCREMENT = 0.05f; + F32 increment = MAX_INCREMENT * llmax(-(F32)sys_budget_debt / (F32)budget_target, 0.f); + sSysMemoryFactor += increment * gFrameIntervalSeconds; + } + sSysMemoryFactor = llclamp(sSysMemoryFactor, 1.f, 2.f); + } + else + { + const S32Megabytes MIN_FREE_MAIN_MEMORY(get_render_free_main_memory_treshold() / 2); + // Only start ramping down when we have breathing room. + // This should be under the value of isSystemMemoryLow to not throw texture + // bias into 1.5+ territory each time we fluctuate around isSystemMemoryLow's + // treshold. + const S32Megabytes MEM_THRESHOLD = MIN_FREE_MAIN_MEMORY + S32Megabytes(150); + if (free_sys_mem > MEM_THRESHOLD && sSysMemoryFactor > 1.f) + { + // Ramp down factor over time. + constexpr F32 DECREMENT = 0.02f; + sSysMemoryFactor -= DECREMENT * gFrameIntervalSeconds; + sSysMemoryFactor = llclamp(sSysMemoryFactor, 1.f, 2.f); + } + } + sys_was_low = is_sys_critically_low; + + // VRAM memory bias + if (is_low && !was_low) + { + if (is_sys_low) + { + // Not having system memory is more serious, so discard harder + sDesiredDiscardBias = llmax(sDesiredDiscardBias, 1.5f * getSystemMemoryBudgetFactor()); + } + else + { + // Slam to 1.5 bias the moment we hit low memory (discards off screen textures immediately) + sDesiredDiscardBias = llmax(sDesiredDiscardBias, 1.5f); + } + + if (is_sys_low || over_pct > 2.f) + { // if we're low on system memory, emergency purge off screen textures to avoid a death spiral + LL_WARNS() << "Low system memory detected, emergency downrezzing off screen textures" << LL_ENDL; + for (auto& image : gTextureList) { - const F32 step = llmax((F32)cooldown_step, 0.01f); - sPixelToTexelRatio = llmax(sPixelToTexelRatio * powf(0.25f, dt / step), bg_min); + gTextureList.updateImageDecodePriority(image, false /*will modify gTextureList otherwise!*/); } } - else if (vram_used > high) + } + + was_low = is_low; + + if (is_low) + { + // ramp up discard bias over time to free memory + if (sEvaluationTimer.getElapsedTimeF32() > MEMORY_CHECK_WAIT_TIME) + { + static LLCachedControl low_mem_min_discard_increment(gSavedSettings, "RenderLowMemMinDiscardIncrement", .1f); + + F32 increment = low_mem_min_discard_increment + llmax(over_pct, 0.f); + sDesiredDiscardBias += increment * gFrameIntervalSeconds; + } + } + else + { + // don't execute above until the slam to 1.5 has a chance to take effect + sEvaluationTimer.reset(); + + // Don't decay bias while downscale is still draining - those bytes + // are about to free and the loop would oscillate. + bool eviction_in_flight = !gTextureList.mDownScaleQueue.empty(); + + // lower discard bias over time when at least 10% of budget is free + constexpr F32 FREE_PERCENTAGE_TRESHOLD = -0.1f; + constexpr U32 FREE_SYS_MEM_THRESHOLD = 100; // 100MB more than isSystemMemoryLow to avoid fluctuations. + const S32Megabytes MIN_FREE_MAIN_MEMORY(get_render_free_main_memory_treshold() + S32Megabytes(FREE_SYS_MEM_THRESHOLD)); + if (sDesiredDiscardBias > 1.f + && over_pct < FREE_PERCENTAGE_TRESHOLD + && free_sys_mem > MIN_FREE_MAIN_MEMORY + && !eviction_in_flight) { - sPixelToTexelRatio -= llmax((F32)tighten_rate, 0.f) * dt; + static LLCachedControl high_mem_discard_decrement(gSavedSettings, "RenderHighMemMinDiscardDecrement", .1f); + + F32 decrement = high_mem_discard_decrement - llmin(over_pct - FREE_PERCENTAGE_TRESHOLD, 0.f); + sDesiredDiscardBias -= decrement * gFrameIntervalSeconds; } - else if (vram_used < low) + } + + // set to max discard bias if the window has been backgrounded for a while + static F32 last_desired_discard_bias = 1.f; + static F32 last_texture_update_count_bias = 1.f; + static bool was_backgrounded = false; + static LLFrameTimer backgrounded_timer; + static LLCachedControl minimized_discard_time(gSavedSettings, "TextureDiscardMinimizedTime", 1.f); + static LLCachedControl backgrounded_discard_time(gSavedSettings, "TextureDiscardBackgroundedTime", 60.f); + + bool in_background = (gViewerWindow && !gViewerWindow->getWindow()->getVisible()) || !gFocusMgr.getAppHasFocus(); + bool is_minimized = gViewerWindow && gViewerWindow->getWindow()->getMinimized() && in_background; + if (in_background) + { + F32 discard_time = is_minimized ? minimized_discard_time : backgrounded_discard_time; + if (discard_time > 0.f && backgrounded_timer.getElapsedTimeF32() > discard_time) { - sPixelToTexelRatio += llmax((F32)relax_rate, 0.f) * dt; + if (!was_backgrounded) + { + LL_INFOS() << "Viewer was " << (is_minimized ? "minimized" : "backgrounded") << " for " << discard_time + << "s, freeing up video memory." << LL_ENDL; + + last_desired_discard_bias = sDesiredDiscardBias; + was_backgrounded = true; + } + sDesiredDiscardBias = 5.f; + } + } + else + { + backgrounded_timer.reset(); + if (was_backgrounded) + { // if the viewer was backgrounded + LL_INFOS() << "Viewer is no longer backgrounded or minimized, resuming normal texture usage." << LL_ENDL; + was_backgrounded = false; + sDesiredDiscardBias = last_desired_discard_bias; } - // else: hold in the hysteresis band. - sPixelToTexelRatio = llclamp(sPixelToTexelRatio, 0.f, r_max); + } - // Keep the GC-suspend frame current while backgrounded. This suppresses - // the foreground GC now, and gives it a grace window after we come back so - // visible content can re-stamp its bind frames before anything is collected. + // Background-window ramp: 0 -> 1 at rate per second while backgrounded, + // snaps to 0 in foreground. Default 0.011 ~ 90s to saturate. + { + static LLCachedControl bg_factor_rate(gSavedSettings, "TextureBackgroundFactorRatePerSec", 0.011f); if (in_background) { - sGCSuspendedFrame = LLFrameTimer::getFrameCount(); + sBackgroundFactor += (F32)bg_factor_rate * gFrameIntervalSeconds; + sBackgroundFactor = llclampf(sBackgroundFactor); + } + else + { + sBackgroundFactor = 0.f; } } + + // Fetch-queue depth as a one-way bias floor (decay path still drops + // bias when the queue drains). Pushes bias up before VRAM overflows + // during teleport/scene-change floods. + if (LLTextureFetch* fetcher = LLAppViewer::getTextureFetch()) + { + S32 pending = fetcher->getNumRequests(); + static LLCachedControl fetch_pressure_scale(gSavedSettings, "TextureFetchPressureScale", 1000.f); + F32 scale = llmax((F32)fetch_pressure_scale, 1.f); + F32 fetch_pressure = llclamp((F32)pending / scale, 0.f, 3.f); + sDesiredDiscardBias = llmax(sDesiredDiscardBias, 1.f + fetch_pressure); + } + + sDesiredDiscardBias = llclamp(sDesiredDiscardBias, 1.f, 4.f); + if (last_texture_update_count_bias < sDesiredDiscardBias) + { + // bias increased, reset texture update counter to + // let updates happen at an increased rate. + last_texture_update_count_bias = sDesiredDiscardBias; + sBiasTexturesUpdated = 0; + } + else if (last_texture_update_count_bias > sDesiredDiscardBias + 0.1f) + { + // bias decreased, 0.1f is there to filter out small fluctuations + // and not reset sBiasTexturesUpdated too often. + // Bias jumps to 1.5 at low memory, so getting stuck at 1.1 is not + // a problem. + last_texture_update_count_bias = sDesiredDiscardBias; + } +} + +//static +U32Megabytes LLViewerTexture::getFreeSystemMemory() +{ + static LLFrameTimer timer; + static U32Megabytes physical_res = U32Megabytes(U32_MAX); + + if (timer.getElapsedTimeF32() < MEMORY_CHECK_WAIT_TIME) //call this once per second. + { + return physical_res; + } + + timer.reset(); + + LLMemory::updateMemoryInfo(); + physical_res = LLMemory::getAvailableMemKB(); + return physical_res; +} + +//static +bool LLViewerTexture::isSystemMemoryLow() +{ + return getFreeSystemMemory() < get_render_free_main_memory_treshold(); +} + +//static +bool LLViewerTexture::isSystemMemoryCritical() +{ + return getFreeSystemMemory() < get_render_free_main_memory_treshold() / 2; +} + +// static +F32 LLViewerTexture::getSystemMemoryBudgetFactor() +{ + return sSysMemoryFactor; } //end of static functions @@ -2028,30 +2362,6 @@ bool LLViewerFetchedTexture::updateFetch() LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - current < min"); make_request = false; } - else - { - // Only fetch streamed world textures the renderer is actually drawing - // (mLastBindFrame is stamped per drawn frame). Out-of-view content gets - // no residency. Exempt: boosted/UI, avatar bakes, textures with loaded - // callbacks, and bake uploads. - static LLCachedControl vis_frames(gSavedSettings, "TextureFetchVisibilityFrames", 5); - const bool visibility_gated = mBoostLevel < LLGLTexture::BOOST_HIGH - && mUseMipMaps - && !mDontDiscard - && !isAgentAvatarBoost(mBoostLevel) - && !mForceToSaveRawImage - && mLoadedCallbackList.empty(); - if (visibility_gated && mGLTexturep.notNull()) - { - const U32 last = mGLTexturep->mLastBindFrame; - const U32 now = LLFrameTimer::getFrameCount(); - if (last == 0 || now - last > llmax((U32)vis_frames, 1u)) - { - LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - not visible"); - make_request = false; - } - } - } if (make_request) { @@ -2107,7 +2417,6 @@ bool LLViewerFetchedTexture::updateFetch() // in some cases createRequest can modify discard, as an example // bake textures are always at discard 0 mRequestedDiscardLevel = llmin(desired_discard, fetch_request_response); - mFetchState = LLAppViewer::getTextureFetch()->getFetchState(mID, mDownloadProgress, mRequestedDownloadPriority, mFetchPriority, mFetchDeltaTime, mRequestDeltaTime, mCanUseHTTP); } @@ -2949,151 +3258,6 @@ S8 LLViewerLODTexture::getType() const return LLViewerTexture::LOD_TEXTURE; } -// Desired discard from the pixel:texel ratio - this is the entire streaming -// policy. For each channel bucket the texture is used in, the most-demanding -// (largest screen coverage) face sets that bucket's requirement at -// floor(log4(texels / (R_global * channelRatio[b] * coverage))); the sharpest -// requirement across buckets wins, since one GL image serves every channel it -// is used in. floor (not ceil) keeps content native up close - "1:1" is a -// target, not a hard cap that downrezzes anything slightly oversampled. A -// per-mip hysteresis dead-band against the current discard level prevents -// fetch/scaleDown thrash as an object slowly crosses a mip boundary. -S32 LLViewerLODTexture::computeDesiredDiscard(S32 dim_max_i, bool avatar_bake) const -{ - static const F64 log_4 = log(4.0); - - // UI-pinned (icons / thumbnails): size against the known draw size, with no - // ratio or pressure - these want exact native-for-their-slot resolution. - if (mKnownDrawWidth && mKnownDrawHeight) - { - S32 draw_texels = llclamp(mKnownDrawWidth * mKnownDrawHeight, MIN_IMAGE_AREA, MAX_IMAGE_AREA); - S32 d = (draw_texels >= (S32)mTexelsPerImage) - ? 0 - : (S32)floor(log((F64)mTexelsPerImage / (F64)draw_texels) / log_4); - return llclamp(d, 0, dim_max_i); - } - - // Avatar bakes ignore the global pressure ramp (a blurred bake reads as a - // cloud avatar); they always size against the configured max ratio. - static LLCachedControl ratio_max(gSavedSettings, "TexturePixelToTexelRatio", 1.0f); - const F32 r_global = avatar_bake ? llmax((F32)ratio_max, 0.01f) : sPixelToTexelRatio; - - static LLCachedControl ch_normal (gSavedSettings, "TextureChannelRatioNormal", 1.0f); - static LLCachedControl ch_basecolor(gSavedSettings, "TextureChannelRatioBaseColor", 1.0f); - static LLCachedControl ch_specular (gSavedSettings, "TextureChannelRatioSpecular", 0.5f); - static LLCachedControl ch_emissive (gSavedSettings, "TextureChannelRatioEmissive", 0.5f); - const F32 channel_ratio[4] = { (F32)ch_normal, (F32)ch_basecolor, (F32)ch_specular, (F32)ch_emissive }; - - // Downrez bias: 0 sizes each bucket to its most demanding use (the lowest - // texels-per-pixel variant - the quality bound); 1 sizes to its least - // demanding use (the most oversampled variant - frees the most memory). - // Values between lerp across the texture's measured coverage spread. - static LLCachedControl downrez_bias(gSavedSettings, "TextureDownrezCoverageBias", 0.25f); - const F32 cov_bias = llclampf((F32)downrez_bias); - - // Continuous ideal discard = sharpest (smallest) requirement across the - // channels this texture is actually used in. - F32 ideal = (F32)dim_max_i; // default: coarsest, until a measurement arrives - bool measured = false; - for (S32 b = 0; b < 4; ++b) - { - F32 coverage = mChannelCoverage[b]; - if (coverage <= 0.f) - { - continue; - } - if (cov_bias > 0.f && mChannelCoverageMin[b] > 0.f && mChannelCoverageMin[b] < coverage) - { - // Geometric (log-space) lerp between the coverage bounds. The - // consumer below is log4(coverage), and min/max are routinely - // orders of magnitude apart - a linear pixel-area lerp barely - // moves the resulting discard until bias approaches 1, then - // plunges (reads as binary). Interpolating the RATIO instead - // moves the discard linearly with bias: 0.5 = halfway between - // the two ends in mip levels. - coverage *= powf(mChannelCoverageMin[b] / coverage, cov_bias); - } - measured = true; - F32 allowed_texels = coverage * r_global * llmax(channel_ratio[b], 0.01f); - F32 d; - if (allowed_texels <= 0.f) // ratio driven to 0 -> deepest mip - d = (F32)dim_max_i; - else if (allowed_texels >= (F32)mTexelsPerImage) - d = 0.f; - else - d = (F32)(log((F64)mTexelsPerImage / (F64)allowed_texels) / log_4); - ideal = llmin(ideal, d); - } - if (!measured) - { - return dim_max_i; // off-screen / never measured -> coarsest mip - } - - // Round toward sharper (floor): a texture stays at a mip level until its - // ideal is a full level past the boundary. This is what makes "1:1" mean - // "native up close" - ceil would downrez anything even slightly oversampled - // (a 2048 map can't hit its own resolution on a 1080p screen), which reads - // as everything being blurry. Pressure still evicts by lowering R_global. - ideal = llmax(ideal, 0.f); - const S32 target = (S32)floor(ideal); - - // Hysteresis: a texture at discard C is "happy" while floor(ideal) == C, - // i.e. ideal in [C, C+1). Only leave that band once ideal is past it by the - // margin, so coverage jitter at a boundary doesn't ping-pong fetch<->scaleDown. - static LLCachedControl uprez_margin(gSavedSettings, "TextureUpRezMargin", 0.2f); - const F32 margin = llclamp((F32)uprez_margin, 0.f, 0.9f); - const S32 current = getDiscardLevel(); - S32 desired; - if (current < 0) - { - desired = target; // nothing loaded yet - } - else if (ideal >= (F32)current + 1.f + margin) - { - desired = target; // clearly coarser -> evict - } - else if (ideal <= (F32)current - margin) - { - desired = target; // clearly finer -> uprez - } - else - { - desired = current; // inside the dead-band -> hold - } - - // Foreground visibility GC (avatar bakes exempt). Background degradation is - // handled by the ratio decay in updateClass, and the GC self-suppresses while - // backgrounded via the sGCSuspendedFrame check below, so the two don't fight. - // - // For every gc_cooldown frames a texture goes without a camera bind, drop its - // mip by gc_step, walking gradually toward the deepest mip instead of slamming. - // Content drawn within the last cooldown stays full-res, so a fast camera pan - // finds it only a step or two coarse on the way back. Resets when drawn again. - if (!avatar_bake) - { - if (LLImageGL* gli = getGLTexture()) - { - static LLCachedControl gc_cooldown_frames(gSavedSettings, "TextureGCStepFrames", 5); - static LLCachedControl gc_step_mips(gSavedSettings, "TextureGCStepMips", 1); - constexpr U32 GC_RESUME_GRACE_FRAMES = 10; - const U32 now = LLFrameTimer::getFrameCount(); - if (gli->mLastBindFrame > 0 // drawn at least once - && now - sGCSuspendedFrame > GC_RESUME_GRACE_FRAMES) // not just back from background - { - const U32 cooldown = llmax((U32)gc_cooldown_frames, 1u); - const S32 periods = (S32)((now - gli->mLastBindFrame) / cooldown); - if (periods > 0) - { - const S32 step_mips = (S32)llmax((U32)gc_step_mips, 1u); - desired = llclamp(desired + periods * step_mips, desired, dim_max_i); - } - } - } - } - - return llclamp(desired, 0, dim_max_i); -} - // This is gauranteed to get called periodically for every texture //virtual void LLViewerLODTexture::processTextureStats() @@ -3101,13 +3265,7 @@ void LLViewerLODTexture::processTextureStats() LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE; updateVirtualSize(); - // Hoisted once: avatar bake textures are exempt from several pressure - // mechanisms below (anti-cloud-bug protection). Reads of `avatar_bake` - // replace inline isAgentAvatarBoost(mBoostLevel) calls; each site keeps - // its own intent comment explaining *why* the exemption applies. See - // also LLViewerFetchedTexture::isAgentAvatarBoost() in the header for - // the canonical list of exemption sites. - const bool avatar_bake = isAgentAvatarBoost(mBoostLevel); + bool did_downscale = false; static LLCachedControl textures_fullres(gSavedSettings,"TextureLoadFullRes", false); @@ -3126,7 +3284,7 @@ void LLViewerLODTexture::processTextureStats() mDesiredDiscardLevel = 0; } // HUD/UI/preview and mDontDiscard textures bypass streaming - no - // coverage signal applies, they need native resolution. + // face_distance signal applies, they need native resolution. else if (mBoostLevel >= LLGLTexture::BOOST_HIGH || mDontDiscard || !mUseMipMaps) @@ -3142,37 +3300,165 @@ void LLViewerLODTexture::processTextureStats() } else { - // Per-texture max discard (smallest meaningful mip): floor(log2(max(w,h))). + F32 discard_level = 0.f; + + // floor(log2(max(w, h))) - both the multiplier on the normalized + // factor and the cap clamp at the bottom of this function. S32 dim_max_for_image_i = (mFullWidth > 0 && mFullHeight > 0) ? LLImageGL::dimDerivedMaxDiscard(mFullWidth, mFullHeight) : (S32)mCodecMaxDiscardLevel; + F32 dim_max_for_image = (F32)dim_max_for_image_i; + + if (mKnownDrawWidth && mKnownDrawHeight) + { + // UI-pinned target dimensions - use pixel-area math. + static const F64 log_4 = log(4.0); + S32 draw_texels = mKnownDrawWidth * mKnownDrawHeight; + draw_texels = llclamp(draw_texels, MIN_IMAGE_AREA, MAX_IMAGE_AREA); + discard_level = (F32)(log(mTexelsPerImage / draw_texels) / log_4); + } + else + { + // Two 0..1 signals composed multiplicatively: + // discard = distance_factor * size_factor * max_discard + // distance_factor: face_dist / draw_dist, shaped by + // TextureDistanceDiscardPower (default 0.5 = sqrt). + // size_factor: 1 - (mMaxOnScreenSize / window_pixels), shaped + // by TextureSizeDiscardPower. + // Either factor near 0 keeps the result fine - both have to + // be high for the texture to go deep. + static LLCachedControl distance_power(gSavedSettings, "TextureDistanceDiscardPower", 0.5f); + F32 power = llmax((F32)distance_power, 0.0001f); + F32 distance_factor = (power == 1.f) ? mMinDistanceFactor : powf(mMinDistanceFactor, power); + + static LLCachedControl size_power(gSavedSettings, "TextureSizeDiscardPower", 1.f); + F32 sz_power = llmax((F32)size_power, 0.0001f); + F32 coverage = llclampf(mMaxOnScreenSize / sWindowPixelArea); + F32 inv_cov = 1.f - coverage; + F32 size_factor = (sz_power == 1.f) ? inv_cov : powf(inv_cov, sz_power); + + F32 combined = distance_factor * size_factor; + + // VRAM pressure: multiply the combined signal and clamp to 0..1. + // Compresses the effective draw range and picks up close-coverage + // textures (small combined) too. Applied before the channel + // exponent so subsequent transforms see a normalized 0..1 value. + // Avatar bakes exempt. + if (!isAgentAvatarBoost(mBoostLevel) && sMemoryPressureMultiplier > 1.f) + { + combined = llmin(combined * sMemoryPressureMultiplier, 1.f); + } + + // Per-channel exponent. 1.0 = baseline; <1.0 pushes combined + // toward 1 (max attenuation) faster. Edges are preserved: + // pow(0, p) = 0, pow(1, p) = 1. + // mPriorityChannel order: 0=Normal, 1=BaseColor, 2=Specular, 3=Emissive. + S32 priority_channel = (mPriorityChannel >= 0 && mPriorityChannel < 4) ? (S32)mPriorityChannel : 1; + static LLCachedControl channel_normal (gSavedSettings, "TextureChannelNormal", 1.0f); + static LLCachedControl channel_basecolor(gSavedSettings, "TextureChannelBaseColor", 0.75f); + static LLCachedControl channel_specular (gSavedSettings, "TextureChannelSpecular", 0.5f); + static LLCachedControl channel_emissive (gSavedSettings, "TextureChannelEmissive", 0.75f); + const F32 channels[4] = { + (F32)channel_normal, + (F32)channel_basecolor, + (F32)channel_specular, + (F32)channel_emissive, + }; + F32 channel_power = llmax(channels[priority_channel], 0.0001f); + if (channel_power != 1.f) + { + combined = powf(combined, channel_power); + } + + // Own-avatar boost: shave combined for rigged/animated faces + // on gAgentAvatarp. Preference, not exemption - applied + // before the staleness/background/pressure floors so heavy + // pressure can still evict. + if (mOnAgentAvatar) + { + static LLCachedControl agent_avatar_boost(gSavedSettings, "TextureAgentAvatarBoost", 0.5f); + combined *= llclampf((F32)agent_avatar_boost); + } + + // Staleness / background floors. Avatar bakes exempt from + // background to avoid the universal-cloud bug when re-foregrounding. + combined = llmax(combined, mStalenessFactor); + if (!isAgentAvatarBoost(mBoostLevel)) + { + // Background floor capped at (dim_max - offset) so we can + // keep some baseline quality while backgrounded. + static LLCachedControl bg_offset(gSavedSettings, "TextureBackgroundDiscardOffset", 2); + F32 bg = sBackgroundFactor; + if ((S32)bg_offset > 0 && dim_max_for_image > 0.f) + { + F32 cap = llmax(dim_max_for_image - (F32)(S32)bg_offset, 0.f) / dim_max_for_image; + bg = llmin(bg, cap); + } + combined = llmax(combined, bg); + } + + discard_level = combined * dim_max_for_image; + } - // The whole policy: pixel:texel ratio at the most-demanding face. - S32 discard = computeDesiredDiscard(dim_max_for_image_i, avatar_bake); + discard_level = floorf(discard_level); - // Per-texture caps: force >=1 for sources over the resolution cap; - // bound by the debug override or the dim-derived max. - S32 min_discard = 0; + F32 min_discard = 0.f; if (mFullWidth > max_tex_res || mFullHeight > max_tex_res) - min_discard = 1; + min_discard = 1.f; + // dim_max_for_image_i is the per-texture cap. TextureMaxDiscardOverride + // raises it (debug). Codec_max applies only to fetches, not here. static LLCachedControl max_discard_override(gSavedSettings, "TextureMaxDiscardOverride", 0); - const S32 effective_cap = (max_discard_override > 0) ? (S32)max_discard_override : dim_max_for_image_i; - discard = llclamp(discard, min_discard, effective_cap); + S32 effective_cap = (max_discard_override > 0) ? (S32)max_discard_override : dim_max_for_image_i; + discard_level = llclamp(discard_level, min_discard, (F32)effective_cap); + + mDesiredDiscardLevel = llmin(effective_cap, (S32)discard_level); + + // Apply the setMinDiscardLevel cap, relaxed under VRAM pressure + // (cap_relax = 1 - 1/mult: 0 at mult=1, ~0.5 at mult=2, ~0.9 at + // mult=10). Caps of 0 (thumbnails) and avatar bakes are preserved. + S32 effective_min_cap = mMinDesiredDiscardLevel; + if (sMemoryPressureMultiplier > 1.f && + mMinDesiredDiscardLevel > 0 && mMinDesiredDiscardLevel < S8_MAX && + !isAgentAvatarBoost(mBoostLevel)) + { + F32 cap_relax = 1.f - 1.f / sMemoryPressureMultiplier; + F32 room = (F32)dim_max_for_image_i - (F32)mMinDesiredDiscardLevel; + effective_min_cap += (S32)(cap_relax * room); + effective_min_cap = llmin(effective_min_cap, dim_max_for_image_i); + } + mDesiredDiscardLevel = llmin((S8)effective_min_cap, mDesiredDiscardLevel); - // Caller-set min-discard ceiling (terrain / avatar-self / thumbnails): - // never coarser than the caller explicitly asked for. - discard = llmin(discard, (S32)mMinDesiredDiscardLevel); + // Halve the floor for bubble-resident textures (mMinDistanceFactor == 0 + // = at least one face inside the bubble) so the close-vs-far gradient + // is preserved at every pressure level. + if (!isAgentAvatarBoost(mBoostLevel)) + { + S32 forced = (S32)floorf(sLastDitchMinDiscard); + if (mMinDistanceFactor <= 0.f) forced /= 2; + forced = llclamp(forced, 0, dim_max_for_image_i); + if (forced > mDesiredDiscardLevel) + { + mDesiredDiscardLevel = (S8)forced; + } + } - mDesiredDiscardLevel = (S8)discard; - // If the GPU already holds finer data than we now want, evict it. - // Avatar bakes exempt: shrinking mid-bake can leave the avatar stuck - // as a cloud until the next bake completes. + // + // At this point we've calculated the quality level that we want, + // if possible. Now we check to see if we have it, and take the + // proper action if we don't. + // + S32 current_discard = getDiscardLevel(); - if (!avatar_bake && current_discard >= 0 && current_discard < mDesiredDiscardLevel && !mForceToSaveRawImage) + // Avatar bakes exempt: shrinking mid-bake can leave the avatar + // stuck as a cloud until the next bake completes. + if (!isAgentAvatarBoost(mBoostLevel)) { - scaleDown(); + if (current_discard < mDesiredDiscardLevel && !mForceToSaveRawImage) + { // should scale down + scaleDown(); + } } mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S32)mLoadedCallbackDesiredDiscardLevel); @@ -3200,7 +3486,12 @@ bool LLViewerLODTexture::scaleDown() return false; } - // Structural blocks only; per-texture policy lives in processTextureStats. + // Hard structural blocks only. Per-texture policy (icons pinned to full + // res, etc.) lives in processTextureStats; if that policy is later + // relaxed (e.g. honor mKnownDrawWidth for icons rendered at 8x8 in a + // friend list) the scaleDown path stays open. + // BOOST_HIGH is the emergency-out for GLTF's "force full res" hack; + // the other two flags are structural. if (!mUseMipMaps || mDontDiscard || mBoostLevel >= LLGLTexture::BOOST_HIGH) { return false; diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h index cc9fbe5e48..8c5c48bafd 100644 --- a/indra/newview/llviewertexture.h +++ b/indra/newview/llviewertexture.h @@ -114,6 +114,11 @@ protected: public: static void initClass(); static void updateClass(); + static bool isSystemMemoryLow(); + static bool isSystemMemoryCritical(); + + // Ranges from 1 (no RAM deficit) to 2 (RAM deficit) + static F32 getSystemMemoryBudgetFactor(); LLViewerTexture(bool usemipmaps = true); LLViewerTexture(const LLUUID& id, bool usemipmaps) ; @@ -145,11 +150,6 @@ public: virtual F32 getMaxVirtualSize() ; - // Read-only debug access to the per-bucket coverage bounds (see - // mChannelCoverage) - used by the RENDER_DEBUG_TEXTURE_PRIORITY overlay. - F32 getChannelCoverage(S32 bucket) const { return (bucket >= 0 && bucket < 4) ? mChannelCoverage[bucket] : 0.f; } - F32 getChannelCoverageMin(S32 bucket) const { return (bucket >= 0 && bucket < 4) ? mChannelCoverageMin[bucket] : 0.f; } - LLFrameTimer* getLastReferencedTimer() { return &mLastReferencedTimer; } S32 getFullWidth() const { return mFullWidth; } @@ -193,6 +193,8 @@ private: friend class LLBumpImageList; friend class LLUIImageList; + static U32Megabytes getFreeSystemMemory(); + protected: friend class LLViewerTextureList; LLUUID mID; @@ -203,17 +205,24 @@ protected: mutable S32 mMaxVirtualSizeResetInterval; LLFrameTimer mLastReferencedTimer; - // Screen-space pixel coverage bounds among the texture's faces, per - // priority bucket (0=Normal, 1=BaseColor, 2=Specular, 3=Emissive). 0 = the - // texture is not used in that channel (or hasn't been measured yet). - // Populated by LLViewerTextureList::updateImageDecodePriority; consumed by - // LLViewerLODTexture::computeDesiredDiscard. This is the only view-dependent - // streaming signal - distance, size, tiling, and channel role all collapse - // into it. Max = the most demanding use (lowest texels-per-pixel variant, - // the quality bound); Min = the least demanding positive use (highest - // texels-per-pixel, most oversampled - the downrez-bias end). - F32 mChannelCoverage[4] = { 0.f, 0.f, 0.f, 0.f }; - F32 mChannelCoverageMin[4] = { 0.f, 0.f, 0.f, 0.f }; + // 0=Normal, 1=BaseColor, 2=Specular, 3=Emissive. -1 -> base color. + S8 mPriorityChannel = -1; + + // Bind-staleness floor, 0..1. Per-interval increment is 1/max_discard + // so any texture saturates after interval x max_discard seconds idle. + F32 mStalenessFactor = 0.f; + + // Closest face's face_distance / draw_distance, clamped 0..1. + // Defaults to 1 so never-measured textures resolve to deepest discard. + F32 mMinDistanceFactor = 1.f; + + // Largest per-face screen-space coverage in pixels. Raw - no bias or + // channel-priority contamination. + F32 mMaxOnScreenSize = 0.f; + + // Any face on the agent's avatar (rigged / animated). Drives the + // own-avatar quality boost in processTextureStats. + bool mOnAgentAvatar = false; ll_face_list_t mFaceList[LLRender::NUM_TEXTURE_CHANNELS]; //reverse pointer pointing to the faces using this image as texture U32 mNumFaces[LLRender::NUM_TEXTURE_CHANNELS]; @@ -235,17 +244,24 @@ public: static S32 sRawCount; static S32 sAuxCount; static LLFrameTimer sEvaluationTimer; - - // The global max pixel:texel ratio (texels per screen pixel, the "R" in 1:R). - // The watermark controller in updateClass walks it between TexturePixelToTexelRatio - // and 0 as VRAM pressure changes; lower means coarser desired discards. - static F32 sPixelToTexelRatio; - - // Frame index the GC was last suspended (kept current while backgrounded). - // The foreground GC only runs once getFrameCount() is a grace window past - // this, so content can re-stamp after an alt-tab before anything is collected. - static U32 sGCSuspendedFrame; - + static F32 sDesiredDiscardBias; + // Backgrounded-window discard floor, 0..1. Ramps while backgrounded, + // snaps to 0 in foreground. Avatar bakes exempt. + static F32 sBackgroundFactor; + + // VRAM-pressure distance multiplier, >= 1. Compresses the distance + // signal: dist_factor = clamp(mMinDistanceFactor * mult, 0, 1). + // Grows geometrically while over budget; decays back to 1 when fitting. + static F32 sMemoryPressureMultiplier; + // Last-ditch global discard floor. Mirrors sDesiredDiscardBias once the + // multiplier is exhausted. + static F32 sLastDitchMinDiscard; + + // 0..1 progress of the pressure multiplier from baseline (1) to its + // configured cap (TextureMemoryPressureMaxMultiplier). Used to gate + // bubble shrink and last-ditch engagement. + static F32 getMemoryPressureProgress(); + static U32 sBiasTexturesUpdated; static S32 sMaxSculptRez ; static U32 sMinLargeImageSize ; static U32 sMaxSmallImageSize ; @@ -254,6 +270,7 @@ public: // estimated free memory for textures, by bias calculation static F32 sFreeVRAMMegabytes; + static F32 sSysMemoryFactor; // Viewport pixel area, refreshed once per frame. Hoisted to keep the // per-texture hot path out of gViewerWindow. static F32 sWindowPixelArea; @@ -313,6 +330,27 @@ public: || boost_level == BOOST_AVATAR_BAKED_SELF; } +public: + + struct Compare + { + // lhs < rhs + bool operator()(const LLPointer &lhs, const LLPointer &rhs) const + { + const LLViewerFetchedTexture* lhsp = (const LLViewerFetchedTexture*)lhs; + const LLViewerFetchedTexture* rhsp = (const LLViewerFetchedTexture*)rhs; + + // greater priority is "less" + const F32 lpriority = lhsp->mMaxVirtualSize; + const F32 rpriority = rhsp->mMaxVirtualSize; + if (lpriority > rpriority) // higher priority + return true; + if (lpriority < rpriority) + return false; + return lhsp < rhsp; + } + }; + public: /*virtual*/ S8 getType() const override; FTType getFTType() const; @@ -564,16 +602,6 @@ public: private: void init(bool firstinit) ; - - // The whole streaming pipeline: desired discard from the pixel:texel ratio. - // For each channel bucket the texture is used in, the most-demanding - // (largest coverage) face sets that bucket's requirement at - // floor(log4(texels / (R_global * channelRatio[b] * coverage))); the sharpest - // requirement across buckets wins (one GL image serves all its channels). - // A per-mip hysteresis dead-band against the current discard level prevents - // fetch/scaleDown thrash. avatar_bake textures use the configured max ratio - // instead of the pressure-driven sPixelToTexelRatio (anti cloud-bug). - S32 computeDesiredDiscard(S32 dim_max_i, bool avatar_bake) const; }; // diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp index 3e1481f8b4..4d09eff74e 100644 --- a/indra/newview/llviewertexturelist.cpp +++ b/indra/newview/llviewertexturelist.cpp @@ -64,9 +64,6 @@ #include "llviewerwindow.h" #include "llsurface.h" #include "llvoavatarself.h" -#include "lldrawable.h" -#include "llvovolume.h" -#include "llviewertextureanim.h" #include "llprogressview.h" //////////////////////////////////////////////////////////////////////////// @@ -74,6 +71,7 @@ void (*LLViewerTextureList::sUUIDCallback)(void **, const LLUUID&) = NULL; S32 LLViewerTextureList::sNumImages = 0; +F32 LLViewerTextureList::sCurrentBubbleMeters = 0.f; LLViewerTextureList gTextureList; @@ -919,86 +917,100 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag { llassert(!gCubeSnapshot); - // Refresh spotlight priorities first: light projector textures register as - // LIGHT_TEX volumes (no faces), and both their fetch priority - // (addTextureStats inside updateSpotLightPriority) and their coverage - // (folded into the block below) derive from mSpotLightPriority. - for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) - { - LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; - volume->updateSpotLightPriority(); - } + constexpr F32 BIAS_TRS_ON_SCREEN = 1.f; // perf gate for face-loop early exit if (imagep->getBoostLevel() < LLViewerFetchedTexture::BOOST_HIGH) // don't bother checking face list for boosted textures { - // Bounds on the per-face UV repeat-area divisor (mined from the old - // getTextureVirtualSize texel_area clamp [1/64, 128]): atlas/crop boost - // capped at 64x (3 mips finer), tiling penalty at 128x (3.5 mips - // coarser) so pathological UV scales can't explode either direction. - constexpr F32 MIN_REPEAT_AREA = 1.f / 64.f; - constexpr F32 MAX_REPEAT_AREA = 128.f; - - // Per priority bucket (0=Normal, 1=BaseColor, 2=Specular, 3=Emissive): - // the HIGHEST per-face effective coverage (= the lowest texels-per-pixel - // use, the most demanding variant - drives desired discard) and the - // LOWEST positive coverage (= the highest texels-per-pixel use, the most - // oversampled variant - available for downrez-bias policy). The overall - // max is the fetch priority (raw - no bias). A bucket with faces but - // zero coverage (all off-screen) publishes 0, which - // computeDesiredDiscard reads as "coarsest mip". - F32 channel_coverage[4] = { 0.f, 0.f, 0.f, 0.f }; - F32 channel_coverage_min[4] = { FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX }; - bool bucket_used[4] = { false, false, false, false }; - F32 max_coverage = 0.f; - + static LLCachedControl texture_scale_min(gSavedSettings, "TextureScaleMinAreaFactor", 0.0095f); + static LLCachedControl texture_scale_max(gSavedSettings, "TextureScaleMaxAreaFactor", 25.f); + + F32 max_vsize = 0.f; + bool on_screen = false; + + // Accumulators for the per-texture signals published below. + // Defaults map to "deepest discard wanted" until evidence updates them. + F32 min_distance_factor = 1.f; + F32 max_on_screen_size = 0.f; + bool on_agent_avatar = false; + F32 draw_distance = llmax(gAgentCamera.mDrawDistance, 0.001f); + + // Close-camera bubble: faces inside `bubble` meters resolve to + // dist_factor = 0, so the distance ramp spans (bubble, draw_distance]. + static LLCachedControl close_bubble(gSavedSettings, "TextureCloseBubbleMeters", 5.f); + static LLCachedControl close_bubble_min(gSavedSettings, "TextureCloseBubbleMinMeters", 0.1f); + static LLCachedControl bubble_shrink_threshold(gSavedSettings, "TextureCloseBubbleShrinkThreshold", 0.8f); + static LLCachedControl bubble_track_rate(gSavedSettings, "TextureCloseBubbleTrackRate", 0.5f); + F32 bubble_full = llmax((F32)close_bubble, 0.f); + F32 bubble_min = llclamp((F32)close_bubble_min, 0.f, bubble_full); + // Advance the slow-track once per frame, not per texture: this + // function runs once per texture so a naive per-call lerp converges + // in a single frame. + static F32 s_tracked_bubble = -1.f; + static U32 s_tracked_bubble_frame = 0; + if (s_tracked_bubble < 0.f) s_tracked_bubble = bubble_full; + if (s_tracked_bubble_frame != LLFrameTimer::getFrameCount()) + { + s_tracked_bubble_frame = LLFrameTimer::getFrameCount(); + F32 progress = LLViewerTexture::getMemoryPressureProgress(); + F32 shrink_thresh = llclampf((F32)bubble_shrink_threshold); + F32 shrink_frac = (progress > shrink_thresh) + ? (progress - shrink_thresh) / llmax(1.f - shrink_thresh, 0.0001f) + : 0.f; + F32 target_bubble = bubble_full - (bubble_full - bubble_min) * shrink_frac; + F32 dt = (F32)gFrameIntervalSeconds; + F32 alpha = 1.f - expf(-llmax(dt, 0.f) * llmax((F32)bubble_track_rate, 0.f)); + s_tracked_bubble += (target_bubble - s_tracked_bubble) * alpha; + s_tracked_bubble = llclamp(s_tracked_bubble, bubble_min, bubble_full); + sCurrentBubbleMeters = s_tracked_bubble; + } + F32 bubble = llclamp(s_tracked_bubble, 0.f, draw_distance - 0.001f); + F32 ramp_range = llmax(draw_distance - bubble, 0.001f); U32 face_count = 0; - const U32 max_faces_to_check = 1024; + U32 max_faces_to_check = 1024; - // Cheap first pass: which buckets is this texture used in, and how many - // faces total. No per-face geometry work. + // Pick the least-aggressive channel across all uses, so a texture + // used as both diffuse and normal isn't penalized by its harshest + // role. -1 sentinel keeps emissive-only textures (W=3) from being + // clobbered by a smaller init value. + S32 priority_channel = -1; for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i) { - U32 n = imagep->getNumFaces(i); - face_count += n; - if (n > 0) + if (imagep->getNumFaces(i) > 0) { - S32 b = sChannelToPriority[i]; - if (b >= 0 && b < 4) bucket_used[b] = true; + S32 mapped = sChannelToPriority[i]; + priority_channel = (priority_channel < 0) ? mapped : llmin(priority_channel, mapped); } } - - if (face_count > max_faces_to_check) + if (priority_channel < 0) { - // Used in so many places that scanning the face list isn't worth it - // (and isn't time-sliced) - treat as full-screen so it loads sharp. - for (S32 b = 0; b < 4; ++b) - { - if (bucket_used[b]) - { - channel_coverage[b] = (F32)MAX_IMAGE_AREA; - channel_coverage_min[b] = (F32)MAX_IMAGE_AREA; - } - } - max_coverage = (F32)MAX_IMAGE_AREA; + priority_channel = 1; // no faces - default to diffuse } - else + imagep->mPriorityChannel = (S8)priority_channel; + + // get adjusted bias based on image resolution + LLImageGL* img = imagep->getGLTexture(); + F32 max_discard = F32(img ? img->getMaxDiscardLevel() : MAX_DISCARD_LEVEL); + F32 bias = llclamp(max_discard - 2.f, 1.f, LLViewerTexture::sDesiredDiscardBias); + + // convert bias into a vsize scaler + bias = (F32) llroundf(powf(4, bias - 1.f)); + + LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE; + for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i) { - LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE; - for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i) + face_count += imagep->getNumFaces(i); + S32 faces_to_check = (face_count > max_faces_to_check) ? 0 : imagep->getNumFaces(i); + + for (S32 fi = 0; fi < faces_to_check; ++fi) { - const S32 bucket = sChannelToPriority[i]; - const U32 num_faces = imagep->getNumFaces(i); - for (U32 fi = 0; fi < num_faces; ++fi) - { - LLFace* face = (*(imagep->getFaceList(i)))[fi]; - if (!face || !face->getViewerObject()) - { - continue; - } + LLFace* face = (*(imagep->getFaceList(i)))[fi]; + if (face && face->getViewerObject()) + { F32 radius; F32 cos_angle_to_view_dir; + if ((gFrameCount - face->mLastTextureUpdate) > 10) { // only call calcPixelArea at most once every 10 frames for a given face // this helps eliminate redundant calls to calcPixelArea for faces that have multiple textures @@ -1007,251 +1019,171 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag face->mLastTextureUpdate = gFrameCount; } - // Most-demanding-point measurement: the spec is that the - // LOWEST pixel:texel ratio governs, so pixel density is - // evaluated at the face's NEAREST point and applied to the - // face's true world area. The previous whole-face average - // (bounding-disc pixel area) under-resolved perspective - // surfaces: on a floor, the tile at your feet covers far - // more screen than the average tile, and the GPU samples - // fine mips right there - tiled (PBR-heavy) content went - // soft while untiled content looked fine. - const LLVector4a* ext = face->isState(LLFace::RIGGED) ? face->mRiggedExtents : face->mExtents; - LLVector4a diag; - diag.setSub(ext[1], ext[0]); - // World area of the face ~ product of the two largest AABB - // dims (max pairwise product; robust for flat faces). - F32 dx = diag[0], dy = diag[1], dz = diag[2]; - F32 area_world = llmax(dx * dy, llmax(dx * dz, dy * dz)); - // Pixels per meter at the nearest point. Distance floored: - // nearer than this the screen clamp below governs anyway. - F32 dist = llmax(face->mDistanceToCamera, 0.5f); - F32 ppm = LLDrawable::sCurPixelAngle / dist; - F32 face_px = area_world * ppm * ppm; - if (face_px <= 0.f) + F32 vsize = face->getPixelArea(); + + on_screen |= face->mInFrustum; + + F32 dist_above_bubble = llmax(face->mDistanceToCamera - bubble, 0.f); + F32 dist_factor = llclampf(dist_above_bubble / ramp_range); + min_distance_factor = llmin(min_distance_factor, dist_factor); + + if (face->mAvatar && face->mAvatar == gAgentAvatarp) { - // Degenerate extents: the face hasn't been through a - // geometry build yet (or a rigged face has no rigged - // extents) - it isn't renderable, so it must not be - // measured. Skipping matters especially for the - // per-bucket MIN bound: any invented placeholder - // value (the old fallback hit LLFace::init's 16px - // default) becomes the texture's least-demanding - // "use" and, under TextureDownrezCoverageBias, drags - // the whole texture to its deepest mip - and it - // poisoned BP and PBR asymmetrically since the two - // systems register faces at different points in the - // geometry lifecycle. - continue; + on_agent_avatar = true; } - // Effective UV repeat AREA across this face: the tiling - // term of texels-drawn-per-screen-pixel. More tiling => - // each tile is smaller on screen => coarser mips suffice - // (penalty). Repeats < 1 (atlas/crop) => only a sub-rect - // of the image is shown, but discard levels are whole- - // image, so the full image must be resident at 1/repeats - // times the crop's pixel count (boost). + // Scale desired texture resolution higher or lower depending on texture scale + // + // Minimum usage examples: a 1024x1024 texture with aplhabet (texture atlas), + // runing string shows one letter at a time. If texture has ten 100px symbols + // per side, minimal scale is (100/1024)^2 = 0.0095 + // + // Maximum usage examples: huge chunk of terrain repeats texture + // TODO: make this work with the GLTF texture transforms S32 te_offset = face->getTEOffset(); // offset is -1 if not inited LLViewerObject* objp = face->getViewerObject(); const LLTextureEntry* te = (te_offset < 0 || te_offset >= objp->getNumTEs()) ? nullptr : objp->getTE(te_offset); + F32 min_scale = te ? llmin(fabsf(te->getScaleS()), fabsf(te->getScaleT())) : 1.f; + min_scale = llclamp(min_scale * min_scale, texture_scale_min(), texture_scale_max()); + vsize /= min_scale; - F32 repeats = 1.f; - if (te) - { - // UV scale source: every channel reads the repeat - // values ITS renderer actually applies, then flows - // through the identical pipeline below. Sources: - // diffuse -> TE scale - // Blinn normal/spec -> LLMaterial per-map repeats - // PBR channels -> KHR texture_transform scale - // Fallback for any missing material is the TE scale - - // never a silent hardcoded 1. - F32 scale_s = te->getScaleS(); - F32 scale_t = te->getScaleT(); - if (i >= LLRender::BASECOLOR_MAP) - { - // LLRender channel -> LLGLTFMaterial::TextureInfo - static const S32 gltf_info[4] = { - LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR, // BASECOLOR_MAP (3) - LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS, // METALLIC_ROUGHNESS_MAP (4) - LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL, // GLTF_NORMAL_MAP (5) - LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE, // EMISSIVE_MAP (6) - }; - if (const LLGLTFMaterial* gltf_mat = te->getGLTFRenderMaterial()) - { - const LLVector2& s = gltf_mat->mTextureTransform[gltf_info[i - LLRender::BASECOLOR_MAP]].mScale; - scale_s = s.mV[0]; - scale_t = s.mV[1]; - } - } - else if (i == LLRender::NORMAL_MAP || i == LLRender::SPECULAR_MAP) - { - // Blinn-Phong normal/specular maps carry their own - // repeats in LLMaterial - the renderer builds their - // texture matrices from these, NOT from the TE's - // diffuse scale. Reading the diffuse scale here made - // Blinn normals scale differently than PBR normals - // (whose per-channel transform IS read above). - if (const LLMaterial* mat = te->getMaterialParams().get()) - { - if (i == LLRender::NORMAL_MAP) - { - mat->getNormalRepeat(scale_s, scale_t); - } - else - { - mat->getSpecularRepeat(scale_s, scale_t); - } - } - } - - // Continuously-animated scale (llSetTextureAnim SCALE) - // bypasses both static sources via mTextureMatrix - - // the live animated values win on either path. - if (LLVOVolume* vvo = face->getDrawable() ? face->getDrawable()->getVOVolume() : nullptr) - { - LLViewerTextureAnim* anim = vvo->mTextureAnimp; - if (anim && (anim->mMode & LLTextureAnim::ON) && (anim->mMode & LLTextureAnim::SCALE) - && (anim->mFace < 0 || anim->mFace == te_offset)) - { - scale_s = anim->mScaleS; - scale_t = anim->mScaleT; - } - } - - repeats = fabsf(scale_s * scale_t); - - // Mesh atlas sub-rect: a face whose intrinsic UVs span - // only part of [0,1]^2 shows that fraction of the - // image. Applies identically to both paths - the - // transforms above stack on the raw face UVs. - if (LLVolume* vol = objp->getVolume()) - { - if (te_offset >= 0 && te_offset < vol->getNumVolumeFaces()) - { - const LLVolumeFace& vf = vol->getVolumeFace(te_offset); - F32 span = fabsf((vf.mTexCoordExtents[1].mV[0] - vf.mTexCoordExtents[0].mV[0]) - * (vf.mTexCoordExtents[1].mV[1] - vf.mTexCoordExtents[0].mV[1])); - if (span > 0.f) - { - repeats *= span; - } - } - } - } + // Raw screen-space coverage - taken before the bias / + // camera-boost mutations below so the size signal is clean. + max_on_screen_size = llmax(max_on_screen_size, vsize); - repeats = llclamp(repeats, MIN_REPEAT_AREA, MAX_REPEAT_AREA); - - // Apply the two sides of the repeat term in the right - // order relative to the screen clamp: - // - tiling (repeats > 1): the per-tile footprint at the - // nearest point, THEN clamped - one tile can't draw - // more pixels than the screen. (Clamping the whole - // face first and then dividing crushed near tiles.) - // - atlas/crop (repeats < 1): boost AFTER the clamp - - // whole-image residency for a crop legitimately - // demands more than its screen coverage. - F32 tiling = llmax(repeats, 1.f); - F32 crop = llmin(repeats, 1.f); - F32 vsize = llmin(face_px / tiling, LLViewerTexture::sWindowPixelArea) / crop; - - // Avatar bonus: worn attachments get a coverage - // multiplier - avatars are what people look at, and - // rigged extents make attachment coverage measurement - // unreliable anyway. Multiplicative, not a slam: a - // nearby avatar gains ~a mip of headroom while a distant - // one still downrezzes naturally with its coverage. - // (System-avatar bakes get the same bonus in the - // no-faces branch below.) - if (objp->isAttachment()) + // apply bias to offscreen faces all the time, but only to onscreen faces when bias is large + // use mImportanceToCamera to make bias switch a bit more gradual + if (!face->mInFrustum || LLViewerTexture::sDesiredDiscardBias > 1.9f + face->mImportanceToCamera / 2.f) { - static LLCachedControl avatar_boost(gSavedSettings, "TextureAvatarBoost", 4.f); - vsize *= llmax((F32)avatar_boost, 1.f); + vsize /= bias; } - if (bucket >= 0 && bucket < 4) + max_vsize = llmax(max_vsize, vsize); + + // addTextureStats limits size to sMaxVirtualSize + if (max_vsize >= LLViewerFetchedTexture::sMaxVirtualSize + && (on_screen || LLViewerTexture::sDesiredDiscardBias <= BIAS_TRS_ON_SCREEN)) { - channel_coverage[bucket] = llmax(channel_coverage[bucket], vsize); - if (vsize > 0.f) - { - channel_coverage_min[bucket] = llmin(channel_coverage_min[bucket], vsize); - } + break; } - max_coverage = llmax(max_coverage, vsize); } } + + if (max_vsize >= LLViewerFetchedTexture::sMaxVirtualSize + && (on_screen || LLViewerTexture::sDesiredDiscardBias <= BIAS_TRS_ON_SCREEN)) + { + break; + } + } + + bool used_face_fast_path = (face_count > max_faces_to_check); + if (used_face_fast_path) + { // this texture is used in so many places we should just boost it and not bother checking its vsize + // this is especially important because the above is not time sliced and can hit multiple ms for a single texture + max_vsize = MAX_IMAGE_AREA; } - // Terrain detail textures register no faces (LLVOSurfacePatch - // addFace(NULL)); synthesize coverage from the nearest visible patch so - // they degrade with distance like everything else. - if (face_count == 0 && imagep->getBoostLevel() == LLGLTexture::BOOST_TERRAIN) + imagep->addTextureStats(max_vsize); + + // Publish per-texture signals for processTextureStats. Closest face + // wins for distance (min); biggest face wins for size (max). Default + // distance=1, size=0 maps to "deepest discard wanted" - never- + // measured textures stay coarse until distance/size evidence arrives. + if (used_face_fast_path) + { + // Fast path saw only a prefix of faces - force best-quality + // sentinels to match the MAX_IMAGE_AREA vsize boost above. + imagep->mMinDistanceFactor = 0.f; + imagep->mMaxOnScreenSize = (F32)MAX_IMAGE_AREA; + } + else if (face_count == 0 && imagep->getBoostLevel() == LLGLTexture::BOOST_TERRAIN) { + // Terrain detail textures don't register faces with the texture + // (LLVOSurfacePatch addFace(NULL)). Drive distance from the LOD + // system; floor at a small nonzero value so pressure has + // something to bite into (pow(0, p) = 0). + static LLCachedControl terrain_distance_floor(gSavedSettings, "TextureTerrainDistanceFloor", 0.01f); + static LLCachedControl terrain_coverage(gSavedSettings, "TextureTerrainCoverageFraction", 0.99f); F32 nearest = LLSurface::sNearestVisiblePatchDistance; - F32 draw_distance = llmax(gAgentCamera.mDrawDistance, 1.f); - F32 near_frac = (nearest < FLT_MAX) ? llclampf(1.f - nearest / draw_distance) : 0.f; - // Floor so terrain never collapses to nothing at draw distance. - F32 cov = LLViewerTexture::sWindowPixelArea * llmax(near_frac, 0.05f); - channel_coverage[1] = cov; // terrain detail maps are diffuse / base color - channel_coverage_min[1] = cov; - max_coverage = cov; + F32 nearest_above_bubble = (nearest < FLT_MAX) ? llmax(nearest - bubble, 0.f) : ramp_range; + F32 dist = llclampf(nearest_above_bubble / ramp_range); + imagep->mMinDistanceFactor = llmax(dist, llclampf((F32)terrain_distance_floor)); + imagep->mMaxOnScreenSize = LLViewerTexture::sWindowPixelArea * llclampf((F32)terrain_coverage); + } + else + { + imagep->mMinDistanceFactor = min_distance_factor; + imagep->mMaxOnScreenSize = max_on_screen_size; } - // Baked avatar textures render on system-avatar body meshes whose - // joint meshes never register faces with the texture list - // (LLAvatarJointMesh::setTexture just stores the pointer). - // LLVOAvatar::updateTextures feeds their on-screen pixel area through - // addTextureStats every frame - use that as BaseColor coverage, with - // the same avatar bonus attachments get above. - else if (face_count == 0 - && (imagep->getFTType() == FTT_SERVER_BAKE || imagep->getFTType() == FTT_HOST_BAKE)) + imagep->mOnAgentAvatar = on_agent_avatar; + + // Bind-staleness. Avatar bakes exempt (cloud-bug protection). + // Per-interval increment is 1/max_discard so saturation time is + // interval * max_discard seconds regardless of texture size. + // Never-bound textures defer to distance/size or initial fetch + // could never start. + if (LLViewerFetchedTexture::isAgentAvatarBoost(imagep->getBoostLevel())) { - static LLCachedControl avatar_boost(gSavedSettings, "TextureAvatarBoost", 4.f); - F32 cov = llmin(imagep->getMaxVirtualSize(), LLViewerTexture::sWindowPixelArea) - * llmax((F32)avatar_boost, 1.f); - if (cov > 0.f) - { - channel_coverage[1] = cov; - channel_coverage_min[1] = cov; - max_coverage = cov; - } + imagep->mStalenessFactor = 0.f; } - - // Light projector textures register as LIGHT_TEX volumes, not faces. - // mSpotLightPriority (refreshed above) is already a screen-pixel-area - // estimate of the lit radius - fold it in as BaseColor coverage so - // projectors stream view-dependently like everything else. - for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) + else if (LLImageGL* gli = imagep->getGLTexture()) { - LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; - F32 cov = llmin(volume->getSpotLightPriority(), LLViewerTexture::sWindowPixelArea); - if (cov > 0.f) + static LLCachedControl bind_decay_seconds(gSavedSettings, "TextureBindDecaySeconds", 5.f); + static LLCachedControl staleness_interval(gSavedSettings, "TextureStalenessIntervalSeconds", 5.f); + F32 grace = llmax((F32)bind_decay_seconds, 0.f); + F32 interval = llmax((F32)staleness_interval, 0.0001f); + + // Clock starts at whichever is later: the last real bind or + // the GL-create time. The latter is the fallback for textures + // decoded into GL but never actually rendered - without it, + // mLastBindTime stays 0 forever and staleness can't evict. + F32 clock_time = llmax(gli->mLastBindTime, gli->mGLCreateTime); + bool has_clock = (clock_time > 0.f); + F32 time_since = has_clock ? (LLImageGL::sLastFrameTime - clock_time) : 0.f; + + if (!has_clock || time_since <= grace) + { + imagep->mStalenessFactor = 0.f; + } + else { - channel_coverage[1] = llmax(channel_coverage[1], cov); - channel_coverage_min[1] = llmin(channel_coverage_min[1], cov); - max_coverage = llmax(max_coverage, cov); + S32 full_w = imagep->getFullWidth(); + S32 full_h = imagep->getFullHeight(); + S32 max_discard = (full_w > 0 && full_h > 0) + ? LLImageGL::dimDerivedMaxDiscard(full_w, full_h) + : (S32)gli->getMaxDiscardLevel(); + if (max_discard > 0) + { + F32 steps = (time_since - grace) / interval; + F32 step_size = 1.f / (F32)max_discard; + imagep->mStalenessFactor = llclampf(steps * step_size); + } + else + { + imagep->mStalenessFactor = 0.f; + } } } - imagep->addTextureStats(max_coverage); - - // Publish per-bucket coverage bounds for - // LLViewerLODTexture::computeDesiredDiscard. - for (S32 b = 0; b < 4; ++b) - { - imagep->mChannelCoverage[b] = channel_coverage[b]; - imagep->mChannelCoverageMin[b] = (channel_coverage_min[b] == FLT_MAX) ? 0.f : channel_coverage_min[b]; - } } #if 0 - imagep->setDebugText(llformat("%d/%d -- %d/%d", + imagep->setDebugText(llformat("%d/%d - %d/%d -- %d/%d", + (S32)sqrtf(max_vsize), + (S32)sqrtf(imagep->mMaxVirtualSize), imagep->getDiscardLevel(), imagep->getDesiredDiscardLevel(), imagep->getWidth(), imagep->getFullWidth())); #endif + // make sure to addTextureStats for any spotlights that are using this texture + for (S32 vi = 0; vi < imagep->getNumVolumes(LLRender::LIGHT_TEX); ++vi) + { + LLVOVolume* volume = (*imagep->getVolumeList(LLRender::LIGHT_TEX))[vi]; + volume->updateSpotLightPriority(); + } + F32 max_inactive_time = 20.f; // inactive time before deleting saved raw image S32 min_refs = 3; // 1 for mImageList, 1 for mUUIDMap, and 1 for "entries" in updateImagesFetchTextures @@ -1477,6 +1409,21 @@ F32 LLViewerTextureList::updateImagesFetchTextures(F32 max_time) //update MIN_UPDATE_COUNT or 5% of other textures, whichever is greater update_count = llmax((U32) MIN_UPDATE_COUNT, (U32) mUUIDMap.size()/20); + // Scale up the per-frame update window under VRAM pressure so eviction + // candidates get re-evaluated quickly. Both the legacy bias and the + // new pressure multiplier widen the window. + F32 pressure_scale = llmax(LLViewerTexture::sDesiredDiscardBias, + LLViewerTexture::sMemoryPressureMultiplier); + if (pressure_scale > 1.f + && LLViewerTexture::sBiasTexturesUpdated < (U32)mUUIDMap.size()) + { + update_count = (S32)(update_count * pressure_scale); + + // This isn't particularly precise and can overshoot, but it doesn't need + // to be, just making sure it did a full circle and doesn't get stuck updating + // at bias = 4 with 4 times the rate permanently. + LLViewerTexture::sBiasTexturesUpdated += update_count; + } update_count = llmin(update_count, (U32) mUUIDMap.size()); { // copy entries out of UUID map to avoid iterator invalidation from deletion inside updateImageDecodeProiroty or updateFetch below diff --git a/indra/newview/llviewertexturelist.h b/indra/newview/llviewertexturelist.h index 931f2ed50e..dbed8b5c2f 100644 --- a/indra/newview/llviewertexturelist.h +++ b/indra/newview/llviewertexturelist.h @@ -244,6 +244,10 @@ private: bool mInitialized ; LLFrameTimer mForceDecodeTimer; +public: + // Current close-camera bubble in meters (frame-coherent, slow-tracked). + static F32 sCurrentBubbleMeters; + private: static S32 sNumImages; static void (*sUUIDCallback)(void**, const LLUUID &); diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index e2601e6465..dea96e2012 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -5597,13 +5597,7 @@ bool LLViewerWindow::cubeSnapshot(const LLVector3& origin, LLCubeMapArray* cubea // actually render the scene gCubeSnapshot = true; - { - // Probe binds aren't visibility - otherwise every probe slice re-stamps - // behind-camera textures and cycles them evict->refetch. RAII so the - // nested shadow pass in display_cube_face doesn't re-enable stamping. - LLImageGLStampBypass stamp_bypass; - display_cube_face(); - } + display_cube_face(); gCubeSnapshot = false; } diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp index d57456aa5a..3b41ccb6fc 100644 --- a/indra/newview/llvovolume.cpp +++ b/indra/newview/llvovolume.cpp @@ -878,15 +878,11 @@ void LLVOVolume::updateTextureVirtualSize(bool forced) LLViewerFetchedTexture* img = LLViewerTextureManager::staticCastToFetchedTexture(imagep) ; if(img) { - // cur:desired:width then per-bucket coverage bounds - // (N/BC/S/E, sqrt so values read as pixel dimensions, - // max~min) - the exact inputs computeDesiredDiscard sees. - debug_text << img->getDiscardLevel() << ":" << img->getDesiredDiscardLevel() << ":" << img->getWidth() - << " N" << (S32)sqrtf(img->getChannelCoverage(0)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(0)) - << " BC" << (S32)sqrtf(img->getChannelCoverage(1)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(1)) - << " S" << (S32)sqrtf(img->getChannelCoverage(2)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(2)) - << " E" << (S32)sqrtf(img->getChannelCoverage(3)) << "~" << (S32)sqrtf(img->getChannelCoverageMin(3)) - << "\n"; + debug_text << img->getDiscardLevel() << ":" << img->getDesiredDiscardLevel() << ":" << img->getWidth() << ":" << (S32) sqrtf(vsize) << ":" << (S32) sqrtf(img->getMaxVirtualSize()) << "\n"; + /*F32 pri = img->getDecodePriority(); + pri = llmax(pri, 0.0f); + if (pri < min_vsize) min_vsize = pri; + if (pri > max_vsize) max_vsize = pri;*/ } } else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA)) @@ -932,7 +928,7 @@ void LLVOVolume::updateTextureVirtualSize(bool forced) { LLLightImageParams* params = getLightImageParams(); LLUUID id = params->getLightTexture(); - mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE); if (mLightTexture.notNull()) { F32 rad = getLightRadius(); @@ -1801,41 +1797,6 @@ void LLVOVolume::regenFaces() facep->setNormalMap(getTENormalMap(i)); facep->setSpecularMap(getTESpecularMap(i)); } - - // Register PBR channel textures HERE, at geometry build, exactly when - // the Blinn textures above register - mirrored from rebuildGeom - // (which still re-runs this when the material resolves later). - // Without this, PBR textures had zero registered faces until the - // spatial group's budget-throttled rebuildGeom ran, so the streaming - // math read "not measured -> deepest mip" for PBR content while - // identical Blinn content on the same geometry measured immediately. - { - const LLTextureEntry* te = facep->getTextureEntry(); - LLFetchedGLTFMaterial* gltf_mat = te ? (LLFetchedGLTFMaterial*)te->getGLTFRenderMaterial() : nullptr; - if (gltf_mat) - { - if (!facep->hasMedia()) - { - facep->setTexture(LLRender::DIFFUSE_MAP, nullptr); - } - facep->setTexture(LLRender::NORMAL_MAP, nullptr); - facep->setTexture(LLRender::SPECULAR_MAP, nullptr); - facep->setTexture(LLRender::BASECOLOR_MAP, gltf_mat->mBaseColorTexture); - facep->setTexture(LLRender::GLTF_NORMAL_MAP, gltf_mat->mNormalTexture); - facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, gltf_mat->mMetallicRoughnessTexture); - facep->setTexture(LLRender::EMISSIVE_MAP, gltf_mat->mEmissiveTexture); - } - else - { - // No (or no longer a) PBR material: clear any stale GLTF - // channel registrations so a removed material's textures - // stop accruing phantom coverage from this face. - facep->setTexture(LLRender::BASECOLOR_MAP, nullptr); - facep->setTexture(LLRender::GLTF_NORMAL_MAP, nullptr); - facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, nullptr); - facep->setTexture(LLRender::EMISSIVE_MAP, nullptr); - } - } facep->setViewerObject(this); // If the face had media on it, this will have broken the link between the LLViewerMediaTexture and the face. @@ -3406,7 +3367,7 @@ LLViewerTexture* LLVOVolume::getLightTexture() { if (mLightTexture.isNull() || id != mLightTexture->getID()) { - mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE); + mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE); } } else @@ -5890,16 +5851,6 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group) facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, gltf_mat->mMetallicRoughnessTexture); facep->setTexture(LLRender::EMISSIVE_MAP, gltf_mat->mEmissiveTexture); } - else - { - // Face is not (or no longer) PBR: clear any stale GLTF - // channel registrations, or a removed material's textures - // keep accruing phantom coverage from this face forever. - facep->setTexture(LLRender::BASECOLOR_MAP, nullptr); - facep->setTexture(LLRender::GLTF_NORMAL_MAP, nullptr); - facep->setTexture(LLRender::METALLIC_ROUGHNESS_MAP, nullptr); - facep->setTexture(LLRender::EMISSIVE_MAP, nullptr); - } //ALWAYS null out vertex buffer on rebuild -- if the face lands in a render // batch, it will recover its vertex buffer reference from the spatial group diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index f18ec727df..4ef88f5deb 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -9461,9 +9461,6 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa LL_PROFILE_GPU_ZONE("renderShadow"); LLPipeline::sShadowRender = true; - // Shadow binds aren't visibility. RAII (not a hardcoded restore) so a shadow - // pass nested in a probe render doesn't re-enable stamping for the rest of it. - LLImageGLStampBypass stamp_bypass; // disable occlusion culling during shadow render U32 saved_occlusion = sUseOcclusion; @@ -10848,9 +10845,6 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool sShadowRender = true; sImpostorRender = true; - // Impostor binds aren't visibility. RAII so the nested shadow pass can't - // re-enable stamping mid-render. - LLImageGLStampBypass stamp_bypass; LLViewerCamera* viewer_camera = LLViewerCamera::getInstance(); -- cgit v1.3