UE4运用C++和框架开发坦克大战教程笔记（六）（第16~19集）

最新推荐文章于 2024-10-19 15:29:34 发布
最新推荐文章于 2024-10-19 15:29:34 发布
阅读量101 收藏
点赞数
分类专栏： UE4/5 的学习笔记 文章标签： ue4 c++ 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q446013924/article/details/133910705
版权

UE4运用C++和框架开发坦克大战教程笔记（六）（第16~19集）

16. 生命周期系统一

DDModel 保存对象，并且也管理这些对象的生命周期。

下图截取自梁迪老师的 DataDriven 思维导图和说明文档。

对象的生命周期
UE4 的原生对象的生命周期没有这么多的方法，老师是以自己以前研究 Unity 的经验来复刻出这一套生命周期。框架里的对象根据自身生命周期的不同时刻处于对应的状态枚举（如右侧所示）。

接下来我们编写一下框架内对象的生命周期所用到的方法。

来到 DDTypes，声明两个对象生命周期相关的枚举。

再顺便声明一个根据对象名字或类名来调整查找对象的方式的枚举（比如获取这个名字的对象；或者是获取这个类所有的对象）。

DDTypes.h

#pragma region LifeTimePart

// BaseObject 生命周期
UENUM()
enum class EBaseObjectLife : uint8
{
	None = 0,	// 初始化状态
	Init,
	Loading,
	Register,
	Enable,
	Disable,
	UnRegister,
	UnLoading
};

// BaseObject 生命周期状态
UENUM()
enum class EBaseObjectState : uint8
{
	Active = 0,		// 激活
	Stable,			// 稳定
	Destroy			// 销毁
};

#pragma endregion

#pragma region ReflectPart

// 对象调用协议
UENUM()
enum class EAgreementType : uint8
{
	SelfObject,		// 给传入的对象通信
	OtherObject,	// 给传入的对象之外的对象通信
	ClassOtherObject,	// 给传入的对象的相同类的其他对象通信，调用这个方法要确保传过来的对象都是同一类的，如果不同类就多次通信
	SelfClass,		// 给这个类的对象通信
	OtherClass,		// 给这个类之外的类通信
	All				// 给所有的对象通信
};

#pragma endregion

既然是框架内对象的生命周期，那么我们把方法安排在框架内对象都要继承的 DDOO 接口。

DDOO.h

public:

	// 激活生命周期，激活成功后返回 true，停止调用
	bool ActiveLife();

	// 销毁生命周期函数，销毁成功后返回 true，从数据模块注销
	bool DestroyLife();

	// 生命周期，由模组管理器调用
	virtual void DDInit();	// 初始化
	virtual void DDLoading();	// 加载绑定的资源
	virtual void DDRegister();	// 注册数据或者事件
	virtual void DDEnable();	// 激活对象

	virtual void DDTick(float DeltaSeconds);	// 帧函数

	virtual void DDDisable();	// 失活对象
	virtual void DDUnRegister();	// 注销数据或者事件
	virtual void DDUnLoading();	// 销毁绑定资源
	virtual void DDRelease();	// 释放自己

	// 激活对象
	virtual void OnEnable();

	// 失活对象
	virtual void OnDisable(); 

	// 销毁自己
	void DDDestroy();

public:

	// 是否允许帧运行，如果要允许帧运行需要在构造函数或者 BeginPlay() 设置，在 UE4 里默认为 false
	bool IsAllowTickEvent;

	// 生命周期
	EBaseObjectLife LifeState;

	// 生命运行状态
	EBaseObjectState RunState;

生命周期的一些方法的实现部分先空着，后面再补充。

DDOO.cpp

bool IDDOO::ActiveLife()
{
	switch (LifeState)
	{
	case EBaseObjectLife::None:
		DDInit();
		LifeState = EBaseObjectLife::Init;
		break;
	case EBaseObjectLife::Init:
		DDLoading();
		LifeState = EBaseObjectLife::Loading;
		break;
	case EBaseObjectLife::Loading:
		DDRegister();
		LifeState = EBaseObjectLife::Register;
		break;
	case EBaseObjectLife::Register:
		DDEnable();
		LifeState = EBaseObjectLife::Enable;
		// 设置运行状态为稳定
		RunState = EBaseObjectState::Stable;
		// 返回 true，停止运行激活状态函数
		return true;
	}
	return false;
}

bool IDDOO::DestroyLife()
{
	switch (LifeState)
	{
	case EBaseObjectLife::Enable:
		DDDisable();
		LifeState = EBaseObjectLife::Disable;
		// 设置状态为销毁
		RunState = EBaseObjectState::Destroy;
		break;
	case EBaseObjectLife::Disable:
		DDUnRegister();
		LifeState = EBaseObjectLife::UnRegister;
		// 设置运行状态为销毁，避免从 Disable 状态下运行的对象没有修改 RunState 为销毁
		RunState = EBaseObjectState::Destroy;
		break;
	case EBaseObjectLife::UnRegister:
		DDUnLoading();
		LifeState = EBaseObjectLife::UnLoading;
		// 返回 true，停止运行销毁状态函数
		return true;
	}
	return false;
}

void IDDOO::DDInit()
{}
void IDDOO::DDLoading()
{}
void IDDOO::DDRegister()
{}
void IDDOO::DDEnable()
{}
void IDDOO::DDTick(float DeltaSeconds)
{}
void IDDOO::DDDisable()
{}
void IDDOO::DDUnRegister()
{}
void IDDOO::DDUnLoading()
{}
void IDDOO::DDRelease()
{}
void IDDOO::OnEnable()
{
	// 设置状态为激活状态
	LifeState = EBaseObjectLife::Enable;
}

void IDDOO::OnDisable()
{
	// 设置状态为失活状态
	LifeState = EBaseObjectLife::Disable;
}

void IDDOO::DDDestroy()
{
}

来到负责管理对象生命周期的 DDModel，完善之前没写完的 RegisterObject()。

声明三个用于保存对象的容器。

DDModel.h

protected:

	// 框架对象数组，Key : ObjectName， Value : *
	TMap<FName, IDDOO*> ObjectGroup;

	// 框架对象类集合，Key : ClassName，Value : TArray<IDDOO*>
	TMap<FName, TArray<IDDOO*>> ObjectClassGroup;

	// 需要激活生命周期的对象集
	TArray<IDDOO*> ObjectActiveGroup;

DDModel.cpp

void UDDModel::RegisterObject(IDDOO* ObjectInst)
{
	// 如果不重复就添加到模组对象
	if (!ObjectGroup.Contains(ObjectInst->GetObjectName())) {
		// 添加到对象组
		ObjectGroup.Add(ObjectInst->GetObjectName(), ObjectInst);
		// 添加到对象类组
		FName ObjectClassName = ObjectInst->GetClassName();
		if (ObjectClassGroup.Contains(ObjectClassName)) {
			ObjectClassGroup.Find(ObjectClassName)->Push(ObjectInst);
		}
		else {
			TArray<IDDOO*> ObjectArray;
			ObjectClassGroup.Add(ObjectClassName, ObjectArray);
			ObjectClassGroup.Find(ObjectClassName)->Push(ObjectInst);
		}
		// 添加对象到激活生命周期组
		ObjectActiveGroup.Push(ObjectInst);
	}
	else {
		// 有重复注册进行 Debug
		DDH::Debug() << "Object Repeated --> " << ObjectInst->GetObjectName() << DDH::Endl();
	}
}

void UDDModel::ModelTick(float DeltaSeconds)
{
}

如果编译没问题，则可以继续下一节课了。

17. 生命周期系统二

继续补充 DDModel 内的逻辑。

声明一个数组，专门保存需要运行 Tick 函数的对象。

通过 ModelTick() 来让需要运行 Tick 的对象参与到 Tick 里。

DDModel.h

protected:

	// 运行需要运行 Tick 函数的对象集合
	TArray<IDDOO*> ObjectTickGroup;

DDModel.cpp

void UDDModel::ModelTick(float DeltaSeconds)
{
	// 运行 Tick 组的 Tick 函数，放在此处确保在 Tick 组里的对象才会执行 DDTick()
	for (int i = 0; i < ObjectTickGroup.Num(); ++i)
		ObjectTickGroup[i]->DDTick(DeltaSeconds);
		
	// 临时保存完成某个周期的对象
	TArray<IDDOO*> TempObjectGroup;
	// 循环运行激活生命周期函数
	for (int i = 0; i < ObjectActiveGroup.Num(); ++i) {
		// 如果激活成功
		if (ObjectActiveGroup[i]->ActiveLife()) {
			TempObjectGroup.Push(ObjectActiveGroup[i]);
		}
	}
	// 将运行完激活生命周期的对象移出激活生命周期组，并且将运行 Tick 的对象添加到 Tick 组
	for (int i = 0; i < TempObjectGroup.Num(); ++i) {
		ObjectActiveGroup.Remove(TempObjectGroup[i]);
		if (TempObjectGroup[i]->IsAllowTickEvent)
			ObjectTickGroup.Push(TempObjectGroup[i]);
	}
}

编译后，创建一个 C++ 的 DDActor 类，目标模块选择 RaceCarFrame (Runtime)，路径直接为 Source/RaceCarFrame，取名为 LifeCallActor。

在 LifeCallActor 重写 DDOO 的激活周期相关的方法，添加一些 Debug 语句，简单测试下其生命周期。

LifeCallActor.h

public:

	virtual void DDInit() override;

	virtual void DDLoading() override;

	virtual void DDRegister() override;

	virtual void DDEnable() override;

	virtual void DDTick(float DeltaSeconds) override;

LifeCallActor.cpp

void ALifeCallActor::DDInit()
{
	Super::DDInit();

	IsAllowTickEvent = true;	// 如果改成 false 则关闭 DDTick()

	DDH::Debug() << "DDInit" << DDH::Endl();
}

void ALifeCallActor::DDLoading()
{
	DDH::Debug() << "DDLoading" << DDH::Endl();
}

void ALifeCallActor::DDRegister()
{
	DDH::Debug() << "DDRegister" << DDH::Endl();
}

void ALifeCallActor::DDEnable()
{
	DDH::Debug() << "DDEnable" << DDH::Endl();
}

void ALifeCallActor::DDTick(float DeltaSeconds)
{
	DDH::Debug(0.f) << "DDTick" << DDH::Endl();
}

编译后，来到 Blueprint 文件夹，之前创建的 ShowActor_BP 可以删掉了。

在文件夹内创建 LifeCallActor 的蓝图，取名为 LifeCallActor_BP。打开蓝图，在其细节面板的 DataDriven 目录下，将 Module Name 的值设置为 Center。
将蓝图放进场景中，运行游戏，可以看见左上角的 Debug 语句。说明框架内的对象在激活生命周期中运行正常。

在这里插入图片描述

销毁生命周期

接下来我们测试下框架内对象的销毁生命周期。

来到 DDModel，声明一个指定对象名来销毁对象的方法；再声明三个容器用于保存进入销毁流程的对象。

DDModel.h

public:

	// 通过对象名销毁对象，销毁对象本体调用
	void DestroyObject(FName ObjectName);

protected:

	// 销毁生命周期的对象集
	TArray<IDDOO*> ObjectDestroyGroup;

	// 释放周期函数对象集合，只执行一次就全部释放
	TArray<IDDOO*> ObjectReleaseGroup;

	// 预销毁对象组，这些对象还处于激活生命周期，但是在激活生命周期没运行完之前就已经设定为要进行销毁
	TArray<IDDOO*> PreObjectDestroyGroup;

在 ModelTick() 里添加让对象进入销毁生命周期的逻辑。

由于老师不希望让一个仍处于激活中的、但已经预定要被销毁的对象直接在同一帧内从 “激活完毕” 直接进入到 “销毁 + 释放” 的流程，所以要把 “销毁 + 释放” 的逻辑放在 “把对象放进销毁对象组” 这个操作之前。

同理，释放的逻辑也放在销毁的逻辑之前，让方法处理的对象都是上一帧得出来的对象。

DDModel.cpp

void UDDModel::ModelTick(float DeltaSeconds)
{


	// 执行释放对象函数，清空释放组
	for (int i = 0; i < ObjectReleaseGroup.Num(); ++i)
		ObjectReleaseGroup[i]->DDRelease();
	ObjectReleaseGroup.Empty();

	// 清空临时对象组
	TempObjectGroup.Empty();
	// 运行销毁对象组的销毁生命周期函数
	for (int i = 0; i < ObjectDestroyGroup.Num(); ++i) {
		// 如果销毁生命周期执行完毕
		if (ObjectDestroyGroup[i]->DestroyLife()) {
			// 添加对象到释放对象组
			ObjectReleaseGroup.Push(ObjectDestroyGroup[i]);
			// 添加对象到临时组
			TempObjectGroup.Push(ObjectDestroyGroup[i]);
			// 清除掉该销毁的对象
			ObjectGroup.Remove(ObjectDestroyGroup[i]->GetObjectName());
			ObjectClassGroup.Find(ObjectDestroyGroup[i]->GetClassName())->Remove(ObjectDestroyGroup[i]);
			// 如果类对象数组为空
			if (ObjectClassGroup.Find(ObjectDestroyGroup[i]->GetClassName())->Num() == 0)
				ObjectClassGroup.Remove(ObjectDestroyGroup[i]->GetClassName());
		}
	}

	// 把销毁的对象从销毁对象组移除
	for (int i = 0; i < TempObjectGroup.Num(); ++i)
		ObjectDestroyGroup.Remove(TempObjectGroup[i]);

	// 清空临时对象组
	TempObjectGroup.Empty();
	// 处理预销毁对象组，如果对象进入稳定状态，就跳转到临时对象组
	for (int i = 0; i < PreObjectDestroyGroup.Num(); ++i) {
		if (PreObjectDestroyGroup[i]->RunState == EBaseObjectState::Stable) {
			// 添加稳定运行状态的对象到临时对象组
			TempObjectGroup.Push(PreObjectDestroyGroup[i]);
		}
	}
	// 从预销毁对象组中清除稳定状态对象
	for (int i = 0; i < TempObjectGroup.Num(); ++i) {
		PreObjectDestroyGroup.Remove(TempObjectGroup[i]);
		// 添加到销毁对象组
		ObjectDestroyGroup.Push(TempObjectGroup[i]);
		// 移除出帧函数组
		ObjectTickGroup.Remove(TempObjectGroup[i]);
	}
}

void UDDModel::DestroyObject(FName ObjectName)
{
	// 获取需要销毁的对象
	if (ObjectGroup.Contains(ObjectName)) {
		IDDOO* TargetObject = *ObjectGroup.Find(ObjectName);
		// 如果销毁对象组以及预销毁对象组都没有该对象
		if (!ObjectDestroyGroup.Contains(TargetObject) && !PreObjectDestroyGroup.Contains(TargetObject)) {
			// 如果是稳定状态就添加到 ObjectDestroyGroup，如果是激活状态就添加到 PreObjectDestroyGroup
			switch (TargetObject->RunState)
			{
				case EBaseObjectState::Active:
					PreObjectDestroyGroup.Push(TargetObject);
					break;
				case EBaseObjectState::Stable:
					ObjectDestroyGroup.Push(TargetObject);
					ObjectTickGroup.Remove(TargetObject);
					break;
			}
		}
	}
}

如果编译成功，则说明没有问题，下一节课会继续补充销毁过程的代码，并测试对象的销毁生命周期。

18. 数据模块系统一

接下来测试销毁方法。先来到 DDModule 声明一个销毁模组下指定名字的对象的方法。

DDModule.h

public:

	// 模组所属对象销毁自身
	void ChildDestroy(FName ObjectName);

DDModule.cpp

void UDDModule::ChildDestroy(FName ObjectName)
{
	Model->DestroyObject(ObjectName);
}

某些类调用获取世界的方法会返回空，所以给 DDOO 声明一个获取世界的方法，用于调用引擎原生的销毁函数。

DDOO.h

public:

	// 框架获取世界函数
	UWorld* GetDDWorld() const;

让 DDOO 的 DDDestroy() 调用 DDModule 的销毁方法。

DDOO.cpp

UWorld* IDDOO::GetDDWorld() const
{
	// 通过 Driver 获取世界，必然可以获取到
	if (IDriver)
		return IDriver->GetWorld();
	return NULL;
}

void IDDOO::DDDestroy()
{
	IModule->ChildDestroy(GetObjectName());
}

比如 DDUserWidget、DDObject 等可能就不能直接获取到世界。之前忘了给 DDObject 继承一下 DDOO 的接口。

DDObject.h

#include "DDOO.h"	// 引入头文件
#include "DDObject.generated.h"

UCLASS()
class DATADRIVEN_API UDDObject : public UObject, public IDDOO	// 继承接口
{
	GENERATED_BODY()
};

不同对象之间释放资源的操作可能有差异。所以我们让继承 DDOO 接口的类来重写释放函数。

DDActor.h

public:

	// 重写释放函数
	virtual void DDRelease() override;

DDActor.cpp

void ADDActor::DDRelease()
{
	IDDOO::DDRelease();
	// 能调用这个方法那么一定是注册到了框架，获取的世界一定不为空
	GetDDWorld()->DestroyActor(this);
}

来到 LifeCallActor，重写销毁周期相关的方法，添加一些 Debug 语句测试下销毁生命周期。

声明一个整型变量，我们希望让对象在第三帧的时候进入销毁流程。

LifeCallActor.h

public:

	virtual void DDDisable() override;	// 失活对象

	virtual void DDUnRegister() override;	// 注销数据或者事件

	virtual void DDUnLoading() override;	// 销毁绑定资源

	virtual void DDRelease() override;	// 释放自己

protected:

	int32 TimeCounter;

给这些生命周期相关的方法都补充下对父类函数的调用。

LifeCallActor.cpp

void ALifeCallActor::DDInit()
{

	TimeCounter = 0;	// 初始化计时器

	DDH::Debug() << "DDInit" << DDH::Endl();
}


void ALifeCallActor::DDLoading()
{
	Super::DDLoading();

	DDH::Debug() << "DDLoading" << DDH::Endl();
}

void ALifeCallActor::DDRegister()
{
	Super::DDRegister();

	DDH::Debug() << "DDRegister" << DDH::Endl();
}

void ALifeCallActor::DDEnable()
{
	Super::DDEnable();

	DDH::Debug() << "DDEnable" << DDH::Endl();
}

void ALifeCallActor::DDTick(float DeltaSeconds)
{
	Super::DDTick(DeltaSeconds);

	TimeCounter++;

	if (TimeCounter < 3) {
		DDH::Debug() << "DDTick --> " << TimeCounter << DDH::Endl();
	}
	else if (TimeCounter == 3) {
		DDDestroy();
		
		DDH::Debug() << "DDDestroy" << DDH::Endl();
	}
}

void ALifeCallActor::DDDisable()
{
	Super::DDDisable();

	DDH::Debug() << "DDDisable" << DDH::Endl();
}

void ALifeCallActor::DDUnRegister()
{
	Super::DDUnRegister();

	DDH::Debug() << "DDUnRegister" << DDH::Endl();
}

void ALifeCallActor::DDUnLoading()
{
	Super::DDUnLoading();

	DDH::Debug() << "DDUnLoading" << DDH::Endl();
}

void ALifeCallActor::DDRelease()
{
	Super::DDRelease();

	DDH::Debug() << "DDRelease" << DDH::Endl();
}

打开 LifeCallActor_BP，给其添加一个网格体组件，然后任意赋予一个网格体。确保其 Tick 函数可以运行。

运行游戏，可以看到场景的 LifeCallActor_BP 实例被销毁了，并且左上角按生命周期的顺序输出了 Debug 语句。

在这里插入图片描述
前面说到不同对象的销毁方式可能有差异。比如 Actor 可以用 UE4 提供的 DestroyActor() 来销毁并释放（但并不是立刻销毁，而是在空闲时在销毁并释放）。老师之所以要设计 DDRelease() 和 ObjectReleaseGroup 是为了让将要释放的对象在完全不需要的时候才进行释放，否则立即销毁可能会导致一些指向对象的、还要使用的指针变成野指针。

通过对象名字批量获取目标对象

我们前面实现了让指定名字的对象销毁的方法，现在我们想一次性让多个对象改变生命周期状态。这时候就需要用到前面声明的 EAgreementType 枚举来选中相应对象了。

来到 DDModel，声明三个方法用于改变目标对象组的生命周期状态，不过我们先留到后面再写。然后再声明两个方法，它们会用两种不同的方式获取目标对象，对应了 EAgreementType 的前两个枚举值。

DDModel.h

public:

	// 销毁对象
	void DestroyObject(EAgreementType Agreement, TArray<FName> TargetNameGroup);

	// 激活对象
	void EnableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup);

	// 失活对象
	void DisableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup);

	// 根据传入的对象名获取对象
	void GetSelfObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

	// 根据传入的对象名获取这些对象名对应对象外的其他对象
	void GetOtherObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

DDModel.cpp

void UDDModel::DestroyObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
}

void UDDModel::EnableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
}

void UDDModel::DisableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
}

void UDDModel::GetSelfObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	for (int i = 0; i < TargetNameGroup.Num(); ++i)
		if (ObjectGroup.Contains(TargetNameGroup[i]))
			TargetObjectGroup.Push(*ObjectGroup.Find(TargetNameGroup[i]));
}

void UDDModel::GetOtherObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	for (TMap<FName, IDDOO*>::TIterator It(ObjectGroup); It; ++It) {
		bool IsSame = false;
		for (int i = 0; i < TargetNameGroup.Num(); ++i) {
			// 检测名字是否相同，相同就跳出
			if (TargetNameGroup[i].IsEqual(It->Key)) {
				IsSame = true;
				break;
			}
		} 
		if (!IsSame)
			TargetObjectGroup.Push(It->Value);
	}
}

剩余的部分留到下一节课继续完善。

19. 数据模块系统二

继续在 DDModel 里完善获取框架内对象的四个方法，毕竟对象获取协议的枚举 EAgreementType 是定义了六个枚举值的。

再声明一个方法，根据传入的 EAgreementType 的值来以相应的方法获取对象。

DDModel.h

public:


	// 根据名字数组获取相同类的其他对象，返回这个类的对象的数量
	// 名字数组里面对应的对象必须都是同一个类的
	void GetClassOtherObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

	// 根据名字获取类的对象
	void GetSelfClass(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

	// 根据名字获取类以外的对象
	void GetOtherClass(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

	// 获取所有对象
	void GetAll(TArray<IDDOO*>& TargetObjectGroup);

	// 根据协议获取对象集合
	void GetAgreementObject(EAgreementType Agreement, TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup);

并且把我们上节课声明好的，批量改变对象生命周期状态的方法给补充上逻辑。

DDModel.cpp

void UDDModel::DestroyObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
	// 定义获取到的对象数组
	TArray<IDDOO*> TargetObjectGroup;

	// 根据协议获取对象
	GetAgreementObject(Agreement, TargetNameGroup, TargetObjectGroup);

	// 批量销毁对象
	for (int i = 0; i < TargetObjectGroup.Num(); ++i) {
		// 如果销毁对象组以及预销毁对象组都没有该对象
		if (!ObjectDestroyGroup.Contains(TargetObjectGroup[i]) && !PreObjectDestroyGroup.Contains(TargetObjectGroup[i])) {
			// 如果是稳定状态就添加到 ObjectDestroyGroup，如果是激活状态就添加到 PreObjectDestroyGroup
			switch(TargetObjectGroup[i]->RunState) 
			{
				case EBaseObjectState::Active:
					PreObjectDestroyGroup.Push(TargetObjectGroup[i]);
					break;
				case EBaseObjectState::Stable:
					ObjectDestroyGroup.Push(TargetObjectGroup[i]);
					ObjectTickGroup.Remove(TargetObjectGroup[i]);
					break;
			}
		}
	}
}

void UDDModel::EnableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
	// 定义获取到的对象数组
	TArray<IDDOO*> TargetObjectGroup;

	// 根据协议获取对象
	GetAgreementObject(Agreement, TargetNameGroup, TargetObjectGroup);

	for (int i = 0; i < TargetObjectGroup.Num(); ++i) {
		// 如果这个对象处于稳定与失活状态就运行它的激活状态函数
		if (TargetObjectGroup[i]->RunState == EBaseObjectState::Stable && TargetObjectGroup[i]->LifeState == EBaseObjectLife::Disable) {
			TargetObjectGroup[i]->OnEnable();
		}
	}
}

void UDDModel::DisableObject(EAgreementType Agreement, TArray<FName> TargetNameGroup)
{
	// 定义获取到的对象数组
	TArray<IDDOO*> TargetObjectGroup;

	// 根据协议获取对象
	GetAgreementObject(Agreement, TargetNameGroup, TargetObjectGroup);

	for (int i = 0; i < TargetObjectGroup.Num(); ++i) {
		// 如果这个对象处于稳定与失活状态就运行它的激活状态函数
		if (TargetObjectGroup[i]->RunState == EBaseObjectState::Stable && 
			TargetObjectGroup[i]->LifeState == EBaseObjectLife::Enable) {
			TargetObjectGroup[i]->OnDisable();
		}
	}
}



void UDDModel::GetClassOtherObject(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	if (!ObjectGroup.Contains(TargetNameGroup[0]))
		return;
	// 先获取对象类名
	FName ObjectClassName = (*ObjectGroup.Find(TargetNameGroup[0]))->GetClassName();
	// 迭代对象类实例数组
	for (TArray<IDDOO*>::TIterator It(*ObjectClassGroup.Find(ObjectClassName)); It; ++It) {
		bool IsSame = false;
		for (int i = 0; i < TargetNameGroup.Num(); ++i) {
			if ((*It)->GetObjectName().IsEqual(TargetNameGroup[i])) {
				IsSame = true;
				break;
			}
		}
		if (!IsSame)
			TargetObjectGroup.Push(*It);
	}
}

void UDDModel::GetSelfClass(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	for(int i = 0; i < TargetNameGroup.Num(); ++i) {
		// 如果不包含这个类，跳到下一个循环
		if (!ObjectClassGroup.Contains(TargetNameGroup[i]))
			continue;
		TargetObjectGroup.Append(*ObjectClassGroup.Find(TargetNameGroup[i]));
	}
}

void UDDModel::GetOtherClass(TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	for (TMap<FName, TArray<IDDOO*>>::TIterator It(ObjectClassGroup); It; ++It) {
		if (!TargetNameGroup.Contains(It->Key))
			TargetObjectGroup.Append(It->Value);
	}
}

void UDDModel::GetAll(TArray<IDDOO*>& TargetObjectGroup)
{
	ObjectGroup.GenerateValueArray(TargetObjectGroup);
}

void UDDModel::GetAgreementObject(EAgreementType Agreement, TArray<FName> TargetNameGroup, TArray<IDDOO*>& TargetObjectGroup)
{
	switch(Agreement)
	{
		case EAgreementType::SelfObject:
			GetSelfObject(TargetNameGroup, TargetObjectGroup);
			break;
		case EAgreementType::OtherObject:
			GetOtherObject(TargetNameGroup, TargetObjectGroup);
			break;
		case EAgreementType::ClassOtherObject:
			GetClassOtherObject(TargetNameGroup, TargetObjectGroup);
			break;
		case EAgreementType::SelfClass:
			GetSelfClass(TargetNameGroup, TargetObjectGroup);
			break;
		case EAgreementType::OtherClass:
			GetOtherClass(TargetNameGroup, TargetObjectGroup);
			break;
		case EAgreementType::All:
			GetAll(TargetObjectGroup);
			break;
	}
}

DDActor 类有 BeginPlay()，在里面调用注册到框架的方法后，只要把实例放进场景里就可以自动注册到框架。但是像 UObject、UserWidget 这些类就没有 BeginPlay()，所以它们需要手动进行注册，后面会讲到。

来到接口类 DDOO，添加一个 “根据传入的模组 ID 来注册模组” 的方法。

DDOO.h

public:

	void RegisterToModule(FName ModName, FName ObjName = FName(), FName ClsName = FName());

	// 同上，只转入模组 Index
	void RegisterToModule(int32 ModIndex, FName ObjName = FName(), FName ClsName = FName());

DDOO.cpp

void IDDOO::RegisterToModule(int32 ModIndex, FName ObjName, FName ClsName)
{
	if (IDriver && IModule) return;
	// 去掉对 ModName 的判断
	if (!ObjName.IsNone()) IObjectName = ObjName;
	if (ClsName.IsNone()) IClassName = ClsName;
	IBody = Cast<UObject>(this);
	IDriver = UDDCommon::Get()->GetDriver();
	if (IDriver) {
		// 直接提供模组序号
		ModuleIndex = ModIndex;
		if (ModuleIndex < 0) {
			// 更改下 Debug 语句
			DDH::Debug() << GetObjectName() << " Get ModuleIndex " << ModuleIndex << " Failed!" << DDH::Endl();
			return;
		}
		if (!IDriver->RegisterToModule(this)) {
			// 更改下 Debug 语句
			DDH::Debug() << GetObjectName() << " Register To ModuleIndex " << ModuleIndex << " Failed!" << DDH::Endl();
		}
	}
	else {
		DDH::Debug() << GetObjectName() << " Get DDDriver Failed!" << DDH::Endl();
	}
}

给 DDObject 和 DDUserWidget 也重写一下 DDRelease()，因为它们的销毁方法不同。并且由于是手动注册到框架所以不需要 3 个名字变量了。

DDObject.h

public:

	// 重写释放函数
	virtual void DDRelease() override;

DDObject.cpp

void UDDObject::DDRelease()
{
	IDDOO::DDRelease();
	// 从 Root 移除
	RemoveFromRoot();
	// 准备回收资源
	ConditionalBeginDestroy();
}

DDUserWidget.h

#include "DDOO.h"	// 引入头文件
#include "DDUserWidget.generated.h"

UCLASS()
class DATADRIVEN_API UDDUserWidget : public UUserWidget, public IDDOO	// 继承接口
{
	GENERATED_BODY()

public:

	// 重写释放函数
	virtual void DDRelease() override;
};

DDUserWidget.h

void UDDUserWidget::DDRelease()
{
	IDDOO::DDRelease();
	// 再检查一次从父类移除
	RemoveFromParent();
	// 从 Root 移除
	RemoveFromRoot();
	// 准备回收资源
	ConditionalBeginDestroy();
}

如果编译可以通过，则说明没问题了。

犀利贝XD
关注
专栏目录
UE4 C++教程 虚幻四C++教程
06-10
UE4 C++教程 虚幻四C++教程
UE4游戏编程蓝图c++语言教程
06-07
虚幻引擎4（UE4）提供了两种主要的编程方式，即C++和蓝图。C++是一种通用的文本编程语言，适合进行底层逻辑和性能敏感的代码编写，而蓝图则是一种图形化编程工具，更适合快速原型设计和游戏逻辑的可视化表达。 在UE...
(UE4UE5)UE5开发回合制游戏（蓝图和C++版本）PGJ.zip
10-02
(UE4UE5)UE5开发回合制游戏（蓝图和C++版本）【PGJ】.zip (UE4UE5)UE5开发回合制游戏（蓝图和C++版本）【PGJ】.zip (UE4UE5)UE5开发回合制游戏（蓝图和C++版本）【PGJ】.zip (UE4UE5)UE5开发回合制游戏（蓝图和C++...
毕业设计基于C++的一款UE4射击游戏源码.zip
06-16
毕业设计基于C++的一款UE4射击游戏源码。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套...
UE4 材质学习笔记08（雨滴流淌着色器/雨水涟漪着色器）
Mr_Dongzheng的博客
10-11 748
法线贴图在红色通道和绿色通道上，那是法线的X轴和Y轴，在蓝色通道中 我有个用于雨滴流淌的蒙版，在Alpha通道中，有个时间偏移蒙版。这些贴图都是可以在PS上制作做来的，雨滴流淌图可以直接用笔刷画出来然后模糊下线，然后可以将这个图作为高度图并使用NVIDIA Photoshop插件将其转换为法线贴图直接输出以后是这样的效果，但是我不想用UV坐标把它投射到立方体上，实际上我想把它们投射到世界空间中，这样不管物体有多大，也不管物体去哪里或者如何旋转，这些小水流将始终保持向上和向下的方向。
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 540
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
OpenGL Texture C++ Camera Filter滤镜视频录制
最新发布
wangyongyao1989的博客
10-19 571
​ OpenGL Texture C++ Camera Filter滤镜视频录制; 基于文章1/2/3的代码，结合Google开源项目grafika中的WindowSurface.java/Coregl.java/TextureMovieEncoder2.java/VideoEncoderCore.java创建出录制视频的surface并根据此切换GLContext上下文交换（swapBuffer）渲染与显示的视频数据，最终在VideoEncoderCore中通过MediaCodec获取出encodeDat
编码风格之(8)C++语言规范(Google风格)3.md
Once_day的回忆
10-17 933
**最重要的一致性规则是那些控制命名的规则**。名称的风格会立即告诉我们命名实体是什么类型：类型、变量、函数、常量、宏等，而无需我们搜索该实体的声明。我们大脑中的模式匹配引擎很大程度上依赖于这些命名规则。 命名规则相当随意，但我们认为一致性比个人偏好更重要，因此无论您是否认为它们合理，规则就是规则(遵循一致性)。
C++中的vector介绍（常用函数）
zxybf_的博客
10-15 795
vector的文档介绍vector是序列容器，表示可以改变大小的数组。(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造int main()//无参的构造//n个val的构造//拷贝构造//迭代器区间构造return 0;
第一节、C语言概览
lopowh的博客
10-13 307
C语言中格式化输出函数为printf（），它用来输出数据到计算机屏幕或文件中。程序语言一般都是由关键字，标识符和其他语法单位组成。Printf("，")；Scanf("",)用来从标准输入设备（键盘）读取输入的信息。
【C++】使用 yaml-cpp 库操作 YAML
coco的专栏
10-16 863
配置文件有利于我们灵活配置工程，解决大量重复劳动，也方便调试。YAML 是一种人类可读的数据序列化格式，它使用缩进和特定的符号来表示数据结构。在本文中，我们将详细介绍如何在 C++ 中使用yaml-cpp库来解析和生成 YAML 格式的数据。
[C++ 核心编程]笔记 4.1.2 struct和class的区别
Alex的博客
10-13 253
在C++中 struct和class唯一的区别就在于 默认的访问权限不同。
STL-string+题目
cleveryuoyuo的博客
10-16 209
string
详细说明如何使用C++编写A*算法
zsy54577的博客
10-19 973
它结合了广度优先搜索的全面性和深度优先搜索的效率，通过估计当前路径代价和到达目标的预估代价，来找到从起点到目标的最短路径。类型的指针，它指向当前节点的父节点。在路径搜索树中，每个节点（除了根节点）都有一个父节点，指向它在树中的直接上级。这个指针用于重建从起点到终点的路径，一旦找到终点，可以通过追踪这些父节点指针回溯到起点。通过构建一个优先队列，A*算法每次从未探索的节点中选择f值最小的节点进行扩展，直至找到目标节点或遍历完整个搜索空间。
南沙C++信奥赛陈老师解一本通题 1943：【08NOIP普及组】排座椅
vx_cyf1333888的博客
10-16 263
第一行包含KK个整数，a1,a2……bL，表示第b1b1列和b1+1b1+1列之间，第b2b2列和b2+1b2+1列之间、。第ii行的44个证书Xi，Yi，Pi，OiXi，Yi，Pi，Oi,表示坐在位置（Xi，YiXi，Yi）与（Pi，OiPi，Oi）的两个同学会交头接耳（输入保证他们前后相邻或者左右相邻）。第一行，有55个用空格隔开的证书，分别是M,N,K,L,D（2≤N,M≤1000,0≤K<M,0≤L<N,D≤2000）M,N,K,L,D（2≤N,M≤1000,0≤K<M,0≤L<N,D≤2000）
【C语言】define宏定义与const修饰限定
我的我的博客
10-15 240
define宏定义纸进行字符串替换，无类型检查。const修饰符限定变量为只读变量。两者都是将字符替换为相应的数值。
C++ vector迭代器失效
10-15 263
参考博文： https://blog.csdn.net/m0_61982936/article/details/132548446此前一直没有注意到vector的失效情景，但仔细思考下发现有很多失效的坑。首先需要明确的是vector的扩容：有两个参数size:指的是vector当前元素多少capacity:指的是vector的容量，也即max_size。如果size >= capacity时就会发生扩容，拷贝元素并且释放旧空间。通常采用1.5倍扩容或者2倍扩容。
每日OJ题_牛客_对称之美_哈希_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
10-16 313
每日OJ题_牛客_对称之美_哈希_C++_Java（左右指针判断回文串。 判断左右指针相等的时候，应该看看两个字符串中有没有相同的字符。）
C++：从小白到基础（一）
zh060515的博客
10-14 1052
C++是基于C进行开发的，不仅有着超高的运行效率，还有着诸多被封装好的库，这大大加强了C++的开发效率。现在C++主要运用在游戏开发，嵌入式系统开发等领域。以下是C++的关键字关于具体介绍请看以下链接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值