StateTargets.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "BaseGizmos/GizmoInterfaces.h"
#include "Changes/TransformChange.h"
#include "Components/SceneComponent.h"
#include "Containers/Array.h"
#include "CoreMinimal.h"
#include "InteractiveGizmoManager.h"
#include "InteractiveToolChange.h"
#include "InteractiveToolManager.h"
#include "Internationalization/Text.h"
#include "Math/Transform.h"
#include "Templates/Casts.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Package.h"
#include "UObject/ScriptInterface.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "StateTargets.generated.h"
 
 
UCLASS(MinimalAPI)
class UGizmoNilStateTarget : public UObject, public IGizmoStateTarget
{
    GENERATED_BODY()
public:
    virtual void BeginUpdate() final
    {
    }
 
    virtual void EndUpdate() final
    {
    }
 
};
 
 
 
UCLASS(MinimalAPI)
class UGizmoLambdaStateTarget : public UObject, public IGizmoStateTarget
{
    GENERATED_BODY()
public:
    virtual void BeginUpdate()
    {
        if (BeginUpdateFunction)
        {
            BeginUpdateFunction();
        }
    }
 
    virtual void EndUpdate()
    {
        if (EndUpdateFunction)
        {
            EndUpdateFunction();
        }
    }
 
    TUniqueFunction<void(void)> BeginUpdateFunction = TUniqueFunction<void(void)>();
    TUniqueFunction<void(void)> EndUpdateFunction = TUniqueFunction<void(void)>();
};
 
 
 
UCLASS(MinimalAPI)
class UGizmoObjectModifyStateTarget : public UObject, public IGizmoStateTarget
{
    GENERATED_BODY()
public:
    virtual void BeginUpdate()
    {
        if (TransactionManager)
        {
            TransactionManager->BeginUndoTransaction(TransactionDescription);
        }
        if (ModifyObject.IsValid())
        {
            ModifyObject->Modify();
        }
    }
 
    virtual void EndUpdate()
    {
        if (TransactionManager)
        {
            TransactionManager->EndUndoTransaction();
        }
    }
 
 
    TWeakObjectPtr<UObject> ModifyObject;
 
    FText TransactionDescription;
 
    UPROPERTY()
    TScriptInterface<IToolContextTransactionProvider> TransactionManager;
 
public:
    static UGizmoObjectModifyStateTarget* Construct(
        UObject* ModifyObjectIn,
        const FText& DescriptionIn,
        IToolContextTransactionProvider* TransactionManagerIn,
        UObject* Outer = (UObject*)GetTransientPackage())
    {
        UGizmoObjectModifyStateTarget* NewTarget = NewObject<UGizmoObjectModifyStateTarget>(Outer);
        NewTarget->ModifyObject = ModifyObjectIn;
        NewTarget->TransactionDescription = DescriptionIn;
 
        // have to explicitly configure this because we only have IToolContextTransactionProvider pointer
        NewTarget->TransactionManager.SetInterface(TransactionManagerIn);
        NewTarget->TransactionManager.SetObject(CastChecked<UObject>(TransactionManagerIn));
 
        return NewTarget;
    }
};
 
 
 
 
 
 
 
UCLASS(MinimalAPI)
class UGizmoTransformChangeStateTarget : public UObject, public IGizmoStateTarget
{
    GENERATED_BODY()
public:
    virtual void BeginUpdate()
    {
        if (TargetComponent.IsValid())
        {
            if (TransactionManager)
            {
                TransactionManager->BeginUndoTransaction(ChangeDescription);
            }
 
            InitialTransform = TargetComponent->GetComponentTransform();
 
            for (TUniquePtr<IToolCommandChangeSource>& Source : DependentChangeSources)
            {
                Source->BeginChange();
            }
 
            for (IToolCommandChangeSource* Source : ExternalDependentChangeSources)
            {
                Source->BeginChange();
            }
        }
    }
 
    virtual void EndUpdate()
    {
        if (TargetComponent.IsValid())
        {
            FinalTransform = TargetComponent->GetComponentTransform();
 
            if (TransactionManager)
            {
                TUniquePtr<FComponentWorldTransformChange> TransformChange 
                    = MakeUnique<FComponentWorldTransformChange>(InitialTransform, FinalTransform);
                TransactionManager->EmitObjectChange(TargetComponent.Get(), MoveTemp(TransformChange), ChangeDescription);
 
                for (TUniquePtr<IToolCommandChangeSource>& Source : DependentChangeSources)
                {
                    TUniquePtr<FToolCommandChange> Change = Source->EndChange();
                    if (Change)
                    {
                        UObject* Target = Source->GetChangeTarget();
                        TransactionManager->EmitObjectChange(Target, MoveTemp(Change), Source->GetChangeDescription());
                    }
                }
 
                for (IToolCommandChangeSource* Source : ExternalDependentChangeSources)
                {
                    TUniquePtr<FToolCommandChange> Change = Source->EndChange();
                    if (Change)
                    {
                        UObject* Target = Source->GetChangeTarget();
                        TransactionManager->EmitObjectChange(Target, MoveTemp(Change), Source->GetChangeDescription());
                    }
                }
 
                TransactionManager->EndUndoTransaction();
            }
        }
    }
 
 
    TWeakObjectPtr<USceneComponent> TargetComponent;
 
    FText ChangeDescription;
 
    UPROPERTY()
    TScriptInterface<IToolContextTransactionProvider> TransactionManager;
 
    FTransform InitialTransform;
    FTransform FinalTransform;
 
 
    TArray<TUniquePtr<IToolCommandChangeSource>> DependentChangeSources;
 
    TArray<IToolCommandChangeSource*> ExternalDependentChangeSources;
 
public:
 
    static UGizmoTransformChangeStateTarget* Construct(
        USceneComponent* TargetComponentIn,
        const FText& DescriptionIn,
        IToolContextTransactionProvider* TransactionManagerIn,
        UObject* Outer = (UObject*)GetTransientPackage())
    {
        UGizmoTransformChangeStateTarget* NewTarget = NewObject<UGizmoTransformChangeStateTarget>(Outer);
        NewTarget->TargetComponent = TargetComponentIn;
        NewTarget->ChangeDescription = DescriptionIn;
 
        // have to explicitly configure this because we only have IToolContextTransactionProvider pointer
        NewTarget->TransactionManager.SetInterface(TransactionManagerIn);
        NewTarget->TransactionManager.SetObject(CastChecked<UObject>(TransactionManagerIn));
        
        return NewTarget;
    }
 
 
};