TypedElementWorldInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Elements/Framework/TypedElementHandle.h"
 
#include "Elements/Interfaces/TypedElementSelectionInterface.h"
 
#include "CoreFwd.h"
#include "UObject/Interface.h"
#include "Templates/SharedPointer.h"
 
#include "TypedElementWorldInterface.generated.h"
 
class ULevel;
class UTypedElementSelectionSet; 
class UWorld;
struct FCollisionShape;
struct FCollisionQueryParams;
struct FConvexVolume;
struct FEngineShowFlags;
struct FWorldSelectionElementArgs;
 
UENUM()
enum class ETypedElementWorldType : uint8
{
    Game,
    Editor,
};
 
USTRUCT(BlueprintType)
struct FTypedElementDeletionOptions
{
    GENERATED_BODY()
 
public:
    FTypedElementDeletionOptions& SetVerifyDeletionCanHappen(const bool InVerifyDeletionCanHappen) { bVerifyDeletionCanHappen = InVerifyDeletionCanHappen; return *this; }
    bool VerifyDeletionCanHappen() const { return bVerifyDeletionCanHappen; }
 
    FTypedElementDeletionOptions& SetWarnAboutReferences(const bool InWarnAboutReferences) { bWarnAboutReferences = InWarnAboutReferences; return *this; }
    bool WarnAboutReferences() const { return bWarnAboutReferences; }
 
    FTypedElementDeletionOptions& SetWarnAboutSoftReferences(const bool InWarnAboutSoftReferences) { bWarnAboutSoftReferences = InWarnAboutSoftReferences; return *this; }
    bool WarnAboutSoftReferences() const { return bWarnAboutSoftReferences; }
    
private:
    UPROPERTY(BlueprintReadWrite, Category="TypedElementInterfaces|World|DeletionOptions", meta=(AllowPrivateAccess=true))
    bool bVerifyDeletionCanHappen = false;
 
    UPROPERTY(BlueprintReadWrite, Category="TypedElementInterfaces|World|DeletionOptions", meta=(AllowPrivateAccess=true))
    bool bWarnAboutReferences = true;
 
    UPROPERTY(BlueprintReadWrite, Category="TypedElementInterfaces|World|DeletionOptions", meta=(AllowPrivateAccess=true))
    bool bWarnAboutSoftReferences = true;
};
 
struct FWorldElementPasteImporter
{
    virtual ~FWorldElementPasteImporter() = default;
 
    struct FContext
    {
        FTypedElementListConstPtr CurrentSelection;
        UWorld* World;
        FStringView Text;
    };
    
    virtual void Import(FContext& Context) {}
    
    virtual TArray<FTypedElementHandle> GetImportedElements() { return {}; }
};
 
UINTERFACE(MinimalAPI, BlueprintType, meta = (CannotImplementInterfaceInBlueprint))
class UTypedElementWorldInterface : public UInterface
{
    GENERATED_BODY()
};
 
class ITypedElementWorldInterface
{
    GENERATED_BODY()
 
public:
    virtual bool IsTemplateElement(const FTypedElementHandle& InElementHandle) { return false; }
 
    virtual bool CanEditElement(const FTypedElementHandle& InElementHandle) { return true; }
 
    virtual ULevel* GetOwnerLevel(const FTypedElementHandle& InElementHandle) { return nullptr; }
 
    virtual UWorld* GetOwnerWorld(const FTypedElementHandle& InElementHandle) { return nullptr; }
 
    virtual bool GetBounds(const FTypedElementHandle& InElementHandle, FBoxSphereBounds& OutBounds) { return false; }
 
    virtual bool CanMoveElement(const FTypedElementHandle& InElementHandle, const ETypedElementWorldType InWorldType) { return false; }
 
    virtual bool CanScaleElement(const FTypedElementHandle& InElementHandle) { return true; }
 
    virtual bool GetWorldTransform(const FTypedElementHandle& InElementHandle, FTransform& OutTransform) { return false; }
    
    virtual bool SetWorldTransform(const FTypedElementHandle& InElementHandle, const FTransform& InTransform) { return false; }
 
    virtual bool GetRelativeTransform(const FTypedElementHandle& InElementHandle, FTransform& OutTransform) { return GetWorldTransform(InElementHandle, OutTransform); }
    
    virtual bool SetRelativeTransform(const FTypedElementHandle& InElementHandle, const FTransform& InTransform) { return SetWorldTransform(InElementHandle, InTransform); }
 
    virtual bool GetPivotOffset(const FTypedElementHandle& InElementHandle, FVector& OutPivotOffset) { return false; }
 
    virtual bool SetPivotOffset(const FTypedElementHandle& InElementHandle, const FVector& InPivotOffset) { return false; }
 
    virtual void NotifyMovementStarted(const FTypedElementHandle& InElementHandle) {}
 
    virtual void NotifyMovementOngoing(const FTypedElementHandle& InElementHandle) {}
 
    virtual void NotifyMovementEnded(const FTypedElementHandle& InElementHandle) {}
 
    virtual bool FindSuitableTransformAtPoint(const FTypedElementHandle& InElementHandle, const FTransform& InPotentialTransform, FTransform& OutSuitableTransform)
    {
        OutSuitableTransform = InPotentialTransform;
        return true;
    }
 
    virtual bool FindSuitableTransformAlongPath(const FTypedElementHandle& InElementHandle, const FVector& InPathStart, const FVector& InPathEnd, const FCollisionShape& InTestShape, TArrayView<const FTypedElementHandle> InElementsToIgnore, FTransform& OutSuitableTransform)
    {
        return false;
    }
 
    virtual bool AddIgnoredElementToCollisionQueryParams(const FTypedElementHandle& InElementHandle,
        FCollisionQueryParams& InOutParams, bool bAlsoIgnoreSubElements = true)
    {
        return false;
    }
 
    virtual bool CanDeleteElement(const FTypedElementHandle& InElementHandle) { return false; }
 
    virtual bool DeleteElement(const FTypedElementHandle& InElementHandle, UWorld* InWorld, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& InDeletionOptions)
    {
        return DeleteElements(MakeArrayView(&InElementHandle, 1), InWorld, InSelectionSet, InDeletionOptions);
    }
 
    virtual bool DeleteElements(TArrayView<const FTypedElementHandle> InElementHandles, UWorld* InWorld, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& InDeletionOptions) { return false; }
 
    virtual bool CanDuplicateElement(const FTypedElementHandle& InElementHandle) { return false; }
 
    virtual FTypedElementHandle DuplicateElement(const FTypedElementHandle& InElementHandle, UWorld* InWorld, const FVector& InLocationOffset)
    {
        TArray<FTypedElementHandle> NewElements;
        DuplicateElements(MakeArrayView(&InElementHandle, 1), InWorld, InLocationOffset, NewElements);
        return NewElements.Num() > 0 ? MoveTemp(NewElements[0]) : FTypedElementHandle();
    }
 
    virtual void DuplicateElements(TArrayView<const FTypedElementHandle> InElementHandles, UWorld* InWorld, const FVector& InLocationOffset, TArray<FTypedElementHandle>& OutNewElements)
    {
    }
 
    virtual bool CanCopyElement(const FTypedElementHandle& InElementHandle) { return false; }
 
    virtual void CopyElement(const FTypedElementHandle& InElementHandle, FOutputDevice& Out)
    {
        CopyElements(MakeArrayView(&InElementHandle, 1), Out);
    }
 
    virtual void CopyElements(TArrayView<const FTypedElementHandle> InElementHandles, FOutputDevice& Out)
    {
    }
    
    virtual TSharedPtr<FWorldElementPasteImporter> GetPasteImporter()
    {
        return {};
    }
 
    virtual bool CanPromoteElement(const FTypedElementHandle& InElementHandle)
    {
        return false;
    }
 
    virtual FTypedElementHandle PromoteElement(const FTypedElementHandle& InElementHandle, UWorld* OverrideWorld = nullptr)
    {
        return FTypedElementHandle();
    }
 
    ENGINE_API virtual bool IsElementInConvexVolume(const FTypedElementHandle& Handle, const FConvexVolume& InVolume, bool bMustEncompassEntireElement = false);
 
    ENGINE_API virtual bool IsElementInBox(const FTypedElementHandle& Handle, const FBox& InBox, bool bMustEncompassEntireElement = false);
 
    ENGINE_API TArray<FTypedElementHandle> GetSelectionElementsInConvexVolume(const FTypedElementHandle& Handle, const FConvexVolume& InVolume, const FWorldSelectionElementArgs& SelectionArgs);
 
    ENGINE_API TArray<FTypedElementHandle> GetSelectionElementsInBox(const FTypedElementHandle& Handle, const FBox& InBox, const FWorldSelectionElementArgs& SelectionArgs);
 
    ENGINE_API virtual TArray<FTypedElementHandle> GetSelectionElementsFromSelectionFunction(
        const FTypedElementHandle& Handle,
        const FWorldSelectionElementArgs& SelectionArgs,
        const TFunction<bool(const FTypedElementHandle& /*ElementHandle*/, const FWorldSelectionElementArgs& /*SelectionArgs*/)>& SelectionFunction
        );
 
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool IsTemplateElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanEditElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual ULevel* GetOwnerLevel(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual UWorld* GetOwnerWorld(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool GetBounds(const FScriptTypedElementHandle& InElementHandle, FBoxSphereBounds& OutBounds);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanMoveElement(const FScriptTypedElementHandle& InElementHandle, const ETypedElementWorldType InWorldType);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanScaleElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool GetWorldTransform(const FScriptTypedElementHandle& InElementHandle, FTransform& OutTransform);
    
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool SetWorldTransform(const FScriptTypedElementHandle& InElementHandle, const FTransform& InTransform);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool GetRelativeTransform(const FScriptTypedElementHandle& InElementHandle, FTransform& OutTransform);
    
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool SetRelativeTransform(const FScriptTypedElementHandle& InElementHandle, const FTransform& InTransform);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool GetPivotOffset(const FScriptTypedElementHandle& InElementHandle, FVector& OutPivotOffset);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool SetPivotOffset(const FScriptTypedElementHandle& InElementHandle, const FVector& InPivotOffset);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual void NotifyMovementStarted(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual void NotifyMovementOngoing(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual void NotifyMovementEnded(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanDeleteElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool DeleteElement(const FScriptTypedElementHandle& InElementHandle, UWorld* InWorld, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& InDeletionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanDuplicateElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual FScriptTypedElementHandle DuplicateElement(const FScriptTypedElementHandle& InElementHandle, UWorld* InWorld, const FVector& InLocationOffset);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual bool CanPromoteElement(const FScriptTypedElementHandle& InElementHandle);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementInterfaces|World")
    ENGINE_API virtual FScriptTypedElementHandle PromoteElement(const FScriptTypedElementHandle& InElementHandle, UWorld* OverrideWorld = nullptr);
 
protected:
    ENGINE_API virtual class UTypedElementRegistry& GetRegistry() const;
};
 
template <>
struct TTypedElement<ITypedElementWorldInterface> : public TTypedElementBase<ITypedElementWorldInterface>
{
    bool IsTemplateElement() const { return InterfacePtr->IsTemplateElement(*this); }
    bool CanEditElement() const { return InterfacePtr->CanEditElement(*this); }
    ULevel* GetOwnerLevel() const { return InterfacePtr->GetOwnerLevel(*this); }
    UWorld* GetOwnerWorld() const { return InterfacePtr->GetOwnerWorld(*this); }
    bool GetBounds(FBoxSphereBounds& OutBounds) const { return InterfacePtr->GetBounds(*this, OutBounds); }
    bool CanMoveElement(const ETypedElementWorldType InWorldType) const { return InterfacePtr->CanMoveElement(*this, InWorldType); }
    bool CanScaleElement() const { return InterfacePtr->CanScaleElement(*this); }
    bool GetWorldTransform(FTransform& OutTransform) const { return InterfacePtr->GetWorldTransform(*this, OutTransform); }
    bool SetWorldTransform(const FTransform& InTransform) const { return InterfacePtr->SetWorldTransform(*this, InTransform); }
    bool GetRelativeTransform(FTransform& OutTransform) const { return InterfacePtr->GetRelativeTransform(*this, OutTransform); }
    bool SetRelativeTransform(const FTransform& InTransform) const { return InterfacePtr->SetRelativeTransform(*this, InTransform); }
    bool GetPivotOffset(FVector& OutPivotOffset) const { return InterfacePtr->GetPivotOffset(*this, OutPivotOffset); }
    bool SetPivotOffset(const FVector& InPivotOffset) const { return InterfacePtr->SetPivotOffset(*this, InPivotOffset); }
    void NotifyMovementStarted() const { InterfacePtr->NotifyMovementStarted(*this); }
    void NotifyMovementOngoing() const { InterfacePtr->NotifyMovementOngoing(*this); }
    void NotifyMovementEnded() const { InterfacePtr->NotifyMovementEnded(*this); }
    bool FindSuitableTransformAtPoint(const FTransform& InPotentialTransform, FTransform& OutSuitableTransform) const { return InterfacePtr->FindSuitableTransformAtPoint(*this, InPotentialTransform, OutSuitableTransform); }
    bool FindSuitableTransformAlongPath(const FVector& InPathStart, const FVector& InPathEnd, const FCollisionShape& InTestShape, TArrayView<const FTypedElementHandle> InElementsToIgnore, FTransform& OutSuitableTransform) const { return InterfacePtr->FindSuitableTransformAlongPath(*this, InPathStart, InPathEnd, InTestShape, InElementsToIgnore, OutSuitableTransform); }
    bool AddIgnoredElementToCollisionQueryParams(const FTypedElementHandle& InElementHandle, FCollisionQueryParams& InOutParams, bool bAlsoIgnoreSubElements = true) const { return InterfacePtr->AddIgnoredElementToCollisionQueryParams(InElementHandle, InOutParams, bAlsoIgnoreSubElements); }
    bool CanDeleteElement() const { return InterfacePtr->CanDeleteElement(*this); }
    bool DeleteElement(UWorld* InWorld, UTypedElementSelectionSet* InSelectionSet, const FTypedElementDeletionOptions& InDeletionOptions) const { return InterfacePtr->DeleteElement(*this, InWorld, InSelectionSet, InDeletionOptions); }
    bool CanDuplicateElement() const { return InterfacePtr->CanDuplicateElement(*this); }
    FTypedElementHandle DuplicateElement(UWorld* InWorld, const FVector& InLocationOffset) const { return InterfacePtr->DuplicateElement(*this, InWorld, InLocationOffset); }
    bool CanCopyElement() const { return InterfacePtr->CanCopyElement(*this); }
    void CopyElement(FOutputDevice& Out) const { InterfacePtr->CopyElement(*this, Out); }
    bool CanPromoteElement() const { return InterfacePtr->CanPromoteElement(*this); }
    FTypedElementHandle PromoteElement(UWorld* OverrideWorld = nullptr) const { return InterfacePtr->PromoteElement(*this, OverrideWorld); }
    bool IsElementInConvexVolume(const FConvexVolume& InVolume, bool bMustEncompassEntireElement = false) const { return InterfacePtr->IsElementInConvexVolume(*this, InVolume, bMustEncompassEntireElement); }
    bool IsElementInBox(const FBox& InBox, bool bMustEncompassEntireElement = false) const { return InterfacePtr->IsElementInBox(*this, InBox, bMustEncompassEntireElement); }
    TArray<FTypedElementHandle> GetSelectionElementsInConvexVolume(const FConvexVolume& InVolume, const FWorldSelectionElementArgs& SelectionArgs) const { return InterfacePtr->GetSelectionElementsInConvexVolume(*this, InVolume, SelectionArgs); }
    TArray<FTypedElementHandle> GetSelectionElementsInBox(const FBox& InBox, const FWorldSelectionElementArgs& SelectionArgs) const { return InterfacePtr->GetSelectionElementsInBox(*this, InBox, SelectionArgs); }
    TArray<FTypedElementHandle> GetSelectionElementsFromSelectionFunction(const FWorldSelectionElementArgs& SelectionArgs, const TFunction<bool(const FTypedElementHandle&, const FWorldSelectionElementArgs&)>& SelectionFunction) const
    {
        return InterfacePtr->GetSelectionElementsFromSelectionFunction(*this, SelectionArgs, SelectionFunction);
    }
};
 
struct FWorldSelectionElementArgs
{
    // Optional selection set to use to get the selectable elements only
    const UTypedElementSelectionSet* SelectionSet;
 
    ETypedElementSelectionMethod SelectionMethod = ETypedElementSelectionMethod::Primary;
 
    FTypedElementSelectionOptions SelectionOptions;
 
    // Optional show flag to avoid selecting non rendered elements
    FEngineShowFlags* ShowFlags;
 
    bool bMustEncompassEntireElement = false;
 
    // To deprecate once the BSP tools are removed from the engine
    bool bBSPSelectionOnly = false;
};