HLODBuilder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Algo/Transform.h"
#include "Templates/SubclassOf.h"
 
#include "HLODBuilder.generated.h"
 
class AActor;
class FHLODHashBuilder;
class UActorComponent;
class UHLODInstancedStaticMeshComponent;
class UHLODInstancedSkinnedMeshComponent;
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogHLODBuilder, Log, All);
 
UCLASS(MinimalAPI, DefaultToInstanced)
class UHLODBuilderSettings : public UObject
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITOR
public:
    virtual void ComputeHLODHash(FHLODHashBuilder& InHashBuilder) const {}
 
    virtual bool IsReusingSourceMaterials() const { return false; }
 
    UE_DEPRECATED(5.7, "GetCRC() has been replaced by ComputeHLODHash()")
    virtual uint32 GetCRC() const final { return 0; }
#endif // WITH_EDITOR
};
 
 
struct FHLODBuildContext
{
    UWorld* World;
 
    TArray<UActorComponent*> SourceComponents;
 
    UObject* AssetsOuter;
 
    FString AssetsBaseName;
 
    // Location of this HLOD actor in the world
    FVector WorldPosition;
 
    double MinVisibleDistance;
};
 
USTRUCT()
struct FHLODBuildInputReferencedAssets
{
    GENERATED_BODY()
 
    UPROPERTY()
    TMap<FTopLevelAssetPath, uint32> StaticMeshes;
};
 
USTRUCT()
struct FHLODBuildInputStats
{
    GENERATED_BODY()
 
    UPROPERTY()
    TMap<FName, FHLODBuildInputReferencedAssets> BuildersReferencedAssets;
};
 
struct FHLODBuildResult
{
    FHLODBuildInputStats        InputStats;
    TArray<UActorComponent*>    HLODComponents;
};
 
UCLASS(Abstract, Config = Editor, MinimalAPI)
class UHLODBuilder : public UObject
{
     GENERATED_UCLASS_BODY()
 
#if WITH_EDITOR
public:
    ENGINE_API void SetHLODBuilderSettings(const UHLODBuilderSettings* InHLODBuilderSettings);
 
    ENGINE_API FHLODBuildResult Build(const FHLODBuildContext& InHLODBuildContext) const;
 
    UE_DEPRECATED(5.2, "Use Build() method that takes a single FHLODBuildContext parameter.")
    TArray<UActorComponent*> Build(const FHLODBuildContext& InHLODBuildContext, const TArray<AActor*>& InSourceActors) const { return Build(InHLODBuildContext).HLODComponents; }
 
    ENGINE_API virtual TSubclassOf<UHLODBuilderSettings> GetSettingsClass() const;
 
    ENGINE_API virtual bool RequiresWarmup() const;
 
    ENGINE_API virtual bool ComputeHLODHash(class FHLODHashBuilder& InHashBuilder, const UActorComponent* InSourceComponent) const;
 
    virtual TArray<UActorComponent*> Build(const FHLODBuildContext& InHLODBuildContext, const TArray<UActorComponent*>& InSourceComponents) const PURE_VIRTUAL(UHLODBuilder::Build, return {};);
 
    static ENGINE_API void ComputeHLODHash(class FHLODHashBuilder& HashBuilder, const TArray<UActorComponent*>& InSourceComponents);
 
    static ENGINE_API TSubclassOf<UHLODInstancedStaticMeshComponent> GetInstancedStaticMeshComponentClass();
 
    static ENGINE_API TSubclassOf<UHLODInstancedSkinnedMeshComponent> GetInstancedSkinnedMeshComponentClass();
 
protected:
    virtual bool ShouldIgnoreBatchingPolicy() const { return false; }
 
    static ENGINE_API TArray<UActorComponent*> BatchInstances(const TArray<UActorComponent*>& InSourceComponents);
    static ENGINE_API TArray<UActorComponent*> BatchInstances(const TArray<UActorComponent*>& InSourceComponents, TFunctionRef<bool(const FBox&)> InFilterFunc);
 
    template <typename TComponentClass>
    static inline TArray<TComponentClass*> FilterComponents(const TArray<UActorComponent*>& InSourceComponents)
    {
        TArray<TComponentClass*> FilteredComponents;
        FilteredComponents.Reserve(InSourceComponents.Num());
        Algo::TransformIf(InSourceComponents, FilteredComponents, [](UActorComponent* SourceComponent) { return Cast<TComponentClass>(SourceComponent); }, [](UActorComponent* SourceComponent) { return Cast<TComponentClass>(SourceComponent); });
        if (InSourceComponents.Num() != FilteredComponents.Num())
        {
            UE_LOG(LogHLODBuilder, Warning, TEXT("Excluding %d components from the HLOD build."), InSourceComponents.Num() - FilteredComponents.Num());
        }
        return FilteredComponents;
    }
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
protected:
    UPROPERTY()
    TObjectPtr<const UHLODBuilderSettings> HLODBuilderSettings;
 
private:
    UPROPERTY(Config)
    TSubclassOf<UHLODInstancedStaticMeshComponent> HLODInstancedStaticMeshComponentClass;
 
    UPROPERTY(Config)
    TSubclassOf<UHLODInstancedSkinnedMeshComponent> HLODInstancedSkinnedMeshComponentClass;
#endif
};
 
 
UCLASS(HideDropdown, MinimalAPI)
class UNullHLODBuilder : public UHLODBuilder
{
    GENERATED_UCLASS_BODY()
 
#if WITH_EDITOR
    virtual bool RequiresWarmup() const { return false; }
    virtual bool ComputeHLODHash(FHLODHashBuilder& HashBuilder, const UActorComponent* InSourceComponent) const { return false; }
    virtual TArray<UActorComponent*> Build(const FHLODBuildContext& InHLODBuildContext, const TArray<UActorComponent*>& InSourceComponents) const { return {}; }
#endif
};