SceneCaptureComponent.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 "Components/SceneComponent.h"
#include "SceneTypes.h"
#include "SceneView.h"
#include "ShowFlags.h"
#include "Engine/GameViewportClient.h"
#include "SceneCaptureComponent.generated.h"
 
class AActor;
class FSceneViewStateInterface;
class UMaterialParameterCollection;
class UPrimitiveComponent;
 
struct FSceneCaptureViewInfo : public FSceneViewProjectionData
{
    FVector ViewLocation;
    FRotator ViewRotation;
    EStereoscopicPass StereoPass;
    int32 StereoViewIndex;
    float FOV;
};
 
#if WITH_EDITORONLY_DATA
struct FSceneCaptureMemorySize : public FThreadSafeRefCountedObject
{
    uint64 Size = 0;
};
#endif
 
USTRUCT(BlueprintType)
struct FEngineShowFlagsSetting
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture)
    FString ShowFlagName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture)
    bool Enabled = false;
 
 
    bool operator == (const FEngineShowFlagsSetting& Other) const
    {
        return ShowFlagName == Other.ShowFlagName && Other.Enabled == Enabled;
    }
};
 
UENUM()
enum class ESceneCapturePrimitiveRenderMode : uint8
{
    PRM_LegacySceneCapture UMETA(DisplayName = "Render Scene Primitives (Legacy)"),
    PRM_RenderScenePrimitives UMETA(DisplayName = "Render Scene Primitives"),
    PRM_UseShowOnlyList UMETA(DisplayName = "Use ShowOnly List")
};
 
    // -> will be exported to EngineDecalClasses.h
UCLASS(abstract, hidecategories=(Collision, Object, Physics, SceneComponent, Mobility), MinimalAPI)
class USceneCaptureComponent : public USceneComponent
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture)
    ESceneCapturePrimitiveRenderMode PrimitiveRenderMode;
 
    UPROPERTY(interp, Category = SceneCapture, meta = (DisplayName = "Capture Source"))
    TEnumAsByte<enum ESceneCaptureSource> CaptureSource;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture)
    uint8 bCaptureEveryFrame : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture)
    uint8 bCaptureOnMovement : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, DuplicateTransient, SkipSerialization, NonTransactional, AdvancedDisplay, Category = SceneCapture)
    uint8 bCaptureGpuNextRender : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, DuplicateTransient, SkipSerialization, NonTransactional, AdvancedDisplay, Category = SceneCapture)
    uint8 bDumpGpuNextRender : 1;
 
    uint8 bSuppressGpuCaptureOrDump : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = SceneCapture)
    uint8 bExcludeFromSceneTextureExtents : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture, meta = (editcondition = "!bCaptureEveryFrame"))
    bool bAlwaysPersistRenderingState;
 
    UPROPERTY()
    TArray<TWeakObjectPtr<UPrimitiveComponent> > HiddenComponents;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=SceneCapture)
    TArray<TObjectPtr<AActor>> HiddenActors;
 
    UPROPERTY()
    TArray<TWeakObjectPtr<UPrimitiveComponent> > ShowOnlyComponents;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=SceneCapture)
    TArray<TObjectPtr<AActor>> ShowOnlyActors;
 
    UPROPERTY(EditAnywhere, Category=PlanarReflection, meta=(UIMin = ".1", UIMax = "10"), AdvancedDisplay)
    float LODDistanceFactor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture, meta=(UIMin = "100", UIMax = "10000"))
    float MaxViewDistanceOverride;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=SceneCapture)
    int32 CaptureSortPriority;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SceneCapture)
    bool bUseRayTracingIfEnabled;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture, AdvancedDisplay)
    TObjectPtr<UMaterialParameterCollection> CollectionTransform;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture, AdvancedDisplay)
    FName CollectionTransformWorldToLocal;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture, AdvancedDisplay)
    FName CollectionTransformProjection;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SceneCapture)
    FViewLightingChannels ViewLightingChannels;
 
    UE_DEPRECATED_FORGAME(5.5, "Public access to this property is deprecated, and it will become private in a future release. Please use SetShowFlagSettings and GetShowFlagSettings instead.")
    UPROPERTY(EditAnywhere, interp, Blueprintgetter = GetShowFlagSettings, BlueprintSetter = SetShowFlagSettings, Category=SceneCapture)
    TArray<FEngineShowFlagsSetting> ShowFlagSettings;
 
    // TODO: Make this a UStruct to set directly?
    FEngineShowFlags ShowFlags;
 
    UFUNCTION(BlueprintGetter)
    ENGINE_API const TArray<FEngineShowFlagsSetting>& GetShowFlagSettings() const;
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void SetShowFlagSettings(const TArray<FEngineShowFlagsSetting>& InShowFlagSettings);
 
public:
    UPROPERTY(EditAnywhere, interp, Category = SceneCapture)
    FString ProfilingEventName;
 
    ENGINE_API virtual void BeginDestroy() override;
 
    //~ Begin UActorComponent Interface
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;
    ENGINE_API virtual void OnRegister() override;
    //~ End UActorComponent Interface
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void HideComponent(UPrimitiveComponent* InComponent);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void HideActorComponents(AActor* InActor, const bool bIncludeFromChildActors = false);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void ShowOnlyComponent(UPrimitiveComponent* InComponent);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void ShowOnlyActorComponents(AActor* InActor, const bool bIncludeFromChildActors = false);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void RemoveShowOnlyComponent(UPrimitiveComponent* InComponent);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void RemoveShowOnlyActorComponents(AActor* InActor, const bool bIncludeFromChildActors = false);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void ClearShowOnlyComponents();
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void ClearHiddenComponents();
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|SceneCapture")
    ENGINE_API void SetCaptureSortPriority(int32 NewCaptureSortPriority);
 
    ENGINE_API FSceneViewStateInterface* GetViewState(int32 ViewIndex);
 
#if WITH_EDITOR
    ENGINE_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    ENGINE_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
#endif  
 
    ENGINE_API virtual void Serialize(FArchive& Ar);
 
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void PostLoad() override;
 
    virtual const AActor* GetViewOwner() const { return nullptr; }
 
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    static ENGINE_API void UpdateDeferredCaptures(FSceneInterface* Scene);
 
    virtual bool Is2D() const { return false; }
 
    virtual bool IsCube() const { return false; }
 
    UE_DEPRECATED(5.6, "SetFrameUpdated is no longer used")
    bool SetFrameUpdated() { return false; }
 
    UE_DEPRECATED(5.6, "UpdateSceneCaptureContents now requires a SceneRenderBuilder")
    virtual void UpdateSceneCaptureContents(FSceneInterface* Scene) {};
 
    virtual void UpdateSceneCaptureContents(FSceneInterface* Scene, class ISceneRenderBuilder& SceneRenderBuilder) {};
 
    bool IsUnlit() const
    {
        return CaptureSource == SCS_SceneDepth || CaptureSource == SCS_DeviceDepth || CaptureSource == SCS_Normal || CaptureSource == SCS_BaseColor ||
            (ShowFlags.Lighting == false && (CaptureSource == SCS_SceneColorHDR || CaptureSource == SCS_SceneColorHDRNoAlpha || CaptureSource == SCS_SceneColorSceneDepth));
    }
 
protected:
    ENGINE_API void UpdateShowFlags();
 
    ENGINE_API void RegisterDelegates();
    ENGINE_API void UnregisterDelegates();
    ENGINE_API void ReleaseGarbageReferences();
 
    ENGINE_API bool IsCulledByDetailMode() const;
 
    TIndirectArray<FSceneViewStateReference> ViewStates;
 
#if WITH_EDITORONLY_DATA
    TObjectPtr<class UStaticMeshComponent> ProxyMeshComponent;
    
    FSoftObjectPath CaptureMeshPath;
 
public:
    TRefCountPtr<FSceneCaptureMemorySize> CaptureMemorySize;
#endif
};