file
function     FTextureLODGroup

		, LODBias_Smaller(-1)
		, LODBias_Smallest(-1)
		, NumStreamedMips(-1)
		, MipGenSettings(TextureMipGenSettings::TMGS_SimpleAverage)
		, MinLODSize(1)
		, MaxLODSize(4096)
		, MaxLODSize_Smaller(-1)
		, MaxLODSize_Smallest(-1)
		, MaxLODSize_VT(0)

	/** Number of mip-levels that can be streamed. -1 means all mips can stream.	*/
	UPROPERTY()
	int32 NumStreamedMips;

	/** Defines how the the mip-map generation works, e.g. sharpening				*/
	UPROPERTY()
	TEnumAsByte<TextureMipGenSettings> MipGenSettings;

	/** Prevent LODBias from making the textures smaller than this value. Note that this does _not_ affect the smallest mip level size. */

file
function     FRenderAssetStreamingManager::FRenderAssetStreamingManager

		const TextureGroup TextureLODGroup = (TextureGroup)LODGroup;
		const FTextureLODGroup& TexGroup = UDeviceProfileManager::Get().GetActiveProfile()->GetTextureLODSettings()->GetTextureLODGroup(TextureLODGroup);
		NumStreamedMips_Texture[LODGroup] = TexGroup.NumStreamedMips;
		// For compatibility reason, Character groups are always loaded with higher priority
		Settings.HighPriorityLoad_Texture[LODGroup] = TexGroup.HighPriorityLoad || TextureLODGroup == TEXTUREGROUP_Character || TextureLODGroup == TEXTUREGROUP_CharacterSpecular || TextureLODGroup == TEXTUREGROUP_CharacterNormalMap;
	}

	// TODO: NumStreamedMips_StaticMesh, NumStreamedMips_SkeletalMesh, NumStreamedMips_LandscapeMeshMobile
	NumStreamedMips_StaticMesh.Empty(1);

file
function     void FRenderAssetStreamingManager::ProcessAddedRenderAssets

		{
			Asset->StreamingIndex = StreamingRenderAssets.Num();
			const int32* NumStreamedMips = nullptr;
			const int32 NumLODGroups = GetNumStreamedMipsArray(Asset->GetRenderAssetType(), NumStreamedMips);
			new (StreamingRenderAssets) FStreamingRenderAsset(Asset, NumStreamedMips, NumLODGroups, Settings);
		}
	}
	PendingStreamingRenderAssets.Reset();
}

void FRenderAssetStreamingManager::ConditionalUpdateStaticData()

file
function     void FRenderAssetStreamingManager::UpdateIndividualRenderAsset

	if (!StreamingRenderAsset) return;

	const int32* NumStreamedMips;
	const int32 NumLODGroups = GetNumStreamedMipsArray(StreamingRenderAsset->RenderAssetType, NumStreamedMips);

	StreamingRenderAsset->UpdateDynamicData(NumStreamedMips, NumLODGroups, Settings, false);

	if (StreamingRenderAsset->bForceFullyLoad) // Somewhat expected at this point.
	{
		StreamingRenderAsset->WantedMips = StreamingRenderAsset->BudgetedMips = StreamingRenderAsset->MaxAllowedMips;
	}

file
function     void FRenderAssetStreamingManager::UpdateStreamingRenderAssets
lambda-function

				}

				const int32* NumStreamedMips;
				const int32 NumLODGroups = GetNumStreamedMipsArray(StreamingRenderAsset.RenderAssetType, NumStreamedMips);

				StreamingRenderAsset.UpdateDynamicData(NumStreamedMips, NumLODGroups, Settings, bWaitForMipFading, &Packets[PacketIndex].LocalDeferredTickCBAssets); // We always use the Deferred CBs when doing the ParallelFor since those CBs are not thread safe.

				// Make a list of each texture/mesh that can potentially require additional UpdateStreamingStatus
				if (StreamingRenderAsset.RequestedMips != StreamingRenderAsset.ResidentMips)
				{
					Packets[PacketIndex].LocalInflightRenderAssets.Add(Index);
				}

file
function     void FRenderAssetStreamingManager::UpdateStreamingRenderAssets

			STAT(int32 PreviousResidentMips = StreamingRenderAsset.ResidentMips;)

			const int32* NumStreamedMips;
			const int32 NumLODGroups = GetNumStreamedMipsArray(StreamingRenderAsset.RenderAssetType, NumStreamedMips);

			StreamingRenderAsset.UpdateDynamicData(NumStreamedMips, NumLODGroups, Settings, bWaitForMipFading, bAsync ? &DeferredTickCBAssets : nullptr);

			// Make a list of each texture/mesh that can potentially require additional UpdateStreamingStatus
			if (StreamingRenderAsset.RequestedMips != StreamingRenderAsset.ResidentMips)
			{
				InflightRenderAssets.Add(Index);
			}

file
function     bool FRenderAssetStreamingManager::HandleNumStreamedMipsCommand

		if ( NumMips >= -1 && NumMips <= MAX_TEXTURE_MIP_COUNT )
		{
			TexGroup.NumStreamedMips = NumMips;
		}
		Ar.Logf( TEXT("%s.NumStreamedMips = %d"), UTexture::GetTextureGroupString(TextureGroup(LODGroup)), TexGroup.NumStreamedMips );
	}
	else if (LODGroupType == TEXT("StaticMesh"))
	{
		// TODO
		Ar.Logf(TEXT("NumStreamedMips command is not implemented for static mesh yet"));
	}

file
function     bool FRenderAssetStreamingManager::Exec

		return HandleShadowmapStreamingFactorCommand( Cmd, Ar );
	}
	else if (FParse::Command(&Cmd,TEXT("NumStreamedMips")))
	{
		return HandleNumStreamedMipsCommand( Cmd, Ar );
	}
	else if (FParse::Command(&Cmd,TEXT("TrackTexture"))
		|| FParse::Command(&Cmd, TEXT("TrackRenderAsset")))
	{

file
function     FStreamingRenderAsset::FStreamingRenderAsset

FStreamingRenderAsset::FStreamingRenderAsset(
	UStreamableRenderAsset* InRenderAsset,
	const int32* NumStreamedMips,
	int32 NumLODGroups,
	const FRenderAssetStreamingSettings& Settings)
	: RenderAsset(InRenderAsset)
	, RenderAssetType(InRenderAsset->GetRenderAssetType())
{
	UpdateStaticData(Settings);
	UpdateDynamicData(NumStreamedMips, NumLODGroups, Settings, false);

	// In the editor, some paths can recreate the FStreamingRenderAsset, which could potentiallly trigger the unkown ref heuristic.
	// To prevent this, we consider that the asset bindings where reset when creating the FStreamingRenderAsset.
	// In game, we set it to FLT_MAX so that unkown ref heurisitic can kick in immeditaly (otherwise it incurs a 5 sec penalty on async loading)
	InstanceRemovedTimestamp = GIsEditor ? FApp::GetCurrentTime() : -FLT_MAX;
	DynamicBoostFactor = 1.f;

file
function     void FStreamingRenderAsset::UpdateDynamicData

}

void FStreamingRenderAsset::UpdateDynamicData(const int32* NumStreamedMips, int32 NumLODGroups, const FRenderAssetStreamingSettings& Settings, bool bWaitForMipFading, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets)
{
	// Note that those values are read from the async task and must not be assigned temporary values!!
	if (RenderAsset)
	{
		// Get the resource state after calling UpdateStreamingStatus() since it might have updated it.
		const FStreamableRenderResourceState ResourceState = UpdateStreamingStatus(bWaitForMipFading, DeferredTickCBAssets);

file
function     void FStreamingRenderAsset::UpdateDynamicData

		check(LODGroup < NumLODGroups);
		if (NumStreamedMips[LODGroup] > 0)
		{
			MinAllowedMips = FMath::Clamp<int32>(ResourceState.MaxNumLODs - NumStreamedMips[LODGroup], ResourceState.NumNonStreamingLODs, MaxAllowedMips);
		}
		else
		{
			MinAllowedMips = ResourceState.NumNonStreamingLODs;
		}
	}

	FStreamingRenderAsset(
		UStreamableRenderAsset* InRenderAsset,
		const int32* NumStreamedMips,
		int32 NumLODGroups,
		const FRenderAssetStreamingSettings& Settings);

	/** Update data that should not change unless changing settings. */
	void UpdateStaticData(const FRenderAssetStreamingSettings& Settings);

	/** Update data that the engine could change through gameplay. */
	void UpdateDynamicData(const int32* NumStreamedMips, int32 NumLODGroups, const FRenderAssetStreamingSettings& Settings, bool bWaitForMipFading, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets = nullptr);

	/** Lightweight version of UpdateDynamicData. */
	FStreamableRenderResourceState UpdateStreamingStatus(bool bWaitForMipFading, TArray<UStreamableRenderAsset*>* DeferredTickCBAssets = nullptr);

	/**
	 * Returns the amount of memory used by the texture/mesh given a specified number of mip-maps, in bytes.