UE C++进阶 | 异步

已于 2023-04-06 23:03:08 修改
阅读量1.3k 收藏 11
点赞数 5
分类专栏： 虚幻引擎 文章标签： c++ unreal engine 5
于 2023-03-05 19:38:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryacber/article/details/129345097
版权

文章目录

UE C++进阶 | 异步

潜伏事件

  • 在UE的蓝图中存在一种可以实现异步执行的节点，
  • 想要去实现我们自己的异步节点，首先我们需要了解FPendingLatentAction。

Unreal - FPendingLatentAction

  • 中文翻译来说应该是待定的潜伏动作。
  • 我们先来看看它的源码。
  • 存在几个虚函数，看起来UpdateOperation是关键。
  • Response.DoneIf(true);是该动作标志着工作做完了调用的，相当与需要 destory了。
class ENGINE_API FPendingLatentAction
{
public:
    // 构造
	FPendingLatentAction()
	{
	}

    // 析构
	virtual ~FPendingLatentAction()
	{
	}

	// 动作完成后传入true，然后就会被销毁。
	virtual void UpdateOperation(FLatentResponse& Response)
	{
		Response.DoneIf(true);
	}

	/* 让潜伏的动作知道，产生它的对象已经被垃圾回收了。
     * 并且该动作将被销毁（不再有UpdateOperation的调用，并且CallbackTarget已经是NULL)
     * 只有当对象在动作完成前离开时才会被调用。
    */
	virtual void NotifyObjectDestroyed() {}

	virtual void NotifyActionAborted() {}
#if WITH_EDITOR
	// 返回对潜伏操作当前状态的可读描述。
	virtual FString GetDescription() const;
#endif
};

Unreal - Delay节点

  • 例如我们常用的Delay节点，当输入执行节点被触发后，输出执行节点直到对应时间耗尽后才会触发。
    Delay节点
  • 让我们先分析一下源码。

FDelayAction

  • 继承自FPendingLatentAction。
  • 声明有几个变量，其中有几个参数是为LatentInfo服务的。
  • 重写了UpdateOperation，这个函数因为相当于 Tick函数，所以可以写一些计时的业务逻辑。
  • 重写了GetDescription，为了使得在蓝图调试过程中打印在节点上。
    Delay节点的打印
class FDelayAction : public FPendingLatentAction
{
public:
	float TimeRemaining;            // 业务变量
	FName ExecutionFunction;        // LatentInfo服务
	int32 OutputLink;               // LatentInfo服务
	FWeakObjectPtr CallbackTarget;  // LatentInfo服务

    // 有参构造
	FDelayAction(float Duration, const FLatentActionInfo& LatentInfo)
		: TimeRemaining(Duration)
		, ExecutionFunction(LatentInfo.ExecutionFunction)
		, OutputLink(LatentInfo.Linkage)
		, CallbackTarget(LatentInfo.CallbackTarget)
	{
	}

    // 业务逻辑
	virtual void UpdateOperation(FLatentResponse& Response) override
	{   
        // 定时器
		TimeRemaining -= Response.ElapsedTime();
        // 完成与触发，如果想要深入理解可以去看FLatentResponse，这个函数相当于DoneIf + TriggerLink。
		Response.FinishAndTriggerIf(TimeRemaining <= 0.0f, ExecutionFunction, OutputLink, CallbackTarget);
	}

#if WITH_EDITOR
    // 蓝图调试过程中打印
	virtual FString GetDescription() const override
	{
		static const FNumberFormattingOptions DelayTimeFormatOptions = FNumberFormattingOptions()
			.SetMinimumFractionalDigits(3)
			.SetMaximumFractionalDigits(3);
		return FText::Format(NSLOCTEXT("DelayAction", "DelayActionTimeFmt", "Delay ({0} seconds left)"), FText::AsNumber(TimeRemaining, &DelayTimeFormatOptions)).ToString();
	}
#endif
};

函数声明:

UFUNCTION(BlueprintCallable, Category="Utilities|FlowControl", meta=(Latent, WorldContext="WorldContextObject", LatentInfo="LatentInfo", Duration="0.2", Keywords="sleep"))
static void	Delay(const UObject* WorldContextObject, float Duration, struct FLatentActionInfo LatentInfo );
  • 头文件基本信息:
    • 基类 - UBlueprintFunctionLibrary
      • ↳ UKismetSystemLibrary- \\UE_5.1\Engine\Source\Runtime\Engine\Classes\Kismet\KismetSystemLibrary.h
        • ↳ 类静态函数 Delay。
  • 用法：执行一个有延迟的潜伏动作（以秒为单位指定），在其倒计时时再次调用将被忽略。
  • 宏标记解析：
    • BlueprintCallable: 该函数可以在蓝图或关卡蓝图图表中执行。
    • Category: 指定函数在编辑器中的显示分类层级。
    • meta
      • Lantent: 表示潜在的行动。
      • WorldContext = “WorldContextObject”: 用来指示哪个参数确定操作正在发生的世界。
      • LatentInfo = “LatentInfo”: 指示哪个参数是LatentInfo参数。
      • Duration = “0.2”: 默认值。
      • Keywords = “sleep”: 指定搜索此函数时可以使用的一组关键字。
  • 参数：
    • WorldContextObject - 世界上下文，已经由meta绑定。
    • Duration - 延迟的长度（以秒为单位）
    • LatentInfo - 潜在的动作信息，已经由meta绑定。

函数实现:

void UKismetSystemLibrary::Delay(const UObject* WorldContextObject, float Duration, FLatentActionInfo LatentInfo )
{
	if (UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull))
	{
        // 去获得潜伏动作管理器
		FLatentActionManager& LatentActionManager = World->GetLatentActionManager(); 
        // 从潜伏动作管理器查找该节点位置是否已经存在此类动作位置
		if (LatentActionManager.FindExistingAction<FDelayAction>(LatentInfo.CallbackTarget, LatentInfo.UUID) == NULL)
		{
            // 找不到就加入新的潜伏动作
			LatentActionManager.AddNewAction(LatentInfo.CallbackTarget, LatentInfo.UUID, new FDelayAction(Duration, LatentInfo));
		}
	}
}

案例 - SustainedAxisTriggerAction (持续轴映射触发动作)

  • 到这我们大致了解了需要了解虚幻的潜伏动作，开始写我们自己的异步节点。
  • 这是一个我自己工作中实践出来的功能。
  • 它可以接受手柄的Axis值然后进行连续触发动作。
    • 具体：在接收手柄输入后，进行第一次触发，如果持续按住的状态下，在一定时间过后开始进行连续触发。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 源码展示
// Copyright(c) 2023 TangYijun All rights reserved.

#pragma once

#include "LatentActions.h"
#include "Misc/EnumRange.h"

// 轴输入的几个阶段
UENUM(BlueprintType)
enum class ESustainedAxisState : uint8
{
	EPress,
	ELowPulseInterval,
	ELowPulseTrigger,
	EHighPulseInterval,
	ELowToHighTransition,
	EHighPulseTrigger,
	ECount
};

// 轴映射的正反
UENUM(BlueprintType)
enum class ESustainedAxisExec : uint8
{
	EPositive,
	ENegative
};

// 创建枚举的计数
ENUM_RANGE_BY_COUNT(ESustainedAxisState, ESustainedAxisState::ECount);

// 基类
class FSustainedAxisTriggerActionBase : public FPendingLatentAction
{
public:
	float Axis;             // 轴输入
	float AxisThreshold;    // 创建枚举的计数

	FName ExecutionFunction;
	int32 OutputLink;
	FWeakObjectPtr CallbackTarget;

	ESustainedAxisExec& ExecRef;    // 节点的输出执行线

protected:
	TBitArray<> AxisStateBits;      // 轴输入的激活状态集
	TMap<ESustainedAxisState, float> CountMap;  // 计时器
	bool bIsPress;  // 是否摁下
public:
    //构造
	FSustainedAxisTriggerActionBase(float Axis, float AxisThreshold, const FLatentActionInfo& LatentInfo, ESustainedAxisExec& AxisExec)
		: Axis(Axis)
		, AxisThreshold(AxisThreshold)
		, ExecutionFunction(LatentInfo.ExecutionFunction)
		, OutputLink(LatentInfo.Linkage)
		, CallbackTarget(LatentInfo.CallbackTarget)
		, ExecRef(AxisExec)
	{
        // 初始化状态集
		AxisStateBits = TBitArray<>(false, uint8(ESustainedAxisState::ECount));
	}

    // 业务更新
	virtual void UpdateOperation(FLatentResponse& Response) override
	{
        // 判断轴输入
		bIsPress = Axis > AxisThreshold || Axis < -AxisThreshold;
        
		UpdateDoneIf(Response); // 更新执行线走向
		UpdateTimer(Response);  // 更新计时器
	}

protected:
	FORCEINLINE bool IsTimeOver(const ESustainedAxisState& State)
	{
		return CountMap[State] <= 0.f && AxisStateBits[uint8(State)];
	}

	FORCEINLINE void EnterState(const ESustainedAxisState& State)
	{
		AxisStateBits[uint8(State)] = true;
	}

	FORCEINLINE void ExitState(const ESustainedAxisState& State)
	{
		AxisStateBits[uint8(State)] = false;
	}

	FORCEINLINE void UpdateTimer(FLatentResponse& Response)
	{
		for (ESustainedAxisState AxisState : TEnumRange<ESustainedAxisState>())
		{
			if (CountMap.Contains(AxisState))
			{
				if (AxisStateBits[uint8(AxisState)])
				{
					CountMap[AxisState] -= Response.ElapsedTime();
				}
			}
		}
	}

	FORCEINLINE void UpdateDoneIf(FLatentResponse& Response)
	{
		if (!bIsPress)
		{
			Response.DoneIf(!bIsPress);
		}
		else
		{
			if (Axis > AxisThreshold)
			{
				ExecRef = ESustainedAxisExec::EPositive;
			}
			else if (Axis < -AxisThreshold)
			{
				ExecRef = ESustainedAxisExec::ENegative;
			}
		}
	}

};

// 一阶段持续轴触发动作，就是按下后一定时间开始保持持续触发状态。
class FOneStepSustainedAxisTriggerAction : public FSustainedAxisTriggerActionBase
{
public:

	float PulseTriggerTime; // 脉冲触发时间 - 触发频率。
	float PulseIntervalTime;// 脉冲间隔时间 - 从触发第一次到开始持续触发状态的间隔时间。

	FOneStepSustainedAxisTriggerAction(float Axis, float AxisThreshold, float PulseTriggerTime, float PulseIntervalTime,
		const FLatentActionInfo& LatentInfo, ESustainedAxisExec& AxisExec)
		: FSustainedAxisTriggerActionBase(Axis, AxisThreshold, LatentInfo, AxisExec)
		, PulseTriggerTime(PulseTriggerTime)
		, PulseIntervalTime(PulseIntervalTime)
	{
        // 增加这两种状态的定时器
		CountMap.Emplace(ESustainedAxisState::ELowPulseInterval, PulseIntervalTime);
		CountMap.Emplace(ESustainedAxisState::ELowPulseTrigger, PulseTriggerTime);
	}

	virtual void UpdateOperation(FLatentResponse& Response) override
	{
		FSustainedAxisTriggerActionBase::UpdateOperation(Response);
        // 简易状态机
		if (bIsPress && !AxisStateBits[uint8(ESustainedAxisState::EPress)])
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			EnterState(ESustainedAxisState::EPress);
			EnterState(ESustainedAxisState::ELowPulseInterval);
		}

		if (IsTimeOver(ESustainedAxisState::ELowPulseInterval))
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			ExitState(ESustainedAxisState::ELowPulseInterval);
			EnterState(ESustainedAxisState::ELowPulseTrigger);
		}

		if (IsTimeOver(ESustainedAxisState::ELowPulseTrigger))
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			CountMap[ESustainedAxisState::ELowPulseTrigger] = PulseTriggerTime;
		}
	}
};

class FTwoStepSustainedAxisTriggerAction : public FSustainedAxisTriggerActionBase
{
public:
	float LowPulseTriggerTime;  // 低频脉冲触发时间 - 阶段一触发频率。
	float LowPulseIntervalTime; // 低频脉冲间隔时间 - 从触发第一次到开始阶段一的间隔时间。
	float HighPulseTriggerTime; // 高频脉冲触发时间 - 阶段二触发频率。
	float HighPulseIntervalTime;// 高频脉冲间隔时间 - 从阶段一到阶段二的间隔时间。

	FTwoStepSustainedAxisTriggerAction(float Axis, float AxisThreshold, float LowPulseTriggerTime,
		float LowPulseIntervalTime, float HighPulseTriggerTime, float HighPulseIntervalTime,
		const FLatentActionInfo& LatentInfo, ESustainedAxisExec& AxisExec)
		: FSustainedAxisTriggerActionBase(Axis, AxisThreshold, LatentInfo, AxisExec)
		, LowPulseTriggerTime(LowPulseTriggerTime)
		, LowPulseIntervalTime(LowPulseIntervalTime)
		, HighPulseTriggerTime(HighPulseTriggerTime)
		, HighPulseIntervalTime(HighPulseIntervalTime)
	{
        // 增加这四种状态的定时器
		CountMap.Emplace(ESustainedAxisState::ELowPulseInterval, LowPulseIntervalTime);
		CountMap.Emplace(ESustainedAxisState::ELowPulseTrigger, LowPulseTriggerTime);
		CountMap.Emplace(ESustainedAxisState::EHighPulseInterval, HighPulseIntervalTime);
		CountMap.Emplace(ESustainedAxisState::EHighPulseTrigger, HighPulseTriggerTime);
	}

	virtual void UpdateOperation(FLatentResponse& Response) override
	{
		FSustainedAxisTriggerActionBase::UpdateOperation(Response);

        // 简易状态机
		if (bIsPress && !AxisStateBits[uint8(ESustainedAxisState::EPress)])
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			EnterState(ESustainedAxisState::EPress);
			EnterState(ESustainedAxisState::ELowPulseInterval);
		}

		if (IsTimeOver(ESustainedAxisState::ELowPulseInterval))
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			ExitState(ESustainedAxisState::ELowPulseInterval);
			EnterState(ESustainedAxisState::ELowPulseTrigger);
			EnterState(ESustainedAxisState::EHighPulseInterval);
		}

		if (IsTimeOver(ESustainedAxisState::ELowPulseTrigger))
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			CountMap[ESustainedAxisState::ELowPulseTrigger] = LowPulseTriggerTime;
			if (AxisStateBits[uint8(ESustainedAxisState::ELowToHighTransition)])
			{
				EnterState(ESustainedAxisState::EHighPulseTrigger);
				ExitState(ESustainedAxisState::ELowPulseTrigger);
			}
		}

		if (IsTimeOver(ESustainedAxisState::EHighPulseInterval))
		{
			if (CountMap[ESustainedAxisState::ELowPulseTrigger] <= 0)
			{
				EnterState(ESustainedAxisState::EHighPulseTrigger);
			}
			else
			{
				EnterState(ESustainedAxisState::ELowToHighTransition);
			}
			ExitState(ESustainedAxisState::EHighPulseInterval);
		}

		if (IsTimeOver(ESustainedAxisState::EHighPulseTrigger))
		{
			Response.TriggerLink(ExecutionFunction, OutputLink, CallbackTarget);
			CountMap[ESustainedAxisState::EHighPulseTrigger] = HighPulseTriggerTime;
		}
	}
};
  • 源码展示 (LatentFunctionLibrary.h)
// Copyright(c) 2023 TangYijun All rights reserved.

#pragma once

#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "PendingLatentAction/SustainedAxisTriggerAction.h"
#include "LatentFunctionLibrary.generated.h"

UCLASS()
class HECATONCHEIRES_API ULatentFunctionLibrary : public UBlueprintFunctionLibrary
{
	GENERATED_BODY()
public:
	UFUNCTION(BlueprintCallable, Category = "UI|Trigger", meta = (ExpandEnumAsExecs = "AxisExec", Latent, WorldContext = "WorldContextObject", LatentInfo = "LatentInfo"))
	static void OneStepSustainedAxisTrigger(const UObject* WorldContextObject, ESustainedAxisExec& AxisExec, float Axis, float AxisThreshold, float PulseTriggerTime,
		float PulseIntervalTime, FLatentActionInfo LatentInfo);
	UFUNCTION(BlueprintCallable, Category = "UI|Trigger", meta = (ExpandEnumAsExecs = "AxisExec", Latent, WorldContext = "WorldContextObject", LatentInfo = "LatentInfo"))
	static void TwoStepSustainedAxisTrigger(const UObject* WorldContextObject, ESustainedAxisExec& AxisExec, float Axis, float AxisThreshold, float LowPulseTriggerTime,
		float LowPulseIntervalTime, float HighPulseTriggerTime, float HighPulseIntervalTime, FLatentActionInfo LatentInfo);
};
  • 源码展示 (LatentFunctionLibrary.cpp)
// Copyright(c) 2023 TangYijun All rights reserved.

#include "FunctionLibrary/LatentFunctionLibrary.h"
#include "Engine/LatentActionManager.h"

void ULatentFunctionLibrary::OneStepSustainedAxisTrigger(const UObject* WorldContextObject, ESustainedAxisExec& AxisExec, float Axis, float AxisThreshold,
	float PulseTriggerTime, float PulseIntervalTime, FLatentActionInfo LatentInfo)
{
	if (UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull))
	{
		FLatentActionManager& LatentActionManager = World->GetLatentActionManager();
		FOneStepSustainedAxisTriggerAction* Action = LatentActionManager.FindExistingAction<FOneStepSustainedAxisTriggerAction>(LatentInfo.CallbackTarget, LatentInfo.UUID);
		if (!Action)
		{
			LatentActionManager.AddNewAction(LatentInfo.CallbackTarget, LatentInfo.UUID, new FOneStepSustainedAxisTriggerAction(Axis,
				AxisThreshold, PulseTriggerTime, PulseIntervalTime, LatentInfo, AxisExec));
		}
		else
		{
			Action->Axis = Axis;
		}
	}
}

void ULatentFunctionLibrary::TwoStepSustainedAxisTrigger(const UObject* WorldContextObject, ESustainedAxisExec& AxisExec, float Axis, float AxisThreshold,
	float LowPulseTriggerTime, float LowPulseIntervalTime, float HighPulseTriggerTime, float HighPulseIntervalTime, FLatentActionInfo LatentInfo)
{
	if (UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull))
	{
		FLatentActionManager& LatentActionManager = World->GetLatentActionManager();
		FTwoStepSustainedAxisTriggerAction* Action = LatentActionManager.FindExistingAction<FTwoStepSustainedAxisTriggerAction>(LatentInfo.CallbackTarget, LatentInfo.UUID);
		if (!Action)
		{
			LatentActionManager.AddNewAction(LatentInfo.CallbackTarget, LatentInfo.UUID, new FTwoStepSustainedAxisTriggerAction(Axis,
				AxisThreshold, LowPulseTriggerTime, LowPulseIntervalTime, HighPulseTriggerTime, HighPulseIntervalTime, LatentInfo, AxisExec));
		}
		else
		{
			Action->Axis = Axis;
		}
	}
}

定时器

FTimerManager

绑定定时器
  • BindLambda.
FTimerHandle TimerHandle;
const auto Exec = []()
{
	// Implement...
};
World->GetTimerManager().SetTimer(TimerHandle, Exec, 1.0f, false);
  • BindFunction.
FTimerHandle TimerHandle;
World->GetTimerManager().SetTimer(TimeHandler, this, &ThisClass::TimerFunction, 1.0f, false);
清除定时器
GetWorld()->GetTimerManager().ClearTimer(TimeHandler);
定时器的模式
延迟模式
  • 延迟2秒后执行一次 Exec()。
World->GetTimerManager().SetTimer(TimerHandle, Exec, 2.0f, false);
循环模式
  • 自设置时起就执行一次 Exec()，并开始每隔1秒就执行一次 Exec()，永不停歇，直到定时器被清除。
World->GetTimerManager().SetTimer(TimerHandle, Exec, 2.0f, true, 0.0f);
延迟循环模式
  • 延迟2秒后第一次执行 Exec()，之后每隔1秒就执行一次 Exec()，永不停歇，直到定时器被清除。
World->GetTimerManager().SetTimer(TimerHandle, Exec, 1.0f, true, 2.0f);

异步蓝图节点

Unreal - UBlueprintAsyncActionBase

(TODO)

Flame老唐
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
UE4 C++JSON读取示例.zip
09-03
UE4 C++JSON读取示例.zip
UE4 C++教程 虚幻四C++教程
06-10
UE4 C++教程 虚幻四C++教程
UE4离线C++API
08-18
The API reference is an early work in progress, and some information may be missing or out of date. It serves mainly as a low level index of Engine classes and functions. For tutorials, walkthroughs and detailed guides to programming with Unreal, please see the Unreal Engine Programming！ API参考是一项早期的工作，有些信息可能缺失或过时。 它主要用作引擎类和函数的低级索引。 有关使用Unreal进行编程的教程，演练和详细指南，请参阅虚幻引擎编程！
ue4蓝图c++动态改变staticmeshactor材质例子动态修改纹理
05-12
这是ue4 4.22.1 engine 版本的例子。实现了通过蓝图把场景中的AStaticMeshActor和两个动态材质实例UMaterialInstanceDynamic 传给c++ 自定义函数参数。 并在自定义函数里面实现两张材质的动态交替变更，其中一张材质还动态加载了本地1.png图片，使得能动态修改AStaticMeshActor材质。这是一个可以扩展其为一个播放器的典型例子。如果1.png 是通过视频流解码而来，并生成texture.那就是一个典型的ue4 播放器了。本例子不是一个打开就能跑的例子。你需要先用ue4建立一个名字为a2的工程，然后用zip里面的source plugins 覆盖你建好的工程的目录。以达到迁移代码的目的。注意，可能建好的材质，要拖到场景里才生效。
UE4游戏编程蓝图c++语言教程
06-07
虚幻引擎为您提供了多个编程游戏选项：您可以使用C++，也可以使用虚幻蓝图系统。 C++和蓝图之间的一些区别是不言而喻的：有了C++，您使用通用的基于文本的编程语言编写代码。蓝图更直观，更具体地针对更高级的游戏编程：您通过将表示事件、控制结构和函数调用的图形节点串在一起来编写代码，并通过编辑内对话来定义您的数据和界面，而不必使用精确的语法写出定义。
UE C++学习笔记
weixin_44212242的博客
05-16 3083
UE C++入门级程序编制笔记，基础中的基础，了解UE C++的书写规范和一般要求，实现蓝图，C++混合开发。
UE5 C++ 编程指南
ttod的博客
10-11 1487
UE5 C++ 编程指南
【UE4】C++编程
Goulandis
10-16 7298
右键.uproject会出现几个选项：.uproject是UE的项目描述文件，采用json的格式来描述一个项目的版本信息、模块信息、插件信息等。 .uproject参数描述文件— FileVersion：描述项目版本；EngineAssociation：引擎版本；Category：这个分类着实是不知道有什么卵用；Description：项目描述；Modules：模块信息，是一个类型的数组，数组中一个元素代表一个模块，的具体描述在ModuleDescriptor.h里面涉及很多模块的描述，最常使用的基本只
UE C++基础 | 委托与事件
ryacber的博客
01-24 2306
UE C++基础 | 委托与事件
UE5 C++教程（一、基本结构）
skycol的博客
09-11 8673
虚幻API由三块组成，分别是Runtime,Developer utilitiew,functionality for the Editor,大多数游戏性编程只使用运行时模块，最常见的三个是Corn、CornUObject和Engine。
ue4，c++,平面最小封闭区域识别
03-27
程序思路： ①：得到线段我们的线段集合S（本次项目鼠标点击得到线段（p1，p2两点）已经在ue4蓝图里面实现，这一步就不过多阐述） ②：移除孤立的线段（两端的点都是孤立的）； ③：拆分所有的线段（就是将所有的相交线线段拆分开，得到新的线段集合S） ④：移除一个端点孤立的线段（一个端点孤立的线段是不构成多边形的） ⑤：找出所有的大区域线段集合M，M是线段集合的集合，二维数组；（这里的大区域指的是：以任意一条线为起点找到和它相交的其他线段，再找到和这些线段相交的其他线段，直到找不到相交线段，那么这些线段的集合就是一个大区域Mi。然后找完所有的大区域） ⑥：分别对每一个大区域进行封闭区域的提取。
UE5.3 C++和蓝图实现的经典炸弹人.zip
最新发布
03-07
UE5.3 C++和蓝图实现的经典炸弹人.zip 适合学习/练手、毕业设计、课程设计、期末/期中/大作业、工程实训、相关项目/竞赛学习等。 项目具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。 可放心下载学习借鉴，你会有所收获。 —— 对于学习和实践，选择合适的项目和资源确实是一种有效的方式。 在进行毕业设计、课程设计或大作业时，选择具备学习借鉴价值的项目可以帮助你理解和应用所学知识，同时也可以通过修改和扩展来实现其他功能。 通过参与实际项目，你可以应用所学的理论知识，深入了解软件开发或其他领域的实践流程和技术要求。 博主领域：嵌入式领域&人工智能&软件开发。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担。 2. 部分字体以及插图等来自网络，若是侵权请联系删除。
UE4的C++离线文档
01-04
UE4 C++离线API文档是Unreal Engine 4的官方C++ API文档的离线版本。该文档包含了UE4 C++ API的所有类、函数、宏、枚举等内容，并提供了详细的说明和示例代码。 文档内容 UE4 C++离线API文档的内容主要分为以下几部分： 类（Classes）：该部分包含了UE4 C++ API中所有类的信息，包括类名、继承关系、成员变量、成员函数等。 函数（Functions）：该部分包含了UE4 C++ API中所有函数的信息，包括函数名、参数、返回值、说明等。 宏（Macros）：该部分包含了UE4 C++ API中所有宏的信息，包括宏名、参数、说明等。 枚举（Enumerations）：该部分包含了UE4 C++ API中所有枚举的信息，包括枚举名、枚举值、说明等。 文档使用 UE4 C++离线API文档可以通过以下方式使用： 使用CHM文件查看：该文档提供了CHM格式的文件，可以使用Windows自带的CHM查看器或其他第三方CHM查看器来查看。 使用HTML文件查看：该文档还提供了HTML格式的文件，可以使用Web浏览器来查看。 使用API查询工具
毕业设计基于C++的一款UE4射击游戏源码.zip
06-16
毕业设计基于C++的一款UE4射击游戏源码。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。一款UE4射击游戏Demo，包含UE4游戏框架及整套联网射击游戏功能。
UE4 UI简单例子 C++
09-13
一个简单实现点击按钮更换图片的UE4C++代码例子，例子很简洁，使用到了简单的UI创建、类型转换等等相关常用的UE4中需要的方法
UE4 C++ 离线API
05-10
UE4 C++ 离线API 下载直接使用 无障碍
ue4 c++ 多边形三角化
10-14
将一个多边形的所有点（点数组）按顺序输入，顺逆皆可，将其拆分成多个不重叠的三角形，输出所有三角形的点的index；
UE4蓝图调用C++函数的工程分享
03-11
1. 继承C++类的蓝图类直接调用 2.C++类中的全局函数，任意蓝图都能调用的方式。
UE5 C++（一）— 入门介绍
qq_40120946的博客
12-14 1397
表示项目环境依赖信息，用到哪些模块（“Core”,“CoreUObject”,“Engine”,“InputCore”，这些是初始内置模块）。GENERATED_BODY() ：表示我们不直接使用父类的构造函数，如果要定义类中初始化操作，需要在.h头文件中声明构造函数，然后在.cpp文件中实现构造函数，它之后的成员是private的。
UE5, c++ 实现异步线程执行
07-16
在 Unreal Engine 5 中，你可以使用 C++ 来实现异步线程执行。下面是一个简单的示例代码： ```cpp #include "Async/Async.h" // 定义一个异步任务 class MyAsyncTask : public FNonAbandonableTask { public: // 构造函数传入需要执行的参数 MyAsyncTask(int32 InParam) : Param(InParam) {} // 在异步线程中执行的任务 void DoWork() { // 执行一些耗时操作，比如计算或者加载资源等等 // ... // 任务执行结束后可以将结果回调到主线程 FGraphEventRef GameThreadTask = FFunctionGraphTask::CreateAndDispatchWhenReady([&]() { // 在主线程中执行回调操作，可以更新UI或者其他逻辑 // ... }, TStatId(), nullptr, ENamedThreads::GameThread); } // 返回任务名称 static const TCHAR* Name() { return TEXT("MyAsyncTask"); } FORCEINLINE TStatId GetStatId() const { RETURN_QUICK_DECLARE_CYCLE_STAT(MyAsyncTask, STATGROUP_ThreadPoolAsyncTasks); } private: int32 Param; }; // 启动异步任务 void StartAsyncTask(int32 Param) { // 创建异步任务并提交到线程池中执行 MyAsyncTask* AsyncTask = new MyAsyncTask(Param); AsyncTask->StartBackgroundTask(); } ``` 在上面的示例代码中，我们定义了一个名为 `MyAsyncTask` 的异步任务，它继承自 `FNonAbandonableTask`，并实现了 `DoWork` 方法来执行异步线程中的任务。在 `DoWork` 方法中，你可以执行一些耗时操作，并在任务结束后通过 `FFunctionGraphTask` 将结果回调到主线程进行处理。 要启动异步任务，你可以调用 `StartAsyncTask` 函数，并传入需要执行的参数。该函数会创建一个 `MyAsyncTask` 实例，并提交到线程池中执行。 请注意，异步任务的执行是在一个单独的线程中进行的，因此你需要确保在任务中不会访问或修改与主线程共享的对象或数据，以避免潜在的竞态条件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Flame老唐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值