[UE4]委托代理：单播委托，多播委托，动态单播委托，动态多播委托，事件

已于 2022-10-12 12:26:01 修改
阅读量8.4k 收藏 48
点赞数 12
分类专栏： UE 文章标签： 单播委托 多播委托
于 2021-08-11 17:47:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZFSR05255134/article/details/119612832
版权
本文详细介绍了在Unreal Engine中使用不同类型的委托，包括单播、多播、动态单播和动态多播委托的声明、绑定、解绑及调用。通过具体的C++代码示例展示了如何在游戏模式类中声明委托，在Actor类中绑定和解绑委托，以及在触发事件时调用委托，从而实现游戏逻辑间的通信。
摘要由CSDN通过智能技术生成

UE文档参考：

委托https://docs.unrealengine.com/4.26/zh-CN/ProgrammingAndScripting/ProgrammingWithCPP/UnrealArchitecture/Delegates/

事件分发器/委托快速入门指南https://docs.unrealengine.com/4.27/zh-CN/ProgrammingAndScripting/ActorCommunication/EventDispatcherQuickStart/

注意事项

1.在 声明动态 单播/多播 委托(DECLARE_DYNAMIC_DELEGATE/DECLARE_DYNAMIC_MULTICAST_DELEGATE)时，DelegateName 参数必须以字符 'F' 开头，否则编译无法通过。

 最好时声明所有委托时，DelegateName 参数都以字符 'F' 开头，这样就没有问题了。

报错参考如下：

​

2.在C++代码中 绑定 动态 单播/多播时，被绑定的函数必须有UFUNCTION宏，如

	UFUNCTION()
	void onEnterTriggerDyMult_00();

C++应用举例

 说明：

为了方便测试，这里新建了 DelegateTest_GameMode 类用来申明与定义所有的委托。新建了ATrggerActor_Test 类来调用所有的委托。而委托的绑定则分类在不同的Actor类中实现。

委托声明与定义

新建 DelegateTest_GameMode 类(继承 GameModeBase 类)声明与定义这次测试的委托类型。

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "DelegateTest_GameMode.generated.h"

// 声明 无参 无返回值 的单播委托
DECLARE_DELEGATE(FOnEnterTrigger_00);
// 声明 1个参数 无返回值 的单播委托
DECLARE_DELEGATE_OneParam(FOnEnterTrigger_01, bool);
// 声明 2个参数 无返回值 的单播委托
DECLARE_DELEGATE_TwoParams(FOnEnterTrigger_02, bool, int32);
// 声明 3个参数 无返回值 的单播委托
DECLARE_DELEGATE_ThreeParams(FOnEnterTrigger_03, bool, int32, float);
// 声明 无参 有返回值 的单播委托
DECLARE_DELEGATE_RetVal(bool, FOnEnterTrigger_10);
// 声明 1个参数 有返回值 的单播委托
DECLARE_DELEGATE_RetVal_OneParam(bool, FOnEnterTrigger_11, FString);
// 声明 5个参数 有返回值 的单播委托
DECLARE_DELEGATE_RetVal_FiveParams(bool, FOnEnterTrigger_15, bool, int32, float, FString, FString);

// 声明 无参 的多播委托
DECLARE_MULTICAST_DELEGATE(FOnEnterTriggerMult_00);
// 声明 3个参数 的多播委托
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnEnterTriggerMult_03, bool, int32, float);

// 声明 无参 的动态单播播委托
DECLARE_DYNAMIC_DELEGATE_RetVal(int32,FOnEnterTriggerDy_10);
// 声明 4个参数 的动态单播播委托
DECLARE_DYNAMIC_DELEGATE_FourParams(FOnEnterTriggerDy_04, bool, bVal, int32, iVal, float, fVal, FString, fStr);

// 声明 无参 的动态多播委托
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnEnterTriggerDyMult_00);
// 声明 3个参数 的动态多播委托
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnEnterTriggerDyMult_02, bool, bVal, int32, iVal);

UCLASS()
class CMYGAME_API ADelegateTest_GameMode : public AGameModeBase
{
	GENERATED_BODY()

public:
	// 定义 单播委托
	FOnEnterTrigger_00 onEnterTrigger_00;
	FOnEnterTrigger_01 onEnterTrigger_01;
	FOnEnterTrigger_02 onEnterTrigger_02;
	FOnEnterTrigger_03 onEnterTrigger_03;
	FOnEnterTrigger_10 onEnterTrigger_10;
	FOnEnterTrigger_11 onEnterTrigger_11;
	FOnEnterTrigger_15 onEnterTrigger_15;

	// 定义 多播委托
	FOnEnterTriggerMult_00 onEnterTriggerMult_00;
	FOnEnterTriggerMult_03 onEnterTriggerMult_03;

	// 定义 动态 单播委托
	FOnEnterTriggerDy_10 onEnterTriggerDy_10;
	FOnEnterTriggerDy_04 onEnterTriggerDy_04;

	// 定义 动态 多播委托
	FOnEnterTriggerDyMult_00 onEnterTriggerDyMult_00;
	FOnEnterTriggerDyMult_02 onEnterTriggerDyMult_02;
};

单播委托绑定与解绑

DECLARE_DELEGATE

新建类 ALightActor_Test 中声明与实现对应的绑定函数，并在类中实现绑定

protected:
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason)override;

public:
	UPROPERTY(EditAnywhere)
	class UPointLightComponent* PointLigth;
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* TextRender;

	UFUNCTION()
	void TestBindDelegate();
	UFUNCTION()
	void TestUnBindDelegate();

	// LightActor_Test 类 声明函数
	UFUNCTION(BlueprintCallable)
	void TestFuncNoParam();
	UFUNCTION(BlueprintCallable)
	void TestFuncThreeParams(bool bVal,int32 iVal,float fVal);
	UFUNCTION(BlueprintCallable)
	bool TestFuncRetValNoParam();
	UFUNCTION(BlueprintCallable)
	bool TestFuncRetValFiveParams(bool bVal, int32 iVal, float fVal, FString fStr1, FString fStr2);
	UFUNCTION(BlueprintCallable)
	void EnablePointLight(bool bEnable);

// Fill out your copyright notice in the Description page of Project Settings.

#include "LightActor_Test.h"
#include <Components/PointLightComponent.h>
#include <Kismet/GameplayStatics.h>
#include "DelegateTest_GameMode.h"
#include <Components/TextRenderComponent.h>

// Sets default values
ALightActor_Test::ALightActor_Test()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
	PointLigth = CreateDefaultSubobject<UPointLightComponent>(TEXT("Point"));
	PointLigth->SetupAttachment(RootComponent);
	PointLigth->SetLightColor(FColor::Red);
	PointLigth->SetVisibility(false);

	TextRender = CreateDefaultSubobject<UTextRenderComponent>(TEXT("TextRender"));
	TextRender->SetupAttachment(RootComponent);
	TextRender->SetRelativeLocation(FVector::FVector(0.f, 0.f, 1.f));
	TextRender->SetTextRenderColor(FColor::Red);
	TextRender->SetText(TEXT(""));
	TextRender->SetRelativeRotation(FRotator::FRotator(0.f, 180.f, 0.f));
	TextRender->SetVisibility(false);
}

// Called when the game starts or when spawned
void ALightActor_Test::BeginPlay()
{
	Super::BeginPlay();
	
	TestBindDelegate();
}

void ALightActor_Test::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	TestUnBindDelegate();
}

// Called every frame
void ALightActor_Test::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

// 委托绑定
void ALightActor_Test::TestBindDelegate()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::White, TEXT("-- TestDelegate"));

	UWorld* curWorld = GetWorld();
	if (curWorld)
	{
		AGameModeBase* curGameMode = UGameplayStatics::GetGameMode(curWorld);
		ADelegateTest_GameMode* myGameMode = Cast<ADelegateTest_GameMode>(curGameMode);

		myGameMode->onEnterTrigger_01.BindUObject(this, &ALightActor_Test::EnablePointLight);

		myGameMode->onEnterTrigger_00.BindUObject(this, &ALightActor_Test::TestFuncNoParam);
		myGameMode->onEnterTrigger_03.BindUObject(this, &ALightActor_Test::TestFuncThreeParams);
		myGameMode->onEnterTrigger_10.BindUObject(this, &ALightActor_Test::TestFuncRetValNoParam);
		myGameMode->onEnterTrigger_15.BindUObject(this, &ALightActor_Test::TestFuncRetValFiveParams);
	}
}
// 委托解绑定
void ALightActor_Test::TestUnBindDelegate()
{
	UWorld* curWorld = GetWorld();
	if (curWorld)
	{
		AGameModeBase* gameMode = UGameplayStatics::GetGameMode(curWorld);
		ADelegateTest_GameMode* myGameMode = Cast<ADelegateTest_GameMode>(gameMode);
		if (myGameMode)
		{
			myGameMode->onEnterTrigger_00.Unbind();
			myGameMode->onEnterTrigger_01.Unbind();
			myGameMode->onEnterTrigger_03.Unbind();
			myGameMode->onEnterTrigger_10.Unbind();
			myGameMode->onEnterTrigger_15.Unbind();
		}
	}
}

// 实现LightActor_Test头文件中声明的函数
void ALightActor_Test::TestFuncNoParam()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::White, TEXT("-- TestFuncNoParam"));
}
// 实现LightActor_Test头文件中声明的函数
void ALightActor_Test::TestFuncThreeParams(bool bVal, int32 iVal, float fVal)
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::White, FString::Printf(TEXT("-- TestFuncThreeParams,%d, %d,%f"), bVal ? 1:0, iVal, fVal));
}
// 实现LightActor_Test头文件中声明的函数
bool ALightActor_Test::TestFuncRetValNoParam()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::White, TEXT("-- TestFuncRetValNoParam"));
	return false;
}
// 实现LightActor_Test头文件中声明的函数
bool ALightActor_Test::TestFuncRetValFiveParams(bool bVal, int32 iVal, float fVal, FString fStr1, FString fStr2)
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::White, FString::Printf(TEXT("-- TestFuncRetValFiveParams,%d, %d, %f,%s,%s"), bVal?1:0, iVal, fVal, *fStr1, *fStr2));
	return false;
}
// 实现LightActor_Test头文件中声明的函数
void ALightActor_Test::EnablePointLight(bool bEnable)
{
	PointLigth->SetLightColor(FColor::Red);
	PointLigth->SetVisibility(bEnable);
	TextRender->SetVisibility(bEnable);
	if (bEnable)
	{
		TextRender->SetRelativeRotation(FRotator::FRotator(0.f, 180.f, 0.f));
		TextRender->SetText(TEXT("Light"));
	}
	else
	{
		TextRender->SetText(TEXT(""));
	}
}

多播委托绑定与解绑

DECLARE_MULTICAST_DELEGATE

新建 FOnEnterTriggerMult_Actor 类实现绑定与解绑

protected:
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* TheTextRender;
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* TheTextRender2;

	UFUNCTION()
	void BindDelegate();
	UFUNCTION()
	void UnBindDelegate();

	int32 count = 0;
	FDelegateHandle delegateHandle;

	UFUNCTION(BlueprintCallable)
	void FOnEnterTriggerMult_00();
	UFUNCTION(BlueprintCallable)
	void FOnEnterTriggerMult_03(bool bVal,int32 iVal,float fVal);
// Fill out your copyright notice in the Description page of Project Settings.

#include "FOnEnterTriggerMult_Actor.h"
#include <Components/TextRenderComponent.h>
#include <Kismet/GameplayStatics.h>
#include "DelegateTest_GameMode.h"

// Sets default values
AFOnEnterTriggerMult_Actor::AFOnEnterTriggerMult_Actor()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
	TheTextRender = CreateDefaultSubobject<UTextRenderComponent>(TEXT("TextRender01"));
	TheTextRender->SetupAttachment(RootComponent);
	TheTextRender->SetWorldSize(10.f);
	TheTextRender->SetText("DECLARE_MULTICAST_DELEGATE");
	TheTextRender->SetTextRenderColor(FColor::Red);

	TheTextRender2 = CreateDefaultSubobject<UTextRenderComponent>(TEXT("TextRender02"));
	TheTextRender2->SetupAttachment(RootComponent);
	TheTextRender2->SetWorldSize(10.f);
	TheTextRender2->SetRelativeLocation(FVector::FVector(0.f, 0.f, 10.f));
	TheTextRender2->SetText(TEXT("DECLARE_MULTICAST_DELEGATE"));
	TheTextRender2->SetTextRenderColor(FColor::Red);
}

void AFOnEnterTriggerMult_Actor::BeginPlay()
{
	Super::BeginPlay();
	BindDelegate();
}

void AFOnEnterTriggerMult_Actor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	UnBindDelegate();
}

void AFOnEnterTriggerMult_Actor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

// 委托绑定
void AFOnEnterTriggerMult_Actor::BindDelegate()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	delegateHandle = curGameMode->onEnterTriggerMult_00.AddUObject(this, &AFOnEnterTriggerMult_Actor::FOnEnterTriggerMult_00);
	curGameMode->onEnterTriggerMult_03.AddUObject(this, &AFOnEnterTriggerMult_Actor::FOnEnterTriggerMult_03);
}

// 委托解绑
void AFOnEnterTriggerMult_Actor::UnBindDelegate()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	curGameMode->onEnterTriggerMult_00.Remove(delegateHandle);
	curGameMode->onEnterTriggerMult_00.RemoveAll(this);
	curGameMode->onEnterTriggerMult_03.RemoveAll(this);
}

void AFOnEnterTriggerMult_Actor::FOnEnterTriggerMult_00()
{
	TheTextRender->SetText("FOnEnterTriggerMult_00");
	count++;
	if (count % 2 == 1)
	{
		TheTextRender->SetTextRenderColor(FColor::Black);
	}
	else
	{
		TheTextRender->SetTextRenderColor(FColor::Red);
	}
}

void AFOnEnterTriggerMult_Actor::FOnEnterTriggerMult_03(bool bVal, int32 iVal, float fVal)
{
	TheTextRender2->SetText("FOnEnterTriggerMult_03");
	if (bVal)
	{
		TheTextRender2->SetTextRenderColor(FColor::Black);
	}
	else
	{
		TheTextRender2->SetTextRenderColor(FColor::FColor(255,0,255));
	}
}

动态单播委托绑定与解绑

DECLARE_DYNAMIC_DELEGATE

新建 FOnEnterTriggerDy_Actor 类实现委托绑定与解绑，注意：动态单播/多播委托绑定的函数必须带有宏 UFUNCTION()

protected:
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:
	UPROPERTY(EditAnyWhere)
	class UTextRenderComponent* theTextRender01;
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* theTextRender02;

	int32 count = 0;

	UFUNCTION()
	void BindDelegate();
	UFUNCTION()
	void UnBindDelegate();

	UFUNCTION(BlueprintCallable)
	int32 onEnterTriggerDy_10();
	UFUNCTION(BlueprintCallable)
	void onEnterTriggerDy_04(bool bVal,int32 iVal,float fVal,FString fStr);
// Fill out your copyright notice in the Description page of Project Settings.

#include "FOnEnterTriggerDy_Actor.h"
#include <Kismet/GameplayStatics.h>
#include "DelegateTest_GameMode.h"
#include <Components/TextRenderComponent.h>

// Sets default values
AFOnEnterTriggerDy_Actor::AFOnEnterTriggerDy_Actor()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
	theTextRender01 = CreateDefaultSubobject<UTextRenderComponent>(TEXT("theTextRender01"));
	theTextRender01->SetupAttachment(RootComponent);
	theTextRender01->SetText("DECLARE_DYNAMIC_DELEGATE");
	theTextRender01->SetTextRenderColor(FColor::Blue);
	theTextRender01->SetWorldSize(10.f);

	theTextRender02 = CreateDefaultSubobject<UTextRenderComponent>(TEXT("theTextRender02"));
	theTextRender02->SetupAttachment(RootComponent);
	theTextRender02->SetText("DECLARE_DYNAMIC_DELEGATE");
	theTextRender02->SetTextRenderColor(FColor::Blue);
	theTextRender02->SetWorldSize(10.f);
	theTextRender02->SetRelativeLocation(FVector(0.f, 0.f, 10.f));
}

// Called when the game starts or when spawned
void AFOnEnterTriggerDy_Actor::BeginPlay()
{
	Super::BeginPlay();
	BindDelegate();
}

void AFOnEnterTriggerDy_Actor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	UnBindDelegate();
}

// Called every frame
void AFOnEnterTriggerDy_Actor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

// 委托绑定
void AFOnEnterTriggerDy_Actor::BindDelegate()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, TEXT("AFOnEnterTriggerDy_Actor::BindDelegate()"));

	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	// BindUFunction 与 BindDynamic 同样可以实现委托的绑定
	curGameMode->onEnterTriggerDy_10.BindUFunction(this, STATIC_FUNCTION_FNAME(TEXT("AFOnEnterTriggerDy_Actor::onEnterTriggerDy_10")));
	//curGameMode->onEnterTriggerDy_10.BindDynamic(this, &AFOnEnterTriggerDy_Actor::onEnterTriggerDy_10);

	// BindUFunction 与 BindDynamic 同样可以实现委托的绑定
	//curGameMode->onEnterTriggerDy_04.BindUFunction(this, STATIC_FUNCTION_FNAME(TEXT("AFOnEnterTriggerDy_Actor::onEnterTriggerDy_04")));
	curGameMode->onEnterTriggerDy_04.BindDynamic(this, &AFOnEnterTriggerDy_Actor::onEnterTriggerDy_04);
	//curGameMode->onEnterTriggerDy_04.__Internal_BindDynamic()
}

// 委托解绑定
void AFOnEnterTriggerDy_Actor::UnBindDelegate()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, TEXT("AFOnEnterTriggerDy_Actor::BindDelegate()"));

	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	curGameMode->onEnterTriggerDy_10.Clear();
	curGameMode->onEnterTriggerDy_04.Unbind();
}

int32 AFOnEnterTriggerDy_Actor::onEnterTriggerDy_10()
{
	theTextRender01->SetText(TEXT("onEnterTriggerDy_10"));
	count++;
	if (count % 2 == 1)
	{
		theTextRender01->SetTextRenderColor(FColor::Green);
	}
	else
	{
		theTextRender01->SetTextRenderColor(FColor::Blue);
	}
	return 9;
}

void AFOnEnterTriggerDy_Actor::onEnterTriggerDy_04(bool bVal, int32 iVal, float fVal, FString fStr)
{
	theTextRender02->SetText(TEXT("onEnterTriggerDy_04"));
	if (bVal)
	{
		theTextRender02->SetTextRenderColor(FColor::Green);
	}
	else
	{
		theTextRender02->SetTextRenderColor(FColor::Black);
	}
}

动态多播委托绑定与解绑

DECLARE_DYNAMIC_MULTICAST_DELEGATE

新建 FOnEnterTriggerDyMult_Actor 类实现委托绑定与解绑，注意：动态单播/多播委托绑定的函数必须带有宏 UFUNCTION()

protected:
	virtual void BeginPlay() override;
	virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;

public:
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* TheTextRender01;
	UPROPERTY(EditAnywhere)
	class UTextRenderComponent* TheTextRender02;
	int32 count = 0;

	UFUNCTION()
	void BindDelegate();
	UFUNCTION()
	void UnBindDelegate();
	
	UFUNCTION()
	void onEnterTriggerDyMult_00();
	UFUNCTION()
	void onEnterTriggerDyMult_02(bool bVal,int32 iVal);

// Fill out your copyright notice in the Description page of Project Settings.


#include "FOnEnterTriggerDyMult_Actor.h"
#include <Kismet/GameplayStatics.h>
#include "DelegateTest_GameMode.h"
#include <Components/TextRenderComponent.h>

// Sets default values
AFOnEnterTriggerDyMult_Actor::AFOnEnterTriggerDyMult_Actor()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root"));
	

	TheTextRender01 = CreateDefaultSubobject<UTextRenderComponent>(TEXT("TheText"));
	TheTextRender01->SetupAttachment(RootComponent);
	TheTextRender01->SetText(TEXT("DECLARE_DYNAMIC_MULTICAST_DELEGATE"));
	TheTextRender01->SetWorldSize(10.f);
	TheTextRender01->SetTextRenderColor(FColor::Green);
	TheTextRender01->SetWorldRotation(FRotator::FRotator(0.0f, 180.f, 0.f));

	TheTextRender02 = CreateDefaultSubobject<UTextRenderComponent>(TEXT("TheText2"));
	TheTextRender02->SetupAttachment(RootComponent);
	TheTextRender02->SetText(TEXT("DECLARE_DYNAMIC_MULTICAST_DELEGATE"));
	TheTextRender02->SetWorldSize(10.f);
	TheTextRender02->SetTextRenderColor(FColor::Green);
	TheTextRender02->SetRelativeLocation(FVector::FVector(0.f, 0.f, 10.f));
	TheTextRender02->SetWorldRotation(FRotator::FRotator(0.0f, 180.f, 0.f));
}

// Called when the game starts or when spawned
void AFOnEnterTriggerDyMult_Actor::BeginPlay()
{
	Super::BeginPlay();
	BindDelegate();
}

void AFOnEnterTriggerDyMult_Actor::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
	Super::EndPlay(EndPlayReason);
	UnBindDelegate();
}

// Called every frame
void AFOnEnterTriggerDyMult_Actor::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

// 委托绑定
void AFOnEnterTriggerDyMult_Actor::BindDelegate()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr) {
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	//curGameMode->onEnterTriggerDyMult_00.__Internal_AddDynamic
	curGameMode->onEnterTriggerDyMult_00.AddDynamic(this, &AFOnEnterTriggerDyMult_Actor::onEnterTriggerDyMult_00);
	curGameMode->onEnterTriggerDyMult_02.AddDynamic(this, &AFOnEnterTriggerDyMult_Actor::onEnterTriggerDyMult_02);
}

// 委托解除绑定
void AFOnEnterTriggerDyMult_Actor::UnBindDelegate()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr) {
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}
	curGameMode->onEnterTriggerDyMult_00.RemoveAll(this);
	curGameMode->onEnterTriggerDyMult_02.RemoveAll(this);
}

void AFOnEnterTriggerDyMult_Actor::onEnterTriggerDyMult_00()
{
	TheTextRender01->SetText("onEnterTriggerDyMult_00");
	if (count/2==1)
	{
		TheTextRender01->SetTextRenderColor(FColor::FColor(255, 0, 255));

	}
	else
	{
		TheTextRender01->SetTextRenderColor(FColor::Green);
	}
}

void AFOnEnterTriggerDyMult_Actor::onEnterTriggerDyMult_02(bool bVal, int32 iVal)
{
	TheTextRender02->SetText("onEnterTriggerDyMult_02");
	if (bVal)
	{
		TheTextRender02->SetTextRenderColor(FColor::FColor(255, 0, 255));
	}
	else
	{
		TheTextRender02->SetTextRenderColor(FColor::Green);
	}
}

 委托调用 

新建 TrggerActor_Test 类来触发委托事件的调用

public:
	virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;
	virtual void NotifyActorEndOverlap(AActor* OtherActor) override;

	UPROPERTY(EditAnywhere)
	class UBoxComponent* BoxTrigger;

	// 调用 单播委托
	void call_BeginOverlap_DECLARE_DELEGATE();
	void call_EndOverlap_DECLARE_DELEGATE();

	// 调用 多播委托
	void call_BeginOverlap_DECLARE_MULTICAST_DELEGATE();
	void call_EndOverlap_DECLARE_MULTICAST_DELEGATE();

	// 调用 动态单播委托
	void call_BeginOverlap_DECLARE_DYNAMIC_DELEGATE();
	void call_EndOverlap_DECLARE_DYNAMIC_DELEGATE();

	// 调用 动态多播委托
	void call_BeginOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE();
	void call_EndOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE();

// Fill out your copyright notice in the Description page of Project Settings.


#include "TrggerActor_Test.h"
#include <Components/BoxComponent.h>
#include <GameFramework/GameMode.h>
#include <Kismet/GameplayStatics.h>
#include "DelegateTest_GameMode.h"
#include <Components/TextRenderComponent.h>

// Sets default values
ATrggerActor_Test::ATrggerActor_Test()
{
	PrimaryActorTick.bCanEverTick = false;

	RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootComponent"));
	// create 1个触发器，重写 NotifyActorBeginOverlap 与 NotifyActorEndOverlap 函数
	BoxTrigger = CreateDefaultSubobject<UBoxComponent>(TEXT("BoxTrigger"));
	BoxTrigger->SetupAttachment(RootComponent);
	BoxTrigger->SetWorldScale3D(FVector::FVector(5.f, 5.f, 5.f));
}

// Called when the game starts or when spawned
void ATrggerActor_Test::BeginPlay()
{
	Super::BeginPlay();

}

// Called every frame
void ATrggerActor_Test::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

}

void ATrggerActor_Test::NotifyActorBeginOverlap(AActor* OtherActor)
{
	Super::NotifyActorBeginOverlap(OtherActor);
	// 单播委托调用
	call_BeginOverlap_DECLARE_DELEGATE();
	// 多播委托调用
	call_BeginOverlap_DECLARE_MULTICAST_DELEGATE();
	// 动态 单播委托调用
	call_BeginOverlap_DECLARE_DYNAMIC_DELEGATE();
	// 动态 多播委托调用
	call_BeginOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE();
}

void ATrggerActor_Test::NotifyActorEndOverlap(AActor* OtherActor)
{
	Super::NotifyActorEndOverlap(OtherActor);
	// 单播委托调用
	call_EndOverlap_DECLARE_DELEGATE();
	// 多播委托调用
	call_EndOverlap_DECLARE_MULTICAST_DELEGATE();
	// 动态 单播委托调用
	call_EndOverlap_DECLARE_DYNAMIC_DELEGATE();
	// 动态 多播委托调用
	call_EndOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE();
}

// 单播委托调用
void ATrggerActor_Test::call_BeginOverlap_DECLARE_DELEGATE()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Blue, TEXT("-- NotifyActorBeginOverlap"));

	UWorld* curWorld = GetWorld();
	if (curWorld != nullptr)
	{
		AGameModeBase* GameMode = Cast<AGameModeBase>(UGameplayStatics::GetGameMode(curWorld));
		ADelegateTest_GameMode* myGameMode = Cast<ADelegateTest_GameMode>(GameMode);
		if (myGameMode == nullptr)
		{
			GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, TEXT("-- myGameMode == nullptr"));
			return;
		}
		if (myGameMode->onEnterTrigger_00.IsBound())
		{
			myGameMode->onEnterTrigger_00.Execute();
		}
		myGameMode->onEnterTrigger_01.ExecuteIfBound(true);
		myGameMode->onEnterTrigger_02.ExecuteIfBound(true, 11);
		myGameMode->onEnterTrigger_03.ExecuteIfBound(true, 11, 11.f);
		if (myGameMode->onEnterTrigger_10.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_10.Execute();
		}
		if (myGameMode->onEnterTrigger_11.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_11.Execute(TEXT("test - 11"));
		}
		if (myGameMode->onEnterTrigger_15.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_15.Execute(true, 11, 11.f, TEXT("test - 11"), TEXT("test - 11"));
		}
	}
}
// 单播委托调用
void ATrggerActor_Test::call_EndOverlap_DECLARE_DELEGATE()
{
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Black, TEXT("-- NotifyActorEndOverlap"));

	UWorld* curWorld = GetWorld();
	if (curWorld != nullptr)
	{
		AGameModeBase* gameMode = Cast<AGameModeBase>(UGameplayStatics::GetGameMode(curWorld));
		ADelegateTest_GameMode* myGameMode = Cast<ADelegateTest_GameMode>(gameMode);
		if (myGameMode == nullptr)
		{
			GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, TEXT("-- myGameMode == nullptr"));
			return;
		}
		myGameMode->onEnterTrigger_00.ExecuteIfBound();
		myGameMode->onEnterTrigger_01.ExecuteIfBound(false);
		myGameMode->onEnterTrigger_02.ExecuteIfBound(false, 22);
		myGameMode->onEnterTrigger_03.ExecuteIfBound(false, 22, 22.f);
		if (myGameMode->onEnterTrigger_10.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_10.Execute();
		}
		if (myGameMode->onEnterTrigger_11.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_11.Execute(TEXT("Test - 22"));
		}
		if (myGameMode->onEnterTrigger_15.IsBound())
		{
			bool bValue = myGameMode->onEnterTrigger_15.Execute(false, 22, 22.f, TEXT("Test - 22"), TEXT("Test - 22"));
		}
	}
}

// 多播委托调用
void ATrggerActor_Test::call_BeginOverlap_DECLARE_MULTICAST_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld)) ;
	if (curGameMode == nullptr)
	{
		return;
	}
	curGameMode->onEnterTriggerMult_00.Broadcast();
	curGameMode->onEnterTriggerMult_03.Broadcast(true,3,3.f);
}
// 多播委托调用
void ATrggerActor_Test::call_EndOverlap_DECLARE_MULTICAST_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}
	curGameMode->onEnterTriggerMult_00.Broadcast();
	curGameMode->onEnterTriggerMult_03.Broadcast(false, 3, 3.f);
}

// 动态 单播委托调用
void ATrggerActor_Test::call_BeginOverlap_DECLARE_DYNAMIC_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}
	if (curGameMode->onEnterTriggerDy_10.IsBound())
	{
		curGameMode->onEnterTriggerDy_10.Execute();
	}
	curGameMode->onEnterTriggerDy_04.ExecuteIfBound(true, 4, 4.f, TEXT("onEnterTriggerDy_04"));
}
// 动态 单播委托调用
void ATrggerActor_Test::call_EndOverlap_DECLARE_DYNAMIC_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}

	//GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, TEXT("ATrggerActor_Test::call_EndOverlap_DECLARE_DYNAMIC_DELEGATE()"));
	if (curGameMode->onEnterTriggerDy_10.IsBound())
	{
		//GEngine->AddOnScreenDebugMessage(-1, 10.0f, FColor::Red, TEXT("ATrggerActor_Test::call_EndOverlap_DECLARE_DYNAMIC_DELEGATE()"));
		curGameMode->onEnterTriggerDy_10.Execute();
	}
	curGameMode->onEnterTriggerDy_04.ExecuteIfBound(false, 4, 4.f, TEXT("onEnterTriggerDy_04"));
}

// 动态 多播委托调用
void ATrggerActor_Test::call_BeginOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}
	curGameMode->onEnterTriggerDyMult_00.Broadcast();
	curGameMode->onEnterTriggerDyMult_02.Broadcast(true, 2);
}
// 动态 多播委托调用
void ATrggerActor_Test::call_EndOverlap_DECLARE_DYNAMIC_MULTICAST_DELEGATE()
{
	UWorld* curWorld = GetWorld();
	if (curWorld == nullptr)
	{
		return;
	}
	ADelegateTest_GameMode* curGameMode = Cast<ADelegateTest_GameMode>(UGameplayStatics::GetGameMode(curWorld));
	if (curGameMode == nullptr)
	{
		return;
	}
	curGameMode->onEnterTriggerDyMult_00.Broadcast();
	curGameMode->onEnterTriggerDyMult_02.Broadcast(false, 2);
}

事件暂时留个坑

有时间在补齐

iDaDi
关注
专栏目录
JQuery事件委托(适用于给动态生成的脚本元素添加事件)
11-21
事件委托是一种优化事件处理的技术，特别适合于那些在页面加载后由JavaScript动态创建的元素。 事件委托的基本原理是利用事件冒泡的特性，将事件绑定到一个静态的、父级的元素上，而不是直接绑定到动态生成的子元素...
C++ UE4 脚本编程秘籍（二）
龙哥盟
07-08 1244
自定义委托非常有用，但它们的一个限制是它们可以被一些其他第三方类外部广播，也就是说，它们的 Execute/Broadcast 方法是公开可访问的。有时，您可能需要一个委托，可以由其他类外部分配，但只能由包含它们的类广播。这是事件的主要目的。良好的输入控件在您的游戏中非常重要。提供键盘、鼠标和尤其是游戏手柄输入将使您的游戏更受用户欢迎。在您的游戏项目中，有时需要一系列潜在不同的对象共享共同的功能，但使用继承是不合适的，因为这些不同对象之间没有“是一个”关系。
UE4 代理事件（C++）
qq_35760525的博客
08-31 2178
参考文档： https://wiki.unrealengine.com/Delegates_In_UE4,_Raw_Cpp_and_BP_Exposed  //C++代理事件 https://docs.unrealengine.com/latest/CHN/Programming/UnrealArchitecture/Delegates/index.html     用宏定义类似格式:
UE5 C++中的委托详细说明
最新发布
记录值得记录的东西
08-04 696
额
UE4C++之动态多播委托的简单使用
卡西莫多说的博客
01-07 1813
本文讲述一下动态多播委托的简单使用，包括它的声明，定义，在蓝图中的使用。
UE5 C++（十二）— 委托（代理）、多播委托
qq_40120946的博客
01-05 1802
这个官网上有很详细介绍，这里介绍几个点委托 是一种泛型但类型安全的方式，可在C++对象上调用成员函数。可使用委托动态绑定到任意对象的成员函数，之后在该对象上调用函数，即使调用程序不知对象类型也可进行操作。复制委托对象很安全。你也可以利用值传递委托，但这样操作需要在堆上分配内存，因此通常并不推荐。请尽量通过引用传递委托。
UE5 C++ 单播 多播代理 动态多播代理
m0_64217692的博客
02-27 1014
一. 代理机制，代理也叫做委托，其作用就是提供一种消息机制。1.动态多播代理类型声明,区别在于可以暴露给蓝图，在蓝图中进行事件的绑定。1.类型的声明（代理的名称，参数类型（个数）），在Actor外。1.多播代理的类型声明（一个代理可绑定多个函数）2.在Actor里声明对应类型的的单播代理变量。2.在Actor里声明对应类型的的多播代理变量。3.在Actor里声明多播代理绑定的函数。6.在BeginPlay里执行多播代理。2.动态多播代理变量的反射声明。3.编译后，在蓝图里绑定。3.声明代理用绑定的函数。
UE5 C++中的单播、多播、动态多播及的创建使用方法附带（%s/%d/%f）
weixin_42318094的博客
12-29 947
UE5 C++中的单播、多播、动态多播及的创建使用方法附带（%s/%02d/%f）.arg(变量)，占位符
UE C++基础 | 委托与事件
ryacber的博客
01-24 2996
UE C++基础 | 委托与事件
jQuery动态追加页面数据以及事件委托详解
12-11
我们要执行的任务是页面起初有一部分图片，我们在... 首先效果图如下： 这个只截取了最底下的一部分页面。在鼠标悬停在图片上时，还会有文字出现，鼠标移出时文字消失。 ... 首先body中代码如下： ...<div xss=removed>
委托与事件示例代码
11-27
委托和事件是C#编程中的核心特性，它们在构建可扩展和交互性强的应用程序时扮演着重要角色。本文将深入探讨这两个概念，并提供一个Windows Forms应用程序的示例代码，以帮助理解它们的工作原理。 首先，让我们理解...
委托和代理示例代码-个人独创
11-03
最后，事件是.NET中基于委托的多播机制，用于实现发布/订阅模式。事件通常用于在类之间传递通知，而不会暴露内部实现细节。在示例中，你可能会看到如何声明事件，以及如何触发和订阅事件： ```csharp public class ...
jQuery事件绑定和委托实例
11-30
jQuery事件绑定和委托是JavaScript库jQuery中用于处理用户交互的核心机制。它们允许开发者响应用户的动作，如点击、鼠标悬浮、键盘输入等。本文将详细解释这些概念，并通过实例展示其用法。 1. `on()` 方法 `on()` ...
【UE4】入门级，游戏角色的生命,蓝条,盾值等属性动态多播代理的实现方法
Eiron_的博客
12-30 1366
【UE4】入门级，游戏角色的生命,蓝条,盾值等属性动态多播代理的实现方法动态多播代理（结合UMG蓝图）一：声明宏二：声明调度器三：代理调用四：在UMG蓝图中绑定五：结，扩展一下 动态多播代理（结合UMG蓝图） 动态多播代理允许被序列化的数据结构，这将使得代理可以被数据化提供给蓝图进行使用，达到在CPP中调用代理广播，事件通知到蓝图中。 用一个Demo里面角色的生命等属性的动态改变做案例介绍 一：声...
UE委托机制
qq_51466060的博客
12-13 1178
一、基本概念：Delegate,委托，又称代理，本质是一个特殊类的对象，它内部可以储存（一个或多个）函数指针、调用参数和返回值.委托的触发者不与监听者有直接关联，两者通过委托对象间接地建立联系.委托的作用如同函数指针，但它更安全（支持编译期类型安全检查），并且更易于使用。动态委托：同样分为单播和多播,意义和上面一样. 只能绑定UFUNCTION, 支持序列化, 可在蓝图中使用, 可以有UPROPERTY修饰,上面三种都不可以.绑定时不需要函数指针，仅需要函数名称字符串即可。移除委托：UnBind()
【UE】UEC++委托代理
Hank_W
11-30 838
UEC++委托代理
Unity游戏开发(C#语法):委托
weixin_49120362的博客
01-21 8455
一.什么是委托 1.委托的概述 为了实现方法的参数化，提出了委托的概念。委托是一种类，是一种引用类型，可以指向一个或者多个方法，该引用类型与其他引用类型不同。在委托对象的引用中存放的不是数据的引用，而是对方法的引用，即在委托的内部包含一个指向某个方法的指针。通过使用委托把方法的引用封装在委托对象中，然后将传递的给调用的引用方法的代码。这个委托类型的实例，可以和任何其他方法相关联起来，储存这些方法的引用只要类型兼容（类型兼容即任何方法他们的参数和返回值与委托的参数和返回值保持一致）。委托也是事件的本质，事件也
10.20UEC++/代理，单播，多播
qq_44160901的博客
07-09 418
构建一个无参无返回值类型的函数（也可以有参有返回值类型）相对应的构建一个无参无返回值类型的代理。
[UE C++] Delegate使用详解
qq_52179126的博客
03-30 3850
Delegate的使用方法总结终于告一段落，文章比较长，若有错误，欢迎指出。学疏才浅，还请见谅。
payload参数在ue4里单播委托怎么用
07-17
在UE4中，您可以使用单播委托（Unicast Delegate）来实现事件的触发和处理。单播委托允许将一个或多个方法注册为事件的处理程序，并且可以使用payload参数传递数据。 以下是在UE4中使用单播委托和payload参数的示例： 1. 在您的类声明中定义委托类型和委托实例。例如： ```cpp DECLARE_DELEGATE_OneParam(FMyDelegate, const FString&); FMyDelegate MyDelegate; ``` 2. 在需要触发事件的地方，调用委托实例并传递payload参数。例如： ```cpp FString Payload = "Hello, World!"; MyDelegate.Execute(Payload); ``` 3. 在其他地方注册方法作为事件的处理程序，并定义方法的签名与委托类型一致。例如： ```cpp void MyClass::MyMethod(const FString& Payload) { UE_LOG(LogTemp, Warning, TEXT("MyMethod executed with payload: %s"), *Payload); } // 注册方法作为处理程序 MyDelegate.BindUObject(this, &MyClass::MyMethod); ``` 在上面的示例中，我们声明了FMyDelegate作为委托类型，并创建了一个委托实例MyDelegate。然后，在需要触发事件的地方，我们调用MyDelegate的Execute方法，并传递Payload参数。 在另一个类（例如MyClass）中，我们定义了一个名为MyMethod的方法，并使用BindUObject将其注册为处理程序。当事件触发时，MyMethod方法将被执行，并且可以访问传递的payload参数。 请注意，上述示例中的代码仅为演示目的，实际使用时您需要根据您的需求和代码结构进行适当的修改和调整。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值