UE蓝图 Cast节点和源码

已于 2024-02-26 15:09:20 修改
阅读量2.5k 收藏 38
点赞数 42
分类专栏： 可视化编程 文章标签： ue4 c++ Cast节点
于 2024-02-19 15:13:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwc791224/article/details/136170438
版权

系列文章目录

UE蓝图 Get节点和源码
UE蓝图 Set节点和源码
UE蓝图 Cast节点和源码
UE蓝图 分支(Branch)节点和源码
UE蓝图 入口(FunctionEntry)节点和源码
UE蓝图 返回结果(FunctionResult)节点和源码
UE蓝图 函数调用(CallFunction)节点和源码
UE蓝图 序列(Sequence)节点和源码

文章目录

Cast节点功能

在Unreal Engine（UE）中，Cast节点是一种蓝图系统中的节点，用于执行类型转换操作。Cast节点用于检测一个对象是否可以被转换（或“投射”）为另一种类型，并在转换成功时返回转换后的对象。

在这里插入图片描述
具体来说，当你在蓝图中使用Cast节点时，你正在尝试将一个对象转换（或投射）为另一种类型。例如，如果你有一个“玩家角色”对象，并且你想检查它是否是一个特定的“MyCharacter”类型的实例，你可以使用“Get Player Character”节点来获取玩家角色，然后使用“Cast To MyCharacter”节点来尝试将其转换为“MyCharacter”类型。如果转换成功，你就可以访问该对象的特定变量、函数和事件。
上图对应的代码如下：

 bpfv__CallFunc_GetParentActor_ReturnValue__pf = AActor::GetParentActor();
 bpfv__K2Node_DynamicCast_As____pf = Cast<ACharacter>(bpfv__CallFunc_GetParentActor_ReturnValue__pf);
 bpfv__K2Node_DynamicCast_bSuccess__pf = (bpfv__K2Node_DynamicCast_As____pf != nullptr);;
 if (!bpfv__K2Node_DynamicCast_bSuccess__pf)
 {
     __CurrentState = -1;
	 break;
 }

一、Cast节点用法

当然可以。UE Cast节点在Unreal Engine的蓝图系统中的具体用法主要涉及以下步骤：

  1. 获取对象引用：首先，你需要有一个对象引用，这通常是通过其他蓝图节点获取的。例如，你可能有一个指向某个游戏对象（如玩家角色、敌人等）的引用。

  2. 添加Cast节点：在蓝图中，你需要添加一个Cast节点。这个节点通常位于“类型转换”类别下。添加后，你将看到两个主要的输出端：一个是转换后的对象引用，另一个是表示转换是否成功的布尔值（bool）。

  3. 配置Cast节点：在Cast节点的属性窗口中，你需要指定目标类型，即你希望将对象转换成的类型。这通常是一个类名，比如MyCharacter或MyComponent。

  4. 连接对象引用：将你想要转换的对象引用连接到Cast节点的输入端。这通常是通过从获取对象引用的节点拖一条线到Cast节点的输入端来完成的。

  5. 使用转换后的对象：Cast节点有两个输出端。第一个输出端输出转换后的对象引用。如果转换成功，这个输出端将是非空的（即有效的）。你可以将这个输出端连接到需要该类型对象的任何节点上。

  6. 检查转换是否成功：Cast节点的第二个输出端是一个布尔值，表示转换是否成功。你可以将这个输出端连接到条件逻辑节点（如Branch节点）上，以便在转换成功时执行一段逻辑，在转换失败时执行另一段逻辑。

  7. 处理转换失败的情况：如果转换失败（即对象不能被转换为目标类型），你可能需要执行一些备选逻辑。这可以通过使用Cast节点的第二个输出端（布尔值）来实现，将其连接到一个条件节点，以便在转换失败时执行特定的操作。

二、Cast节点使用场景

UE Cast节点在蓝图系统中有多种应用场景，这些场景主要涉及到需要动态类型转换或检查的地方。以下是一些常见的UE Cast节点应用场景：

  1. 继承与多态处理：在面向对象编程中，Cast节点常用于处理继承关系。例如，当你有一个基类指针或引用，并且你想调用仅在派生类中定义的函数时，你需要先使用Cast节点将其转换为派生类类型。

  2. 接口实现检查：如果一个对象实现了某个接口，你可以使用Cast节点来检查这个对象是否确实实现了该接口，并据此执行相应的操作。

  3. 组件查询与访问：在UE中，组件通常附加到实体（如Actor）上。你可以使用Cast节点来尝试将实体转换为特定的组件类型，以便直接访问该组件的属性和方法。

  4. 动态类型识别：在某些情况下，你可能不知道对象的确切类型，但需要根据其类型执行不同的逻辑。通过使用Cast节点，你可以尝试将对象转换为多种可能的类型，并根据转换是否成功来决定执行哪段逻辑。

  5. 事件处理：在处理事件或委托时，你可能会接收到一个通用类型的参数。使用Cast节点，你可以将这个通用参数转换为更具体的类型，以便在事件处理逻辑中使用。

  6. 资源加载与转换：在加载资源时，资源可能以通用或基类形式被加载。在使用资源之前，你可能需要将其转换为正确的派生类型。

  7. 错误处理与调试：在开发过程中，Cast节点可以帮助你验证对象是否如你所期望的那样被正确创建和管理。如果Cast失败，这可能表明存在编程错误或资源管理问题。

三、Cast节点实现步骤

  • 创建输入输出引脚
// Input - Execution Pin
CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Execute);
// Output - Execution Pins
CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_CastSucceeded);
CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_CastFailed);
// Input - Source type Pin
CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Wildcard, UObject::StaticClass(), UEdGraphSchema_K2::PN_ObjectToCast);
CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Object, *TargetType, *CastResultPinName);
UEdGraphPin* BoolSuccessPin = CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Boolean, UK2Node_DynamicCastImpl::CastSuccessPinName);
  • 注册Net
	FBPTerminal* Term = Context.CreateLocalTerminalFromPinAutoChooseScope(Net, Context.NetNameMap->MakeValidName(Net));
	Context.NetMap.Add(Net, Term);
  • 编译
    创建转换Statement
	// Cast Statement
	FBlueprintCompiledStatement& CastStatement = Context.AppendStatementForNode(Node);
	CastStatement.Type = CastOpType;
	CastStatement.LHS = *CastResultTerm;
	CastStatement.RHS.Add(ClassTerm);
	CastStatement.RHS.Add(*ObjectToCast);

四、Cast节点源码


void UK2Node_DynamicCast::AllocateDefaultPins()
{
	const bool bReferenceObsoleteClass = TargetType && TargetType->HasAnyClassFlags(CLASS_NewerVersionExists);
	if (bReferenceObsoleteClass)
	{
		Message_Error(FString::Printf(TEXT("Node '%s' references obsolete class '%s'"), *GetPathName(), *TargetType->GetPathName()));
	}
	ensure(!bReferenceObsoleteClass);

	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());
	check(K2Schema != nullptr);
	if (!K2Schema->DoesGraphSupportImpureFunctions(GetGraph()))
	{
		bIsPureCast = true;
	}

	if (!bIsPureCast)
	{
		// Input - Execution Pin
		CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Execute);

		// Output - Execution Pins
		CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_CastSucceeded);
		CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_CastFailed);
	}

	// Input - Source type Pin
	CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Wildcard, UObject::StaticClass(), UEdGraphSchema_K2::PN_ObjectToCast);

	// Output - Data Pin
	if (TargetType)
	{
		const FString CastResultPinName = UEdGraphSchema_K2::PN_CastedValuePrefix + TargetType->GetDisplayNameText().ToString();
		if (TargetType->IsChildOf(UInterface::StaticClass()))
		{
			CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Interface, *TargetType, *CastResultPinName);
		}
		else 
		{
			CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Object, *TargetType, *CastResultPinName);
		}
	}

	UEdGraphPin* BoolSuccessPin = CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Boolean, UK2Node_DynamicCastImpl::CastSuccessPinName);
	BoolSuccessPin->bHidden = !bIsPureCast;

	Super::AllocateDefaultPins();
}


void FKCHandler_DynamicCast::RegisterNets(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
	FNodeHandlingFunctor::RegisterNets(Context, Node);

	if (const UK2Node_DynamicCast* DynamicCastNode = Cast<UK2Node_DynamicCast>(Node))
	{
		UEdGraphPin* BoolSuccessPin = DynamicCastNode->GetBoolSuccessPin();
		// this is to support backwards compatibility (when a cast node is generating code, but has yet to be reconstructed)
		// @TODO: remove this at some point, when backwards compatibility isn't a concern
		if (BoolSuccessPin == nullptr)
		{
			// Create a term to determine if the cast was successful or not
			FBPTerminal* BoolTerm = Context.CreateLocalTerminal();
			BoolTerm->Type.PinCategory = UEdGraphSchema_K2::PC_Boolean;
			BoolTerm->Source = Node;
			BoolTerm->Name = Context.NetNameMap->MakeValidName(Node, TEXT("CastSuccess"));
			BoolTermMap.Add(Node, BoolTerm);
		}
	}
	
}

void FKCHandler_DynamicCast::RegisterNet(FKismetFunctionContext& Context, UEdGraphPin* Net)
{
	FBPTerminal* Term = Context.CreateLocalTerminalFromPinAutoChooseScope(Net, Context.NetNameMap->MakeValidName(Net));
	Context.NetMap.Add(Net, Term);
}

void FKCHandler_DynamicCast::Compile(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
	const UK2Node_DynamicCast* DynamicCastNode = CastChecked<UK2Node_DynamicCast>(Node);

	if (DynamicCastNode->TargetType == NULL)
	{
		CompilerContext.MessageLog.Error(*LOCTEXT("BadCastNoTargetType_Error", "Node @@ has an invalid target type, please delete and recreate it").ToString(), Node);
	}

	// Self Pin
	UEdGraphPin* SourceObjectPin = DynamicCastNode->GetCastSourcePin();
	UEdGraphPin* PinToTry = FEdGraphUtilities::GetNetFromPin(SourceObjectPin);
	FBPTerminal** ObjectToCast = Context.NetMap.Find(PinToTry);

	if (!ObjectToCast)
	{
		ObjectToCast = Context.LiteralHackMap.Find(PinToTry);

		if (!ObjectToCast || !(*ObjectToCast))
		{
			CompilerContext.MessageLog.Error(*LOCTEXT("InvalidConnectionOnNode_Error", "Node @@ has an invalid connection on @@").ToString(), Node, SourceObjectPin);
			return;
		}
	}

	// Output pin
	const UEdGraphPin* CastOutputPin = DynamicCastNode->GetCastResultPin();
	if( !CastOutputPin )
	{
		CompilerContext.MessageLog.Error(*LOCTEXT("InvalidDynamicCastClass_Error", "Node @@ has an invalid target class").ToString(), Node);
		return;
	}

	FBPTerminal** CastResultTerm = Context.NetMap.Find(CastOutputPin);
	if (!CastResultTerm || !(*CastResultTerm))
	{
		CompilerContext.MessageLog.Error(*LOCTEXT("InvalidDynamicCastClass_CompilerError", "Node @@ has an invalid target class. (Inner compiler error?)").ToString(), Node);
		return;
	}

	// Create a literal term from the class specified in the node
	FBPTerminal* ClassTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
	ClassTerm->Name = DynamicCastNode->TargetType->GetName();
	ClassTerm->bIsLiteral = true;
	ClassTerm->Source = Node;
	ClassTerm->ObjectLiteral = DynamicCastNode->TargetType;
	ClassTerm->Type.PinCategory = UEdGraphSchema_K2::PC_Class;

	UClass const* const InputObjClass  = Cast<UClass>((*ObjectToCast)->Type.PinSubCategoryObject.Get());
	UClass const* const OutputObjClass = Cast<UClass>((*CastResultTerm)->Type.PinSubCategoryObject.Get());

	const bool bIsOutputInterface = ((OutputObjClass != NULL) && OutputObjClass->HasAnyClassFlags(CLASS_Interface));
	const bool bIsInputInterface  = ((InputObjClass != NULL) && InputObjClass->HasAnyClassFlags(CLASS_Interface));

	EKismetCompiledStatementType CastOpType = KCST_DynamicCast;
	if (bIsInputInterface)
	{
		if (bIsOutputInterface)
		{
			CastOpType = KCST_CrossInterfaceCast;
		}
		else
		{
			CastOpType = KCST_CastInterfaceToObj;
		}
	}
	else if (bIsOutputInterface)
	{
		CastOpType = KCST_CastObjToInterface;
	}

	if (KCST_MetaCast == CastType)
	{
		if (bIsInputInterface || bIsOutputInterface)
		{
			CompilerContext.MessageLog.Error(*LOCTEXT("InvalidClassDynamicCastClass_Error", "Node @@ has an invalid target class. Interfaces are not supported.").ToString(), Node);
			return;
		}
		CastOpType = KCST_MetaCast;
	}

	// Cast Statement
	FBlueprintCompiledStatement& CastStatement = Context.AppendStatementForNode(Node);
	CastStatement.Type = CastOpType;
	CastStatement.LHS = *CastResultTerm;
	CastStatement.RHS.Add(ClassTerm);
	CastStatement.RHS.Add(*ObjectToCast);

	FBPTerminal** BoolSuccessTerm = nullptr;
	if (UEdGraphPin* BoolSuccessPin = DynamicCastNode->GetBoolSuccessPin())
	{
		BoolSuccessTerm = Context.NetMap.Find(BoolSuccessPin);
	}
	else
	{
		BoolSuccessTerm = BoolTermMap.Find(DynamicCastNode);
	}	
	check(BoolSuccessTerm != nullptr);

	// Check result of cast statement
	FBlueprintCompiledStatement& CheckResultStatement = Context.AppendStatementForNode(Node);
	CheckResultStatement.Type = KCST_ObjectToBool;
	CheckResultStatement.LHS  = *BoolSuccessTerm;
	CheckResultStatement.RHS.Add(*CastResultTerm);

	UEdGraphPin* SuccessExecPin = DynamicCastNode->GetValidCastPin();
	bool const bIsPureCast = (SuccessExecPin == nullptr);
	if (!bIsPureCast)
	{
		UEdGraphPin* FailurePin = DynamicCastNode->GetInvalidCastPin();
		check(FailurePin != nullptr);
		// Failure condition...skip to the failed output
		FBlueprintCompiledStatement& FailCastGoto = Context.AppendStatementForNode(Node);
		FailCastGoto.Type = KCST_GotoIfNot;
		FailCastGoto.LHS  = *BoolSuccessTerm;
		Context.GotoFixupRequestMap.Add(&FailCastGoto, FailurePin);

		// Successful cast...hit the success output node
		FBlueprintCompiledStatement& SuccessCastGoto = Context.AppendStatementForNode(Node);
		SuccessCastGoto.Type = KCST_UnconditionalGoto;
		SuccessCastGoto.LHS  = *BoolSuccessTerm;
		Context.GotoFixupRequestMap.Add(&SuccessCastGoto, SuccessExecPin);
	}
}
虚幻基础06：cast to
qq_42863961的博客
01-28 281
能帮到你的话，就给个赞吧 😘。
unreal引擎蓝图代码
03-29
该代码是我买的书中带的，如果链接失效，请私聊我，看到后会补发
UE5 Cast To的作用
最新发布
路虽远,行则将至
04-03 466
（类型转换）操作确实会有一定的性能开销，但它的影响通常可以忽略不计，除非在极端高频（例如每帧多次调用）或大规模批量处理时。在运行时通过检查对象的类继承关系来确定是否转换成功，涉及虚函数表（vtable）查找和类层级遍历。它不仅是虚幻引擎官方推荐的方式，也是唯一能正确处理继承关系、保证代码健壮性的方法。检查一个对象是否属于某个类（或其子类）。是相对较重的操作（因为蓝图是解释执行的），而在 C++ 中直接进行类型转换（如。）是检查对象是否符合某个类型层级的标准方法。：它是虚幻引擎中唯一可靠的类型检查方式。
虚幻四蓝图cast to节点学习。。
qq_43274123的博客
03-02 6055
蓝图中的cast to,尝试检查发出转换的对象是否为被转换的特定对象，举例子就是创建了一个特殊的蓝图，其中包含了许多的自定义功能，我们想要在其他的蓝图中调用这个自定义蓝图的功能。 我们可以用get player character节点在其他蓝图中对玩家角色昌盛影响，但是没有办法使用自定义蓝图中的功能，是因为我们获取的是玩家角色（父类），而不是我们特定的角色。 这个时候，我们就可以使用get pla...
UE中的Cast和CastChecked
ttod的博客
02-06 1560
UE中的Cast和CastChecked
【UE4】Cast to的问题
Akxia的博客
08-07 1万+
我们知道，想要获取另一个蓝图类中的数据需要用到Cast to节点，其中Object的输入端是个难点。 通常为了避免麻烦，我们都尽量把变量放置于角色蓝图中，只需要 而需要Actor Cast to Actor，就需要一个小技巧 再者，若想在Actor，或者Character中获取Widget的变量 ①：Character cast to Widget：可以直接拖出来用 ②：Actor ca...
UE蓝图分支节点解析：控制逻辑与实战应用
"游戏开发 UE蓝图 分支(Branch)节点和源码" UE蓝图是Unreal Engine（虚幻引擎）中的核心可视化编程系统，它允许开发者通过图形化界面构建游戏逻辑，而无需直接编写C++代码。在这个文档中，我们将深入探讨分支...
深入Unreal蓝图开发：自定义蓝图节点(中)
燕良的博客
09-06 7493
通过派生class UK2Node和class SGraphNodeK2Base，为蓝图添加自定义节点，实现一个“动态添加输入Pin”的蓝图节点。
深入Unreal蓝图开发：理解蓝图技术架构
燕良的博客
11-24 1万+
这篇博客主要是深入理解蓝图整个流程的的底层机制，包括节点编辑、编译、字节码解释执行。理解了这些，对前面几篇所讲的蓝图扩展，可以有一个更清晰的认识。
深入Unreal蓝图开发：实现蓝图模板函数
燕良的博客
04-27 7967
使用UFunction CustomThunk函数方式，实现蓝图模板功能节点，用来处理任意类型的数组，并探索实现细节背后的蓝图机制。
UE基础—Garbage Collection(垃圾回收)
m0_45371381的博客
01-21 858
我理解的反射系统：运行时可得到对象的类型信息（包括：属性，方法）、动态创建对象等UE采用的是将对象的类、属性、方法用关键字（UCLASS，UPROPERTY，UFUNCTIOIN）标记；编译之前启动UHT去扫描这些关键字，生成/刷新该对象的UClass"伴随对象"，UClass保存了反射相关的信息，描述了各个属性之间的内存布局，通过UObject对象实例就可以将相应的属性的值取出来，进行读/写操作。要分情况看待。如果没有标记UPROPERTY，该类型合法；
虚幻4 文档翻译<一> Casting节点
Dream World
10-26 3841
虚幻4蓝图，casting 节点讲解
UE4的Cast方法与类型转化
热门推荐
菜鸡瞎讲
11-17 2万+
UE4中，我们经常会用到Cast函数，作用是强制转化一个指针到我们需要的类型，并且如果不能强制转化，就会返回nullptr。通过判断转换之后是不是nullptr，我们也能实现很多有用的功能（比如用于判断子弹击中的到底是什么） 那么Cast到底是如何实现的呢？要看Cast，首先要看到一个类型，叫做UClass，他是实现UE类型识别的重要类型。 我们经常打交道的类型都是继承自UObjectBase的
UE4蓝图通信-蓝图接口
记录值得记录的东西
11-30 6542
蓝图接口 除了最常用的cast to蓝图节点可以实现通信以外，进阶的通信方式就是蓝图接口 目的：与多个对象中的特定几个对象进行通信 方式：对检测到的对象发送消息 消息：发出的消息是接口消息，只有设置了对应接口的对象才会响应，其他的对象发呆 球形检测SphereTraceByChannel start：第一个球的球心点 end：下一个球的球心点 radius：每个球体的半径 注意这个检测生成的检测区域是胶囊体形状的，第一个球到第二个球的中间区域是个圆柱 利用接口蓝图实现通信必须要借助检测通道来检测目标
UE基础篇八：平衡蓝图与C++的使用
yuchenwuhen的专栏
11-17 369
总体而言，主要区别在于执行蓝图中的每个单独节点比执行一行C++代码要慢，但是一旦在一个节点内执行，会像从C++调用一样快。例如，如果蓝图类有一些性能成本较低的顶层节点，而调用的是性能成本较高的"物理跟踪"函数，那么将该类转换为C++不会显著提高性能。此外，原生化蓝图的运行时逻辑与普通蓝图的运行时逻辑不同，因此你可能会看到不同的错误或行为，具体取决于游戏的特征。在蓝图类中，你可以看到花费时间的蓝图函数，然后展开它。在C++写相同的函数，然后编译之后，蓝图会出现错误，删除旧的函数就可以了。
[UE4]Cast to转换数据类型
weixin_30797027的博客
05-25 1870
可以转换纯函数，这样就可以不用加执行线了。 转载于:https://www.cnblogs.com/timy/p/9086245.html
UE4类型转换Cast to
笔记的博客
12-27 3510
转换功能会尝试把输入转变为其他类型，以便访问仅限于某种类型的特定功能。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

shandongwill

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

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

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

打赏作者

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

抵扣说明：

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

余额充值