LODActor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "HAL/IConsoleManager.h"
#include "Engine/MaterialMerging.h"
#include "GameFramework/Actor.h"
#include "Components/StaticMeshComponent.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "LODActor.generated.h"
 
class UStaticMesh;
class UHLODProxy;
class UHLODProxyDesc;
 
extern ENGINE_API TAutoConsoleVariable<FString> CVarHLODDistanceOverride;
 
USTRUCT()
struct FHLODInstancingKey
{
    GENERATED_BODY()
 
    UPROPERTY()
    TObjectPtr<const UStaticMesh> StaticMesh;
 
    UPROPERTY()
    TObjectPtr<const UMaterialInterface> Material;
 
    FHLODInstancingKey()
        : StaticMesh()
        , Material()
    {}
 
    FHLODInstancingKey(const UStaticMesh* InStaticMesh, const UMaterialInterface* InMaterial)
        : StaticMesh(InStaticMesh)
        , Material(InMaterial)
    {}
 
    bool operator==(const FHLODInstancingKey& Other) const
    {
        return StaticMesh == Other.StaticMesh && Material == Other.Material;
    }
 
    bool IsValid() const
    {
        return StaticMesh != nullptr && Material != nullptr;
    }
 
    friend uint32 GetTypeHash(const FHLODInstancingKey& Key)
    {
        return HashCombine(GetTypeHash(Key.StaticMesh), GetTypeHash(Key.Material));
    }
};
 
UCLASS(notplaceable, hidecategories = (Object, Collision, Display, Input, Blueprint, Transform, Physics), MinimalAPI)
class ALODActor : public AActor
{
    GENERATED_UCLASS_BODY()
 
    friend class UHLODProxy;
    friend class UHLODProxyDesc;
 
private:
    // disable display of this component
    UPROPERTY(Category=LODActor, VisibleAnywhere)
    TObjectPtr<UStaticMeshComponent> StaticMeshComponent;
 
    UPROPERTY(Transient)
    TMap<FHLODInstancingKey, TObjectPtr<UInstancedStaticMeshComponent>> InstancedStaticMeshComponents;
 
    UPROPERTY(Category=LODActor, VisibleAnywhere)
    TObjectPtr<UHLODProxy> Proxy;
 
    UPROPERTY(Category=LODActor, VisibleAnywhere)
    FName Key;
 
    UPROPERTY(Category = LODActor, VisibleAnywhere)
    float LODDrawDistance;
 
public:
    UPROPERTY(Category=LODActor, VisibleAnywhere)
    int32 LODLevel;
 
    UPROPERTY(Category=LODActor, VisibleAnywhere)
    TArray<TObjectPtr<AActor>> SubActors;
    
    UPROPERTY()
    uint8 CachedNumHLODLevels;
 
    //~ Begin AActor Interface
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors() override;
    ENGINE_API virtual void EditorApplyTranslation(const FVector& DeltaTranslation, bool bAltDown, bool bShiftDown, bool bCtrlDown) override;
    ENGINE_API virtual void EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown) override;
    ENGINE_API virtual void EditorApplyScale(const FVector& DeltaScale, const FVector* PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown) override;
    ENGINE_API virtual void EditorApplyMirror(const FVector& MirrorScale, const FVector& PivotLocation) override;
#endif // WITH_EDITOR   
    ENGINE_API virtual FBox GetComponentsBoundingBox(bool bNonColliding = false, bool bIncludeFromChildActors = false) const override;
    ENGINE_API virtual void PostRegisterAllComponents() override;
    ENGINE_API virtual void Tick(float DeltaSeconds) override;  
    virtual bool IsLevelBoundsRelevant() const override { return false; }
    //~ End AActor Interface
 
    ENGINE_API void PauseDitherTransition();
    ENGINE_API void StartDitherTransition();
 
    ENGINE_API void SetStaticMesh(UStaticMesh* InStaticMesh);
 
    ENGINE_API void AddInstances(const UStaticMesh* InStaticMesh, const UMaterialInterface* InMaterial, const TArray<FTransform>& InTransforms);
    ENGINE_API void AddInstances(const UStaticMesh* InStaticMesh, const UMaterialInterface* InMaterial, const TArray<FTransform>& InTransforms, const TArray<FCustomPrimitiveData>& InCustomPrimitiveData);
 
    ENGINE_API void ClearInstances();
 
    ENGINE_API void SetDrawDistance(float InDistance);
 
    float GetDrawDistance() const { return LODDrawDistance; }
    float GetLODDrawDistance() const { return LODDrawDistance; }
    ENGINE_API float GetLODDrawDistanceWithOverride() const;
 
    ENGINE_API void SetLODParent(UPrimitiveComponent* InLODParent, float InParentDrawDistance, bool bInApplyToImposters);
 
#if WITH_EDITORONLY_DATA
    void SetLODActorTag(const FString& InLODActorTag) { LODActorTag = InLODActorTag; }
 
    const FString& GetLODActorTag() const { return LODActorTag; }
#endif // WITH_EDITORONLY_DATA
 
    const FName& GetKey() const { return Key; }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) || WITH_EDITOR
    ENGINE_API const bool IsBuilt(bool bInForce = false) const;
#endif
 
    ENGINE_API const bool HasValidLODChildren() const;
 
#if WITH_EDITOR
    ENGINE_API void ForceUnbuilt();
 
    ENGINE_API void AddSubActor(AActor* InActor);
 
    ENGINE_API void AddSubActors(const TArray<AActor*>& InActors);
 
    ENGINE_API const bool RemoveSubActor(AActor* InActor);
 
    ENGINE_API const bool HasValidSubActors() const;
 
    ENGINE_API const bool HasAnySubActors() const;
 
    ENGINE_API void ToggleForceView();
 
    ENGINE_API void SetForcedView(const bool InState);
 
    ENGINE_API void SetHiddenFromEditorView(const bool InState, const int32 ForceLODLevel);
 
    ENGINE_API const uint32 GetNumTrianglesInSubActors();
 
    ENGINE_API const uint32 GetNumTrianglesInMergedMesh();
    
    ENGINE_API void UpdateSubActorLODParents();
 
    // This will determine the shadowing flags for the static mesh component according to all sub actors
    ENGINE_API void DetermineShadowingFlags();
 
    ENGINE_API void CleanSubActorArray();
 
    ENGINE_API void RecalculateDrawingDistance(const float TransitionScreenSize);
 
    UHLODProxy* GetProxy() const { return Proxy; }
 
    const UHLODProxyDesc* GetProxyDesc() const { return ProxyDesc; }
 
    ENGINE_API bool UpdateProxyDesc();
 
    bool WasBuiltFromHLODDesc() const { return bBuiltFromHLODDesc; }
#endif // WITH_EDITOR
 
    //~ Begin UObject Interface.
    ENGINE_API virtual FString GetDetailedInfoInternal() const override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITOR
    ENGINE_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
    ENGINE_API virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
#endif // WITH_EDITOR   
 
    
 
    //~ End UObject Interface.  
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint32 NumTrianglesInSubActors;
 
    UPROPERTY()
    uint32 NumTrianglesInMergedMesh;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings)
    bool bOverrideMaterialMergeSettings;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings, meta = (editcondition = "bOverrideMaterialMergeSettings"))
    FMaterialProxySettings MaterialSettings;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings)
    bool bOverrideTransitionScreenSize;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings, meta = (editcondition = "bOverrideTransitionScreenSize"))
    float TransitionScreenSize;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings)
    bool bOverrideScreenSize;
 
    UPROPERTY(EditAnywhere, Category = HierarchicalLODSettings, meta = (editcondition = "bOverrideScreenSize"))
    int32 ScreenSize;
#endif // WITH_EDITORONLY_DATA
 
    UStaticMeshComponent* GetStaticMeshComponent() const { return StaticMeshComponent; }
 
    TArray<UInstancedStaticMeshComponent*> GetInstancedStaticMeshComponents() const { TArray<typename TDecay<decltype(InstancedStaticMeshComponents[FHLODInstancingKey()])>::Type> ISM; InstancedStaticMeshComponents.GenerateValueArray(ISM); return ISM; }
 
    static ENGINE_API const TArray<float>& GetHLODDistanceOverride();
 
private:
    // Called when CVars are changed to check to see if the maximum HLOD level value has changed
    static ENGINE_API void OnCVarsChanged();
    static ENGINE_API void ParseOverrideDistancesCVar();    
    static ENGINE_API TArray<float> HLODDistances;
 
    // Updates the transition distance according to values (if) set in r.HLOD.DistanceOverride
    ENGINE_API void UpdateOverrideTransitionDistance();
 
    // Called to make sure autoregistration/manual registration state matches based on the LOD override cvar and this actor's lod level
    ENGINE_API void UpdateRegistrationToMatchMaximumLODLevel();
 
    // Setup a LOD static mesh component.
    ENGINE_API void SetupComponent(UStaticMeshComponent* InComponent);
 
    // Utility methods to act on all static mesh components owned by this actor.
    ENGINE_API void SetComponentsMinDrawDistance(float InMinDrawDistance, bool bInMarkRenderStateDirty);
    ENGINE_API void RegisterMeshComponents();
    ENGINE_API void UnregisterMeshComponents();
 
    UFUNCTION()
    ENGINE_API void OnSubActorEndPlay(AActor* Actor, EEndPlayReason::Type Reason);
 
#if WITH_EDITOR
    // Get/Create the LOD instanced static mesh component for a given imposter material.
    ENGINE_API UInstancedStaticMeshComponent* GetISMComponent(const FHLODInstancingKey& InstancingKey) const;
    ENGINE_API UInstancedStaticMeshComponent* GetOrCreateISMComponent(const FHLODInstancingKey& InstancingKey);
 
    // Get/Create the LOD static mesh component to use for a given actor.
    ENGINE_API UStaticMeshComponent* GetLODComponentForActor(const AActor* InActor, bool bFallbackToDefault = true) const;
    ENGINE_API UStaticMeshComponent* GetOrCreateLODComponentForActor(const AActor* InActor);
 
public:
    static ENGINE_API bool ShouldUseInstancing(const UStaticMeshComponent* InComponent);
#endif
 
private:
    // Have we already tried to register components? (a cache to avoid having to query the owning world when the global HLOD max level setting is changed)
    uint8 bHasActorTriedToRegisterComponents : 1;
 
    // Flag whether or not the SubActors have been moved to a Parent LODActor
    uint8 bHasPatchedUpParent : 1;
 
    uint8 bRequiresLODScreenSizeConversion : 1;
 
    uint8 bNeedsDrawDistanceReset : 1;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) || WITH_EDITOR
    mutable uint8 bCachedIsBuilt : 1;
 
    mutable double LastIsBuiltTime;
#endif
 
    float ResetDrawDistanceTime;    
 
    // Sink for when CVars are changed to check to see if the maximum HLOD level value has changed
    static ENGINE_API FAutoConsoleVariableSink CVarSink;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FString LODActorTag;
 
    UPROPERTY()
    uint8 bBuiltFromHLODDesc : 1;
 
    UPROPERTY(Transient)
    TObjectPtr<UHLODProxyDesc> ProxyDesc;
#endif // WITH_EDITORONLY_DATA
};