ToolTargetManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "ToolTargets/ToolTarget.h"
#include "ToolContextInterfaces.h"
 
#include "ToolTargetManager.generated.h"
 
// TODO: Do we need more control over factory order to prioritize which gets used if we can
// make multiple qualifying targets? It should theoretically not matter, but in practice, one
// target or another could be more efficient for certain tasks. This is probably only worth
// thinking about once we encounter it.
 
// NOTE FOR IMPLEMENTING CACHING: Someday we will probably write a tool target manager that
// caches tool targets and gives prebuilt ones when possible to avoid any extra conversions.
// When implementing this, note that currently, some targets store converted versions of their
// source objects without a way to determine whether their stored conversion is out of date.
// The cached target will then give an incorrect result if the source object has been
// modified after caching.
// One way to deal with this is to have subclasses of UToolTarget that give the degree of
// cacheability- fully cacheable (i.e., detects changes and rebuilds if necessary), cacheable
// only if changes are made through that tool target (i.e. target manager has to clear it if
// object may have changed; may choose not to have this option), or not cacheable. 
 
UCLASS(Transient, MinimalAPI)
class UToolTargetManager : public UObject
{
    GENERATED_BODY()
 
public:
    bool IsActive() const { return bIsActive; }
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void AddTargetFactory(UToolTargetFactory* Factory);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void RemoveTargetFactoriesByPredicate(TFunctionRef<bool(UToolTargetFactory*)> Predicate);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UToolTargetFactory* FindFirstFactoryByPredicate(TFunctionRef<bool(UToolTargetFactory*)> Predicate);
 
    template<typename CastToType>
    CastToType* FindFirstFactoryByType()
    {
        UToolTargetFactory* Found = FindFirstFactoryByPredicate([](UToolTargetFactory* Factory) { return Cast<CastToType>(Factory) != nullptr; });
        return (Found != nullptr) ? Cast<CastToType>(Found) : nullptr;
    }
 
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool CanBuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetRequirements) const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UToolTarget* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetRequirements);
 
    template<typename CastToType>
    CastToType* BuildTarget(UObject* SourceObject, const FToolTargetTypeRequirements& TargetType)
    {
        UToolTarget* Result = BuildTarget(SourceObject, TargetType);
        return (Result != nullptr) ? Cast<CastToType>(Result) : nullptr;
    }
 
    INTERACTIVETOOLSFRAMEWORK_API virtual int32 CountSelectedAndTargetable(const FToolBuilderState& SceneState,
        const FToolTargetTypeRequirements& TargetRequirements) const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void EnumerateSelectedAndTargetableComponents(const FToolBuilderState& SceneState,
        const FToolTargetTypeRequirements& TargetRequirements,
        TFunctionRef<void(UActorComponent*)> ComponentFunc) const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual int32 CountSelectedAndTargetableWithPredicate(const FToolBuilderState& SceneState,
        const FToolTargetTypeRequirements& TargetRequirements,
        TFunctionRef<bool(UActorComponent&)> ComponentPred) const;
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UToolTarget* BuildFirstSelectedTargetable(const FToolBuilderState& SceneState,
        const FToolTargetTypeRequirements& TargetRequirements);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual TArray<TObjectPtr<UToolTarget>> BuildAllSelectedTargetable(const FToolBuilderState& SceneState,
        const FToolTargetTypeRequirements& TargetRequirements);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Initialize();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Shutdown();
 
    virtual void SetInputFilterFunction(TFunction<bool(const UObject*)> ShouldAllowBuildingFromInputObject) 
    { 
        InputFilterFunction = ShouldAllowBuildingFromInputObject; 
    }
 
protected:
 
    // This should be removed once tools are transitioned to using tool targets, and the
    // functions in ComponentSourceInterfaces.h do not exist. For now, this is here to call
    // Initialize().
    friend INTERACTIVETOOLSFRAMEWORK_API void AddFactoryToDeprecatedToolTargetManager(UToolTargetFactory* Factory);
 
    UToolTargetManager(){};
 
    bool bIsActive = false;
 
    UPROPERTY()
    TArray<TObjectPtr<UToolTargetFactory>> Factories;
 
    // More state will go here if the manager deals with target caching.
    
private:
    TFunction<bool(const UObject*)> InputFilterFunction;
};