Cache texture LOD requests per mesh across frames

trinity/Eve/SpaceObject/Children/EveChildMesh.cpp

@@ -383,19 +383,6 @@ void EveChildMesh::UpdateVisibility( const EveUpdateContext& updateContext, cons
 
 	if( m_mesh )
 	{
-		CcpMath::AxisAlignedBox bounds;
-		if( m_animationUpdater && m_animationUpdater->IsInitialized() && m_animationUpdater->GetAnimationTransforms() )
-		{
-			auto [meshBindingIndices, boneCount] = GetMeshBindingIndices();
-			auto [morphTargets, morphTargetCount] = GetMorphTargets( MorphTargetAnimationFilter::ALL );
-			bounds = m_mesh->GetBounds( m_animationUpdater->GetAnimationTransforms(), meshBindingIndices, boneCount, morphTargets, morphTargetCount );
-		}
-		else
-		{
-			bounds = m_mesh->GetBounds();
-		}
-
-		bounds.Transform( m_worldTransform );
 		m_currentScreenSize = frustum.GetPixelSizeAccross( m_worldBoundingSphere );
 
 		if( m_instancedMesh )

trinity/Include/ITriEffectParameter.h

@@ -4,6 +4,7 @@
 #define ITr2EffectParameter_h
 
 #include "ITr2EffectValue.h"
+#include "Tr2ScreenSizeRequests.h"
 
 BLUE_DECLARE( Tr2Shader );
 
@@ -36,6 +37,11 @@ BLUE_INTERFACE( ITriEffectTextureParameter ) :
 {
 	static const size_t UV_SET_MAX_COUNT = 8;
 	virtual void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities ) = 0;
+	virtual void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests& requests )
+	{
+		UsedWithScreenSize( screenSize, worldRadius, uvDensities );
+		requests.Invalidate();
+	}
 	virtual void EnableTextureLoding( const std::array<float, UV_SET_MAX_COUNT>& uvDensityScale ) = 0;
 	virtual void DisableTextureLoding() = 0;
 };

trinity/Resources/TriTextureRes.cpp

@@ -1,6 +1,7 @@
 // Copyright © 2023 CCP ehf.
 
 #include "StdAfx.h"
+#include "Tr2ScreenSizeRequests.h"
 #include "TriTextureRes.h"
 #include "TriSettingsRegistrar.h"
 
@@ -154,6 +155,7 @@ TriTextureRes::TriTextureRes() :
 
 TriTextureRes::~TriTextureRes()
 {
+	Tr2ScreenSizeRequests::BumpGeneration();
 	// Note: ReleaseResources now happens in Unlock due to threading issues.
 	// If a texture resource was deleted while it was still being loaded it would cause crash.
 	Tr2TextureLodManager::Instance().UnregisterTexture( this );
@@ -641,6 +643,7 @@ BlueAsyncRes::LoadingResult TriTextureRes::DoLoad()
 
 		m_originalResolution = std::min( m_loadedBitmap->GetWidth(), m_loadedBitmap->GetHeight() );
 		m_originalResolution = m_originalResolution << m_requestedLoadMip;
+		Tr2ScreenSizeRequests::BumpGeneration();
 		m_cpuMip = m_requestedLoadMip;
 		m_maxMip = m_loadedBitmap->GetTrueMipCount();
 		if( m_maxMip > 4 )
@@ -715,8 +718,10 @@ void TriTextureRes::RequestResolution( const uint32_t requestedLod )
 	{
 		return;
 	}
-	m_hadLodRequests = true;
-
+	if( !m_hadLodRequests.load( std::memory_order_relaxed ) )
+	{
+		m_hadLodRequests = true;
+	}
 	AtomicMinUpdate( m_requestedMip, requestedLod );
 }
 

trinity/Shader/Parameter/TriTextureParameter.cpp

@@ -2,6 +2,7 @@
 
 #include "StdAfx.h"
 #include "TriTextureParameter.h"
+#include "Tr2ScreenSizeRequests.h"
 #include "ITr2TextureProvider.h"
 #include "Shader/Tr2Shader.h"
 #include "Shader/Tr2Material.h"
@@ -50,56 +51,105 @@ bool TriTextureParameter::SupportsDirtyNotification() const
 	return true;
 }
 
+namespace
+{
+// Screen sizes for which this parameter keeps requesting the same LOD: the LOD only changes when
+// screenSize / minDensity crosses a power of two of the texture resolution.
+void ConstrainScreenSize( Tr2ScreenSizeRequests& requests, float resolution, float minDensity, uint32_t requestedLod, float originalResolution )
+{
+	if( minDensity <= 0.0f || originalResolution <= 0.0f )
+	{
+		return;
+	}
+	if( resolution <= 0.0f )
+	{
+		requests.Invalidate();
+		return;
+	}
+	const float eps = 1e-4f;
+	if( resolution <= 1.0f )
+	{
+		requests.Constrain( 0.0f, minDensity * ( 1.0f - eps ) );
+		return;
+	}
+	if( resolution > originalResolution )
+	{
+		requests.Constrain( minDensity * originalResolution * ( 1.0f + eps ), std::numeric_limits<float>::max() );
+		return;
+	}
+	const float upper = originalResolution / float( 1u << requestedLod );
+	requests.Constrain( std::max( minDensity, minDensity * upper * 0.5f ) * ( 1.0f + eps ), minDensity * upper * ( 1.0f - eps ) );
+}
+}
+
 void TriTextureParameter::UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities )
 {
-	if( m_textureRes )
+	RequestLod( screenSize, worldRadius, uvDensities, nullptr );
+}
+
+void TriTextureParameter::UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests& requests )
+{
+	RequestLod( screenSize, worldRadius, uvDensities, &requests );
+}
+
+void TriTextureParameter::RequestLod( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests* requests )
+{
+	if( !m_textureRes )
 	{
-		uint32_t requestedLod = 0;
-		if( m_textureLodEnabled && !uvDensities.empty() )
-		{
-			size_t i = 0;
-			float resolution = 0;
+		return;
+	}
+	uint32_t requestedLod = 0;
+	if( m_textureLodEnabled && !uvDensities.empty() )
+	{
+		size_t i = 0;
+		float resolution = 0;
+		float minDensity = 0;
 
+		{
+			auto density = worldRadius * m_uvDensityScale[0];
+			if( density > 0 )
 			{
-				auto density = worldRadius * m_uvDensityScale[0];
-				if( density > 0 )
-				{
-					resolution = std::max( resolution, screenSize / density );
-				}
+				resolution = std::max( resolution, screenSize / density );
+				minDensity = density;
 			}
+		}
 
-			for( auto uv : uvDensities )
+		for( auto uv : uvDensities )
+		{
+			auto scale = m_uvDensityScale[1 + i++];
+			auto density = uv * scale;
+			if( density > 0 )
 			{
-				auto scale = m_uvDensityScale[1 + i++];
-				auto density = uv * scale;
-				if( density > 0 )
-				{
-					resolution = std::max( resolution, screenSize / density );
-				}
+				resolution = std::max( resolution, screenSize / density );
+				minDensity = minDensity > 0 ? std::min( minDensity, density ) : density;
 			}
-			if( resolution != 0 )
+		}
+		if( resolution != 0 )
+		{
+			auto requestedResolution = std::max( 1.f, resolution );
+			auto resolutionChange = (uint32_t)( m_textureRes->GetOriginalResolutionAsFloat() / requestedResolution );
+			if( resolutionChange > 0 )
 			{
-				auto requestedResolution = std::max( 1.f, resolution );
-				auto resolutionChange = (uint32_t)( m_textureRes->GetOriginalResolutionAsFloat() / requestedResolution );
-				if( resolutionChange > 0 )
-				{
-					// quickly calculate log2 of resolutionChange, which gives us the required LOD
+				// quickly calculate log2 of resolutionChange, which gives us the required LOD
 #if __APPLE__
-					requestedLod = 31 - (uint32_t)__builtin_clz( resolutionChange );
+				requestedLod = 31 - (uint32_t)__builtin_clz( resolutionChange );
 #else
-					unsigned long reverse;
-					_BitScanReverse( &reverse, resolutionChange );
-					requestedLod = reverse;
+				unsigned long reverse;
+				_BitScanReverse( &reverse, resolutionChange );
+				requestedLod = reverse;
 #endif
-				}
 			}
-			m_textureRes->RequestResolution( requestedLod );
 		}
-		else
+		if( requests )
 		{
-			m_textureRes->RequestResolution( requestedLod );
+			ConstrainScreenSize( *requests, resolution, minDensity, requestedLod, m_textureRes->GetOriginalResolutionAsFloat() );
 		}
 	}
+	if( requests )
+	{
+		requests->Add( m_textureRes, requestedLod );
+	}
+	m_textureRes->RequestResolution( requestedLod );
 }
 
 // -------------------------------------------------------------
@@ -129,12 +179,14 @@ void TriTextureParameter::SetResourcePath( const char* resourcePath )
 void TriTextureParameter::EnableTextureLoding( const std::array<float, UV_SET_MAX_COUNT>& uvDensityScale )
 {
 	m_textureLodEnabled = true;
+	Tr2ScreenSizeRequests::BumpGeneration();
 	std::copy( begin( uvDensityScale ), end( uvDensityScale ), begin( m_uvDensityScale ) );
 }
 
 void TriTextureParameter::DisableTextureLoding()
 {
 	m_textureLodEnabled = false;
+	Tr2ScreenSizeRequests::BumpGeneration();
 }
 
 bool TriTextureParameter::OnModified( Be::Var* val )
@@ -150,6 +202,7 @@ bool TriTextureParameter::OnModified( Be::Var* val )
 		m_lowResResource = nullptr;
 	}
 	m_textureRes = nullptr;
+	Tr2ScreenSizeRequests::BumpGeneration();
 
 	Initialize();
 
@@ -208,6 +261,7 @@ bool TriTextureParameter::Initialize()
 		m_lowResResource = nullptr;
 	}
 	m_textureRes = nullptr;
+	Tr2ScreenSizeRequests::BumpGeneration();
 
 	if( !m_resourcePath.empty() )
 	{
@@ -235,6 +289,7 @@ bool TriTextureParameter::Initialize()
 			m_resource->OnTextureChange().RegisterListener<TriTextureParameter, &TriTextureParameter::OnTextureChanged>( this );
 		}
 		m_textureRes = BlueCastPtr( m_resource );
+		Tr2ScreenSizeRequests::BumpGeneration();
 	}
 	OnTextureChanged();
 	return true;
@@ -264,6 +319,7 @@ void TriTextureParameter::SetResource( ITr2TextureProvider* newRes )
 		m_lowResResource = nullptr;
 	}
 	m_textureRes = BlueCastPtr( m_resource );
+	Tr2ScreenSizeRequests::BumpGeneration();
 	RebuildEffectHandles( m_cachedEffect );
 	OnTextureChanged();
 }

trinity/Shader/Parameter/TriTextureParameter.h

@@ -53,6 +53,7 @@ BLUE_CLASS( TriTextureParameter ) :
 	bool SupportsDirtyNotification() const override;
 
 	void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities ) override;
+	void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests& requests ) override;
 	void EnableTextureLoding( const std::array<float, UV_SET_MAX_COUNT>& uvDensityScale ) override;
 	void DisableTextureLoding() override;
 
@@ -91,6 +92,8 @@ BLUE_CLASS( TriTextureParameter ) :
 
 	Tr2ShaderPtr m_cachedEffect;
 
+	void RequestLod( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests* requests );
+
 	BlueSharedString m_name;
 
 	ITr2TextureProviderPtr m_resource;

trinity/Shader/Tr2Effect.cpp

@@ -1,6 +1,7 @@
 // Copyright © 2023 CCP ehf.
 
 #include "StdAfx.h"
+#include "Tr2ScreenSizeRequests.h"
 
 #include "ccpparser.h"
 
@@ -675,6 +676,7 @@ void Tr2Effect::RebuildCachedDataInternal()
 	auto bk = m_shader;
 	m_shader = nullptr;
 	m_lodTextureParameters.clear();
+	Tr2ScreenSizeRequests::BumpGeneration();
 	m_compatibleWithGdr = true;
 
 	if( m_effectResource )
@@ -861,6 +863,7 @@ void Tr2Effect::ReleaseCachedData( BlueAsyncRes* p )
 			m_resources[i]->RebuildEffectHandles( nullptr );
 		}
 		m_lodTextureParameters.clear();
+		Tr2ScreenSizeRequests::BumpGeneration();
 	}
 }
 
@@ -2073,6 +2076,7 @@ void Tr2Effect::AddLoddable( ITriEffectParameter* param, const char* name )
 				loddable->DisableTextureLoding();
 			}
 			m_lodTextureParameters.push_back( loddable );
+			Tr2ScreenSizeRequests::BumpGeneration();
 		}
 	}
 }

trinity/Shader/Tr2Material.cpp

@@ -1,6 +1,7 @@
 // Copyright © 2017 CCP ehf.
 
 #include "StdAfx.h"
+#include "Tr2ScreenSizeRequests.h"
 #include "Tr2Material.h"
 #include "ITriReroutable.h"
 #include "Tr2Shader.h"
@@ -369,6 +370,14 @@ void Tr2Material::UsedWithScreenSize( float screenSize, float worldRadius, const
 	}
 }
 
+void Tr2Material::UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests& requests )
+{
+	for( auto& value : m_lodTextureParameters )
+	{
+		value->UsedWithScreenSize( screenSize, worldRadius, uvDensities, requests );
+	}
+}
+
 void Tr2Material::GetUsedBindlessTextures( uint32_t techniqueIndex, Tr2BindlessResourcesAL& usedTextures )
 {
 	if( !m_shader )

trinity/Shader/Tr2Material.h

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "Tr2EffectDescription.h"
+struct Tr2ScreenSizeRequests;
 
 BLUE_DECLARE( Tr2Shader );
 BLUE_DECLARE_INTERFACE( ITriEffectTextureParameter );
@@ -219,6 +220,7 @@ BLUE_CLASS( Tr2Material ) :
 	void MarkConstantBuffersDirty();
 
 	void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities );
+	void UsedWithScreenSize( float screenSize, float worldRadius, const std::vector<float>& uvDensities, Tr2ScreenSizeRequests& requests );
 
 	void GetUsedBindlessTextures( uint32_t techniqueIndex, Tr2BindlessResourcesAL& usedTextures );