1. Epic GamesDeveloper
  3. UGameFrameworkComponentManager

UGameFrameworkComponentManager

GameFrameworkComponentManager

API > API/Plugins > API/Plugins/ModularGameplay > API/Plugins/ModularGameplay/Components

Inheritance Hierarchy

References

   
Module ModularGameplay
Header /Engine/Plugins/Experimental/ModularGameplay/Source/ModularGameplay/Public/Components/GameFrameworkComponentManager.h
Include #include "Components/GameFrameworkComponentManager.h"

Syntax

UCLASS&40;&41;  
class UGameFrameworkComponentManager : public UGameInstanceSubsystem

Remarks

GameFrameworkComponentManager

A manager to handle putting components on actors as they come and go. Put in a request to instantiate components of a given class on actors of a given class and they will automatically be made for them as the actors are spawned. Submit delegate handlers to listen for actors of a given class. Those handlers will automatically run when actors of a given class or registered as receivers or game events are sent. Actors must opt-in to this behavior by calling AddReceiver/RemoveReceiver for themselves when they are ready to receive the components and when they want to remove them. Any actors that are in memory when a request is made will automatically get the components, and any in memory when a request is removed will lose the components immediately. Requests are reference counted, so if multiple requests are made for the same actor class and component class, only one component will be added and that component wont be removed until all requests are removed.

Functions

  Type Name Description
Public function TSharedPtr< FComponentRequestHandle >

AddComponentRequest ( const TSoftClassPtr< AActor >& ReceiverClass,
TSubclassOf< UActorComponent > ComponentClass
)

 Adds a request to instantiate components on actors of the given classes.
Public function TSharedPtr< FComponentRequestHandle >

AddExtensionHandler ( const TSoftClassPtr< AActor >& ReceiverClass,
FExtensionHandlerDelegate ExtensionHandler
)

 Adds an extension handler to run on actors of the given class.
Public function Static void

AddGameFrameworkComponentReceiver ( AActor* Receiver,
bool bAddOnlyInGameWorlds
)

 Adds an actor as a receiver for components (automatically finding the manager for the actor's game instance).
Public function UFunction BlueprintCallable, Category, Meta void

AddReceiver ( AActor* Receiver,
bool bAddOnlyInGameWorlds
)

 Adds an actor as a receiver for components.
Public function Static void  
Public function bool

ChangeFeatureInitState ( AActor* Actor,
FName FeatureName,
UObject* Implementer,
FGameplayTag FeatureState
)

 Changes the current actor feature state, this will call registered callbacks and return true if anything changed
Public function Static void  
Public function Const void

GetAllFeatureImplementers ( TArray< UObject* >& OutImplementers,
AActor* Actor,
FGameplayTag RequiredState,
FName ExcludingFeature
)

 Gets all implementing objects for an actor that are at RequiredState or later, other than excluding feature if specified
Public function Static UGameFrameworkComponentManager *

GetForActor ( const AActor* Actor,
bool bOnlyGameWorlds
)

 Utility to get this manager from an actor, will return null if actor is null or not in a world
Public function Const UObject *

GetImplementerForFeature ( AActor* Actor,
FName FeatureName,
FGameplayTag RequiredState
)

 Returns the object implementing specified feature, filtered by required state if not none
Public function Const FGameplayTag

GetInitStateForFeature ( AActor* Actor,
FName FeatureName
)

 Returns the earliest state found for the given feature
Public function Const bool

HasFeatureReachedInitState ( AActor* Actor,
FName FeatureName,
FGameplayTag FeatureState
)

 Returns true if feature has reached query state or later
Public function Const bool

HaveAllFeaturesReachedInitState ( AActor* Actor,
FGameplayTag RequiredState,
FName ExcludingFeature
)

 Checks to see if all features of object, other than the excluding feature if specified, have reached a specified state or later
Public function Const bool

IsInitStateAfterOrEqual ( FGameplayTag FeatureState,
FGameplayTag RelativeState
)

 Returns true if FeatureState comes after the second state (or is equal)
Public function FDelegateHandle

RegisterAndCallForActorInitState ( AActor* Actor,
FName FeatureName,
FGameplayTag RequiredState,
FActorInitStateChangedDelegate Delegate,
bool bCallImmediately
)

 Registers native delegate for feature state change notifications on a specific actor and may call it immediately
Public function UFunction BlueprintCallable, Category bool

RegisterAndCallForActorInitState ( AActor* Actor,
FName FeatureName,
FGameplayTag RequiredState,
FActorInitStateChangedBPDelegate Delegate,
bool bCallImmediately
)

 Registers blueprint delegate for feature state change notifications on a specific actor and may call it immediately
Public function FDelegateHandle

RegisterAndCallForClassInitState ( const TSoftClassPtr< AActor >& ActorClass,
FName FeatureName,
FGameplayTag RequiredState,
FActorInitStateChangedDelegate Delegate,
bool bCallImmediately
)

 Registers native delegate for feature state change notifications on a class of actors and may call it immediately
Public function UFunction BlueprintCallable, Category bool

RegisterAndCallForClassInitState ( TSoftClassPtr< AActor > ActorClass,
FName FeatureName,
FGameplayTag RequiredState,
FActorInitStateChangedBPDelegate Delegate,
bool bCallImmediately
)

 Registers blueprint delegate for feature state change notifications on a class of actors and may call it immediately
Public function bool

RegisterFeatureImplementer ( AActor* Actor,
FName FeatureName,
UObject* Implementer
)

 Registers an implementer for a given feature, this will create a feature if required and set the implementer object but will not change the current state
Public function void

RegisterInitState ( FGameplayTag NewState,
bool bAddBefore,
FGameplayTag ExistingState
)

 The init state system can be used by components to coordinate their initialization using game-specific states specified as gameplay tags IGameFrameworkInitStateInterface provides a simple implementation that can be inherted by components Adds a new global actor feature state, either before or after an existing one.
Public function void Removes an actor and all of it's state information
Public function void

RemoveFeatureImplementer ( AActor* Actor,
UObject* Implementer
)

 Removes an implementing object and any feature states it implements
Public function Static void Removes an actor as a receiver for components (automatically finding the manager for the actor's game instance).
Public function UFunction BlueprintCallable, Category, Meta void

RemoveReceiver ( AActor* Receiver
)

 Removes an actor as a receiver for components.
Public function UFunction BlueprintCallable, Category, Meta void

SendExtensionEvent ( AActor* Receiver,
FName EventName,
bool bOnlyInGameWorlds
)

 Sends an arbitrary extension event that can be listened for by other systems
Public function Static void

SendGameFrameworkComponentExtensionEvent ( AActor* Receiver,
const FName& EventName,
bool bOnlyInGameWorlds
)

 Sends an arbitrary extension event that can be listened for by other systems
Public function bool Removes a registered delegate bound to a specific actor
Public function UFunction BlueprintCallable, Category bool Removes a registered delegate bound to a specific actor
Public function bool Removes a registered delegate bound to a class
Public function UFunction BlueprintCallable, Category bool Removes a registered delegate bound to a class

Overridden from USubsystem

  Type Name Description
Public function Virtual void Implement this for deinitialization of instances of the system
Public function Virtual void Implement this for initialization of instances of the system

Typedefs

Name Description
FExtensionHandlerDelegate Delegate types for extension handlers
FExtensionHandlerDelegateInternal Using a fake multicast delegate so order can be kept consistent
FExtensionHandlerEvent  

Constants

Name Description
NAME_ExtensionAdded A new extension handler was added
NAME_ExtensionRemoved An extension handler was removed by a freed request handle
NAME_GameActorReady Game-specific event indicating an actor is mostly initialized and ready for extension.
NAME_ReceiverAdded The extension system allows registering for arbitrary event callbacks on receiver actors.
NAME_ReceiverRemoved RemoveReceiver was called for a registered class and components were removed, normally called from EndPlay

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page