ue5API

​

组件

## 组件API

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//组件的声明及应用

//实例组件
StaticMeshComponent=CreateDefaultSubobject<UStaticMeshComponent>("AuraStaticMeshComponent");
SetRootComponent(StaticMeshComponent);  //设置为根组件
SkeletalMeshComponent->SetupAttachment(父级);  //切换组件层级

//以下两个在调用SetupAttachment后可以不用
//注册组件
SkeletalMeshComponent->RegisterComponent()
//添加组件进数组
AddInstanceComponent(SkeletalMeshComponent);

//按类查找组件
FindComponentByClass()
UMyCustomComponent* MyComponent = FindComponentByClass(MyActor, UMyCustomComponent::StaticClass());
//直接访问公开的成员变量
就是组件你已经给定了变量来存储
//使用Tag标签查找

SetVisibility(bool): 设置组件是否可见。传入true表示显示，false表示隐藏。
SetWorldLocation(FVector): 设置组件在世界空间中的位置。
SetWorldRotation(FRotator): 设置组件在世界空间中的旋转。
SetWorldScale3D(FVector): 设置组件在世界空间中的缩放比例。
AddLocalOffset(FVector, bool): 在组件的本地坐标系下添加一个偏移量。第二个参数决定是否更新组件的物理状态。
AddLocalRotation(FRotator, bool): 在组件的本地坐标系下添加一个旋转增量。第二个参数决定是否更新组件的物理状态。
SetRelativeLocation(FVector): 设置组件相对于其父组件的位置。
SetRelativeRotation(FRotator): 设置组件相对于其父组件的旋转。
SetCollisionEnabled(ECollisionEnabled::Type): 控制组件的碰撞检测模式，如禁用、查询或物理模拟。
SetCollisionProfileName(FName): 改变组件的碰撞配置文件，用于定义组件的碰撞行为。
AttachToComponent(UPrimitiveComponent, FAttachmentTransformRules, FName): 将当前组件附加到指定的父组件上，并可自定义附加规则（如是否保持相对位置、旋转等）。
DetachFromParent(bool): 从父组件上分离当前组件。如果参数为true，则保持当前位置和旋转；否则，重置到组件的初始变换。
SetSimulatePhysics(bool): 开启或关闭组件的物理模拟，使组件受到物理引擎的影响。
SetMaterial(int32, UMaterialInterface): 更改组件材质的某一索引处的材质。
GetOwner(): 获取组件所属的Actor。

  • 源文件
1
2
3
4
Myclass::构造函数
{
    //添加到对象
    myclass = CreateDefaultSubobject<USceneCo

加载静态网格体资源

1
2
3
4
5
6
7
8
9
	UPROPERTY(EditInstanceOnly, Category = "StaticMesh")
	UStaticMeshComponent* StaticMeshComponent;


static 	ConstructorHelpers::FObjectFinder<UStaticMesh>Cube(TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Shapes/Shape_Tube.Shape_Tube'")); //加载资源
StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("name")); //组件名字
StaticMeshComponent->SetupAttachment(RootComponent);     //添加组件 RootComponent父级
StaticMeshComponent->SetStaticMesh(Cube.Object);         //设置静态网格

添加骨骼网格体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
USkeletalMesh*Skletamesh;

void construct();
void CreateMode();


void construct();{
  Skletamesh=LoadObject<USkeletalMesh>(NULL,TEXT(CHAT));  
}

void CreateMode(){
GetMesh()->设置旋转(); 0,-90,0
GetMesh()->设置位置(); 0,0,-100
GetMesh()->SetSkeletaMesh(Skletamesh); //设置网格体
GetCapsuleComponent()->InitCapsuleSize(4.,100)   
}

获取玩家对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//获取玩家控制器和玩家的Pawn
APlayerController* PlayerController = UGameplayStatics::GetPlayerController(this, 0);
//判断玩家引用是否有效
if (PlayerController)
{
	APawn* Pawn = PlayerController->GetPawn();
	if (Pawn)
	{
		UE_LOG(LogTemp, Warning, TEXT("PlayerController:%s, Pawn:%s"), *PlayerController->GetName(), *Pawn->GetName());
	}else
	{
		UE_LOG(LogTemp, Warning, TEXT("PlayerController:%s, Pawn:NULL"), *PlayerController->GetName());
	}
}
else
{
	UE_LOG(LogTemp, Warning, TEXT("未能获取到 PlayerController"));
}

类:UGameplayStatics

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UGameplayStatics 是 Unreal Engine 中的一个静态类，提供了一些便捷的静态方法，帮助开发者在游戏中执行常见的操作，比如获取游戏实例、玩家控制器、播放声音、生成粒子效果等。它主要用于简化一些重复性操作，避免直接操作底层 API。

主要功能
以下是 UGameplayStatics 常见的一些功能：

获取玩家控制器：例如，UGameplayStatics::GetPlayerController 可以获取当前玩家的控制器。

获取玩家角色：还有一个方法 UGameplayStatics::GetPlayerPawn，可以直接获取到第一个玩家的角色（Pawn）。

生成对象：使用如 UGameplayStatics::SpawnActor 来在世界中生成新的对象（例如生成子弹或敌人）。

播放声音/音乐：可以通过 UGameplayStatics::PlaySoundAtLocation 播放指定位置的声音等。

蓝图与 C++ 的交互：UGameplayStatics 提供的方法可在蓝图中使用，方便设计师与程序员协作。

朝玩家移动

1
2
APawn*PlayerPawn
    PlayerPawn=Pawn
1
2
3
4
5
6
7
8
9
10
11
12
13
14
if (PlayerPawn)
{
	// 获取玩家的位置
	FVector PlayerLocation = PlayerPawn->GetActorLocation();

	// 设置当前 Actor 的位置，朝玩家位置移动
	// 这里可以使用简单的插值移动，或直接设置位置
	FVector NewLocation = FMath::VInterpTo(GetActorLocation(), PlayerLocation, DeltaTime, 2.0f); // 5.0f 是控制移动速度的因子
	SetActorLocation(NewLocation);
       
       //旋转面朝玩家
      `FRotator NewRotation = (PlayerLocation - GetActorLocation()).Rotation();
	SetActorRotation(NewRotation);
}

在 Unreal Engine 中，有许多常用的类用于不同的游戏开发需求。以下是一些常见的重要类及其简要说明：

以下是将上述内容整理成表格的形式，以便更清晰地查看和比较这些Unreal Engine中常用的类及其简要说明：

类名 简要说明
AActor 所有游戏对象的基类，可以放置在关卡中。它是所有可以在世界中被实例化的对象的基础。
APawn 表示一个可控制的游戏实体，可以是玩家角色或 AI 角色。提供移动和控制的功能。
ACharacter APawn 的子类，适用于需要复杂移动（如跳跃、滑行等）的角色。它通常用于玩家角色，并集成了动画组件。
APlayerController 代表玩家的控制器，用于处理玩家输入、相机控制和与游戏逻辑的交互。
AGameMode 定义游戏规则、胜利条件以及玩家生成的逻辑。一个关卡只能有一个游戏模式。
AGameState 用于保存游戏的状态信息，允许所有客户端（在网络游戏中）访问相同的游戏状态数据。
APlayerState 存储与个别玩家（及其状态）相关的信息，比如分数、生命值等。每个玩家控制器都有一个对应的 APlayerState 实例。
UComponent 所有组件类的基类，用于给 Actor 添加功能（如运动、碰撞、渲染等）。
UStaticMeshComponent 用于在世界中显示静态网格（3D 模型），通常用于表示环境中的物体。
USkeletalMeshComponent 用于显示具有骨骼动画的网格，通常用于角色模型，允许其执行动画。
UCapsuleComponent 通常用于角色的碰撞检测，帮助其处理地面、墙壁等显示和逻辑。
UAnimInstance 动画实例类，用于控制角色的动画状态和过渡，允许开发者实现复杂的动画逻辑。
UBlueprint 可视化脚本系统，用于实现游戏逻辑，无需编写代码。它可以代表任何 Actor 类型，允许设计师和程序员协作。
UTexture2D 用于处理 2D 纹理，常用于界面元素或游戏对象的外观。
USoundBase 一个音频资产的基类，所有音效和背景音乐都从这个类派生。
UMaterial 用于定义表面属性和视觉效果的类，包括颜色、纹理和光照等。
AEnvironment 环境类，允许在环境中引入动态光源和其他视觉效果。
UPhysicsComponent 用于处理物理效果的组件，可以用于模拟重力、碰撞和其他物理现象。

这个表格提供了Unreal Engine中一些常见和重要的类的快速概览，有助于理解这些类在游戏开发中的作用和关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
不一定非要将敌人数组放在游戏模式中，虽然游戏模式是一种常见的做法。根据你的游戏设计和需求，你可以选择以下几个比较适合的方案：

游戏模式（GameMode）：

如果敌人在整个游戏的不同关卡中都是共享的，你可以将敌人数组放在游戏模式中。这是一个便于全球管理敌人的方式。
自定义关卡类（Level Script Actor）：

如前所述，你可以创建一个自定义的关卡类（继承自 ALevelScriptActor），将敌人数组放在这个类中，这样你可以针对每个关卡进行特定的敌人管理。
敌人生成器（Spawner）：

如果你有复杂的敌人生成逻辑，可以创建一个独立的敌人生成器类来管理敌人。这可以让敌人生成和管理更加模块化。
角色类（Character Class）：

尽管不太常见，但如果你的角色需要跟特定的敌人进行交互或者影响，你可以在角色类中持有敌人数组。
全局单例或管理器：

如果你的游戏架构较为复杂，可以考虑使用单例模式或管理器类，它们可以在游戏中完成敌人的全局管理。
总结
虽然将敌人数组放在游戏模式是一个常见且有效的方案，但根据你的实际需求和游戏结构，你可以选择最适合你的方案。考虑到扩展性和代码组织，选择一个易于管理和维护的方法是很重要的。如果你有具体的场景或设计考虑，请告诉我，我可以提供更具体的建议！

遍历世界的物体

1
2
3
4
5
6
7
TArray<AActor*> ActorsToFind;
if(UWorld* World = GetWorld())
{
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), AFireEffect::StaticClass(), ActorsToFind);
}
for (AActor* FireEffectActor: ActorsToFind)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// Copyright Epic Games, Inc. All Rights Reserved.

#include "DemoCharacter.h"
#include "Engine/LocalPlayer.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "GameFramework/Controller.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h"
#include "InputActionValue.h"

// 定义日志类别
DEFINE_LOG_CATEGORY(LogTemplateCharacter);

//////////////////////////////////////////////////////////////////////////
// ADemoCharacter

ADemoCharacter::ADemoCharacter()
{
	// 设置碰撞胶囊的大小
	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

	// 不会因控制器旋转而旋转角色。让控制器只影响相机。
	bUseControllerRotationPitch = false;
	bUseControllerRotationYaw = false;
	bUseControllerRotationRoll = false;

	// 配置角色移动
	GetCharacterMovement()->bOrientRotationToMovement = true; // 角色向输入方向移动
	GetCharacterMovement()->RotationRate = FRotator(0.0f, 500.0f, 0.0f); // 在该旋转速率下移动

	// 注意：为了更快的迭代时间，这些变量和许多其他参数可以在角色蓝图中调整
	// 而无需重新编译
	GetCharacterMovement()->JumpZVelocity = 700.f; // 跳跃时的竖直速度
	GetCharacterMovement()->AirControl = 0.35f; // 空中控制能力
	GetCharacterMovement()->MaxWalkSpeed = 500.f; // 最大行走速度
	GetCharacterMovement()->MinAnalogWalkSpeed = 20.f; // 最小模拟行走速度
	GetCharacterMovement()->BrakingDecelerationWalking = 2000.f; // 行走时刹车减速
	GetCharacterMovement()->BrakingDecelerationFalling = 1500.0f; // 下落时刹车减速

	// 创建相机弹簧臂（当发生碰撞时向玩家靠拢）
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(RootComponent);
	CameraBoom->TargetArmLength = 400.0f; // 相机在角色后方跟随的距离
	CameraBoom->bUsePawnControlRotation = true; // 根据控制器旋转弹簧臂

	// 创建跟随相机
	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // 将相机附加到弹簧臂的末端，并让弹簧臂根据控制器方向进行调整
	FollowCamera->bUsePawnControlRotation = false; // 相机不相对于弹簧臂旋转

	// 注意：在继承的Mesh组件上，骨骼网格和动画蓝图的引用
	// 在名为ThirdPersonCharacter的派生蓝图资产中设置（以避免在C++中直接引用内容）
}

void ADemoCharacter::BeginPlay()
{
	// 调用基类
	Super::BeginPlay();

	// 添加输入映射上下文
	if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
	{
		if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
		{
			Subsystem->AddMappingContext(DefaultMappingContext, 0);
		}
	}
}

//////////////////////////////////////////////////////////////////////////
// 输入处理

void ADemoCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	// 设置动作绑定
	if (UEnhancedInputComponent* EnhancedInputComponent = Cast<UEnhancedInputComponent>(PlayerInputComponent)) {
		
		// 跳跃
		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &ACharacter::Jump);
		EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);

		// 移动
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &ADemoCharacter::Move);

		// 视角控制
		EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &ADemoCharacter::Look);
	}
	else
	{
		UE_LOG(LogTemplateCharacter, Error, TEXT("'%s' 找不到增强输入组件！此模板是建立在增强输入系统上。如果您打算使用传统系统，则需要更新此C++文件。"), *GetNameSafe(this));
	}
}

void ADemoCharacter::Move(const FInputActionValue& Value)
{
	// 输入是一个Vector2D
	FVector2D MovementVector = Value.Get<FVector2D>();

	if (Controller != nullptr)
	{
		// 找出前方方向
		const FRotator Rotation = Controller->GetControlRotation();
		const FRotator YawRotation(0, Rotation.Yaw, 0);

		// 获取前方向向量
		const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
	
		// 获取右方向向量 
		const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);

		// 添加移动 
		AddMovementInput(ForwardDirection, MovementVector.Y); // 前进/后退
		AddMovementInput(RightDirection, MovementVector.X); // 左/右移动
	}
}

void ADemoCharacter::Look(const FInputActionValue& Value)
{
	// 输入是一个Vector2D
	FVector2D LookAxisVector = Value.Get<FVector2D>();

	if (Controller != nullptr)
	{
		// 将偏航和俯仰输入添加到控制器
		AddControllerYawInput(LookAxisVector.X); // 左/右看
		AddControllerPitchInput(LookAxisVector.Y); // 上/下看
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "Logging/LogMacros.h"
#include "DemoCharacter.generated.h"

// 前向声明类
class USpringArmComponent;
class UCameraComponent;
class UInputMappingContext;
class UInputAction;
struct FInputActionValue;

// 声明日志类别
DECLARE_LOG_CATEGORY_EXTERN(LogTemplateCharacter, Log, All);

UCLASS(config=Game)
class ADemoCharacter : public ACharacter
{
	GENERATED_BODY()

	/** 相机弹簧臂，将相机定位在角色后方 */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	USpringArmComponent* CameraBoom;

	/** 跟随相机 */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	UCameraComponent* FollowCamera;
	
	/** 输入映射上下文 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	UInputMappingContext* DefaultMappingContext;

	/** 跳跃输入动作 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	UInputAction* JumpAction;

	/** 移动输入动作 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	UInputAction* MoveAction;

	/** 视角输入动作 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input, meta = (AllowPrivateAccess = "true"))
	UInputAction* LookAction;

public:
	ADemoCharacter(); // 构造函数
	
protected:

	/** 处理移动输入的函数 */
	void Move(const FInputActionValue& Value);

	/** 处理视角输入的函数 */
	void Look(const FInputActionValue& Value);
			

protected:
	// APawn 接口
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override; // 设置输入组件
	
	// 添加映射上下文
	virtual void BeginPlay(); // 初始化函数

public:
	/** 返回 CameraBoom 子对象 **/
	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
	/** 返回 FollowCamera 子对象 **/
	FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
};

类

玩家类

角色移动组件:Pawn

  • 属性

    属性 描述
    Velocity 速度

  • AddMovementInput

1
2
AddMovementInput(FVector WorldDirection, float ScaleValue = 1.0f, bool bForce = false)
//推荐移动角色方法,类似Velocity,也可以通过SetActorLocation实现

碰撞

碰撞检测与命中测试（Overlap and Hit Test）
使用方法：为玩家角色或其攻击组件添加一个碰撞体（如Sphere Collision或Capsule Component），并启用重叠事件（Overlap Events）或使用线性投射（Line Trace）进行命中测试。
实现细节：在蓝图中，可以设置OnComponentBeginOverlap或OnComponentEndOverlap事件处理函数来检测玩家与敌人的碰撞。如果是C++，则需要覆写相关组件的OnComponentBeginOverlap或OnActorBeginOverlap等函数。
2. 视线投射（Raycast）
使用方法：当玩家按下攻击键时，从玩家视角发出一条射线（Raycast），检测这条射线是否击中了敌人。
实现细节：可以使用蓝图中的Line Trace By Channel节点，或者在C++中使用UKismetSystemLibrary::LineTraceSingleForObjects函数。根据返回的结果判断是否击中敌人，并获取击中对象的信息。
3. 感知系统（Sense Component）
使用方法：为敌人添加感知组件（Senses Component），定义它们的感知范围和条件，然后在玩家身上添加相应的标签（Tags）。敌人通过感知组件检查范围内是否有带有特定标签的玩家。
实现细节：配置敌人蓝图中的感知组件（如AIPerceptionComponent），并在玩家蓝图中设置相应的感知标签。通过感知委托处理感知到玩家的逻辑。
4. 基于脚本的行为树（Behavior Tree）
使用方法：创建一个行为树，其中包含一个用于寻找玩家节点（Find Player Node），该节点利用上述的碰撞检测或视线投射机制来定位玩家。
实现细节：在UE编辑器中设计行为树，使用蓝图或C++编写具体逻辑。例如，可以使用BTTask_FindPlayer节点，并在成功找到玩家后触发其他行为，如追击或攻击。
5. 事件调度器（Event Dispatchers）
使用方法：利用UE5的事件系统，在玩家到达特定位置或满足特定条件时，触发一个全局或局部事件，敌人对象监听这个事件并作出反应。
实现细节：可以创建自定义事件，在玩家达到某些条件时广播该事件。敌人蓝图或代码中注册监听这些事件，并执行相应的逻辑来响应玩家的动作

变换向量

旋转

GetUnitDirection 获取一个位置到一个位置的旋转向量

目标相对位置=向前向量乘以距离+自身XYz位置

平均旋转=360除以箭头数量

箭头度数等于上一个箭头加上平均值

用户控件

当然，以下是 UWidget 类中部分 API 的用途翻译：

渲染变换相关

  • GetRenderTransform: 获取小部件的渲染变换。
  • SetRenderTransform: 设置小部件的渲染变换。
  • SetRenderScale: 设置小部件的渲染缩放。
  • SetRenderShear: 设置小部件的渲染剪切。
  • SetRenderTransformAngle: 设置小部件的渲染旋转角度。
  • GetRenderTransformAngle: 获取小部件的渲染旋转角度。
  • SetRenderTranslation: 设置小部件的渲染平移。
  • SetRenderTransformPivot: 设置小部件的渲染变换中心点。
  • GetRenderTransformPivot: 获取小部件的渲染变换中心点。

流向方向偏好

  • GetFlowDirectionPreference: 获取小部件的流向方向偏好。
  • SetFlowDirectionPreference: 设置小部件的流向方向偏好。

启用状态

  • GetIsEnabled: 获取小部件当前的启用状态。
  • SetIsEnabled: 设置小部件当前的启用状态。

是否在视口中

  • IsInViewport: 返回小部件是否已通过 AddToViewport 或 AddToPlayerScreen 添加到视口中。

提示文本

  • GetToolTipText: 获取小部件的提示文本。
  • SetToolTipText: 设置小部件的提示文本。
  • GetToolTip: 获取小部件的自定义提示小部件。
  • SetToolTip: 设置小部件的自定义提示小部件。

鼠标光标

  • GetCursor: 获取小部件上的鼠标光标。
  • SetCursor: 设置小部件上的鼠标光标。
  • ResetCursor: 重置小部件上的鼠标光标，移除任何自定义设置。

渲染状态

  • IsRendered: 返回小部件是否可见且渲染透明度大于 0。
  • IsVisible: 返回小部件是否可见、命中测试不可见或自身命中测试不可见。
  • GetVisibility: 获取小部件当前的可见性。
  • SetVisibility: 设置小部件的可见性。
  • SetVisibilityInternal: 内部方法，用于设置小部件的可见性。

这些 API 主要用于控制和获取小部件的各种属性和状态，以便在用户界面中进行动态调整和响应。

提供的文件 UserWidget.h 是 Unreal Engine 5.3 版本中的一个头文件，定义了 UUserWidget 类。这个类是 Unreal Engine 中用于创建用户界面（UI）的基础类，支持通过蓝图（Blueprint）进行扩展。

主要功能和特性：

  • 继承关系：UUserWidget 继承自 UWidget 和 INamedSlotInterface，提供了基本的 UI 功能和命名插槽接口。
  • 生命周期方法：
    • OnInitialized：初始化时调用，仅在游戏运行时调用一次。
    • PreConstruct：构造前调用，适用于编辑器预览和运行时。
    • Construct：Slate 小部件构造后调用。
    • Destruct：Slate 小部件销毁时调用。
  • 输入事件处理：
    • OnFocusReceived：获取焦点时调用。
    • OnFocusLost：失去焦点时调用。
    • OnAddedToFocusPath：添加到焦点路径时调用。
    • OnRemovedFromFocusPath：从焦点路径中移除时调用。
    • OnKeyChar：接收到字符输入时调用。
    • OnPreviewKeyDown：预览按键按下事件。
    • OnKeyDown：按键按下事件。
    • OnKeyUp：按键释放事件。
    • OnAnalogValueChanged：模拟值变化事件。
    • OnMouseButtonDown：鼠标按钮按下事件。
    • OnPreviewMouseButtonDown：预览鼠标按钮按下事件。
    • OnMouseButtonUp：鼠标按钮释放事件。
    • OnMouseMove：鼠标移动事件。
    • OnMouseEnter：鼠标进入小部件时调用。
    • OnMouseLeave：鼠标离开小部件时调用。
    • OnMouseWheel：鼠标滚轮事件。
  • 其他方法：
    • AddToViewport：将小部件添加到视口中。
    • AddToPlayerScreen：将小部件添加到玩家屏幕。
    • SetPositionInViewport：设置小部件在视口中的位置。
    • SetDesiredSizeInViewport：设置小部件在视口中的大小。
    • SetAnchorsInViewport：设置小部件在视口中的锚点。
    • SetAlignmentInViewport：设置小部件在视口中的对齐方式。
    • SetVisibility：设置小部件的可见性。
    • SetPlayerContext：设置玩家上下文。
    • GetOwningLocalPlayer：获取拥有该小部件的本地玩家。
    • GetOwningPlayer：获取拥有该小部件的玩家控制器。
    • GetOwningPlayerPawn：获取拥有该小部件的玩家角色。
    • GetOwningPlayerState：获取拥有该小部件的玩家状态。
    • GetOwningPlayerCameraManager：获取拥有该小部件的玩家相机管理器。

枚举类型：

  • EWidgetTickFrequency：定义了小部件的更新频率。
  • EWidgetAnimationEvent：定义了动画事件类型。
  • EUMGSequencePlayMode：定义了 UMG 序列的播放模式。
  • EDesignPreviewSizeMode：定义了设计预览的尺寸模式。

结构体：

  • FAnimationEventBinding：用于管理动画事件绑定。
  • FPaintContext：用于绘制上下文。
  • FNamedSlotBinding：用于命名插槽绑定。

其他：

  • GetWorld：获取当前世界。
  • PostDuplicate：复制后调用。
  • BeginDestroy：开始销毁时调用。
  • PostLoad：加载后调用。
  • DuplicateAndInitializeFromWidgetTree：从小部件树中复制并初始化。
  • Initialize：初始化小部件。
  • GetDesiredTickFrequency：获取期望的更新频率。
  • GetWidgetTreeOwningClass：获取生成小部件树的蓝图类。
  • UpdateCanTick：更新是否可以更新。

这些功能和特性使得 UUserWidget 成为 Unreal Engine 中创建和管理用户界面的重要基础类。

绑定UI和动画

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "Blueprint/UserWidget.h"
#include "Components/SizeBox.h"
#include "ItemBoxBase.generated.h"

/**
 * 
 */
//物品箱子,用于包裹小格子容器的组件,获取小格子组件事件发送出去
UCLASS()
class TESTDEMO_API UItemBoxBase : public UUserWidget
{
	GENERATED_BODY()
public:
	// 小格子容器
	//UPROPERTY(BlueprintReadWrite,EditAnywhere)
	//USizeBox *sizebox;

	virtual void NativePreConstruct() override;
	virtual void NativeConstruct() override;

	//	// 小格子容器
	UPROPERTY(BlueprintReadWrite,EditAnywhere,meta = (BindWidget))
	USizeBox* sizebox;

	// 动画
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animations")
	UWidgetAnimation* ShowAnimation;

	//绑定动画
	UPROPERTY(BlueprintReadOnly, Transient, meta = (BindWidgetOptional) , meta = (BindWidgetAnim))
	UWidgetAnimation* Fade;
};

数据表格

1
2
3
4
5
//读取行
const FFairyItemStruct* Row = DataTable->FindRow<FFairyItemStruct>(RowName, ContextString);
//获取命名数组
DataTable->GetRowNames()

FTableRowBase 结构体

成员函数

  • virtual void OnPostDataImport(const UDataTable* InDataTable, const FName InRowName, TArray<FString>& OutCollectedImportProblems)

    • 可以被子类重写；当数据表导入或重新导入时调用。
    • 允许对初始读取的数据进行自定义修复、解析等操作。
    • 参数：
      • InDataTable: 拥有此行的数据表。
      • InRowName: 要进行修复的行的名称。
      • OutCollectedImportProblems: 导入过程中累积的问题列表，可以通过此方法添加问题。

  • virtual void OnDataTableChanged(const UDataTable* InDataTable, const FName InRowName)

    • 可以被子类重写；当拥有此行的数据表被修改时调用。
    • 允许对用户更改进行自定义修复、解析等操作。
    • 参数：
      • InDataTable: 拥有此行的数据表。
      • InRowName: 要进行修复的行的名称。

UDataTable 类

成员变量

  • TObjectPtr<UScriptStruct> RowStruct

    • 数据表中每一行使用的结构体，必须继承自 FTableRowBase。

  • TMap<FName, uint8*> RowMap

    • 行名称到行数据结构的映射。

  • uint8 bStripFromClientBuilds : 1

    • 如果设置为 true，则不会将此数据表打包到客户端构建中。适用于只有服务器需要知道的敏感表。

  • uint8 bIgnoreExtraFields : 1

    • 如果设置为 true，则在导入数据时忽略多余的字段。否则会发出警告。

  • uint8 bIgnoreMissingFields : 1

    • 如果设置为 true，则在导入数据时忽略预期但缺失的字段。否则会发出警告。

  • FString ImportKeyField

    • 导入数据中的显式键字段。如果为空，则使用 JSON 中的 Name 或 CSV 中的第一个字段作为键。

  • TObjectPtr<class UAssetImportData> AssetImportData

    • 导入此数据表的文件，可能为空。

  • FOnDataTableChanged OnDataTableChangedDelegate

    • 当数据表发生变化时调用的多播委托。

成员函数

  • virtual void AddRowInternal(FName RowName, uint8* RowDataPtr)

    • 向数据表中添加行。

  • virtual void RemoveRowInternal(FName RowName)

    • 从数据表中删除行。

  • const TMap<FName, uint8*>& GetRowMap() const

    • 获取行映射。

  • const UScriptStruct* GetRowStruct() const

    • 获取行结构体。

  • virtual bool AllowDuplicateRowsOnImport() const

    • 返回是否允许在导入时存在多个同名行。

  • virtual void FinishDestroy()

    • 完成销毁。

  • virtual void Serialize(FStructuredArchiveRecord Record)

    • 序列化数据表。

  • static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)

    • 添加引用对象。

  • virtual void GetPreloadDependencies(TArray<UObject*>& OutDeps)

    • 获取预加载依赖项。

  • virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)

    • 获取资源大小。

  • virtual bool NeedsLoadForClient() const

    • 判断是否需要在客户端加载。

  • virtual bool NeedsLoadForEditorGame() const

    • 判断是否需要在编辑器游戏中加载。

  • void HandleDataTableChanged(FName ChangedRowName = NAME_None)

    • 当数据表数据发生变化时调用此方法，触发 OnDataTableChanged 委托和每行回调。

  • template <class T> void GetAllRows(const TCHAR* ContextString, OUT TArray<T*>& OutRowArray) const

    • 获取数据表中的所有行。

  • template <class T> T* FindRow(FName RowName, const TCHAR* ContextString, bool bWarnIfRowMissing = true) const

    • 根据名称查找数据表中的行。

  • template <class T> void ForeachRow(const TCHAR* ContextString, TFunctionRef<void (const FName& Key, const T& Value)> Predicate) const

    • 对每一行执行某个操作。

  • FProperty* FindTableProperty(const FName& PropertyName) const

    • 查找与列属性名称匹配的属性。

  • uint8* FindRowUnchecked(FName RowName) const

    • 高性能版本，不进行类型检查。

  • virtual void EmptyTable()

    • 清空数据表（不会清除 RowStruct）。

  • virtual TArray<FName> GetRowNames() const

    • 获取所有行的名称。

  • virtual void RemoveRow(FName RowName)

    • 通过名称删除单个行。

  • virtual void AddRow(FName RowName, const FTableRowBase& RowData)

    • 将行数据复制到数据表中。

  • virtual void CleanBeforeStructChange()

    • 在结构体更改前清理。

  • virtual void RestoreAfterStructChange()

    • 在结构体更改后恢复。

  • FString GetTableAsString(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将整个数据表输出为字符串。

  • FString GetTableAsCSV(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将整个数据表输出为 CSV 格式。

  • FString GetTableAsJSON(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将整个数据表输出为 JSON 格式。

  • template<typename CharType = TCHAR> bool WriteTableAsJSON(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将整个数据表输出为 JSON 格式并写入 JSON 写入器。

  • template<typename CharType = TCHAR> bool WriteTableAsJSONObject(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将整个数据表输出为 JSON 对象并写入 JSON 写入器。

  • template<typename CharType = TCHAR> bool WriteRowAsJSON(const TSharedRef< TJsonWriter<CharType, TPrettyJsonPrintPolicy<CharType> > >& JsonWriter, const void* RowData, const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 将特定行的字段输出为 JSON 格式并写入 JSON 写入器。

  • bool CopyImportOptions(UDataTable* SourceTable)

    • 复制另一个数据表的导入选项，不复制行数据。

  • TArray<FString> CreateTableFromCSVString(const FString& InString)

    • 从 CSV 格式的字符串创建数据表。

  • TArray<FString> CreateTableFromJSONString(const FString& InString)

    • 从 JSON 格式的字符串创建数据表。

  • TArray<FString> CreateTableFromOtherTable(const UDataTable* InTable)

    • 从另一个数据表创建数据表。

  • TArray<FString> CreateTableFromRawData(TMap<FName, const uint8*>& DataMap, UScriptStruct* InRowStruct)

    • 从原始数据映射和给定的脚本结构创建数据表。

  • TArray<FString> GetColumnTitles() const

    • 获取所有列标题，使用属性的友好显示名称。

  • TArray<FString> GetUniqueColumnTitles() const

    • 获取所有列标题，使用属性的唯一名称。

  • TArray< TArray<FString> > GetTableData(const EDataTableExportFlags InDTExportFlags = EDataTableExportFlags::None) const

    • 获取每个行的数据数组，第一行是标题。

  • void SaveStructData(FStructuredArchiveSlot Slot)

    • 保存结构体数据。

  • void LoadStructData(FStructuredArchiveSlot Slot)

    • 加载结构体数据。

  • void OnPostDataImported(OUT TArray<FString>& OutCollectedImportProblems)

    • 当新数据导入数据表时调用，通知每个导入的行，并给行结构体一个操作导入数据的机会。

  • UScriptStruct& GetEmptyUsingStruct() const

    • 获取空的结构体。

FDataTableRowHandle 结构体

成员变量

  • TObjectPtr<const UDataTable> DataTable

    • 指向我们要获取行的数据表。

  • FName RowName

    • 我们要获取的行的名称。

成员函数

  • bool IsNull() const

    • 如果此句柄未指向任何内容，返回 true。

  • template <class T> T* GetRow(const TCHAR* ContextString) const

    • 从行句柄中获取行。

  • template <class T> T* GetRow(const FString& ContextString) const

    • 从行句柄中获取行。

  • FString ToDebugString(bool bUseFullPath = false) const

    • 返回调试字符串。

  • bool operator==(FDataTableRowHandle const& Other) const

    • 判断两个行句柄是否相等。

  • bool operator!=(FDataTableRowHandle const& Other) const

    • 判断两个行句柄是否不相等。

  • void PostSerialize(const FArchive& Ar)

    • 序列化后调用。

FDataTableCategoryHandle 结构体

成员变量

  • TObjectPtr<const class UDataTable> DataTable

    • 指向我们要获取行的数据表。

  • FName ColumnName

    • 我们要获取的列的名称。

  • FName RowContents

    • 我们要获取的行的内容。

成员函数

  • bool IsNull() const

    • 如果此句柄未指向任何内容，返回 true。

  • template <class T> void GetRows(TArray<T*>& OutRows, const FString& ContextString) const

    • 在数据表中搜索所有包含 RowContents 的行，并将它们添加到 OutRows 中。

  • bool operator==(FDataTableCategoryHandle const& Other) const

    • 判断两个类别句柄是否相等。

  • bool operator!=(FDataTableCategoryHandle const& Other) const

    • 判断两个类别句柄是否不相等。