TextureStreamingTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Structs and defines used for texture streaming build
 
#pragma once 
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Misc/Guid.h"
#include "HAL/IConsoleManager.h"
#include "RHIDefinitions.h"
#include "SceneTypes.h"
#include "TextureStreamingTypes.generated.h"
 
class ULevel;
class UMaterialInterface;
class UPrimitiveComponent;
class UTexture;
struct FMaterialTextureInfo;
struct FMeshUVChannelInfo;
struct FSlowTask;
struct FStreamingTextureBuildInfo;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(TextureStreamingBuild, Log, All);
 
class UTexture;
class UStreamableRenderAsset;
struct FStreamingTextureBuildInfo;
struct FMaterialTextureInfo;
 
// The PackedRelativeBox value that return the bound unaltered
inline constexpr uint32 PackedRelativeBox_Identity = 0xffff0000;
 
USTRUCT()
struct FStreamingRenderAssetPrimitiveInfo
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TObjectPtr<UStreamableRenderAsset> RenderAsset;
 
    UPROPERTY()
    FBoxSphereBounds Bounds;
 
    UPROPERTY()
    float TexelFactor;
 
    UPROPERTY()
    uint32 PackedRelativeBox;
 
    UPROPERTY(Transient)
    uint32 bAllowInvalidTexelFactorWhenUnregistered : 1;
 
    UPROPERTY(Transient)
    uint32 bAffectedByComponentScale : 1;
 
    FStreamingRenderAssetPrimitiveInfo() : 
        RenderAsset(nullptr),
        Bounds(ForceInit), 
        TexelFactor(1.0f),
        PackedRelativeBox(0),
        bAllowInvalidTexelFactorWhenUnregistered(false),
        bAffectedByComponentScale(true)
    {
    }
 
    FStreamingRenderAssetPrimitiveInfo(
        UStreamableRenderAsset* InAsset,
        const FBoxSphereBounds& InBounds,
        float InTexelFactor,
        uint32 InPackedRelativeBox = 0,
        bool bInAllowInvalidTexelFactorWhenUnregistered = false,
        bool bInAffectedByComponentScale = true) :
        RenderAsset(InAsset),
        Bounds(InBounds), 
        TexelFactor(InTexelFactor),
        PackedRelativeBox(InPackedRelativeBox),
        bAllowInvalidTexelFactorWhenUnregistered(bInAllowInvalidTexelFactorWhenUnregistered),
        bAffectedByComponentScale(bInAffectedByComponentScale)
    {
    }
 
    bool CanBeStreamedByDistance(bool bOwningCompRegistered) const
    {
        return (TexelFactor > UE_SMALL_NUMBER || (!bOwningCompRegistered && bAllowInvalidTexelFactorWhenUnregistered))
            && (Bounds.SphereRadius > UE_SMALL_NUMBER || !bOwningCompRegistered)
            && ensure(FMath::IsFinite(TexelFactor));
    }
};
 
// Invalid streamable texture registration index
inline constexpr uint16 InvalidRegisteredStreamableTexture = (uint16)INDEX_NONE;
 
struct ITextureStreamingContainer
{
#if WITH_EDITOR
    virtual void InitializeTextureStreamingContainer(uint32 InPackedTextureStreamingQualityLevelFeatureLevel) = 0;
    virtual uint16 RegisterStreamableTexture(UTexture* InTexture) = 0;
    virtual bool GetStreamableTexture(uint16 InTextureIndex, FString& OutTextureName, FGuid& OutTextureGuid) const { return false; }
#endif
};
 
USTRUCT()
struct FStreamingTextureBuildInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    uint32 PackedRelativeBox;
 
    UPROPERTY()
    int32 TextureLevelIndex;
 
    UPROPERTY()
    float TexelFactor;
 
    FStreamingTextureBuildInfo() : 
        PackedRelativeBox(0), 
        TextureLevelIndex(0), 
        TexelFactor(0) 
    {
    }
 
#if WITH_EDITOR
    ENGINE_API void PackFrom(ITextureStreamingContainer* TextureStreamingContainer, const FBoxSphereBounds& RefBounds, const FStreamingRenderAssetPrimitiveInfo& Info);
 
    ENGINE_API uint32 ComputeHash() const;
#endif
};
 
// The max number of uv channels processed in the texture streaming build.
#define TEXSTREAM_MAX_NUM_UVCHANNELS  4
// The initial texture scales (must be bigger than actual used values)
#define TEXSTREAM_INITIAL_GPU_SCALE 256
// The tile size when outputting the material texture scales.
#define TEXSTREAM_TILE_RESOLUTION 32
// The max number of textures processed in the material texture scales build.
#define TEXSTREAM_MAX_NUM_TEXTURES_PER_MATERIAL 256
 
struct FPrimitiveMaterialInfo
{
    FPrimitiveMaterialInfo() : Material(nullptr), UVChannelData(nullptr), PackedRelativeBox(0) {}
 
    // The material
    const UMaterialInterface* Material;
 
    // The mesh UV channel data
    const FMeshUVChannelInfo* UVChannelData;
 
    // The material bounds for the mesh.
    uint32 PackedRelativeBox;
 
    bool IsValid() const { return Material && UVChannelData && PackedRelativeBox != 0; }
};
 
enum ETextureStreamingBuildType
{
    TSB_MapBuild,
    TSB_ActorBuild,
    TSB_ValidationOnly,
    TSB_ViewMode
};
 
class FStreamingTextureLevelContext
{
    const TMap<FGuid, int32>* TextureGuidToLevelIndex;
 
    bool bUseRelativeBoxes;
 
    int32 BuildDataTimestamp;
 
    const TArray<FStreamingTextureBuildInfo>* ComponentBuildData;
 
    TArray<UTexture*> LevelStreamingTextures;
 
    struct FTextureBoundState
    {
        FTextureBoundState() {}
 
        FTextureBoundState(UTexture* InTexture) : BuildDataTimestamp(0), BuildDataIndex(0), Texture(InTexture) {}
 
        int32 BuildDataTimestamp;
        int32 BuildDataIndex;
        UTexture* Texture;
    };
 
    /*
     * The component state of the each texture. Used to prevent processing each texture several time.
     * Also used to find quickly the build data relating to each texture. 
     */
    TArray<FTextureBoundState> BoundStates;
 
    EMaterialQualityLevel::Type QualityLevel;
    ERHIFeatureLevel::Type FeatureLevel;
    bool bIsBuiltDataValid;
    bool bForceNoUseBuiltData;
 
    ENGINE_API int32* GetBuildDataIndexRef(UTexture* Texture, bool bForceUpdate = false);
    ENGINE_API void UpdateQualityAndFeatureLevel(EMaterialQualityLevel::Type InQualityLevel, ERHIFeatureLevel::Type InFeatureLevel, const ULevel* InLevel = nullptr);
 
public:
 
    // Needs InLevel to use precomputed data from 
    ENGINE_API FStreamingTextureLevelContext(EMaterialQualityLevel::Type InQualityLevel, const ULevel* InLevel = nullptr, const TMap<FGuid, int32>* InTextureGuidToLevelIndex = nullptr);
    ENGINE_API FStreamingTextureLevelContext(EMaterialQualityLevel::Type InQualityLevel, ERHIFeatureLevel::Type InFeatureLevel, bool InUseRelativeBoxes);
    ENGINE_API FStreamingTextureLevelContext(EMaterialQualityLevel::Type InQualityLevel, const UPrimitiveComponent* Primitive);
    ENGINE_API ~FStreamingTextureLevelContext();
 
    void SetForceNoUseBuiltData(bool bValue) { bForceNoUseBuiltData = bValue; }
    ENGINE_API void UpdateContext(EMaterialQualityLevel::Type InQualityLevel, const ULevel* InLevel, const TMap<FGuid, int32>* InTextureGuidToLevelIndex);
    ENGINE_API void BindBuildData(const TArray<FStreamingTextureBuildInfo>* PreBuiltData);
    ENGINE_API void ProcessMaterial(const FBoxSphereBounds& ComponentBounds, const FPrimitiveMaterialInfo& MaterialData, float ComponentScaling, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingTextures, bool bIsComponentBuildDataValid = false, const UPrimitiveComponent* DebugComponent = nullptr);
    ENGINE_API bool CanUseTextureStreamingBuiltData() const;
 
    EMaterialQualityLevel::Type GetQualityLevel() { return QualityLevel; }
    ERHIFeatureLevel::Type GetFeatureLevel() { return FeatureLevel; }
};
 
enum class ELODStreamingCallbackResult
{
    Success,
    TimedOut,
    AssetRemoved,
    ComponentRemoved,
    StreamingDisabled,
    NotImplemented
};
 
typedef TFunction<void(UPrimitiveComponent*, UStreamableRenderAsset*, ELODStreamingCallbackResult)> FLODStreamingCallback;
 
typedef TMap<UMaterialInterface*, TArray<FMaterialTextureInfo> > FTexCoordScaleMap;
 
typedef TMap<UMaterialInterface*, TArray<ULevel*> > FMaterialToLevelsMap;
 
#if WITH_EDITOR
ENGINE_API void BuildActorTextureStreamingData(AActor* InActor, EMaterialQualityLevel::Type InQualityLevel, ERHIFeatureLevel::Type InFeatureLevel);
 
ENGINE_API bool BuildLevelTextureStreamingComponentDataFromActors(ULevel* InLevel);
 
ENGINE_API bool GetTextureIsStreamable(const UTexture& Texture);
 
ENGINE_API bool GetTextureIsStreamableOnPlatform(const UTexture& Texture, const ITargetPlatform& TargetPlatform);
#endif
 
ENGINE_API bool BuildTextureStreamingComponentData(UWorld* InWorld, EMaterialQualityLevel::Type QualityLevel, ERHIFeatureLevel::Type FeatureLevel, bool bFullRebuild, FSlowTask& BuildTextureStreamingTask);
 
ENGINE_API void CheckTextureStreamingBuildValidity(UWorld* InWorld);
 
ENGINE_API uint32 PackRelativeBox(const FVector& RefOrigin, const FVector& RefExtent, const FVector& Origin, const FVector& Extent);
ENGINE_API uint32 PackRelativeBox(const FBox& RefBox, const FBox& Box);
ENGINE_API void UnpackRelativeBox(const FBoxSphereBounds& InRefBounds, uint32 InPackedRelBox, FBoxSphereBounds& OutBounds);
 
extern ENGINE_API TAutoConsoleVariable<int32> CVarStreamingUseNewMetrics;
extern ENGINE_API TAutoConsoleVariable<int32> CVarFramesForFullUpdate;
 
ENGINE_API void ResetAverageRequiredTexturePoolSize();
 
ENGINE_API int64 GetAverageRequiredTexturePoolSize();