客户端权威的移动

客户端权威移动

主要应用于一些需要优先保证客户端游玩体验的PVE类型的游戏，通过客户端的权威移动来解决由于网络延迟等造成的玩家位移发生拖拽等问题。

核心思想是服务端关闭对玩家运动的模拟，客户端按照一定的频率上报自己当前的位置，服务器将玩家上报的位置转发给其他的客户端，其他客户端接收到服务器转发的位置信息后进行平滑插值来模拟该角色的运动过程。

注:使用引擎为UE4.27

基础的运动功能

新建一个UE4.27的第三人称模板工程，命名为ClientMovement，使用默认提供的AClientMovementCharacter并且继承自UCharacterMovementComponent创建一个UClientMovementComponent。

替换默认的运动组件

先继承出一个UClientMovementComponent，然后修改ClientMovementCharacter的构造函数，使用FObjectInitializer替换默认的CMC

1
2
3
4
5
6
7
8
9
10
11
12
13
class AClientMovementCharacter : public ACharacter
{
public:
	// 将原先的默认构造函数声明替换为一下函数声明
	AClientMovementCharacter(const FObjectInitializer& Initializer);
};

// 实现
AClientMovementCharacter::AClientMovementCharacter(const FObjectInitializer& Initializer)
	:Super(Initializer.SetDefaultSubobjectClass<UClientMovementComponent>(AClientMovementCharacter::CharacterMovementComponentName))
{
	// ...	
}

替换完成后重新编译并启动就可以在默认提供的角色蓝图中看到默认的CMC被替换为自行创建的CMC。

对UClientMovementComponent的修改

在UCharacterMovementComponent中可以找到一段注释，解释了CMC在服务端对客户端运动的重建以及纠正过程：

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
/*
	========================================================================
	Here's how player movement prediction, replication and correction works in network games:
	
	Every tick, the TickComponent() function is called.  It figures out the acceleration and rotation change for the frame,
	and then calls PerformMovement() (for locally controlled Characters), or ReplicateMoveToServer() (if it's a network client).
	
	ReplicateMoveToServer() saves the move (in the PendingMove list), calls PerformMovement(), and then replicates the move
	to the server by calling the replicated function ServerMove() - passing the movement parameters, the client's
	resultant position, and a timestamp.
	
	ServerMove() is executed on the server.  It decodes the movement parameters and causes the appropriate movement
	to occur.  It then looks at the resulting position and if enough time has passed since the last response, or the
	position error is significant enough, the server calls ClientAdjustPosition(), a replicated function.
	
	ClientAdjustPosition() is executed on the client.  The client sets its position to the servers version of position,
	and sets the bUpdatePosition flag to true.
	
	When TickComponent() is called on the client again, if bUpdatePosition is true, the client will call
	ClientUpdatePosition() before calling PerformMovement().  ClientUpdatePosition() replays all the moves in the pending
	move list which occurred after the timestamp of the move the server was adjusting.
	*/

/*
	尝试翻译：
	========================================================================
	以下为网络游戏下玩家移动预测、复制以及纠错的工作方式：
	
	UCharacterMovementComponent的TickComponent() 函数在每帧被调用，该函数会计算出当前帧的加速度以及旋转变化量，对于本地控制的角色它会调用PerformMovement() 函数，对于网络客户端则会执行ReplicateMoveToServer() 函数。

	ReplicateMoveToServer() 将运动信息保存在PendingMove列表(PendingMove List)中，然后调用PerfoemMovement() 函数并通过ServerMove() 函数将运动信息复制给服务端 - move信息包括运动参数、客户端的最终位置以及一个时间戳

	ServerMove() 函数在服务端执行。该函数会解析运动参数并促使运动发生。然后它会检查(运动的)最终位置，如果距离上一次相应经过太长时间或者位置误差太大，服务器会调用ClientAdjustPosition() 函数来纠正客户端的位置。

	ClientAdjustPosition() 执行在客户端。该函数执行时会将位置设置为服务器发送过来的位置并且将"bUpdatePosition"标志设为true。

	当TickComponent() 函数在客户端被调用时，如果bUpdatePosition为true，客户端会在PerformMovement() 函数执行前调用ClientUpdatePosition() 函数。ClientUpdatePosition() 函数会重放PendingMove List中所有发生在服务器纠正时间戳之后的所有移动操作
	*/

UE在网络游戏架构下的运动系统为客户端预测+服务器校验回滚的模式，具体为当接收到移动输入后客户端会先运动并将运动信息上报给服务器，服务器根据客户端上报的运动信息模拟客户端并进行纠正，当客户端运动的位置于服务端模拟出的位置相差过大时会主动纠正客户端的位置。

因此要修改运动系统首先就要关闭服务器对客户端运动信息进行模拟的过程。

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
class UClientMovementComponent : public UClientMovementComponent
{
public:
	UClientMovementComponent();

protected:
	virtual void BeginPlay() override;

public:
	virtual void TickComponent(float DeltaTime, ELevelTick TickType, AActorComponentTickFunction* ThisTickFunction) override;

	// 首先需要关闭ServerMove相关的函数，主要为ServerMove，ServerMoveDual，ServerMoveDualHybridRootMotion以及ServerMoveOld这几个函数
	void ServerMove_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;

	bool ServerMove_Validate(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;
	
	void ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;

	bool ServerMoveDual_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;
	
	void ServerMoveDualHybridRootMotion_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;

	bool ServerMoveDualHybridRootMotion_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;
	
	void ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags) override;
	
	bool ServerMoveOld_Validate(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags) override;

	// 其次为ClientAdjustPosition函数，需要手动关闭客户端调整位置的方法，忽略任何从服务器而来的纠正信息
	void ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode) override;
};

文件实现

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
#include "ClientMovementComponent.h"

// Sets default values for this component's properties
UClientMovementComponent::UClientMovementComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	PrimaryComponentTick.bCanEverTick = true;
}


// Called when the game starts
void UClientMovementComponent::BeginPlay()
{
	Super::BeginPlay();
}


// Called every frame
void UClientMovementComponent::TickComponent(float DeltaTime, ELevelTick TickType,
                                             FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}

// 改为空实现
void UClientMovementComponent::ServerMove_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel,
	FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View,
	UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
	return;
}

// 直接拦截RPC的上报过程，不上报任何信息
bool UClientMovementComponent::ServerMove_Validate(float TimeStamp, FVector_NetQuantize10 InAccel,
	FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View,
	UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
	return false;
}

// 同样改为空实现
void UClientMovementComponent::ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0,
                                                             uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc,
                                                             uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName,
                                                             uint8 ClientMovementMode)
{
	return;
}

// 同样直接拦截RPC上报的过程
bool UClientMovementComponent::ServerMoveDual_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0,
	uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc,
	uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName,
	uint8 ClientMovementMode)
{
	return false;
}

// 同上
void UClientMovementComponent::ServerMoveDualHybridRootMotion_Implementation(float TimeStamp0,
                                                                             FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel,
                                                                             FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View,
                                                                             UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
	return;
}

// 同上
bool UClientMovementComponent::ServerMoveDualHybridRootMotion_Validate(float TimeStamp0, FVector_NetQuantize10 InAccel0,
	uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc,
	uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName,
	uint8 ClientMovementMode)
{
	return false;
}

// 同上
void UClientMovementComponent::ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel,
                                                            uint8 OldMoveFlags)
{
	return;
}

// 同上
bool UClientMovementComponent::ServerMoveOld_Validate(float OldTimeStamp, FVector_NetQuantize10 OldAccel,
	uint8 OldMoveFlags)
{
	return false;
}

// 直接覆盖原先的纠正逻辑，不进行任何操作
void UClientMovementComponent::ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, FVector NewVel,
                                                                   UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition,
                                                                   uint8 ServerMovementMode)
{
	return;
}

完整源码

CMC

头文件

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
// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "ClientMovementComponent.generated.h"


UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class CLIENTMOVEMENT_API UClientMovementComponent : public UCharacterMovementComponent
{
	GENERATED_BODY()

public:
	// Sets default values for this component's properties
	UClientMovementComponent();

protected:
	// Called when the game starts
	virtual void BeginPlay() override;

public:
	// Called every frame
	virtual void TickComponent(float DeltaTime, ELevelTick TickType,
	                           FActorComponentTickFunction* ThisTickFunction) override;

	void ServerMove_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;
	
	void ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;
	
	void ServerMoveDualHybridRootMotion_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode) override;

	void ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel, uint8 OldMoveFlags) override;
	
	void ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, uint8 ServerMovementMode) override;

	void PhysWalking(float deltaTime, int32 Iterations) override;

	void PhysFalling(float deltaTime, int32 Iterations) override;

	void PhysFlying(float deltaTime, int32 Iterations) override;

	void PhysSwimming(float deltaTime, int32 Iterations) override;

	void PostNetReceive() override;
};

源文件

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
#include "ClientMovementComponent.h"

// Sets default values for this component's properties
UClientMovementComponent::UClientMovementComponent()
{
	// Set this component to be initialized when the game starts, and to be ticked every frame.  You can turn these features
	// off to improve performance if you don't need them.
	PrimaryComponentTick.bCanEverTick = true;
}

// Called when the game starts
void UClientMovementComponent::BeginPlay()
{
	Super::BeginPlay();
}

// Called every frame
void UClientMovementComponent::TickComponent(float DeltaTime, ELevelTick TickType,
                                             FActorComponentTickFunction* ThisTickFunction)
{
	Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

	// ...
}

void UClientMovementComponent::ServerMove_Implementation(float TimeStamp, FVector_NetQuantize10 InAccel,
	FVector_NetQuantize100 ClientLoc, uint8 CompressedMoveFlags, uint8 ClientRoll, uint32 View,
	UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
	return;
}

void UClientMovementComponent::ServerMoveDual_Implementation(float TimeStamp0, FVector_NetQuantize10 InAccel0,
	uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel, 
    FVector_NetQuantize100 ClientLoc,
	uint8 NewFlags, uint8 ClientRoll, uint32 View, UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName,
	uint8 ClientMovementMode)
{
	return;
}

void UClientMovementComponent::ServerMoveDualHybridRootMotion_Implementation(float TimeStamp0,
	FVector_NetQuantize10 InAccel0, uint8 PendingFlags, uint32 View0, float TimeStamp, FVector_NetQuantize10 InAccel,
	FVector_NetQuantize100 ClientLoc, uint8 NewFlags, uint8 ClientRoll, uint32 View,
	UPrimitiveComponent* ClientMovementBase, FName ClientBaseBoneName, uint8 ClientMovementMode)
{
	return;
}

void UClientMovementComponent::ServerMoveOld_Implementation(float OldTimeStamp, FVector_NetQuantize10 OldAccel,
	uint8 OldMoveFlags)
{
	return;
}

void UClientMovementComponent::ClientAdjustPosition_Implementation(float TimeStamp, FVector NewLoc, 
    FVector NewVel, UPrimitiveComponent* NewBase, FName NewBaseBoneName, bool bHasBase, 
    bool bBaseRelativePosition, uint8 ServerMovementMode)
{
	return;
}

void UClientMovementComponent::PhysWalking(float deltaTime, int32 Iterations)
{
	ENetMode NetMode = GetNetMode();
	if (NetMode == NM_DedicatedServer)
	{
		return;
	}
	Super::PhysWalking(deltaTime, Iterations);
}

void UClientMovementComponent::PhysFalling(float deltaTime, int32 Iterations)
{
	ENetMode NetMode = GetNetMode();
	if (NetMode == NM_DedicatedServer)
	{
		return;
	}
	Super::PhysFalling(deltaTime, Iterations);
}

void UClientMovementComponent::PhysFlying(float deltaTime, int32 Iterations)
{
	ENetMode NetMode = GetNetMode();
	if (NetMode == NM_DedicatedServer)
	{
		return;
	}
	Super::PhysFlying(deltaTime, Iterations);
}

void UClientMovementComponent::PhysSwimming(float deltaTime, int32 Iterations)
{
	ENetMode NetMode = GetNetMode();
	if (NetMode == NM_DedicatedServer)
	{
		return;
	}
	Super::PhysSwimming(deltaTime, Iterations);
}

void UClientMovementComponent::PostNetReceive()
{
	AActor* Owner = GetOwner();
	if (IsValid(Owner) && Owner->GetLocalRole() == ROLE_AutonomousProxy)
	{
		return;
	}
	Super::PostNetReceive();
}

Character

头文件

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
// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "ClientMovementCharacter.generated.h"

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

	/** Camera boom positioning the camera behind the character */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class USpringArmComponent* CameraBoom;

	/** Follow camera */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class UCameraComponent* FollowCamera;
public:
	AClientMovementCharacter(const FObjectInitializer& Initializer);

	/** Base turn rate, in deg/sec. Other scaling may affect final turn rate. */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
	float BaseTurnRate;

	/** Base look up/down rate, in deg/sec. Other scaling may affect final rate. */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category=Camera)
	float BaseLookUpRate;

	void BeginPlay() override;

	void Tick(float DeltaSeconds) override;
protected:
	/** 移动的上报频率 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Net")
	float ReportInterval = 0.05; 

	float ReportSumTime = 0.0f;

	UFUNCTION(Server, Unreliable)
	void Server_ReportMovement(FVector Location, FRotator Rotation, FVector Velocity, uint8 MovementMode);

	UFUNCTION(BlueprintCallable)
	void TeleportToLocation(FVector Location, FRotator Rotation);

	UFUNCTION(Server, Reliable)
	void Server_TeleportToLocation(FVector Location, FRotator Rotation);

	void PlayRootMotionMontage_Internal(UAnimMontage* Montage);

	int32 PlayingRootMotion = 0;

	UFUNCTION()
	void OnRootMotionMontageEnded(UAnimMontage* Montage, bool bInterrupted);
	
	/** 用来测试带有根运动的蒙太奇 */
	UFUNCTION(BlueprintCallable)
	void PlayRootMotionMontage(UAnimMontage* Montage);

	UFUNCTION(Server, Reliable, WithValidation)
	void Server_PlayRootMotionMontage(UAnimMontage* Montage);

	UFUNCTION(NetMulticast, Reliable, WithValidation)
	void Multicast_PlayRootMotionMontage(UAnimMontage* Montage);
	
	/** Resets HMD orientation in VR. */
	void OnResetVR();

	/** Called for forwards/backward input */
	void MoveForward(float Value);

	/** Called for side to side input */
	void MoveRight(float Value);

	/** 
	 * Called via input to turn at a given rate. 
	 * @param Rate	This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
	 */
	void TurnAtRate(float Rate);

	/**
	 * Called via input to turn look up/down at a given rate. 
	 * @param Rate	This is a normalized rate, i.e. 1.0 means 100% of desired turn rate
	 */
	void LookUpAtRate(float Rate);

	/** Handler for when a touch input begins. */
	void TouchStarted(ETouchIndex::Type FingerIndex, FVector Location);

	/** Handler for when a touch input stops. */
	void TouchStopped(ETouchIndex::Type FingerIndex, FVector Location);

protected:
	// APawn interface
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	// End of APawn interface

public:
	/** Returns CameraBoom subobject **/
	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
	/** Returns FollowCamera subobject **/
	FORCEINLINE class UCameraComponent* GetFollowCamera() const { return FollowCamera; }
};

源文件

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
// Copyright Epic Games, Inc. All Rights Reserved.

#include "ClientMovementCharacter.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/ClientMovementComponent.h"
#include "Components/InputComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
#include "Kismet/GameplayStatics.h"

//////////////////////////////////////////////////////////////////////////
// AClientMovementCharacter

AClientMovementCharacter::AClientMovementCharacter(const FObjectInitializer& Initializer)
	:Super(Initializer.SetDefaultSubobjectClass<UClientMovementComponent>(AClientMovementCharacter::CharacterMovementComponentName))
{
	// Set size for collision capsule
	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

	// set our turn rates for input
	BaseTurnRate = 45.f;
	BaseLookUpRate = 45.f;

	// Don't rotate when the controller rotates. Let that just affect the camera.
	bUseControllerRotationPitch = false;
	bUseControllerRotationYaw = false;
	bUseControllerRotationRoll = false;

	// Configure character movement
	GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...	
	GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
	GetCharacterMovement()->JumpZVelocity = 600.f;
	GetCharacterMovement()->AirControl = 0.2f;

	// Create a camera boom (pulls in towards the player if there is a collision)
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(RootComponent);
	CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character	
	CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller

	// Create a follow camera
	FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
	FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
	FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

	// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character) 
	// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
}

//////////////////////////////////////////////////////////////////////////
// Input

void AClientMovementCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
	// Set up gameplay key bindings
	check(PlayerInputComponent);
	PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
	PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);

	PlayerInputComponent->BindAxis("MoveForward", this, &AClientMovementCharacter::MoveForward);
	PlayerInputComponent->BindAxis("MoveRight", this, &AClientMovementCharacter::MoveRight);

	// We have 2 versions of the rotation bindings to handle different kinds of devices differently
	// "turn" handles devices that provide an absolute delta, such as a mouse.
	// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
	PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
	PlayerInputComponent->BindAxis("TurnRate", this, &AClientMovementCharacter::TurnAtRate);
	PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
	PlayerInputComponent->BindAxis("LookUpRate", this, &AClientMovementCharacter::LookUpAtRate);

	// handle touch devices
	PlayerInputComponent->BindTouch(IE_Pressed, this, &AClientMovementCharacter::TouchStarted);
	PlayerInputComponent->BindTouch(IE_Released, this, &AClientMovementCharacter::TouchStopped);

	// VR headset functionality
	PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &AClientMovementCharacter::OnResetVR);
}


void AClientMovementCharacter::BeginPlay()
{
	Super::BeginPlay();

}

void AClientMovementCharacter::Tick(float DeltaSeconds)
{
	Super::Tick(DeltaSeconds);
	// 本地上报移动
	if (IsLocallyControlled())
	{
		if (UCharacterMovementComponent* CMC = GetCharacterMovement())
		{
			// 有跟运动或者有手动记录的根运动播放则不进行上报
			if (CMC->HasRootMotionSources() || PlayingRootMotion > 0)
			{
				return;
			}
		}

		ReportSumTime += DeltaSeconds;
		if (ReportSumTime > ReportInterval)
		{
			ReportSumTime -= ReportInterval;
			Server_ReportMovement(GetActorLocation(), GetActorRotation(), GetVelocity(), GetCharacterMovement()->MovementMode);			
		}
	}
}

void AClientMovementCharacter::Server_ReportMovement_Implementation(FVector Location, FRotator Rotation,
	FVector Velocity, uint8 MovementMode)
{
	// 屏蔽客户端的移动
	ENetMode LocalNetMode = GetNetMode();
	if (LocalNetMode == NM_Client)
	{
		return;
	}

	// 直接设置Character在服务端的位置和旋转
	SetActorLocationAndRotation(Location, Rotation);

	// 更新CMC的速度并依赖同步给所有客户端
	if (UCharacterMovementComponent* CMC = GetCharacterMovement())
	{
		CMC->Velocity = Velocity;
		CMC->SetMovementMode(static_cast<EMovementMode>(MovementMode));
	}
}

void AClientMovementCharacter::Server_TeleportToLocation_Implementation(FVector Location, FRotator Rotation)
{
	ENetMode NetMode = GetNetMode();
	if (NetMode == NM_Client)
	{
		return;
	}

	// 在服务器直接使用提供的传送功能,防止出现插值移动
	TeleportTo(Location, Rotation);
	if (UCharacterMovementComponent* CMC = GetCharacterMovement())
	{
		CMC->Velocity = FVector::ZeroVector;
	}
}

void AClientMovementCharacter::TeleportToLocation(FVector Location, FRotator Rotation)
{
	ENetMode LocalNetMode = GetNetMode();
	if (LocalNetMode == NM_Client)
	{
		// 先把速度改为0而后在客户端直接使用移动
		UCharacterMovementComponent* CMC = GetCharacterMovement();
		if (IsValid(CMC))
		{
			CMC->Velocity = FVector::ZeroVector;
			SetActorLocationAndRotation(Location, Rotation);
		}

		// 修改服务器上的位置
		Server_TeleportToLocation(Location, Rotation);
	}
}

void AClientMovementCharacter::PlayRootMotionMontage_Internal(UAnimMontage* Montage)
{
	if (!IsValid(Montage))
	{
		return;
	}
	
	FOnMontageEnded EndDelegate;
	EndDelegate.BindUObject(this, &AClientMovementCharacter::OnRootMotionMontageEnded);
	GetMesh()->GetAnimInstance()->Montage_SetEndDelegate(EndDelegate, Montage);

	PlayAnimMontage(Montage);
}

void AClientMovementCharacter::OnRootMotionMontageEnded(UAnimMontage* Montage, bool bInterrupted)
{
	--PlayingRootMotion;
}

void AClientMovementCharacter::PlayRootMotionMontage(UAnimMontage* Montage)
{
	if (!IsValid(Montage))
	{
		return;
	}

	PlayRootMotionMontage_Internal(Montage);

	Server_PlayRootMotionMontage(Montage);
}

void AClientMovementCharacter::Server_PlayRootMotionMontage_Implementation(UAnimMontage* Montage)
{
	if (!IsValid(Montage))
	{
		return;
	}
	// 在服务器播放这个动画
	PlayRootMotionMontage_Internal(Montage);

	// 给所的客户端广播这个事件
	Multicast_PlayRootMotionMontage(Montage);
}

bool AClientMovementCharacter::Server_PlayRootMotionMontage_Validate(UAnimMontage* Montage)
{
	return IsValid(Montage);
}

void AClientMovementCharacter::Multicast_PlayRootMotionMontage_Implementation(UAnimMontage* Montage)
{
	if (!IsValid(Montage))
	{
		return;
	}

	if (IsLocallyControlled())
	{
		return;
	}

	PlayRootMotionMontage_Internal(Montage);
}

bool AClientMovementCharacter::Multicast_PlayRootMotionMontage_Validate(UAnimMontage* Montage)
{
	return IsValid(Montage);
}

void AClientMovementCharacter::OnResetVR()
{
	// If ClientMovement is added to a project via 'Add Feature' in the Unreal Editor the dependency on HeadMountedDisplay in ClientMovement.Build.cs is not automatically propagated
	// and a linker error will result.
	// You will need to either:
	//		Add "HeadMountedDisplay" to [YourProject].Build.cs PublicDependencyModuleNames in order to build successfully (appropriate if supporting VR).
	// or:
	//		Comment or delete the call to ResetOrientationAndPosition below (appropriate if not supporting VR)
	UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();
}

void AClientMovementCharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
		Jump();
}

void AClientMovementCharacter::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
		StopJumping();
}

void AClientMovementCharacter::TurnAtRate(float Rate)
{
	// calculate delta for this frame from the rate information
	AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}

void AClientMovementCharacter::LookUpAtRate(float Rate)
{
	// calculate delta for this frame from the rate information
	AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}

void AClientMovementCharacter::MoveForward(float Value)
{
	if ((Controller != nullptr) && (Value != 0.0f))
	{
		// find out which way is forward
		const FRotator Rotation = Controller->GetControlRotation();
		const FRotator YawRotation(0, Rotation.Yaw, 0);

		// get forward vector
		const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
		AddMovementInput(Direction, Value);
	}
}

void AClientMovementCharacter::MoveRight(float Value)
{
	if ( (Controller != nullptr) && (Value != 0.0f) )
	{
		// find out which way is right
		const FRotator Rotation = Controller->GetControlRotation();
		const FRotator YawRotation(0, Rotation.Yaw, 0);
	
		// get right vector 
		const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
		// add movement in that direction
		AddMovementInput(Direction, Value);
	}
}

展开全文 >>

朝向扭曲

朝向扭曲

在制作人物的八方向运动时，一般可以使用混合空间来制作，但是混合出来的动画和人物的移动方向角度可能会不匹配或者出现左脚绊右脚的情况，所以可以考虑使用朝向扭曲来解决上述问题。

朝向扭曲

主要关心的参数为节点的LocomotionAngle和LocomotionDirection这两个输入参数以及SpineBones和IKFootBone这两个节点设置。

朝向扭曲的过程

主要更新节点为FAnimNode_OrientationWarping这个节点中的EvaluateSkeletalControl_AnyThread这个方法，现在来对这个方法进行解析。

简单分析，内容可能又误差，其中对调试部分没有特殊注明

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
void FAnimNode_OrientationWarping::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
{
	SCOPE_CYCLE_COUNTER(STAT_OrientationWarping_Eval);
	check(OutBoneTransforms.Num() == 0);


	// 需要朝向的角度
	float TargetOrientationAngleRad;

	const float DeltaSeconds = Output.AnimInstanceProxy->GetDeltaSeconds();
	// 最大校正角度,默认为180°
	const float MaxAngleCorrectionRad = FMath::DegreesToRadians(MaxCorrectionDegrees);
	// 围绕哪个角度进行旋转,默认为Yaw轴
	const FVector RotationAxisVector = UE::Anim::GetAxisVector(RotationAxis);
	// 前进方向
	FVector LocomotionForward = FVector::ZeroVector;

	bool bGraphDrivenWarping = false;
	// 提取根运动
	const UE::Anim::IAnimRootMotionProvider* RootMotionProvider = UE::Anim::IAnimRootMotionProvider::Get();

	// 判断是否为图表模式,在该模式下会使用根运动
	if (Mode == EWarpingEvaluationMode::Graph)
	{
		bGraphDrivenWarping = !!RootMotionProvider;
		ensureMsgf(bGraphDrivenWarping, TEXT("Graph driven Orientation Warping expected a valid root motion delta provider interface."));
	}

#if WITH_EDITORONLY_DATA
	bFoundRootMotionAttribute = false;
#endif

#if ENABLE_ANIM_DEBUG
	FTransform RootMotionTransformDelta = FTransform::Identity;
	float RootMotionDeltaAngleRad = 0.0;
	const float PreviousOrientationAngleRad = ActualOrientationAngleRad;
#endif

#if ENABLE_ANIM_DEBUG || ENABLE_VISUAL_LOG
	if (DeltaSeconds > 0)
	{
		bUsedFutureRootMotion = false;
	}
#endif

	// We will likely need to revisit LocomotionAngle participating as an input to orientation warping.
	// Without velocity information from the motion model (such as the capsule), LocomotionAngle isn't enough
	// information in isolation for all cases when deciding to warp.
	//
	// For example imagine that the motion model has stopped moving with zero velocity due to a
	// transition into a strafing stop. During that transition we may play an animation with non-zero 
	// velocity for an arbitrary number of frames. In this scenario the concept of direction is meaningless 
	// since we cannot orient the animation to match a zero velocity and consequently a zero direction, 
	// since that would break the pose. For those frames, we would incorrectly over-orient the strafe.
	//
	// The solution may be instead to pass velocity with the actor base rotation, allowing us to retain
	// speed information about the motion. It may also allow us to do more complex orienting behavior 
	// when multiple degrees of freedom can be considered.

	/**
	 * 尝试翻译:
	 * 我们可能需要重新评估将LocomotionAngle作为朝向角度,当运动的模型(例如角色的胶囊体)不再有速度信息时,
	 * 此时当决定进行扭曲时LocomotionAngle并不能提供足够的信息(大体意思可能为只依赖LocomotionAnlge并不能将扭曲的所有情况都考虑到)
	 *
	 * 考虑一种情况:由于进入停止运动的过渡状态,运动的模型此时的速度为0,在过渡期间我们可能会在任意帧播放一个速度非0的过渡动画,
	 * 在这种场景下朝向是个没有意义的概念，因为我们不能为了匹配一个为0的速度(因为它的方向为0)去旋转动画,此时我们应该停止动画,
	 * 在这些帧中会产生不正确的过渡旋转
	 *
	 * 解决方案为使用一个带有Actor旋转的速度值,这允许我们保留运动的速度信息,
	 * 当多个自由旋转的朝向被考虑时它也能允许我们使用复杂的朝向逻辑
	 */

	// 判断使用的旋转空间
	if (WarpingSpace == EOrientationWarpingSpace::ComponentTransform)
	{
		WarpingSpaceTransform = Output.AnimInstanceProxy->GetComponentTransform();
	}

	// 如果带有根运动则执行下述逻辑
	if (bGraphDrivenWarping)
	{
#if !ENABLE_ANIM_DEBUG
		FTransform RootMotionTransformDelta = FTransform::Identity;
#endif

		// 提取根运动
		bGraphDrivenWarping = RootMotionProvider->ExtractRootMotion(Output.CustomAttributes, RootMotionTransformDelta);

		// Graph driven orientation warping will modify the incoming root motion to orient towards the intended locomotion angle
		if (bGraphDrivenWarping)
		{
#if WITH_EDITORONLY_DATA
			// Graph driven Orientation Warping expects a root motion delta to be present in the attribute stream.
			bFoundRootMotionAttribute = true;
#endif

			// In UE, forward is defined as +x; consequently this is also true when sampling an actor's velocity. Historically the skeletal 
			// mesh component forward will not match the actor, requiring us to correct the rotation before sampling the LocomotionForward.
			// In order to make orientation warping 'pure' in the future we will need to provide more context about the intent of
			// the actor vs the intent of the animation in their respective spaces. Specifically, we will need some form the following information:
			//
			// 1. Actor Forward
			// 2. Actor Velocity
			// 3. Skeletal Mesh Relative Rotation

			/**
			 * 尝试翻译:
			 * 在UE中,+x的方向被定义为正方向;因此当对Actor的速度进行采样是也是如此(?_?)
			 * 骨骼的MeshComponent中的正方向与Actor的正方向并不匹配,这需要我们在对速度正方向进行采样时纠正旋转
			 * 为了让"朝向扭曲"在未来(后续使用)不受干扰我们需要提供更多关于Actor本身的意图和动画的意图作为上下文信息(?_?)
			 *
			 * Actor的正方向
			 * Actor的速度
			 * 对骨骼进行相对旋转
			 */

			// 根据输入朝向的大小判断是否停止,或者说是否有输入朝向
			// LocomotionDirection如果存在则优先使用
			if (LocomotionDirection.SquaredLength() > UE_SMALL_NUMBER)
			{
				// if we have a LocomotionDirection vector, transform into root bone local space
				// 如果有输入朝向则将这个朝向旋转到根运动的空间中
				LocomotionForward = WarpingSpaceTransform.InverseTransformVector(LocomotionDirection);
				LocomotionForward.Normalize();
			}
			else
			{
				// 没有朝向输入
				LocomotionAngle = FRotator::NormalizeAxis(LocomotionAngle);
				// UE-184297 Avoid storing LocomotionAngle in radians in case haven't updated the pinned input, to avoid a DegToRad(RadianValue)
				// 获取旋转角度
				const float LocomotionAngleRadians = FMath::DegreesToRadians(LocomotionAngle);
				// 根据旋转轴获取旋转值
				const FQuat LocomotionRotation = FQuat(RotationAxisVector, LocomotionAngleRadians);
				// 获取骨骼的相对旋转
				const FTransform SkeletalMeshRelativeTransform = Output.AnimInstanceProxy->GetComponentRelativeTransform();
            	const FQuat SkeletalMeshRelativeRotation = SkeletalMeshRelativeTransform.GetRotation();
				// 获取运动朝向
				LocomotionForward = SkeletalMeshRelativeRotation.UnrotateVector(LocomotionRotation.GetForwardVector()).GetSafeNormal();
			}

			// Flatten locomotion direction, along the rotation axis.
			/**
			 * 将运动方向沿着旋转轴的方向进行扁平化，即将运动方向投影到运动平面中使其与旋转轴锤子
			 * 1. 通过点积计算LocomotionForward在RotationAxisVector上的投影长度,并将长度乘以旋转轴得到旋转轴上的向量
			 * 2. 让LocomotionForward减去这个得到的向量,结果为垂直旋转轴的向量
			 * 3. 进行归一化得到运动方向
			 *
			 * 公式为:V_proj = V - (V·Axis)*Axis
			 * 目的是移除在旋转轴方向的分量，只在平面上计算方向
			 */
			LocomotionForward = (LocomotionForward - RotationAxisVector.Dot(LocomotionForward) * RotationAxisVector).GetSafeNormal();

			// @todo: Graph mode using a "manual value" makes no sense. Restructure logic to address this in the future.
			if (bUseManualRootMotionVelocity)
			{
				RootMotionTransformDelta.SetTranslation(ManualRootMotionVelocity * DeltaSeconds);
			}

			// 操作和上一步类似
			// 获取根运动增量
			FVector RootMotionDeltaTranslation = RootMotionTransformDelta.GetTranslation();
			// 保存上一帧的旋转
			const FQuat PreviousRootMotionDeltaRotation = RootMotionDeltaRotation;
			// 这一帧的旋转
			RootMotionDeltaRotation = RootMotionTransformDelta.GetRotation();
			
			// Flatten root motion translation, along the rotation axis.
			// 使用同样的投影操作
			RootMotionDeltaTranslation = RootMotionDeltaTranslation - RotationAxisVector.Dot(RootMotionDeltaTranslation) * RotationAxisVector;

			// Look forward in root motion to determine orientation warping angle if future time specified
			// 获取预测的根运动方向(根据变量注释这是一个实验性的功能,版本为5.5)
			FVector PredictedRootMotionDeltaTranslation = RootMotionDeltaTranslation;
			if (TargetTime > 0 && CurrentAnimAsset)
			{
				if (UAnimSequenceBase* AnimSequence = Cast<UAnimSequenceBase>(CurrentAnimAsset))
				{
					FTransform PredictedRootMotionTransform = AnimSequence->ExtractRootMotion(CurrentAnimAssetTime, TargetTime, false);
					PredictedRootMotionDeltaTranslation = PredictedRootMotionTransform.GetTranslation();
					PredictedRootMotionDeltaTranslation = PredictedRootMotionDeltaTranslation - RotationAxisVector.Dot(PredictedRootMotionDeltaTranslation) * RotationAxisVector;
				}
			}

			// 根据增量计算根运动的速度
			const float RootMotionDeltaSpeed = RootMotionDeltaTranslation.Size() / DeltaSeconds;
			// 如果运动的速度小于速度阈值,则认为朝向角度为0,即角色运动基本停止,此时不再应用朝向扭曲
			if (RootMotionDeltaSpeed < MinRootMotionSpeedThreshold)
			{
				// If we're under the threshold, snap orientation angle to 0, and let interpolation handle the delta
				TargetOrientationAngleRad = 0.0f;
			}
			else
			{
				// 获取根运动朝向
				const FVector PreviousRootMotionDeltaDirection = RootMotionDeltaDirection;
				// Hold previous direction if we can't calculate it from current move delta, because the root is no longer moving
				// 如果根运动已经停止则使用上一帧保存的朝向
				RootMotionDeltaDirection = RootMotionDeltaTranslation.GetSafeNormal(UE_SMALL_NUMBER, PreviousRootMotionDeltaDirection);
				TargetOrientationAngleRad = UE::Anim::SignedAngleRadBetweenNormals(RootMotionDeltaDirection, LocomotionForward, RotationAxisVector);

				// Motion Matching may return an animation that deviates a lot from the movement direction (e.g movement direction going bwd and motion matching could return the fwd animation for a few frames)
				// When that happens, since we use the delta between root motion and movement direction, we would be over-rotating the lower body and breaking the pose during those frames
				// So, when that happens we use the inverse of the root motion direction to calculate our target rotation. 
				// This feels a bit 'hacky' but its the only option I've found so far to mitigate the problem
				// 看翻译似乎是用来适配MotionMatching的
				if (LocomotionAngleDeltaThreshold > 0.f)
				{
					if (FMath::Abs(FMath::RadiansToDegrees(TargetOrientationAngleRad)) > LocomotionAngleDeltaThreshold)
					{
						TargetOrientationAngleRad = FMath::UnwindRadians(TargetOrientationAngleRad + FMath::DegreesToRadians(180.0f));
						RootMotionDeltaDirection = -RootMotionDeltaDirection;
					}
				}

				// If there is translation in predicted root motion, use it if the orientation error is less than current error
				// 判断是否需要使用预测角度
				if (TargetTime > 0 && CurrentAnimAsset && !PredictedRootMotionDeltaTranslation.IsNearlyZero(UE_SMALL_NUMBER))
				{
					PredictedRootMotionDeltaTranslation.Normalize();
					float PredictedOrientationErrorAngleRad = UE::Anim::SignedAngleRadBetweenNormals(PredictedRootMotionDeltaTranslation, LocomotionForward, RotationAxisVector);

					// The future orientation will often match the current, so add a small delta to avoid further testing for same values
					if (FMath::Abs(PredictedOrientationErrorAngleRad) + UE_KINDA_SMALL_NUMBER < FMath::Abs(TargetOrientationAngleRad))
					{
						// Note: Don't update root motion direction, as the root motion direction is what we are playing, 
						// not the future. Updating root motion direction will break counter compensate. 
						// Also, we rely on the built in interp for continuity / smoothness
#if ENABLE_ANIM_DEBUG || ENABLE_VISUAL_LOG
						FutureRootMotionDeltaDirection = PredictedRootMotionDeltaTranslation;
						bUsedFutureRootMotion = true;
#endif
						TargetOrientationAngleRad = PredictedOrientationErrorAngleRad;
					}
				}

				// Don't compensate interpolation by the root motion angle delta if the previous direction isn't valid.
				// 翻译:如果PreviousDirection是个无效值,则不对根运动的角度差值进行插值补偿
				// 如果PreviousDirection不为0并且使用插值补偿则进入下面的逻辑
				// 主要为补偿根运动自身的方向对插值的影响,例如动画本身就带有旋转的情况
				if (bCounterCompenstateInterpolationByRootMotion && !PreviousRootMotionDeltaDirection.IsNearlyZero(UE_SMALL_NUMBER))
				{
#if !ENABLE_ANIM_DEBUG
					float RootMotionDeltaAngleRad;
#endif
					// Counter the interpolated orientation angle by the root motion direction angle delta.
					// This prevents our interpolation from fighting the natural root motion that's flowing through the graph.
					// To correctly measure the amount to counter, we need to unrotate our previous delta direction by our previous rotation
					// As the previous direction delta is relative to the previous rotation delta
					// static float SignedAngleRadBetweenNormals(const FVector& From, const FVector& To, const FVector& Axis)
					// 获取AB两个方向在Axis轴上的角度差值
					RootMotionDeltaAngleRad = UE::Anim::SignedAngleRadBetweenNormals(RootMotionDeltaDirection, PreviousRootMotionDeltaRotation.UnrotateVector(PreviousRootMotionDeltaDirection), RotationAxisVector);
					
					// Root motion may have large deltas i.e. bad blends or sudden direction changes like pivots.
					// If there's an instantaneous pop in root motion direction, this is likely a pivot.
					// 进行夹值限制
					const float MaxRootMotionDeltaToCompensateRad = FMath::DegreesToRadians(MaxRootMotionDeltaToCompensateDegrees);
					if (FMath::Abs(RootMotionDeltaAngleRad) < MaxRootMotionDeltaToCompensateRad)
					{
						CounterCompensateTargetAngleRad += RootMotionDeltaAngleRad;
						float CounterCompensateAngle = FMath::FInterpTo(0, CounterCompensateTargetAngleRad, DeltaSeconds, CounterCompensateInterpSpeed);
						ActualOrientationAngleRad = FMath::UnwindRadians(ActualOrientationAngleRad + CounterCompensateAngle);
						CounterCompensateTargetAngleRad -= CounterCompensateAngle;
					}
				}

				// Rotate the root motion delta fully by the warped angle
				// 将根运动旋转到LocomotionForward的方向
				const FVector WarpedRootMotionTranslationDelta = FQuat(RotationAxisVector, TargetOrientationAngleRad).RotateVector(RootMotionDeltaTranslation);
				RootMotionTransformDelta.SetTranslation(WarpedRootMotionTranslationDelta);
			}

			// Forward the side effects of orientation warping on the root motion contribution for this sub-graph
			// 覆盖根运动
			const bool bRootMotionOverridden = RootMotionProvider->OverrideRootMotion(RootMotionTransformDelta, Output.CustomAttributes);
			ensureMsgf(bRootMotionOverridden, TEXT("Graph driven Orientation Warping expected a root motion delta to be present in the attribute stream prior to warping/overriding it."));
		}
		else
		{
			// Early exit on missing root motion delta attribute
			return;
		}
	} 
	else
	{
		// Manual orientation warping will take the angle directly
		TargetOrientationAngleRad = FRotator::NormalizeAxis(OrientationAngle);
		TargetOrientationAngleRad = FMath::DegreesToRadians(TargetOrientationAngleRad);
	}

	// Optionally interpolate the effective orientation towards the target orientation angle
	// When the orientation warping node becomes relevant, the input pose orientation may not be aligned with the desired orientation.
	// Instead of interpolating this difference, snap to the desired orientation if it's our first update to minimize corrections over-time.
	// 如果需要进行插值的话则进行插值
	if ((RotationInterpSpeed > 0.f) && !bIsFirstUpdate)
	{
		const float SmoothOrientationAngleRad = FMath::FInterpTo(ActualOrientationAngleRad, TargetOrientationAngleRad, DeltaSeconds, RotationInterpSpeed);
		// Limit our interpolation rate to prevent pops.
		// @TODO: Use better, more physically accurate interpolation here.
		ActualOrientationAngleRad = FMath::Clamp(SmoothOrientationAngleRad, ActualOrientationAngleRad - MaxAngleCorrectionRad, ActualOrientationAngleRad + MaxAngleCorrectionRad);
	}
	else
	{
		ActualOrientationAngleRad = TargetOrientationAngleRad;
	}

	// 对实际朝向进行夹值
	ActualOrientationAngleRad = FMath::Clamp(ActualOrientationAngleRad, -MaxAngleCorrectionRad, MaxAngleCorrectionRad);
	// Allow the alpha value of the node to affect the final rotation
	// 应用作用效果
	ActualOrientationAngleRad *= ActualAlpha;

	// 是否应用全局混合权重,默认为false
	if (bScaleByGlobalBlendWeight)
	{
		ActualOrientationAngleRad *= BlendWeight;
	}

#if ENABLE_ANIM_DEBUG
	bool bDebugging = false;
#if WITH_EDITORONLY_DATA
	bDebugging = bDebugging || bEnableDebugDraw;
#else
	constexpr float DebugDrawScale = 1.f;
#endif
	const int32 DebugIndex = CVarAnimNodeOrientationWarpingDebug.GetValueOnAnyThread();
	bDebugging = bDebugging || (DebugIndex > 0);

	if (bDebugging)
	{
		const FTransform ComponentTransform = Output.AnimInstanceProxy->GetComponentTransform();
		const FVector ActorForwardDirection = Output.AnimInstanceProxy->GetActorTransform().GetRotation().GetForwardVector();
		FVector DebugArrowOffset = FVector::ZAxisVector * DebugDrawScale;

		// Draw debug shapes
		{
			const FVector ForwardDirection = bGraphDrivenWarping
				? ComponentTransform.GetRotation().RotateVector(LocomotionForward)
				: ActorForwardDirection;

			Output.AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + ForwardDirection * 100.f * DebugDrawScale,
				40.f * DebugDrawScale, FColor::Red, false, 0.f, 2.f * DebugDrawScale);

			const FVector RotationDirection = bGraphDrivenWarping
				? ComponentTransform.GetRotation().RotateVector(RootMotionDeltaDirection)
				: ActorForwardDirection.RotateAngleAxis(OrientationAngle, RotationAxisVector);

			DebugArrowOffset += FVector::ZAxisVector * DebugDrawScale;
			Output.AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + RotationDirection * 100.f * DebugDrawScale,
				40.f * DebugDrawScale, FColor::Blue, false, 0.f, 2.f * DebugDrawScale);

			if (bUsedFutureRootMotion && bGraphDrivenWarping)
			{
				const FVector FutureRotationDirection = ComponentTransform.GetRotation().RotateVector(FutureRootMotionDeltaDirection);

				Output.AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
					ComponentTransform.GetLocation() + DebugArrowOffset,
					ComponentTransform.GetLocation() + DebugArrowOffset + FutureRotationDirection * 100.f * DebugDrawScale,
					40.f * DebugDrawScale, FColor::Yellow, false, 0.f, 2.f * DebugDrawScale);
			}

			const float ActualOrientationAngleDegrees = FMath::RadiansToDegrees(ActualOrientationAngleRad);
			const FVector WarpedRotationDirection = bGraphDrivenWarping
				? RotationDirection.RotateAngleAxis(ActualOrientationAngleDegrees, RotationAxisVector)
				: ActorForwardDirection.RotateAngleAxis(ActualOrientationAngleDegrees, RotationAxisVector);

			DebugArrowOffset += FVector::ZAxisVector * DebugDrawScale;
			Output.AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + WarpedRotationDirection * 100.f * DebugDrawScale,
				40.f * DebugDrawScale, FColor::Green, false, 0.f, 2.f * DebugDrawScale);
		}

		// Draw text on mesh in world space
		{
			TStringBuilder<1024> DebugLine;

			const float PreviousOrientationAngleDegrees = FMath::RadiansToDegrees(PreviousOrientationAngleRad);
			const float ActualOrientationAngleDegrees = FMath::RadiansToDegrees(ActualOrientationAngleRad);
			const float TargetOrientationAngleDegrees = FMath::RadiansToDegrees(TargetOrientationAngleRad);
			if (Mode == EWarpingEvaluationMode::Manual)
			{
				DebugLine.Appendf(TEXT("\n - Previous Orientation Angle: (%.3fd)"), PreviousOrientationAngleDegrees);
				DebugLine.Appendf(TEXT("\n - Orientation Angle: (%.3fd)"), ActualOrientationAngleDegrees);
				DebugLine.Appendf(TEXT("\n - Target Orientation Angle: (%.3fd)"), TargetOrientationAngleRad);
			}
			else
			{
				if (RotationInterpSpeed > 0.0f)
				{
					DebugLine.Appendf(TEXT("\n - Previous Orientation Angle: (%.3fd)"), FMath::RadiansToDegrees(PreviousOrientationAngleRad));
					DebugLine.Appendf(TEXT("\n - Root Motion Frame Delta Angle: (%.3fd)"), FMath::RadiansToDegrees(RootMotionDeltaAngleRad));
				}
				DebugLine.Appendf(TEXT("\n - Actual Orientation Angle: (%.3fd)"), FMath::RadiansToDegrees(ActualOrientationAngleRad));
				DebugLine.Appendf(TEXT("\n - Target Orientation Angle: (%.3fd)"), FMath::RadiansToDegrees(TargetOrientationAngleRad));
				// Locomotion angle is already in degrees.
				DebugLine.Appendf(TEXT("\n - Locomotion Angle: (%.3fd)"), LocomotionAngle);
				DebugLine.Appendf(TEXT("\n - Root Motion Delta: %s)"), *RootMotionTransformDelta.GetTranslation().ToString());
				DebugLine.Appendf(TEXT("\n - Root Motion Speed: %.3fd)"), RootMotionTransformDelta.GetTranslation().Size() / DeltaSeconds);
			}
			Output.AnimInstanceProxy->AnimDrawDebugInWorldMessage(DebugLine.ToString(), FVector::UpVector * 50.0f, FColor::Yellow, 1.f /*TextScale*/);
		}
	}
#endif

#if ANIM_TRACE_ENABLED
	{
		const float PreviousOrientationAngleDegrees = FMath::RadiansToDegrees(PreviousOrientationAngleRad);
		const float ActualOrientationAngleDegrees = FMath::RadiansToDegrees(ActualOrientationAngleRad);
		const float TargetOrientationAngleDegrees = FMath::RadiansToDegrees(TargetOrientationAngleRad);

		TRACE_ANIM_NODE_VALUE(Output, TEXT("Previous OrientationAngle Degrees"), PreviousOrientationAngleDegrees);
		TRACE_ANIM_NODE_VALUE(Output, TEXT("Actual Orientation Angle Degrees"), ActualOrientationAngleDegrees);
		TRACE_ANIM_NODE_VALUE(Output, TEXT("Target Orientation Angle Degrees"), TargetOrientationAngleDegrees);

		if (Mode == EWarpingEvaluationMode::Graph)
		{
			const float RootMotionDeltaAngleDegrees = FMath::RadiansToDegrees(RootMotionDeltaAngleRad);
			TRACE_ANIM_NODE_VALUE(Output, TEXT("Root Motion Delta Angle Degrees"), RootMotionDeltaAngleDegrees);
			TRACE_ANIM_NODE_VALUE(Output, TEXT("Locomotion Angle"), LocomotionAngle);
			TRACE_ANIM_NODE_VALUE(Output, TEXT("Root Motion Translation Delta"), RootMotionTransformDelta.GetTranslation());

			const float RootMotionSpeed = RootMotionTransformDelta.GetTranslation().Size() / DeltaSeconds;
			TRACE_ANIM_NODE_VALUE(Output, TEXT("Root Motion Speed"), RootMotionSpeed);
		}
	}
#endif
	

#if ENABLE_VISUAL_LOG
	if (FVisualLogger::IsRecording())
	{
		const FTransform ComponentTransform = Output.AnimInstanceProxy->GetComponentTransform();
		const FVector ActorForwardDirection = Output.AnimInstanceProxy->GetActorTransform().GetRotation().GetForwardVector();
		FVector DebugArrowOffset = FVector::ZAxisVector * DebugDrawScale;

		// Draw debug shapes
		{
			const FVector ForwardDirection = bGraphDrivenWarping
				? ComponentTransform.GetRotation().RotateVector(LocomotionForward)
				: ActorForwardDirection;

			UE_VLOG_ARROW(Output.AnimInstanceProxy->GetAnimInstanceObject(), "OrientationWarping", Display,
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + ForwardDirection * 100.f * DebugDrawScale,
				FColor::Red, TEXT(""));

			const FVector RotationDirection = bGraphDrivenWarping
				? ComponentTransform.GetRotation().RotateVector(RootMotionDeltaDirection)
				: ActorForwardDirection.RotateAngleAxis(OrientationAngle, RotationAxisVector);

			DebugArrowOffset += FVector::ZAxisVector * DebugDrawScale;
			UE_VLOG_ARROW(Output.AnimInstanceProxy->GetAnimInstanceObject(), "OrientationWarping", Display,
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + RotationDirection * 100.f * DebugDrawScale,
				FColor::Blue, TEXT(""));

			if (bUsedFutureRootMotion && bGraphDrivenWarping)
			{
				const FVector FutureRotationDirection = ComponentTransform.GetRotation().RotateVector(FutureRootMotionDeltaDirection);

				Output.AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
					ComponentTransform.GetLocation() + DebugArrowOffset,
					ComponentTransform.GetLocation() + DebugArrowOffset + FutureRotationDirection * 100.f * DebugDrawScale,
					40.f * DebugDrawScale, FColor::Yellow, false, 0.f, 2.f * DebugDrawScale);
			}

			const float ActualOrientationAngleDegrees = FMath::RadiansToDegrees(ActualOrientationAngleRad);
			const FVector WarpedRotationDirection = bGraphDrivenWarping
				? RotationDirection.RotateAngleAxis(ActualOrientationAngleDegrees, RotationAxisVector)
				: ActorForwardDirection.RotateAngleAxis(ActualOrientationAngleDegrees, RotationAxisVector);

			DebugArrowOffset += FVector::ZAxisVector * DebugDrawScale;

			UE_VLOG_ARROW(Output.AnimInstanceProxy->GetAnimInstanceObject(), "OrientationWarping", Display,
				ComponentTransform.GetLocation() + DebugArrowOffset,
				ComponentTransform.GetLocation() + DebugArrowOffset + WarpedRotationDirection * 100.f * DebugDrawScale,
				FColor::Green, TEXT(""));
		}
	}
#endif

	// 首先对根骨骼应用旋转
	// DistributedBoneOrientationAlpha(0-1)用于控制旋转骨骼的分配比例,剩余的部分(1-)会应用到脊椎和脚步
	const float RootOffset = FMath::UnwindRadians(ActualOrientationAngleRad * DistributedBoneOrientationAlpha);
	
	// Rotate Root Bone first, as that cheaply rotates the whole pose with one transformation.
	if (!FMath::IsNearlyZero(RootOffset, KINDA_SMALL_NUMBER))
	{
		const FQuat RootRotation = FQuat(RotationAxisVector, RootOffset);
		const FCompactPoseBoneIndex RootBoneIndex(0);
	
		FTransform RootBoneTransform(Output.Pose.GetComponentSpaceTransform(RootBoneIndex));
		RootBoneTransform.SetRotation(RootRotation * RootBoneTransform.GetRotation());
		RootBoneTransform.NormalizeRotation();
		Output.Pose.SetComponentSpaceTransform(RootBoneIndex, RootBoneTransform);
	}

	// 开始旋转脊椎骨
	const int32 NumSpineBones = SpineBoneDataArray.Num();
	const bool bSpineOrientationAlpha = !FMath::IsNearlyZero(DistributedBoneOrientationAlpha, KINDA_SMALL_NUMBER);
	const bool bUpdateSpineBones = (NumSpineBones > 0) && bSpineOrientationAlpha;

	// 对填入的脊椎骨应用反向旋转,抵消根骨骼的旋转,保持上半身相对稳定
	if (bUpdateSpineBones)
	{
		// Spine bones counter rotate body orientation evenly across all bones.
		for (int32 ArrayIndex = 0; ArrayIndex < NumSpineBones; ArrayIndex++)
		{
			const FOrientationWarpingSpineBoneData& BoneData = SpineBoneDataArray[ArrayIndex];
			const FQuat SpineBoneCounterRotation = FQuat(RotationAxisVector, -ActualOrientationAngleRad * DistributedBoneOrientationAlpha * BoneData.Weight);
			check(BoneData.Weight > 0.f);

			FTransform SpineBoneTransform(Output.Pose.GetComponentSpaceTransform(BoneData.BoneIndex));
			SpineBoneTransform.SetRotation((SpineBoneCounterRotation * SpineBoneTransform.GetRotation()));
			SpineBoneTransform.NormalizeRotation();
			Output.Pose.SetComponentSpaceTransform(BoneData.BoneIndex, SpineBoneTransform);
		}
	}
	
	const float IKFootRootOrientationAlpha = 1.f - DistributedBoneOrientationAlpha;
	const bool bUpdateIKFootRoot = (IKFootData.IKFootRootBoneIndex != FCompactPoseBoneIndex(INDEX_NONE)) && !FMath::IsNearlyZero(IKFootRootOrientationAlpha, KINDA_SMALL_NUMBER);

	// Rotate IK Foot Root
	if (bUpdateIKFootRoot)
	{
		// 根据填入的Alpha应用根脚步IK旋转
		const FQuat BoneRotation = FQuat(RotationAxisVector, ActualOrientationAngleRad * IKFootRootOrientationAlpha);

		FTransform IKFootRootTransform(Output.Pose.GetComponentSpaceTransform(IKFootData.IKFootRootBoneIndex));
		IKFootRootTransform.SetRotation(BoneRotation * IKFootRootTransform.GetRotation());
		IKFootRootTransform.NormalizeRotation();
		Output.Pose.SetComponentSpaceTransform(IKFootData.IKFootRootBoneIndex, IKFootRootTransform);

		// IK Feet 
		// These match the root orientation, so don't rotate them. Just preserve root rotation. 
		// We need to update their translation though, since we rotated their parent (the IK Foot Root bone).
		const int32 NumIKFootBones = IKFootData.IKFootBoneIndexArray.Num();
		const bool bUpdateIKFootBones = bUpdateIKFootRoot && (NumIKFootBones > 0);

		// 对脚步IK骨应用反向旋转,保证相对地面稳定
		if (bUpdateIKFootBones)
		{
			const FQuat IKFootRotation = FQuat(RotationAxisVector, -ActualOrientationAngleRad * IKFootRootOrientationAlpha);

			for (int32 ArrayIndex = 0; ArrayIndex < NumIKFootBones; ArrayIndex++)
			{
				const FCompactPoseBoneIndex& IKFootBoneIndex = IKFootData.IKFootBoneIndexArray[ArrayIndex];

				FTransform IKFootBoneTransform(Output.Pose.GetComponentSpaceTransform(IKFootBoneIndex));
				IKFootBoneTransform.SetRotation(IKFootRotation * IKFootBoneTransform.GetRotation());
				IKFootBoneTransform.NormalizeRotation();
				Output.Pose.SetComponentSpaceTransform(IKFootBoneIndex, IKFootBoneTransform);
			}
		}
	}

	// 按照骨骼树进行排序输出骨骼
	OutBoneTransforms.Sort(FCompareBoneTransformIndex());
	bIsFirstUpdate = false;
}

总结朝向扭曲的过程为:

  1. 通过计算获取需要朝向的角度(代码开始那一大坨,包括预测和插值)
  2. 对根节点进行旋转同时对脊椎骨进行反向旋转
  3. 对FootRoot进行旋转同时对脚步IK骨进行反向旋转
  4. 对设置好的骨骼进行排序

展开全文 >>

距离匹配

距离匹配

在使用距离匹配时需要先在插件中开启AnimationLocomotionLibrary和AnimationWarping这两个插件

基本概念

游戏中动画驱动有两种方式，分别为位移驱动和动画驱动。位移驱动中玩家控制角色胶囊体的运动，动画自己播放，这种方式会导致角色动画的步幅与移动速度不匹配；动画驱动是由动画的根运动来驱动角色位移，这种方式可以很好的解决角色运动中的滑步现象。

基本原理

假如我们有一个起步动画，我们将角色的位移提取为距离曲线，同时每一帧获取曲线上的值，这个值就是角色的位移距离（距离起点的距离），将该值应用到角色的位移中就可以实现步幅匹配。

提取距离曲线

DistanceCurve

提取距离曲线主要使用DistanceCurveModifier类，这个类主要包含的内容如下：

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
enum class EDistanceCurve_Axis : uint8
{
    X,
    Y,
    Z,
    XY,
    XZ,
    YZ,
    XYZ,
};

class UDistanceCurveModifier : public UAnimModifier
{
public:
    int32 SampleRate = 30;

    FName CurveName = "Distance";

    float StopSpeedThreshold = 5.0f;

    EDistanceCurve_Axis Axis = EDistanceCurve_Axis::XY;

    bool bStopAtEnd = false;

    virtual void OnApply_Implementation(UAnimSequence* Animation) override;
}

我们来逐个解析各个参数的含义：

  • SampleRate：采样频率，即每秒采样多少次，默认为30次，采样频率越高，曲线值与实际位置的误差越小
  • CurveName：采样的曲线名称，默认为Distance，供外部获取曲线值
  • StopSpeedThreshold：速度阈值，用于计算动画序列的最小速度
  • Axis：采样轴，即采样哪几个轴的位移，默认为XY，即采样X和Y轴的位移（水平位移）
  • bStopAtEnd：是否选择在动画结束的时间作为速度的最低时间
  • OnApply_Implementation：实际进行采样的函数，实现具体的采样逻辑

实现代码如下：

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
void UDistanceCurveModifier::OnApply_Implementation(UAnimSequence* Animation)
{
    // 1
	if (Animation == nullptr)
	{
		UE_LOG(LogAnimation, Error, TEXT("DistanceCurveModifier failed. Reason: Invalid Animation"));
		return;
	}

	if (!Animation->HasRootMotion())
	{
		UE_LOG(LogAnimation, Error, TEXT("DistanceCurveModifier failed. Reason: Root motion is disabled on the animation (%s)"), *GetNameSafe(Animation));
		return;
	}

    // 2
	const bool bMetaDataCurve = false;
	UAnimationBlueprintLibrary::AddCurve(Animation, CurveName, ERawCurveTrackTypes::RCT_Float, bMetaDataCurve);

    // 3
	const float AnimLength = Animation->GetPlayLength();
	float SampleInterval;
	int32 NumSteps;
	float TimeOfMinSpeed;

	if(bStopAtEnd)
	{ 
		TimeOfMinSpeed = AnimLength;
	}
	else
	{
		// Perform a high resolution search to find the sample point with minimum speed.
		
		TimeOfMinSpeed = 0.f;
		float MinSpeedSq = FMath::Square(StopSpeedThreshold);

		SampleInterval = 1.f / 120.f;
		NumSteps = AnimLength / SampleInterval;
		for (int32 Step = 0; Step < NumSteps; ++Step)
		{
			const float Time = Step * SampleInterval;

			const bool bAllowLooping = false;
			const FVector RootMotionTranslation = Animation->ExtractRootMotion(Time, SampleInterval, bAllowLooping).GetTranslation();
			const float RootMotionSpeedSq = CalculateMagnitudeSq(RootMotionTranslation, Axis) / SampleInterval;

			if (RootMotionSpeedSq < MinSpeedSq)
			{
				MinSpeedSq = RootMotionSpeedSq;
				TimeOfMinSpeed = Time;
			}
		}
	}

    // 4
	SampleInterval = 1.f / SampleRate;
	NumSteps = FMath::CeilToInt(AnimLength / SampleInterval);
	float Time = 0.0f;
	for (int32 Step = 0; Step <= NumSteps && Time < AnimLength; ++Step)
	{
		Time = FMath::Min(Step * SampleInterval, AnimLength);

		// Assume that during any time before the stop/pivot point, the animation is approaching that point.
		// TODO: This works for clips that are broken into starts/stops/pivots, but needs to be rethought for more complex clips.
		const float ValueSign = (Time < TimeOfMinSpeed) ? -1.0f : 1.0f;

		const FVector RootMotionTranslation = Animation->ExtractRootMotionFromRange(TimeOfMinSpeed, Time).GetTranslation();
		UAnimationBlueprintLibrary::AddFloatCurveKey(Animation, CurveName, Time, ValueSign * CalculateMagnitude(RootMotionTranslation, Axis));
	}
}

对源码进行分析：

  • 这一步判断动画是否合法以及是否开启骨骼根运动
  • 添加一条非元数据曲线，并声明需要使用的变量
  • 寻找最低速度：
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
// 判断是否直接使用动画结束时间作为最小速度
if(bStopAtEnd)
{ 
    TimeOfMinSpeed = AnimLength;
}
else
{
    TimeOfMinSpeed = 0.f;
    // 从阈值中获取最小速度，只有比阈值速度还小才会更新
    float MinSpeedSq = FMath::Square(StopSpeedThreshold);

    // 默认采样间隔以及采样次数
    SampleInterval = 1.f / 120.f;
    NumSteps = AnimLength / SampleInterval;
    // 实际计算最小速度
    for (int32 Step = 0; Step < NumSteps; ++Step)
    {
        // 计算每步的步进时长
        const float Time = Step * SampleInterval;

        const bool bAllowLooping = false;
        // 提取两次采样之间的根运动距离
        const FVector RootMotionTranslation = Animation->ExtractRootMotion(Time, SampleInterval, bAllowLooping).GetTranslation();
        // 根据距离和步进时长计算前进速度
        const float RootMotionSpeedSq = CalculateMagnitudeSq(RootMotionTranslation, Axis) / SampleInterval;
        // 更新最小速度以及最小速度的时间
        if (RootMotionSpeedSq < MinSpeedSq)
        {
            MinSpeedSq = RootMotionSpeedSq;
            TimeOfMinSpeed = Time;
        }
    }
}
  • 实际生成采样曲线
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // 计算采样间隔，由暴露给蓝图的值决定
    SampleInterval = 1.f / SampleRate;
    // 计算采样次数
    NumSteps = FMath::CeilToInt(AnimLength / SampleInterval);
    float Time = 0.0f;
    // 遍历采样
    for (int32 Step = 0; Step <= NumSteps && Time < AnimLength; ++Step)
    {
        // 防止采样超出动画时长
        Time = FMath::Min(Step * SampleInterval, AnimLength);
        // 用来判断是起步还是停步
        // 如果是起步动画，速度从0开始递增，速度最小值一定为正数且是开始的时候，所以TimeOfMinSpeed一定比Time小，得到的为1.0f
        // 如果是停步动画，速度逐渐递减到0，速度最小值一定为负数且在动画最后达到最小，则TimeOfMinSpeed的时间一定比Time大，得到的为-1.0f
        const float ValueSign = (Time < TimeOfMinSpeed) ? -1.0f : 1.0f;

        // 提取从TimeOfMinSpeed到Time之间的根运动距离
        const FVector RootMotionTranslation = Animation->ExtractRootMotionFromRange(TimeOfMinSpeed, Time).GetTranslation();
        // 将值添加到曲线中
        UAnimationBlueprintLibrary::AddFloatCurveKey(Animation, CurveName, Time, ValueSign * CalculateMagnitude(RootMotionTranslation, Axis));
    }

通过提取的距离曲线，我们可以实现起步与停步的步幅匹配

起步匹配

StartMatch

起步动画主要依靠AdvanceTimeByDistanceMatching，通过序列求值器选择每一帧的动画进行播放

函数声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
	 * Advance the sequence evaluator forward by distance traveled rather than time. A distance curve is required on the animation that
	 * describes the distance traveled by the root bone in the animation. See UDistanceCurveModifier.
	 * @param UpdateContext - The update context provided in the anim node function.
	 * @param SequenceEvaluator - The sequence evaluator node to operate on.
	 * @param DistanceTraveled - The distance traveled by the character since the last animation update.
	 * @param DistanceCurveName - Name of the curve we want to match 
	 * @param PlayRateClamp - A clamp on the effective play rate of the animation after distance matching. Set to (0,0) for no clamping.
	 */
	UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
	static FSequenceEvaluatorReference AdvanceTimeByDistanceMatching(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator,
		float DistanceTraveled, FName DistanceCurveName, FVector2D PlayRateClamp = FVector2D(0.75f, 1.25f));

函数解释：根据动画前进的距离来设置动画的前进而非使用时间，这需要一个用于描述动画根骨骼位置的距离曲线，这个曲线我们可以从UDistanceCurveModifier中的来获取，这个在之前已经解释。

主要的三个参数为：
SequenceEvaluator：当前动画的序列求值器
DistanceTraveled：本帧移动的距离
DistanceCurveName：距离曲线

函数实现

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
FSequenceEvaluatorReference UAnimDistanceMatchingLibrary::AdvanceTimeByDistanceMatching(const FAnimUpdateContext& UpdateContext, const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceTraveled, FName DistanceCurveName, FVector2D PlayRateClamp)
{
	// 1 进入时绑定了一个lambda函数作为参数一并传入CallAnimNodeFunction中被调用
	SequenceEvaluator.CallAnimNodeFunction<FAnimNode_SequenceEvaluator>(
		TEXT("AdvanceTimeByDistanceMatching"),
		[&UpdateContext, DistanceTraveled, DistanceCurveName, PlayRateClamp](FAnimNode_SequenceEvaluator& InSequenceEvaluator)
		{
			// 2.1 获取动画上下文
			if (const FAnimationUpdateContext* AnimationUpdateContext = UpdateContext.GetContext())
			{
				// 2.2 获取一个tick的时长
				const float DeltaTime = AnimationUpdateContext->GetDeltaTime(); 

				// 2.3 当tick时长与步进距离均大于0时继续执行下一步逻辑
				if (DeltaTime > 0 && DistanceTraveled > 0)
				{
					// 3.1 获取正在播放的动画并从动画中获取数据
					if (const UAnimSequenceBase* AnimSequence = Cast<UAnimSequence>(InSequenceEvaluator.GetSequence()))
					{
						// 3.2 获取当前时间，动画时长，是否循环播放
						const float CurrentTime = InSequenceEvaluator.GetExplicitTime();
						const float CurrentAssetLength = InSequenceEvaluator.GetCurrentAssetLength();
						const bool bAllowLooping = InSequenceEvaluator.IsLooping();

						// 4.1 获取在步进DistanceTraveled之后的动画时间
						// 这个函数的注释为：Advance from the current time to a new time in the animation that will result in the desired distance traveled by the authored root motion.
						// 从当前时间开始，根据根运动所经过的距离计算应到达的新的时间
						float TimeAfterDistanceTraveled = UE::Anim::DistanceMatchingUtility::GetTimeAfterDistanceTraveled(AnimSequence, CurrentTime, DistanceTraveled, DistanceCurveName, bAllowLooping);

						// 4.2 计算播放速率
						if (TimeAfterDistanceTraveled < CurrentTime)
						{
							TimeAfterDistanceTraveled += CurrentAssetLength;
						}
						float EffectivePlayRate = (TimeAfterDistanceTraveled - CurrentTime) / DeltaTime;

						// 4.3 限制播放速率
						if (PlayRateClamp.X >= 0.0f && PlayRateClamp.X < PlayRateClamp.Y)
						{
							EffectivePlayRate = FMath::Clamp(EffectivePlayRate, PlayRateClamp.X, PlayRateClamp.Y);
						}

						// 5.1 计算步进之后的动画时间
						float NewTime = CurrentTime;
						FAnimationRuntime::AdvanceTime(bAllowLooping, EffectivePlayRate * DeltaTime, NewTime, CurrentAssetLength);

						// 5.2 设置新的动画时间
						if (!InSequenceEvaluator.SetExplicitTime(NewTime))
						{
							UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set explicit time on sequence evaluator, value is not dynamic. Set it as Always Dynamic."));
						}
					}
					else
					{
						UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence evaluator does not have an anim sequence to play."));
					}
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("AdvanceTimeByDistanceMatching called with invalid context"));
			}
		});

	return SequenceEvaluator;
}

停步匹配

StopMatch

当角色停止运动时（玩家不再有运动方向的输入），此时角色会逐渐减速，这时需要计算角色的运动距离，然后将这个距离与动画进行匹配

GetPredictedStopDistance：这个函数已经提供了用于预测角色停止运动后的前进距离，在C++中为PredictGroundMovementStopLocation
DistanceMatchToTarget：这个函数用于将预测的距离与动画进行匹配

GetPredictedStopDistance

定义

1
2
3
4
5
6
7
8
9
10
/**
* Predict where the character will stop based on its current movement properties and parameters from the movement component.
* This uses prediction logic that is heavily tied to the UCharacterMovementComponent.
* Each parameter corresponds to a value from the UCharacterMovementComponent with the same name.
* Because this is a thread safe function, it's	recommended to populate these fields via the Property Access system.
* @return The predicted stop position in local space to the character. The size of this vector will be the distance to the stop location.
*/
UFUNCTION(BlueprintPure, Category = "Animation Character Movement", meta = (BlueprintThreadSafe))
static FVector PredictGroundMovementStopLocation(const FVector& Velocity,
	bool bUseSeparateBrakingFriction, float BrakingFriction, float GroundFriction, float BrakingFrictionFactor, float BrakingDecelerationWalking);

可以看到注释内容为：通过角色移动组件中的属性来预测当角色停止运动时角色移动的位置

  • Velocity：角色的速度
  • bUseSeparateBrakingFriction：是否使用单独的制动摩擦力
  • BrakingFriction：制动摩擦力
  • GroundFriction：地面摩擦力
  • BrakingFrictionFactor：制动摩擦力因数
  • BrakingDecelerationWalking：制动减速度

实现

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
FVector UAnimCharacterMovementLibrary::PredictGroundMovementStopLocation(const FVector& Velocity, 
	bool bUseSeparateBrakingFriction, float BrakingFriction, float GroundFriction, float BrakingFrictionFactor, float BrakingDecelerationWalking)
{
	// 预测的停止位置
	FVector PredictedStopLocation = FVector::ZeroVector;

	// 选择实际摩檫力
	float ActualBrakingFriction = (bUseSeparateBrakingFriction ? BrakingFriction : GroundFriction);
	// 计算摩檫力
	const float FrictionFactor = FMath::Max(0.f, BrakingFrictionFactor);
	ActualBrakingFriction = FMath::Max(0.f, ActualBrakingFriction * FrictionFactor);
	float BrakingDeceleration = FMath::Max(0.f, BrakingDecelerationWalking);

	// 计算角色的地面速度
	const FVector Velocity2D = Velocity * FVector(1.f, 1.f, 0.f);
	FVector VelocityDir2D;
	float Speed2D;
	Velocity2D.ToDirectionAndLength(VelocityDir2D, Speed2D);

	// 高中数学：x = v * t + 0.5 * a * t^2
	// 这里先计算加速度
	const float Divisor = ActualBrakingFriction * Speed2D + BrakingDeceleration;
	if (Divisor > 0.f)
	{
		// 根据v = a * t计算停止时间
		const float TimeToStop = Speed2D / Divisor;
		// 将时间带入公式计算位置
		PredictedStopLocation = Velocity2D * TimeToStop + 0.5f * ((-ActualBrakingFriction) * Velocity2D - BrakingDeceleration * VelocityDir2D) * TimeToStop * TimeToStop;
	}

	// 将计算结果返回
	return PredictedStopLocation;
}

DistanceMatchToTarget

定义：

1
2
3
4
5
6
7
8
9
10
11
/**
* Set the time of the sequence evaluator to the point in the animation where the distance curve matches the DistanceToTarget input.
* A common use case is to achieve stops without foot sliding by, each frame, selecting the point in the animation that matches the distance the character has remaining until it stops.
* Note that because this technique sets the time of the animation by distance remaining, it doesn't respect phase of any previous animation (e.g. from a jog cycle).
* @param SequenceEvaluator - The sequence evaluator node to operate on.
* @param DistanceToTarget - The distance remaining to a target (e.g. a stop or pivot point).
* @param DistanceCurveName - Name of the curve we want to match 
*/
UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
static FSequenceEvaluatorReference DistanceMatchToTarget(const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceToTarget, FName DistanceCurveName);

注释为：通过距离来设置序列求值器的播放时间，通过每帧选择动画中与角色剩余距离匹配的点来实现

  • SequenceEvaluator：序列求值器
  • DistanceToTarget：目标距离，即预测的行进距离
  • DistanceCurveName：距离曲线

实现：

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
FSequenceEvaluatorReference UAnimDistanceMatchingLibrary::DistanceMatchToTarget(const FSequenceEvaluatorReference& SequenceEvaluator,
	float DistanceToTarget, FName DistanceCurveName)
{
	// 同样将一个lambda函数作为参数传递给CallAnimNodeFunction函数
	SequenceEvaluator.CallAnimNodeFunction<FAnimNode_SequenceEvaluator>(
		TEXT("DistanceMatchToTarget"),
		[DistanceToTarget, DistanceCurveName](FAnimNode_SequenceEvaluator& InSequenceEvaluator)
		{
			// 获取当前的动画序列
			if (const UAnimSequenceBase* AnimSequence = Cast<UAnimSequence>(InSequenceEvaluator.GetSequence()))
			{
				// 根据距离获取动画播放到的位置(播放时间)并将这个位置设置给当前播放的动画
				const float NewTime = UE::Anim::DistanceMatchingUtility::GetAnimPositionFromDistance(AnimSequence, -DistanceToTarget, DistanceCurveName);
				if (!InSequenceEvaluator.SetExplicitTime(NewTime))
				{
					UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set explicit time on sequence evaluator, value is not dynamic. Set it as Always Dynamic."));
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence evaluator does not have an anim sequence to play."));
			}
			
		});

	return SequenceEvaluator;
}

// 根据位置和距离曲线查找这个动画的时间节点
float GetAnimPositionFromDistance(const UAnimSequenceBase* InAnimSequence, const float& InDistance, FName InCurveName)
{	
	// 获取曲线数据
	FAnimCurveBufferAccess BufferCurveAccess(InAnimSequence, InCurveName);
	if (BufferCurveAccess.IsValid())
	{
		// 获取曲线的key，即在UDistanceCurveModifier中添加的位置
		const int32 NumKeys = BufferCurveAccess.GetNumSamples();
		if (NumKeys < 2)
		{
			return 0.f;
		}

		int32 First = 1;
		int32 Last = NumKeys - 1;
		int32 Count = Last - First;

		// 通过二分法查找符合的距离位置
		while (Count > 0)
		{
			int32 Step = Count / 2;
			int32 Middle = First + Step;

			if (InDistance > BufferCurveAccess.GetValue(Middle))
			{
				First = Middle + 1;
				Count -= Step + 1;
			}
			else
			{
				Count = Step;
			}
		}

		// 将位置转为时间并进行差值获取符合的时间节点
		const float KeyAValue = BufferCurveAccess.GetValue(First - 1);
		const float KeyBValue = BufferCurveAccess.GetValue(First);
		const float Diff = KeyBValue - KeyAValue;
		const float Alpha = !FMath::IsNearlyZero(Diff) ? ((InDistance - KeyAValue) / Diff) : 0.f;

		const float KeyATime = BufferCurveAccess.GetTime(First - 1);
		const float KeyBTime = BufferCurveAccess.GetTime(First);
		return FMath::Lerp(KeyATime, KeyBTime, Alpha);
	}

	return 0.f;
}

流程图

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
flowchart TD
    A[开始距离匹配] --> B{匹配场景选择}
    
    B --> C[起步匹配]
    B --> D[停步匹配]
    
    %% 起步匹配分支
    subgraph C [起步匹配流程]
        direction LR
        C1[起步动画] --> C2[提取根运动距离曲线]
        C2 --> C3[采样生成Distance曲线<br/>采样率:30Hz]
        C3 --> C4[根据本帧移动距离<br/>查找对应动画时间]
        C4 --> C5[设置动画播放时间<br/>播放速率限制:0.75-1.25]
        C5 --> C6[起步匹配完成]
    end
    
    %% 停步匹配分支
    subgraph D [停步匹配流程]
        direction LR
        D1[停步动画] --> D2[预测停止位置<br/>基于速度/摩擦力/减速度]
        D2 --> D3[计算剩余距离]
        D3 --> D4[反向查找距离曲线<br/>对应时间点]
        D4 --> D5[设置停步动画时间]
        D5 --> D6[停步匹配完成]
    end
    
    C6 --> E[应用匹配动画]
    D6 --> E
    
    E --> F[消除滑步]

注意事项

  • 使用UE版本为5.5.4
  • 确保动画已开启根运动
  • 距离曲线名称需与代码中一致
  • 采样率过高可能导致性能问题

展开全文 >>

步幅匹配

步幅匹配

主要用于角色的循环移动动画，当角色完成起步后回进入循环移动动画，但角色的移动速度与动画的速度不匹配时依然会出现滑步的情况，所以我们通常会拿到角色的移动速度与动画的移动速度做比值来调整动画的播放速度从而使动画的移动与角色的速度相匹配。

除了动态调整循环动画的播放速度外，还需要调整角色的脚步步幅，一般来讲，当人的奔跑速度增加时，出了步频会增加外，步幅同样也会增加，所以为了防止角色的高速或低速情况下出现脚步鬼畜的情况，还需要对角色进行footik来调整步幅。

综上步幅匹配主要包括两部分：速度匹配和脚步ik

速度匹配

SpeedMatch

主要通过SetPlayrateToMatchSpeed来实现

1
2
3
4
5
6
7
8
9
10
11
12
/**
* Set the play rate of the sequence player so that the speed of the animation matches in-game movement speed.
* While distance matching is commonly used for transition animations, cycle animations (walk, jog, etc) typically just adjust their play rate to match
* the in-game movement speed.
* This function assumes that the animation has a constant speed.
* @param SequencePlayer - The sequence player node to operate on.
* @param SpeedToMatch - The in-game movement speed to match. This is usually the current speed of the movement component.
* @param PlayRateClamp - A clamp on how much the animation's play rate can change to match the in-game movement speed. Set to (0,0) for no clamping.
*/
UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
static FSequencePlayerReference SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, 
    float SpeedToMatch, FVector2D PlayRateClamp = FVector2D(0.75f, 1.25f));

注释为：根据角色在游戏中的移动速度来设置动画的播放速度

  • SequencePlayer：序列播放器，包含需要播放的动画序列
  • SpeedToMatch：需要匹配的移动速度，通常为角色的地面移动速度
  • PlayRateClamp：播放速度的上下限，默认为0.75到1.25
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
FSequencePlayerReference UAnimDistanceMatchingLibrary::SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, float SpeedToMatch, FVector2D PlayRateClamp)
{
    // 绑定了一个lambda函数作为参数一并传入CallAnimNodeFunction中被调用
	SequencePlayer.CallAnimNodeFunction<FAnimNode_SequencePlayer>(
		TEXT("SetPlayrateToMatchSpeed"),
		[SpeedToMatch, PlayRateClamp](FAnimNode_SequencePlayer& InSequencePlayer)
		{
            // 获取当前播放的动画序列
			if (const UAnimSequence* AnimSequence = Cast<UAnimSequence>(InSequencePlayer.GetSequence()))
			{
                // 获取序列的长度，如果长度大于0则进行调整
				const float AnimLength = AnimSequence->GetPlayLength();
				if (!FMath::IsNearlyZero(AnimLength))
				{
					// Calculate the speed as: (distance traveled by the animation) / (length of the animation)
                    // 获取动画从开始到结束的根运动距离并计算平面的移动距离
					const FVector RootMotionTranslation = AnimSequence->ExtractRootMotionFromRange(0.0f, AnimLength).GetTranslation();
					const float RootMotionDistance = RootMotionTranslation.Size2D();
                    // 当角色的移动距离大于0时则进行调整
					if (!FMath::IsNearlyZero(RootMotionDistance))
					{
                        // 获取动画速度
						const float AnimationSpeed = RootMotionDistance / AnimLength;
                        // 获取速度当前的移动速度与动画的速度的比值
						float DesiredPlayRate = SpeedToMatch / AnimationSpeed;
						if (PlayRateClamp.X >= 0.0f && PlayRateClamp.X < PlayRateClamp.Y)
						{
							DesiredPlayRate = FMath::Clamp(DesiredPlayRate, PlayRateClamp.X, PlayRateClamp.Y);
						}

						// 根据比值来动态调整动画的播放速度
						if (!InSequencePlayer.SetPlayRate(DesiredPlayRate))
						{
							UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set play rate on sequence player, value is not dynamic. Set it as Always Dynamic."));
						}
					}
					else
					{
						UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for animation with no root motion delta (%s)."), *GetNameSafe(AnimSequence));
					}
				}
				else
				{
					UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for zero length animation (%s)."), *GetNameSafe(AnimSequence));
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence player does not have an anim sequence to play."));
			}
		});

	return SequencePlayer;
}

脚步IK

主要是通过跨步扭曲(StrideWarping)来实现。

StrideWarping

在细节面板中展示了需要调整的选项，主要为添加需要进行匹配的脚步骨骼，StrideWarping节点本身需要传入开始混入的alpha值(skeleton control的强度)以及角色地面的移动速度（MatchSpeed）。

该节点定义在UAnimGraphNode_StrideWarping中，其中最主要的内容为声明的一个FAnimNode_StrideWarping类型的成员变量Node，在这个Node中定义了大多在细节面板中使用到的属性，同时还包括一些节点使用的初始化和更新方法。

初始化

其中初始化方法为:Initialize_AnyThread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void FAnimNode_StrideWarping::Initialize_AnyThread(const FAnimationInitializeContext& Context)
{
	FAnimNode_SkeletalControlBase::Initialize_AnyThread(Context);
	
    // 初始化代理
	AnimInstanceProxy = Context.AnimInstanceProxy;
	// 用于夹值和插值
    StrideScaleModifierState.Reinitialize();
	// 初始化朝向
    ActualStrideDirection = FVector::ForwardVector;
	// 初始化步幅
    ActualStrideScale = 1.f;
#if WITH_EDITORONLY_DATA
    // 调试模式下使用，获取根骨骼的位移和速度
	CachedRootMotionDeltaTranslation = FVector::ZeroVector;
	CachedRootMotionDeltaSpeed = 0.f;
#endif
}

其中还有另一个初始化方法:InitializeBoneReferences，这个方法用于初始化我们在节点中写入的骨骼引用

更新

其中更新的方法为:EvaluateSkeletalControl_AnyThread，这是更新的主要方法，也是进行跨步扭曲的核心方法，接下来将对这个方法进行解析。

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
void FAnimNode_StrideWarping::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
{
	SCOPE_CYCLE_COUNTER(STAT_StrideWarping_Eval);
	check(OutBoneTransforms.IsEmpty());

	// 获取当前帧的跨步朝向以及上一帧的朝向
	const FVector PreviousStrideDirection = ActualStrideDirection;
	ActualStrideDirection = StrideDirection;
	// 跨步缩放值->步幅的大小
	ActualStrideScale = StrideScale;

	// 是否使用图表模式
	bool bGraphDrivenWarping = false;
	// 获取根运动提取器,如果改提取器是有效的则使用图表模式
	const UE::Anim::IAnimRootMotionProvider* RootMotionProvider = UE::Anim::IAnimRootMotionProvider::Get();

	// 判断是否为图表模式,在节点的细节面板中可以选择
	if (Mode == EWarpingEvaluationMode::Graph)
	{
		bGraphDrivenWarping = !!RootMotionProvider;
		ensureMsgf(bGraphDrivenWarping, TEXT("Graph driven Stride Warping expected a valid root motion delta provider interface."));
	}

	// 初始化运动距离
	FTransform RootMotionTransformDelta = FTransform::Identity;
#if WITH_EDITORONLY_DATA
	// 编辑器下的调试设置
	bFoundRootMotionAttribute = false;
#else
	FVector CachedRootMotionDeltaTranslation = FVector::ZeroVector;
#endif
	if (bGraphDrivenWarping)
	{
		// 如果根运动是有效的话则提取根运动
		// Output的含义:在AnimInstance更新时会从Root开始递归更新骨骼的pose,这个output就是动画节点左边的连线所计算的pose
		// Graph driven stride warping will override the manual stride direction with the intent of the current animation sub-graph's accumulated root motion
		bGraphDrivenWarping = RootMotionProvider->ExtractRootMotion(Output.CustomAttributes, RootMotionTransformDelta);
		if (bGraphDrivenWarping)
		{
			// 缓存根运动的位移数据
			CachedRootMotionDeltaTranslation = RootMotionTransformDelta.GetTranslation();
			// If there's no root motion delta, keep the previous stride direction
			// 根据两帧之间的位移差值拿到运动的朝向
			ActualStrideDirection = CachedRootMotionDeltaTranslation.GetSafeNormal(UE_SMALL_NUMBER, PreviousStrideDirection);
#if WITH_EDITORONLY_DATA
			// Graph driven Stride Warping expects a root motion delta to be present in the attribute stream.
			// 编辑器下的调试设置
			bFoundRootMotionAttribute = true;
#endif
		}
		// Early exit on missing root motion delta attribute
		// 否则说明在图表模式下没有开启根运动,提前返回
		else if (bDisableIfMissingRootMotion)
		{
			return;
		}
	}

	// 拿到output中的骨骼数据
	const FBoneContainer& RequiredBones = Output.Pose.GetPose().GetBoneContainer();
	// 从output的骨骼数据中拿到脚步ik骨骼的空间网格体数据
	const FTransform IKFootRootTransform = Output.Pose.GetComponentSpaceTransform(IKFootRootBone.GetCompactPoseIndex(RequiredBones));
	// 获取地面的法线向量,一般为(0, 0, 1)
	const FVector ResolvedFloorNormal = FloorNormalDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);
	// 获取重力方向,一般默认向下(0 ,0, -1)
	const FVector ResolvedGravityDirection = GravityDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);

	// 是否使用地面方向来旋转跨步朝向
	// 根据下面的计算可以得到:
	// 首先将实际跨步方向和地面法线方向进行叉乘,可以得到横向的轴向向量
	// 再将轴向向量和地面法向向量进行叉乘得到实际方向
	// 主要用来处理一些上下坡等非水平面的运动方向
	if (bOrientStrideDirectionUsingFloorNormal)
	{
		const FVector StrideWarpingAxis = ResolvedFloorNormal ^ ActualStrideDirection;
		ActualStrideDirection = StrideWarpingAxis ^ ResolvedFloorNormal;
	}

#if ENABLE_ANIM_DEBUG
	bool bDebugging = false;
#if WITH_EDITORONLY_DATA
	bDebugging = bDebugging || bEnableDebugDraw;
#else
	constexpr float DebugDrawScale = 1.f;
#endif
	bDebugging = bDebugging || CVarAnimNodeStrideWarpingDebug.GetValueOnAnyThread() == 1;
	if (bDebugging)
	{
		// 绘制骨骼信息用于调试
		// Draw Floor Normal
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation()),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation() + ResolvedFloorNormal * 25.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Blue, false, 0.f, 2.f * DebugDrawScale);
	}
#endif

	// Get all foot IK Transforms
	// FootData在InitializeBoneReferences中初始化,数据来源与output一致,从节点左边输出的骨骼数据中获取
	for (auto& Foot : FootData)
	{
		Foot.IKFootBoneTransform = Output.Pose.GetComponentSpaceTransform(Foot.IKFootBoneIndex);
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootOrigin
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Red);
		}
#endif
	}

	// 如果开启根运动则对实际步幅进行调整
	if (bGraphDrivenWarping)
	{
		// CachedRootMotionDeltaSpeed,存储根运动的速度
#if WITH_EDITORONLY_DATA
		CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#else
		const float CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#endif

		// 如果速度小于根运动的最小移动速度则不调整步幅
		// 否则根据实际速度对步幅进行等比缩放
		if (CachedRootMotionDeltaSpeed <= MinRootMotionSpeedThreshold)
		{
			// If root motion speed is under the threshold, snap back to no stride adjustment.
			// If interpolation is on, it will blend the result
			ActualStrideScale = 1.0f;
		}
		else
		{
			// Graph driven stride scale factor will be determined by the ratio of the
			// locomotion (capsule/physics) speed against the animation root motion speed
			ActualStrideScale = LocomotionSpeed / CachedRootMotionDeltaSpeed;
		}
	}

	// Allow the opportunity for stride scale clamping and interpolation regardless of evaluation mode
	// 翻译无论采用哪种模式(EWarpingEvaluationMode中的定义),都对步幅进行夹值和插值(可能是用于平滑过渡)
	ActualStrideScale = StrideScaleModifierState.ApplyTo(StrideScaleModifier, ActualStrideScale, CachedDeltaTime);

	// 如果开启了根运动则根据实际的步幅大小对运动位移进行缩放
	// 同时尝试对输入的骨骼数据使用缩放后的位移数据进行覆盖
	if (bGraphDrivenWarping)
	{
		// Forward the side effects of stride warping on the root motion contribution for this sub-graph
		RootMotionTransformDelta.ScaleTranslation(ActualStrideScale);
		const bool bRootMotionOverridden = RootMotionProvider->OverrideRootMotion(RootMotionTransformDelta, Output.CustomAttributes);
		ensureMsgf(bRootMotionOverridden, TEXT("Graph driven Stride Warping expected a root motion delta to be present in the attribute stream prior to warping/overriding it."));
	}

	// 处理脚步ik
	// Scale IK feet bones along Stride Warping Axis, from the Thigh bone location.
	// 翻译:从大腿骨开始沿着跨步扭曲的轴向对脚步ik数据进行缩放
	for (auto& Foot : FootData)
	{
		// Stride Warping along Stride Warping Axis
		// 获取脚步ik骨骼的位置以及大腿骨的位置
		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		const FVector ThighBoneLocation = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex).GetLocation();

		// Project Thigh Bone Location on plane made of FootIKLocation and FloorPlaneNormal, along Gravity Dir.
		// 翻译:沿着重力方向将大腿骨的位置投影在由脚步ik骨的位置和地面法线所组成的平面上
		// LinePlaneIntersection:线平面交点
		// This will be the StrideWarpingPlaneOrigin
		// 首先判断重力和地面法线是否平行,如果平行,则直接使用脚步ik骨骼的位置
		// 否则进行投影:以脚步ik骨的位置作为平面的原点,以地面的法线作为平面的法线得到一个片面,将大腿骨的位置沿着重力的方向投影在这个平面上
		// 实际得到的就是大腿骨在脚步ik骨位置的运动平面上的投影位置
		const FVector StrideWarpingPlaneOrigin = (FMath::Abs(ResolvedGravityDirection | ResolvedFloorNormal) > DELTA) ? FMath::LinePlaneIntersection(ThighBoneLocation, ThighBoneLocation + ResolvedGravityDirection, IKFootLocation, ResolvedFloorNormal) : IKFootLocation;

		// Project FK Foot along StrideWarping Plane, this will be our Scale Origin
		// 翻译:将脚步ik骨的位置投影在跨步平面上(运动平面)
		// 以上一步得到的投影位置作为平面的原点,实际的运动方向作为该平面的法线构造平面
		// 计算脚步ik骨在这个平面上的投影
		const FVector ScaleOrigin = FVector::PointPlaneProject(IKFootLocation, StrideWarpingPlaneOrigin, ActualStrideDirection);

		// 由IKFootLocation和ScaleOrigin可以计算出脚步ik骨的运动方向,再乘以实际的步幅加上投影位置就是新的脚步骨骼应该在的位置
		// Now the ScaleOrigin and IKFootLocation are forming a line parallel to the floor, and we can scale the IK foot.
		const FVector WarpedLocation = ScaleOrigin + (IKFootLocation - ScaleOrigin) * ActualStrideScale;
		Foot.IKFootBoneTransform.SetLocation(WarpedLocation);

#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootAdjustment
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Green);

			const FVector ScaleOriginWorldLoc = AnimInstanceProxy->GetComponentTransform().TransformPosition(ScaleOrigin);
			AnimInstanceProxy->AnimDrawDebugSphere(ScaleOriginWorldLoc, 8.f * DebugDrawScale, 16, FColor::Yellow);
		}
#endif
	}

	// 开始计算盆骨偏移,首先进行初始化
	FVector PelvisOffset = FVector::ZeroVector;
	const FCompactPoseBoneIndex PelvisBoneIndex = PelvisBone.GetCompactPoseIndex(RequiredBones);

	// 获取盆骨的位置信息并初始化盆骨的位置
	FTransform PelvisTransform = Output.Pose.GetComponentSpaceTransform(PelvisBoneIndex);
	const FVector InitialPelvisLocation = PelvisTransform.GetLocation();

	// 声明一个容器用于存储所有FK骨骼到盆骨的距离
	TArray<float, TInlineAllocator<10>> FKFootDistancesToPelvis;
	FKFootDistancesToPelvis.Reserve(FootData.Num());

	// 声明一个容器储存所有IK骨骼的位置
	TArray<FVector, TInlineAllocator<10>> IKFootLocations;
	IKFootLocations.Reserve(FootData.Num());

	// 遍历脚步ik骨骼的数据并获取距离和位置信息
	for (auto& Foot : FootData)
	{
		const FVector FKFootLocation = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex).GetLocation();
		FKFootDistancesToPelvis.Add(FVector::Dist(FKFootLocation, InitialPelvisLocation));

		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		IKFootLocations.Add(IKFootLocation);
	}

	// Adjust Pelvis down if needed to keep foot contact with the ground and prevent over-extension
	// 翻译:将盆骨的位置向下进行调整以保证脚步解除地面同时防止过度拉伸
	PelvisTransform = PelvisIKFootSolver.Solve(PelvisTransform, FKFootDistancesToPelvis, IKFootLocations, CachedDeltaTime);

#if ENABLE_ANIM_DEBUG
	if (bDebugging
#if WITH_EDITORONLY_DATA
		&& bDebugDrawPelvisAdjustment
#endif
	)
	{
		// Draw Adjustments in Pelvis location
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation), 8.f * DebugDrawScale, 16, FColor::Red);
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(PelvisTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
	}

	if (bDebugging)
	{
		// Draw Stride Direction
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation + ActualStrideDirection * ActualStrideScale * 100.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Red, false, 0.f, 2.f * DebugDrawScale);

		// Draw text on mesh in world space
		{
			TStringBuilder<1024> DebugLine;

			DebugLine.Appendf(TEXT("\n - Stride Scale: (%.3fd)"), ActualStrideScale);
			DebugLine.Appendf(TEXT("\n - Stride Direction: (%s)"), *(ActualStrideDirection.ToCompactString()));
			
			if (Mode == EWarpingEvaluationMode::Graph)
			{
				DebugLine.Appendf(TEXT("\n - Locomotion Speed: (%.3fd)"), LocomotionSpeed);

#if WITH_EDITORONLY_DATA
				if (bFoundRootMotionAttribute)
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: Direction(%s), Speed(%.3fd)"), *(CachedRootMotionDeltaTranslation.GetSafeNormal().ToCompactString()), CachedRootMotionDeltaSpeed);
				}
				else
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: NO ATTRIBUTE FOUND"), *(ActualStrideDirection.ToCompactString()));
				}
#endif

				DebugLine.Appendf(TEXT("\n - Min Root Motion Speed Threshold: (%.3fd)"), MinRootMotionSpeedThreshold);
			}

			AnimInstanceProxy->AnimDrawDebugInWorldMessage(DebugLine.ToString(), FVector::UpVector * 50.0f, FColor::Yellow, 1.f /*TextScale*/);
		}
	}
#endif
	// Add adjusted pelvis transform
	check(!PelvisTransform.ContainsNaN());
	// 将盆骨偏移后的位置数据添加到输出骨骼中
	OutBoneTransforms.Add(FBoneTransform(PelvisBoneIndex, PelvisTransform));

	// Compute final offset to use below
	// 获取盆骨调整后的差值
	PelvisOffset = (PelvisTransform.GetLocation() - InitialPelvisLocation);

	// Rotate Thigh bones to help IK, and maintain leg shape.
	// 翻译:旋转大腿骨骼以适配脚步ik,同时保证腿部的形状(应该是为了防止位移过大导致变形)
	if (bCompensateIKUsingFKThighRotation)
	{
		for (auto& Foot : FootData)
		{
			// 获取大腿骨位置和脚步位置
			const FTransform ThighTransform = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex);
			const FTransform FKFootTransform = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex);

			// 将盆骨偏移应用的大腿骨的位置中
			FTransform AdjustedThighTransform = ThighTransform;
			AdjustedThighTransform.AddToTranslation(PelvisOffset);

			// 获取当前的脚步-大腿朝向以及目标的脚步-大腿朝向
			const FVector InitialDir = (FKFootTransform.GetLocation() - ThighTransform.GetLocation()).GetSafeNormal();
			const FVector TargetDir = (Foot.IKFootBoneTransform.GetLocation() - AdjustedThighTransform.GetLocation()).GetSafeNormal();
			
#if ENABLE_ANIM_DEBUG
			if (bDebugging
#if WITH_EDITORONLY_DATA
				&& bDebugDrawThighAdjustment
#endif
			)
			{
				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(ThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(FKFootTransform.GetLocation()),
					FColor::Red, false, 0.f, 2.f * DebugDrawScale);

				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(AdjustedThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()),
					FColor::Green, false, 0.f, 2.f * DebugDrawScale);
			}
#endif
			// Find Delta Rotation take takes us from Old to New dir
			// 获取两个方向之间的旋转值
			const FQuat DeltaRotation = FQuat::FindBetweenNormals(InitialDir, TargetDir);

			// Rotate our Joint quaternion by this delta rotation
			// 将旋转值应用值大腿骨
			AdjustedThighTransform.SetRotation(DeltaRotation * AdjustedThighTransform.GetRotation());

			// Add adjusted thigh transform
			check(!AdjustedThighTransform.ContainsNaN());
			// 将调整后的骨骼添加到输出中
			OutBoneTransforms.Add(FBoneTransform(Foot.ThighBoneIndex, AdjustedThighTransform));

			// Clamp IK Feet bone based on FK leg. To prevent over-extension and preserve animated motion.
			// 通过大腿的FK限制脚步IK防止腿部过度拉伸
			// 如果调整后的脚步IK骨与调整后的大腿骨的距离大于FK的距离则使用FK的距离重新调整这个脚步IK的位置
			if (bClampIKUsingFKLimits)
			{
				const float FKLength = FVector::Dist(FKFootTransform.GetLocation(), ThighTransform.GetLocation());
				const float IKLength = FVector::Dist(Foot.IKFootBoneTransform.GetLocation(), AdjustedThighTransform.GetLocation());
				if (IKLength > FKLength)
				{
					const FVector ClampedFootLocation = AdjustedThighTransform.GetLocation() + TargetDir * FKLength;
					Foot.IKFootBoneTransform.SetLocation(ClampedFootLocation);
				}
			}
		}
	}

	// Add final IK feet transforms
	// 将调整后的脚步数据应用到输出数据中
	for (auto& Foot : FootData)
	{
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootFinal
#endif
		)
		{
			AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
		}
#endif
		check(!Foot.IKFootBoneTransform.ContainsNaN());
		OutBoneTransforms.Add(FBoneTransform(Foot.IKFootBoneIndex, Foot.IKFootBoneTransform));
	}

	// Sort OutBoneTransforms so indices are in increasing order.
	// 按照骨骼树的位置对骨骼进行排序让其对应骨骼树中的索引
	OutBoneTransforms.Sort(FCompareBoneTransformIndex());
}

更新流程:

  1. 获取实际的运动方向和运动速度
  2. 根据速度和方向调整脚步的位置
  3. 调整盆骨位置
  4. 根据盆骨的偏移和大腿的旋转限制脚步的位置
  5. 将调整后的骨骼数据添加到输出中并按照骨骼树进行排序

流程图

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
flowchart TD
    A[开始步幅匹配] --> B{匹配模式选择}
    
    B --> C[速度匹配模式]
    B --> D[脚步IK模式]
    
    %% 速度匹配分支
    subgraph C [速度匹配流程]
        direction LR
        C1[循环移动动画] --> C2[计算动画固有速度<br/>根运动距离/动画时长]
        C2 --> C3[计算速度比值<br/>角色速度/动画速度]
        C3 --> C4[应用播放速率<br/>限制范围:0.75-1.25]
        C4 --> C5[速度匹配完成]
    end
    
    %% 脚步IK分支
    subgraph D [脚步IK流程]
        direction LR
        D1[获取运动参数<br/>方向与速度] --> D2[计算步幅缩放比例<br/>角色速度/根运动速度]
        D2 --> D3[脚步骨骼空间投影<br/>基于运动平面]
        D3 --> D4[应用步幅缩放<br/>调整骨骼位置]
        D4 --> D5[盆骨偏移计算<br/>保持腿部形态]
        D5 --> D6[大腿旋转补偿<br/>防止过度拉伸]
        D6 --> D7[应用所有骨骼调整]
        D7 --> D8[脚步IK完成]
    end
    
    C5 --> E[动态调整步频<br/>保持动画节奏]
    D8 --> F[调整步幅大小<br/>防止鬼畜现象]
    
    E --> G[自然流畅的循环移动]
    F --> G

展开全文 >>

常用的IK算法

TowBoneIK

双骨骼IK，一般用于根据末端骨骼和目标位置来计算中间骨骼的位置，常用于角色的手部和脚步。

基本原理

基本原理图解

基本原理图解

UE实现与源码解析

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
namespace AnimationCore
{

void SolveTwoBoneIK(FTransform& InOutRootTransform, FTransform& InOutJointTransform, FTransform& InOutEndTransform, const FVector& JointTarget, const FVector& Effector, bool bAllowStretching, double StartStretchRatio, double MaxStretchScale)
{
	double LowerLimbLength = (InOutEndTransform.GetLocation() - InOutJointTransform.GetLocation()).Size();
	double UpperLimbLength = (InOutJointTransform.GetLocation() - InOutRootTransform.GetLocation()).Size();
	SolveTwoBoneIK(InOutRootTransform, InOutJointTransform, InOutEndTransform, JointTarget, Effector, UpperLimbLength, LowerLimbLength, bAllowStretching, StartStretchRatio, MaxStretchScale);
}

void SolveTwoBoneIK(FTransform& InOutRootTransform, FTransform& InOutJointTransform, FTransform& InOutEndTransform, const FVector& JointTarget, const FVector& Effector, double UpperLimbLength, double LowerLimbLength, bool bAllowStretching, double StartStretchRatio, double MaxStretchScale)
{
	FVector OutJointPos, OutEndPos;

	FVector RootPos = InOutRootTransform.GetLocation();
	FVector JointPos = InOutJointTransform.GetLocation();
	FVector EndPos = InOutEndTransform.GetLocation();

	// IK solver
	AnimationCore::SolveTwoBoneIK(RootPos, JointPos, EndPos, JointTarget, Effector, OutJointPos, OutEndPos, UpperLimbLength, LowerLimbLength, bAllowStretching, StartStretchRatio, MaxStretchScale);

	// Update transform for upper bone.
	{
		// Get difference in direction for old and new joint orientations
		FVector const OldDir = (JointPos - RootPos).GetSafeNormal();
		FVector const NewDir = (OutJointPos - RootPos).GetSafeNormal();
		// Find Delta Rotation take takes us from Old to New dir
		FQuat const DeltaRotation = FQuat::FindBetweenNormals(OldDir, NewDir);
		// Rotate our Joint quaternion by this delta rotation
		InOutRootTransform.SetRotation(DeltaRotation * InOutRootTransform.GetRotation());
		// And put joint where it should be.
		InOutRootTransform.SetTranslation(RootPos);

	}

	// update transform for middle bone
	{
		// Get difference in direction for old and new joint orientations
		FVector const OldDir = (EndPos - JointPos).GetSafeNormal();
		FVector const NewDir = (OutEndPos - OutJointPos).GetSafeNormal();

		// Find Delta Rotation take takes us from Old to New dir
		FQuat const DeltaRotation = FQuat::FindBetweenNormals(OldDir, NewDir);
		// Rotate our Joint quaternion by this delta rotation
		InOutJointTransform.SetRotation(DeltaRotation * InOutJointTransform.GetRotation());
		// And put joint where it should be.
		InOutJointTransform.SetTranslation(OutJointPos);

	}

	// Update transform for end bone.
	// currently not doing anything to rotation
	// keeping input rotation
	// Set correct location for end bone.
	InOutEndTransform.SetTranslation(OutEndPos);
}

void SolveTwoBoneIK(const FVector& RootPos, const FVector& JointPos, const FVector& EndPos, const FVector& JointTarget, const FVector& Effector, FVector& OutJointPos, FVector& OutEndPos, bool bAllowStretching, double StartStretchRatio, double MaxStretchScale)
{
	const double LowerLimbLength = (EndPos - JointPos).Size();
	const double UpperLimbLength = (JointPos - RootPos).Size();

	SolveTwoBoneIK(RootPos, JointPos, EndPos, JointTarget, Effector, OutJointPos, OutEndPos, UpperLimbLength, LowerLimbLength, bAllowStretching, StartStretchRatio, MaxStretchScale);
}

void SolveTwoBoneIK(const FVector& RootPos, const FVector& JointPos, const FVector& EndPos, const FVector& JointTarget, const FVector& Effector, FVector& OutJointPos, FVector& OutEndPos, double UpperLimbLength, double LowerLimbLength, bool bAllowStretching, double StartStretchRatio, double MaxStretchScale)
{
	// This is our reach goal.
	FVector DesiredPos = Effector;
	FVector DesiredDelta = DesiredPos - RootPos;
	double DesiredLength = DesiredDelta.Size();

	// Find lengths of upper and lower limb in the ref skeleton.
	// Use actual sizes instead of ref skeleton, so we take into account translation and scaling from other bone controllers.
	double MaxLimbLength = LowerLimbLength + UpperLimbLength;

	// Check to handle case where DesiredPos is the same as RootPos.
	FVector	DesiredDir;
	if (DesiredLength < DOUBLE_KINDA_SMALL_NUMBER)
	{
		DesiredLength = DOUBLE_KINDA_SMALL_NUMBER;
		DesiredDir = FVector(1, 0, 0);
	}
	else
	{
		DesiredDir = DesiredDelta.GetSafeNormal();
	}

	// Get joint target (used for defining plane that joint should be in).
	FVector JointTargetDelta = JointTarget - RootPos;
	const double JointTargetLengthSqr = JointTargetDelta.SizeSquared();

	// Same check as above, to cover case when JointTarget position is the same as RootPos.
	FVector JointPlaneNormal, JointBendDir;
	if (JointTargetLengthSqr < FMath::Square(DOUBLE_KINDA_SMALL_NUMBER))
	{
		JointBendDir = FVector(0, 1, 0);
		JointPlaneNormal = FVector(0, 0, 1);
	}
	else
	{
		JointPlaneNormal = DesiredDir ^ JointTargetDelta;

		// If we are trying to point the limb in the same direction that we are supposed to displace the joint in, 
		// we have to just pick 2 random vector perp to DesiredDir and each other.
		if (JointPlaneNormal.SizeSquared() < FMath::Square(DOUBLE_KINDA_SMALL_NUMBER))
		{
			DesiredDir.FindBestAxisVectors(JointPlaneNormal, JointBendDir);
		}
		else
		{
			JointPlaneNormal.Normalize();

			// Find the final member of the reference frame by removing any component of JointTargetDelta along DesiredDir.
			// This should never leave a zero vector, because we've checked DesiredDir and JointTargetDelta are not parallel.
			JointBendDir = JointTargetDelta - ((JointTargetDelta | DesiredDir) * DesiredDir);
			JointBendDir.Normalize();
		}
	}

	//UE_LOG(LogAnimationCore, Log, TEXT("UpperLimb : %0.2f, LowerLimb : %0.2f, MaxLimb : %0.2f"), UpperLimbLength, LowerLimbLength, MaxLimbLength);

	if (bAllowStretching)
	{
		const double ScaleRange = MaxStretchScale - StartStretchRatio;
		if (ScaleRange > DOUBLE_KINDA_SMALL_NUMBER && MaxLimbLength > DOUBLE_KINDA_SMALL_NUMBER)
		{
			const double ReachRatio = DesiredLength / MaxLimbLength;
			const double ScalingFactor = (MaxStretchScale - 1.0) * FMath::Clamp((ReachRatio - StartStretchRatio) / ScaleRange, 0.0, 1.0);
			if (ScalingFactor > DOUBLE_KINDA_SMALL_NUMBER)
			{
				LowerLimbLength *= (1.0 + ScalingFactor);
				UpperLimbLength *= (1.0 + ScalingFactor);
				MaxLimbLength *= (1.0 + ScalingFactor);
			}
		}
	}

	OutEndPos = DesiredPos;
	OutJointPos = JointPos;

	// If we are trying to reach a goal beyond the length of the limb, clamp it to something solvable and extend limb fully.
	if (DesiredLength >= MaxLimbLength)
	{
		OutEndPos = RootPos + (MaxLimbLength * DesiredDir);
		OutJointPos = RootPos + (UpperLimbLength * DesiredDir);
	}
	else
	{
		// So we have a triangle we know the side lengths of. We can work out the angle between DesiredDir and the direction of the upper limb
		// using the sin rule:
		const double TwoAB = 2.0 * UpperLimbLength * DesiredLength;

		const double CosAngle = (TwoAB != 0.0) ? ((UpperLimbLength*UpperLimbLength) + (DesiredLength*DesiredLength) - (LowerLimbLength*LowerLimbLength)) / TwoAB : 0.0;

		// If CosAngle is less than 0, the upper arm actually points the opposite way to DesiredDir, so we handle that.
		const bool bReverseUpperBone = (CosAngle < 0.0);

		// Angle between upper limb and DesiredDir
		// ACos clamps internally so we dont need to worry about out-of-range values here.
		const double Angle = FMath::Acos(CosAngle);

		// Now we calculate the distance of the joint from the root -> effector line.
		// This forms a right-angle triangle, with the upper limb as the hypotenuse.
		const double JointLineDist = UpperLimbLength * FMath::Sin(Angle);

		// And the final side of that triangle - distance along DesiredDir of perpendicular.
		// ProjJointDistSqr can't be neg, because JointLineDist must be <= UpperLimbLength because appSin(Angle) is <= 1.
		const double ProjJointDistSqr = (UpperLimbLength*UpperLimbLength) - (JointLineDist*JointLineDist);
		// although this shouldn't be ever negative, sometimes Xbox release produces -0.f, causing ProjJointDist to be NaN
		// so now I branch it. 						
		double ProjJointDist = (ProjJointDistSqr > 0.0) ? FMath::Sqrt(ProjJointDistSqr) : 0.0;
		if (bReverseUpperBone)
		{
			ProjJointDist *= -1.f;
		}

		// So now we can work out where to put the joint!
		OutJointPos = RootPos + (ProjJointDist * DesiredDir) + (JointLineDist * JointBendDir);
	}
}

}

FABRIK

正反双向IK

基本原理

基本原理图解

UE实现与源码解析

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
namespace AnimationCore
{
	/////////////////////////////////////////////////////
	// Implementation of the FABRIK IK Algorithm
	// Please see http://andreasaristidou.com/publications/FABRIK.pdf for more details

	bool SolveFabrik(TArray<FFABRIKChainLink>& InOutChain, const FVector& TargetPosition, double MaximumReach, double Precision, int32 MaxIterations)
	{
		bool bBoneLocationUpdated = false;
		double const RootToTargetDistSq = FVector::DistSquared(InOutChain[0].Position, TargetPosition);
		int32 const NumChainLinks = InOutChain.Num();

		// FABRIK algorithm - bone translation calculation
		// If the effector is further away than the distance from root to tip, simply move all bones in a line from root to effector location
		if (RootToTargetDistSq > FMath::Square(MaximumReach))
		{
			for (int32 LinkIndex = 1; LinkIndex < NumChainLinks; LinkIndex++)
			{
				FFABRIKChainLink const & ParentLink = InOutChain[LinkIndex - 1];
				FFABRIKChainLink & CurrentLink = InOutChain[LinkIndex];
				CurrentLink.Position = ParentLink.Position + (TargetPosition - ParentLink.Position).GetUnsafeNormal() * CurrentLink.Length;
			}
			bBoneLocationUpdated = true;
		}
		else // Effector is within reach, calculate bone translations to position tip at effector location
		{
			int32 const TipBoneLinkIndex = NumChainLinks - 1;

			// Check distance between tip location and effector location
			double Slop = FVector::Dist(InOutChain[TipBoneLinkIndex].Position, TargetPosition);
			if (Slop > Precision)
			{
				// Set tip bone at end effector location.
				InOutChain[TipBoneLinkIndex].Position = TargetPosition;

				int32 IterationCount = 0;
				while ((Slop > Precision) && (IterationCount++ < MaxIterations))
				{
					// "Forward Reaching" stage - adjust bones from end effector.
					for (int32 LinkIndex = TipBoneLinkIndex - 1; LinkIndex > 0; LinkIndex--)
					{
						FFABRIKChainLink & CurrentLink = InOutChain[LinkIndex];
						FFABRIKChainLink const & ChildLink = InOutChain[LinkIndex + 1];

						CurrentLink.Position = ChildLink.Position + (CurrentLink.Position - ChildLink.Position).GetUnsafeNormal() * ChildLink.Length;
					}

					// "Backward Reaching" stage - adjust bones from root.
					for (int32 LinkIndex = 1; LinkIndex < TipBoneLinkIndex; LinkIndex++)
					{
						FFABRIKChainLink const & ParentLink = InOutChain[LinkIndex - 1];
						FFABRIKChainLink & CurrentLink = InOutChain[LinkIndex];

						CurrentLink.Position = ParentLink.Position + (CurrentLink.Position - ParentLink.Position).GetUnsafeNormal() * CurrentLink.Length;
					}

					// Re-check distance between tip location and effector location
					// Since we're keeping tip on top of effector location, check with its parent bone.
					Slop = FMath::Abs(InOutChain[TipBoneLinkIndex].Length - FVector::Dist(InOutChain[TipBoneLinkIndex - 1].Position, TargetPosition));
				}

				// Place tip bone based on how close we got to target.
				{
					FFABRIKChainLink const & ParentLink = InOutChain[TipBoneLinkIndex - 1];
					FFABRIKChainLink & CurrentLink = InOutChain[TipBoneLinkIndex];

					CurrentLink.Position = ParentLink.Position + (CurrentLink.Position - ParentLink.Position).GetUnsafeNormal() * CurrentLink.Length;
				}

				bBoneLocationUpdated = true;
			}
		}

		return bBoneLocationUpdated;
	}
}

CCDIK

循环坐标下降IK

基本原理

基本原理图解

UE实现与源码解析

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
133
namespace AnimationCore
{

	bool SolveCCDIK(TArray<FCCDIKChainLink>& InOutChain, const FVector& TargetPosition, float Precision, int32 MaxIteration, bool bStartFromTail, bool bEnableRotationLimit, const TArray<float>& RotationLimitPerJoints)
	{
		struct Local
		{
			static bool UpdateChainLink(TArray<FCCDIKChainLink>& Chain, int32 LinkIndex, const FVector& TargetPos, bool bInEnableRotationLimit, const TArray<float>& InRotationLimitPerJoints)
			{
				int32 const TipBoneLinkIndex = Chain.Num() - 1;

				ensure(Chain.IsValidIndex(TipBoneLinkIndex));
				FCCDIKChainLink& CurrentLink = Chain[LinkIndex];

				// update new tip pos
				FVector TipPos = Chain[TipBoneLinkIndex].Transform.GetLocation();

				FTransform& CurrentLinkTransform = CurrentLink.Transform;
				FVector ToEnd = TipPos - CurrentLinkTransform.GetLocation();
				FVector ToTarget = TargetPos - CurrentLinkTransform.GetLocation();

				ToEnd.Normalize();
				ToTarget.Normalize();

				double RotationLimitPerJointInRadian = FMath::DegreesToRadians(InRotationLimitPerJoints[LinkIndex]);
				double Angle = FMath::ClampAngle(FMath::Acos(FVector::DotProduct(ToEnd, ToTarget)), -RotationLimitPerJointInRadian, RotationLimitPerJointInRadian);
				bool bCanRotate = (FMath::Abs(Angle) > DOUBLE_KINDA_SMALL_NUMBER) && (!bInEnableRotationLimit || RotationLimitPerJointInRadian > CurrentLink.CurrentAngleDelta);
				if (bCanRotate)
				{
					// check rotation limit first, if fails, just abort
					if (bInEnableRotationLimit)
					{
						if (RotationLimitPerJointInRadian < CurrentLink.CurrentAngleDelta + Angle)
						{
							Angle = RotationLimitPerJointInRadian - CurrentLink.CurrentAngleDelta;
							if (Angle <= DOUBLE_KINDA_SMALL_NUMBER)
							{
								return false;
							}
						}

						CurrentLink.CurrentAngleDelta += Angle;
					}

					// continue with rotating toward to target
					FVector RotationAxis = FVector::CrossProduct(ToEnd, ToTarget);
					if (RotationAxis.SizeSquared() > 0.f)
					{
						RotationAxis.Normalize();
						// Delta Rotation is the rotation to target
						FQuat DeltaRotation(RotationAxis, Angle);

						FQuat NewRotation = DeltaRotation * CurrentLinkTransform.GetRotation();
						NewRotation.Normalize();
						CurrentLinkTransform.SetRotation(NewRotation);

						// if I have parent, make sure to refresh local transform since my current transform has changed
						if (LinkIndex > 0)
						{
							FCCDIKChainLink const & Parent = Chain[LinkIndex - 1];
							CurrentLink.LocalTransform = CurrentLinkTransform.GetRelativeTransform(Parent.Transform);
							CurrentLink.LocalTransform.NormalizeRotation();
						}

						// now update all my children to have proper transform
						FTransform CurrentParentTransform = CurrentLinkTransform;

						// now update all chain
						for (int32 ChildLinkIndex = LinkIndex + 1; ChildLinkIndex <= TipBoneLinkIndex; ++ChildLinkIndex)
						{
							FCCDIKChainLink& ChildIterLink = Chain[ChildLinkIndex];
							const FTransform LocalTransform = ChildIterLink.LocalTransform;
							ChildIterLink.Transform = LocalTransform * CurrentParentTransform;
							ChildIterLink.Transform.NormalizeRotation();
							CurrentParentTransform = ChildIterLink.Transform;
						}

						return true;
					}
				}

				return false;
			}
		};

		bool bBoneLocationUpdated = false;
		int32 const NumChainLinks = InOutChain.Num();

		// iterate
		{
			int32 const TipBoneLinkIndex = NumChainLinks - 1;

			// @todo optimize locally if no update, stop?
			bool bLocalUpdated = false;
			// check how far
			const FVector TargetPos = TargetPosition;
			FVector TipPos = InOutChain[TipBoneLinkIndex].Transform.GetLocation();
			double Distance = FVector::Dist(TargetPos, TipPos);
			int32 IterationCount = 0;
			while ((Distance > Precision) && (IterationCount++ < MaxIteration))
			{
				// iterate from tip to root
				if (bStartFromTail)
				{
					for (int32 LinkIndex = TipBoneLinkIndex - 1; LinkIndex > 0; --LinkIndex)
					{
						bLocalUpdated |= Local::UpdateChainLink(InOutChain, LinkIndex, TargetPos, bEnableRotationLimit, RotationLimitPerJoints);
					}
				}
				else
				{
					for (int32 LinkIndex = 1; LinkIndex < TipBoneLinkIndex; ++LinkIndex)
					{
						bLocalUpdated |= Local::UpdateChainLink(InOutChain, LinkIndex, TargetPos, bEnableRotationLimit, RotationLimitPerJoints);
					}
				}

				Distance = FVector::Dist(InOutChain[TipBoneLinkIndex].Transform.GetLocation(), TargetPosition);

				bBoneLocationUpdated |= bLocalUpdated;

				// no more update in this iteration
				if (!bLocalUpdated)
				{
					break;
				}
			}
		}

		return bBoneLocationUpdated;
	}

}

展开全文 >>

服务器倒带

服务器倒带(Server Rewind)主要用于解决多人在线游戏中，由于网络延迟导致的客户端与服务器表现不一致问题。该技术特别适用于第一人称射击(FPS)和动作类游戏，能够在不牺牲响应性的前提下保证游戏的公平性。

服务器倒带算法的实现思路

在服务器上保存玩家一段时间内的历史状态信息（位置、旋转等），当收到客户端的命中请求时，根据客户端上报的时间戳将目标玩家的状态回滚到对应时刻，重新进行碰撞检测以验证命中有效性。

所以我们需要如下结构体：

1
2
3
4
5
6
7
8
9
struct FHistoryCache
{
public:
    float Time; // 运行时间
    FVector Loction; // 位置
    FRotator Rotation; // 旋转

    static void Create(...); // 创建方法
};

保存的时间

在这个结构体中我们保存了游戏的运行时间，UE给我们提供了游戏自开始一共运行了多少时间，我们可以很容易的获取并将其保存到缓存中，但需要注意的是：这个时间会因为客户端服务端的差异而存在不同，所以我们需要对时间进行校准。

时间校准的方法

我们可以向服务器请求一次当前服务器的运行时间并将客户端时间一并上报，当服务器收到客户端的请求后便将服务器运行时间于客户端上报的时间一并下发给客户端，这样便可以计算出服务器的运行时间。

具体过程：

  1. 在需要校准时间时将客户端的时间上报给服务器
  2. 服务器收到客户端上报的时间后将服务器的时间于客户端的时间一并发送给客户端
  3. 客户端收到后可以根据上报时的客户端时间计算出RTT，这里假设客户端服务端进行一次通信所花费的时间相同，即服务端收到客户端上报的时间于客户端收到服务器下发的数据所花费的时间相同，就可以计算出客户端在收到服务器下发数据时的运行时间

具体实现

我们将实现放在玩家的控制器中，继承APlayerController类。

ASGPlayerController的头文件

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

class ASGPlayerController : public APlayerController
{
public:
    ASGPlayerController();

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaSeconds) override;

    /** 客户端上报服务器 */
    UFUNCTION(Server, Reliable)
    void Server_ReqServerTime(float ClientTime);

    /** 服务器响应客户端 */
    UFUNCTION(Client, Reliable)
    void Client_RspServerTime(float ServerTime, float ClientTime);

    UFUNCTION(BlueprintPure)
    float GetServerTime();
protected:
    /** 客户端服务端运行时间的差值 */
    float DeltaTimeInCS = 0.0f;

    /** 检查时间 */
    float CheckTime = 0.0f;

    /** RTT */
    float RTT = 0.0f;

    /** 检查间隔 */
    UPROPERTY(EditAnywhere)
    float CheckInterval = 4.0f;
};

ASGPlayerController的实现

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
ASGPlayerController::ASGPlayerController()
{
    // 在Tick中决定校准运行时间的时机
    PrimaryActorTick.bCanEverTick = true;
};

ASGPlayerController::BeginPlay()
{
    Super::BeginPlay();

    // 客户端玩家进入游戏时校准一次时间
    if(!HasAuthority())
    {
        Server_ReqServerTime(GetWorld()->GetTimeSeconds());
    }
}

ASGPlayerController::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

    // 只在客户端校准
    if(!HasAuthority())
    {
        if(CheckTime > CheckInterval)
        {
            CheckTime = 0.0f;
            Server_ReqServerTime(GetWorld()->GetTimeSeconds());
        }
        CheckTime += DeltaSeconds;
    }
}

ASGPlayerController::Server_ReqServerTime_Implementation(float ClientTime)
{
    // 服务器收到后将服务器运行时间于客户端上报的时间一并下发给客户端
    Client_RspServerTime(GetWorld()->GetTimeSeconds(), ClientTime);
}

ASGPlayerController::Client_RspServerTime_Implementation(float ServerTime, float ClientTime)
{
    RTT = GetWorld()->GetTimeSeconds() - ClientTime;
    // 当前时刻服务器的实际运行时间
    ServerTime += RTT * 0.5;
    // 客户端与服务器运行时间的差值
    DeltaTimeInCS = GetWorld()->GetTimeSeconds() - ServerTime;
}

float ASGPlayerController::GetServerTime()
{
    // 如果是服务器直接返回世界时间
    if (HasAuthority())
    {
        return GetWorld()->GetTimeSeconds();
    }
    // 否则返回客户端时间减去差值
    return GetWorld()->GetTimeSeconds() - DeltaTimeInCS;
}

位置与旋转

为了便于实现，我们只在玩家身上挂载一个UBoxComponent, 将这个BoxComponent用作玩家回滚后的击中判定：

1
2
3
4
5
6
7
8
class ASGCharacter : public ACharacter
{
    // ...

public:
    UPROPERTY(EditAnywhere)
    TObjectPtr<UBoxComponent> BoxComponent;
};

倒带过程

我们使用一个组件来承担倒带的主要逻辑，主要实现功能为：

  1. 记录一段时间内玩家的历史位置信息
  2. 根据上报的信息回滚玩家位置并确认击中
  3. 使用循环数组保存信息以减少开销
  4. 需要提供可视化调试

USGLagComponent的头文件

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
/** 历史缓存的结构体，存储每帧玩家的位置以及时间信息 */
USTRUCT(BlueprintType)
struct FSGHistoryFrameCache
{
	GENERATED_BODY()
public:
	/** 缓存的时间 */
	float Time;

	/** 位置信息 */
	FVector BoxLocation;

	/** 旋转信息 */
	FRotator BoxRotation;
	
    /** 创建方法 */
	static void CreateHistoryFrame(ASGCharacter* Character, FSGHistoryFrameCache& CurrentFrame)
	{
		if (IsValid(Character))
		{
			CurrentFrame.Time = Character->GetWorld()->GetTimeSeconds();
			CurrentFrame.BoxLocation = Character->GetHitBoxComponent()->GetComponentLocation();
			CurrentFrame.Rotation = Character->GetHitBoxComponent()->GetComponentRotation();
		}
	}
};

class USGLagComponent : public UActorComponent
{
public:	
	
	USGLagComponent();

	virtual void BeginPlay() override;

	virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

    /** 检查是否被击中 */
	UFUNCTION(BlueprintCallable)
	bool CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime);

protected:
    /** 尝试保存每帧的回滚信息 */
	void TrySaveFrame();

    /**
    * 根据目标时间查找历史帧并进行线性插值
    * @param TargetTime 目标时间（服务器时间）
    * @param bFind 输出参数，是否找到合适帧
    * @param FrameCache 输出参数，插值后的帧数据
    */
	void FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache);
	
    /** 玩家 */
	TWeakObjectPtr<ASGCharacter> OwnerCharacter;

    /** 历史帧缓存列表 */
	TArray<FSGHistoryFrameCache> HistoryFrameCache;
	
    /** 保存的有效帧数 */
	UPROPERTY(EditAnywhere, BlueprintReadOnly)
	int32 ValidTickNum = 64;
    
    /** 用于记录保存的帧号，为了与数组下标对应，从-1开始记录 */
	int32 CurrentTickNum = -1;
	
    /** 是否开启调试 */
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	bool bDebug = false;
};

USGLagComponent的实现

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
USGLagComponent::USGLagComponent()
{
	PrimaryComponentTick.bCanEverTick = true;
}

USGLagComponent::BeginPlay()
{
	Super::BeginPlay();
}

USGLagComponent::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);

    // 尝试保存每帧的回滚信息
	TrySaveFrame();
}

bool USGLagComponent::CheckHit(FVector& StartLocation, FVector& EndLocation, float HittedTime)
{
    // 前置检查
	if (!OwnerCharacter.IsValid() || !GetWorld())
	{
		return false;
	}

    UBoxComponent* HittedBox = OwnerCharacter->GetHitBoxComponent();
    if (!IsValid(HittedBox))
    {
        return false;
    }
	
	bool bFind = false;
	FSGHistoryFrameCache FrameCache;
	FindFrame_Liner(HittedTime, bFind, FrameCache);
	if (bFind == false)
	{
		return false;
	}

	// 获取原先的位置并记录

	FVector OriginLocation = HittedBox->GetComponentLocation();
	FRotator OriginRotation = HittedBox->GetComponentRotation();
	
	// 将碰撞体移动到被击中的位置
	HittedBox->SetWorldLocation(FrameCache.BoxLocation);
	HittedBox->SetWorldRotation(FrameCache.BoxRotation);
	HittedBox->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
	
	// 专门用来进行回滚检测的碰撞预设
	FHitResult HitResult;
	bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_GameTraceChannel1);

	// 关闭碰撞并且恢复原先的位置
	HittedBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);
	HittedBox->SetWorldLocation(OriginLocation);
	HittedBox->SetWorldRotation(OriginRotation);

    // 在调试模式下绘制检测过程
#if WITH_EDITOR
    if (bDebug == true && !OwnerCharacter->HasAuthority())
    {
    // 绘制射线
    DrawDebugLine(GetWorld(), StartLocation, EndLocation, 
                    bHit ? FColor::Green : FColor::Green, false, 5.0f);

    // 绘制碰撞体在回滚时刻的位置
    DrawDebugBox(GetWorld(), FrameCache.BoxLocation,
                    HitBox->GetScaledBoxExtent(),
                    FQuat(FrameCache.BoxRotation), 
                    bHit ? FColor::Green : FColor::Red, false, 5.0f);
    }
#endif

	return bHit;
}

void USGLagComponent::TrySaveFrame()
{
    if(!OwnerCharacter.IsValid())
    {
        OwnerCharacter = Cast<ASGCharacter>(GetOwner());
        return;
    }

	int32 CurrentFrameSize = HistoryFrameCache.Num();
    // 计算要保存的帧索引
	int32 SavedFrameIndex = (CurrentTickNum + 1) % ValidTickNum;
	// 如果当前数量小于最大数量则直接添加
	if (CurrentFrameSize < ValidTickNum)
	{
		FSGHistoryFrameCache CurrentFrameCache;
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), CurrentFrameCache);
		HistoryFrameCache.Add(CurrentFrameCache);
	}
	else
	{
		// 否则循环更新
		FSGHistoryFrameCache::CreateHistoryFrame(OwnerCharacter.Get(), HistoryFrameCache[SavedFrameIndex]);
	}
	CurrentTickNum = SavedFrameIndex;

    // 调试功能
#if WITH_EDITOR
    if(bDebug == true && !OwnerCharacter->HasAuthority())
    {
        // 将调试Box绘制出来
        DrawDebugBox(GetWorld(), HistoryFrameCache[CurrentTickNum].BoxLocation,
		             OwnerCharacter->GetHitBoxComponent()->GetScaledBoxExtent(),
		             FQuat(HistoryFrameCache[CurrentTickNum].BoxRotation), FColor::Red, false, ValidTickNum * GetWorld()->GetDeltaSeconds());
    }
#endif
}

void USGLagComponent::FindFrame_Liner(float TargetTime, bool& bFind, FSGHistoryFrameCache& FrameCache)
{
bFind = false;
	
	// 获取有效帧的数量和范围
	int32 TotalValidFrames = HistoryFrameCache.Num();
	int32 StartIndex = 0;
	int32 EndIndex = TotalValidFrames - 1;

	// 如果已满，调整起始和结束索引
	if (TotalValidFrames >= ValidTickNum)
	{
		StartIndex = (CurrentTickNum + 1) % ValidTickNum;
		EndIndex = CurrentTickNum;
	}
	
	// 检查目标时间是否在有效范围内
	float FirstTime = HistoryFrameCache[StartIndex].Time;
	float LastTime = HistoryFrameCache[EndIndex].Time;

	if (TargetTime < FirstTime || LastTime < TargetTime)
	{
		bFind = false;
		return;
	}

	// 查找目标时间所在的时间段
	int32 PreIndex = -1;
	int32 NextIndex = -1;

	// 遍历查找合适的时间段
	for (int32 i = 0; i < TotalValidFrames; i++)
	{
		int32 CurrentIndex = (StartIndex + i) % ValidTickNum;
		float CurrentTime = HistoryFrameCache[CurrentIndex].Time;
        
		if (CurrentTime <= TargetTime)
		{
			PreIndex = CurrentIndex;
		}
		else
		{
			NextIndex = CurrentIndex;
			break;
		}
	}

	// 如果Pre没更新过，则说明是第一帧
	if (PreIndex == -1)
	{
		FrameCache = HistoryFrameCache[StartIndex];
		bFind = true;
		return;
	}

	// 如果Next没更新过，则说明是最后一帧
	if (NextIndex == -1)
	{
		FrameCache = HistoryFrameCache[EndIndex];
		bFind = true;
		return;
	}

	float PreTime = HistoryFrameCache[PreIndex].Time;
	float NextTime = HistoryFrameCache[NextIndex].Time;

	if (FMath::IsNearlyEqual(PreTime, NextTime))
	{
        bFind = false;
		return;
	}
	
	// 长度大于2，进行插值
	FVector PreLocation = HistoryFrameCache[PreIndex].BoxLocation;
	FVector NextLocation = HistoryFrameCache[NextIndex].BoxLocation;
	FRotator PreRotation = HistoryFrameCache[PreIndex].BoxRotation;
	FRotator NextRotation = HistoryFrameCache[NextIndex].BoxRotation;
	
	// 进行线性插值
	float Distance = NextTime - PreTime;
	float InterpSpeed = (TargetTime - PreTime) / Distance;
	FrameCache.BoxLocation = FMath::VInterpTo(PreLocation, NextLocation, 1.0f, InterpSpeed);
	FrameCache.BoxRotation = FMath::RInterpTo(PreRotation, NextRotation, 1.0f, InterpSpeed);
	bFind = true;
}

总结

工作流程

以下mermaid展示了整个服务器倒带的工作流程：

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
graph LR
    A[客户端开始射击] --> B[本地碰撞检测]
    B --> C[检测到命中]
    C --> D[上报服务器<br>包含命中时间]
    
    E[服务器接收命中请求] --> F[获取目标玩家LagComponent]
    F --> G[调用CheckHit函数]
    G --> H[FindFrame_Liner查找历史帧]
    H --> I{是否找到合适帧?}
    I -->|是| J[回滚碰撞体位置]
    I -->|否| K[返回命中失败]
    J --> L[执行碰撞检测]
    L --> M[恢复碰撞体位置]
    M --> N[返回检测结果]
    
    O[服务器Tick更新] --> P[TrySaveFrame保存帧]
    P --> Q{缓存是否已满?}
    Q -->|否| R[添加新帧]
    Q -->|是| S[循环覆盖旧帧]
    R --> T[更新CurrentTickNum]
    S --> T
    
    U[时间校准流程] --> V[客户端请求校准]
    V --> W[服务器响应时间]
    W --> X[客户端计算DeltaTimeInCS]
    
    subgraph 数据存储
        Y[HistoryFrameCache<br>历史帧缓存]
        Z[CurrentTickNum<br>当前帧索引]
    end
    
    H --> Y
    P --> Y
    T --> Z

mermaid网站链接：https://mermaid-live.nodejs.cn/edit#pako:eNptlOtOGkEUx1-FzGc0IEKVNDYV661oVahWB9OsMApRdsm629SiidrWO2iLt1ZrxXprrYiNiimiL8PM4lt0mFm7mDgfNjtzfufMOf85M1HglwIIOMGALESCJneHTzTR8RTi1A6ZyWhHJ_hqHB_M4_QHPJ3tNZWV1ZhqIdn8jTfT2k6afN4iP8bJ-Xwv96tlgAvyRTyTxp9y-ctj3epi1jqYv5wjc3tkM4bnkvjL4eM-uQYvfMRLR5wmaxe3a2e6D_8-g_9pEt8jyxecLJxkyOkkz6oeFuIZvLiqbaTI9rQW_4lTF25hwCWFI5KIREWPV8_gBlhIv9eWD11B5B9sDCl4OkdW0jrSwJBGWB8SA_WyEEav3SERyeT7Hpm9xvEpvPgHXx7ocCODm6Jk_QQv7RcBWvTSzO34JGWejHGoqQiNUmTU1AzxxhbJfuXi5XOJfC6m5VK9pSANNGp6Dgs3y5TlleLd08LZnk41sz3dkMweFJILDxyDmwEtkEzs4N3Yw1u1MKZV34W7a9kE2dq8p_wLQ3lvyD9INs7Iapor3ga98ohHeIOYSPmbb_h43RCmjTHtUe0qQde5PDjzh2STd6q0G8V2QJLJ4rltGtuI0G6o5oH4-pcWPynsT2kbq2TtwKA62D5eyDNzqbJMD7uYaqsa1hEPR0rLegl5l5HtJJ6eIucT2uE8r6rTaH3eXhzRQ3UypssQBSdi-O_yvZbtYsyrkjippJZaq0NDiuANhVGT6PLc03hY7ePXj_YgiaWKMk4eclNxdMPG0LAiySNMZ5fgDyJ2Ze46kSvcazj0wPsyMDqXwLOxIn22g69WdBqJgdJEeDN3lx6gPvGySQ8wgzCSw0IoQJ-MaNHkA0oQhZEPOOlvAPUL6pDiAz5xjKKCqkieEdEPnIqsIjOQJXUgCJz9wtAwnamRgKCgupBAaw_fIRFB7JGk0ilwRsFb4CxzVNrK7RXWKpvtUaW1oqraDEaA02qrLrdbHBWOaovVYqmwVTnGzOAdC2Att9urLRaHjQ671Wqz28z0kSsmridDa0eyS1JFBTjtY_8AjNc7_w

调试与优化

如果要模拟高延迟的情况，可以选择在DefaultEngine.ini中添加:

1
2
[PacketSimulationSettings]
PktLag = 500

可修改PktLag这个值来改变测试的延迟

依然可优化的方案：

  1. 如果保存的历史帧非常长的话使用遍历会影响性能，可以使用二分查找来优化
  2. 在进行回滚检测时，可以使用更细致的检测方案

参考

https://zhuanlan.zhihu.com/p/690661788
https://zhuanlan.zhihu.com/p/1929071131677143054

展开全文 >>

消息系统(上)

前言

这是对上一篇消息系统的重置和补充，之前的消息系统在使用上并不灵活，使用起来过于死板，于是参考了Lyra的消息系统并对原有的项目进行改进。

在新的消息系统中，将使用充分使用C++模板函数和UScriptStruct的特性，使得消息统统能够支持更灵活的定义和数据传递。

项目使用UE版本为5.2。

消息系统概述

消息系统的一个重要特性就是可以降低代码的耦合度，使代码更加简洁。
在UE中，如果当一个对象需要向另一个对象想要对另一个对象的某些变化做出响应，一般而言可以使用使用虚幻的委托来实现这个功能，但美中不足的是我们依然需要先在两个对象间建立联系随后绑定一方的委托，这依然带来了代码耦合度的提升。所以为了进一步优化我们的代码，我们便可以使用消息系统，当一个对象需要对一些变化做出响应时，就只需要监听一条特定的消息，等待消息的发起者将消息广播给所有监听者即可，这样一来我们便不用关系消息的发起者是谁，只需要处理消息发送过来的数据即可。

为了实现上述描述的消息系统，我们需要实现以下功能：

  1. 提供消息的监听功能
  2. 消息的发起者能够将消息发送给所有监听者
  3. 消息系统能够将消息发起者发送的数据传递给所有监听者
  4. 在监听者不需要时能够及时对消息进行解绑

为了方便管理我们的消息，所以我们可以先创建一个消息子系统用于管理所有的消息，之后所有的功能都将在这个类里实现。

注册消息

注册消息的目的是能够监听消息的变化并处理一些数据，所以我们需要一个注册的消息通道和一个接收到的数据类型，在UE中，我们使用FGameplayTag来作为消息通道，使用UStruct来作为绑定的数据类型。

因为我们可以知道这个监听者的回调函数应该长这样：

1
2
3
4
void Callback(FGameplayTag Channel, const FSomeStruct& SomeStruct)
{
    //...
}

为了能匹配通道类型和数据类型，我们将这个回调函数作为观察者注册进消息系统，当进行广播时由消息系统来调用这个回调函数。
这样我们的注册函数的样子大致如下：

1
void Register(FGameplayTag Channel, class SomeClass* Owner, void(SomeClass::*Callback)(FGameplayTag, const FSomeStruct&));

为了能够对类型进行匹配，我们将其改为模板函数，并在这个函数中对传进来的参数进行一些处理，在这一步对消息数据的类型进行解析同时将回调函数进行注册：

1
2
3
// 这个的Owner不一定会是UObject类型，只是UE中大多数的类都是使用UObject的，所以这里使用UObject作为默认类型
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&));

对回调函数进行注册

先看代码：

1
2
3
4
5
6
7
8
9
10
11
12
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, Callback](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };
}

这一步我们先创建了一个Owner的弱引用并在lambda表达式中捕获，并且在函数体中执行Owner的回调函数，在这一步需要确保回调函数的参数和数据类型能够匹配。

对数据的类型进行解析

这一步我们需要对回调函数进一步封装，使之能够获取正确的数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };

    auto Thunk = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const void* MessagePayloadData)
    {
        // 先将数据进行一次类型转换随后解引用，便能得到我们想要的类型
        Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
    };
}

在这一步我们定义了一个Thunk函数，这个函数的主要作用是将发送过来的数据转化为与回调函数类型匹配的数据

在这一步完成后我们便完成了对注册内容的初步解析，随后我们需要将解析的内容保存在消息系统中，所以我们使用一个结构体来对消息进行保存：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;
};

有了存储的结构以后还需要让消息系统持有这个结构体，已知一个通道可以存储多个监听，又有多个消息通道，所以选择使用TMap的key来存储所有的消息通道，用一个数组来存储所有该消息通道下的监听者。为了便于使用，需要将数组进行一层包装：

1
2
3
4
5
6
7
/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};
1
2
3
4
5
6
7
8
UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    GENERATED_BODY()

protected:
    TMap<FGameplayTag, FChannelListenerList> Listeners;
}

随后我们将解析的内容保存进这个结构体并由消息系统持有：

1
2
3
4
5
6
7
8
9
10
11
12
13
void RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const void*)>&& Callback, const UScriptStruct* StructType)
{
    // 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 在数组尾部创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
}

直到这一步我们便完成了消息的注册功能，接下来将消息进行广播。

广播消息

这一步就比较简单，广播消息时只需要设置消息的通道和发送的数据即可，在消息系统内部会对数据进行处理，对外提供如下方法：

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
template<typename FMessageStructType>
void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
    // 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

void BoradcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayloadData)
{
    // 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}

从消息的注册到广播可以发现对回调的处理是由内及外和由外及内的，在注册时，我们对回调函数进行封装处理使之变成广播时易于调用的类型，在广播时又逐层解析调用真正的回调函数。这一切都发生在Thunk函数中，这个函数便是消息系统能够支持任意类型数据结构的基石之一。

对消息的解绑

当一个对象不在需要监听消息时便需要对消息进行解绑。

当下的问题时，我们只在消息注册时保存了这份消息，而注册者却什么都不知道，所以在注册成功后我们需要返回一个句柄，当注册者不再需要监听时便通过这个句柄来解除绑定，所以我们需要一个句柄结构体同时对现有的一些结构体进行一些小小的修改：

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
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

// 对FGameplayMessageListenerData进行修改，同样增加一个handleid
USTRUCT(BlueprintType)
struct FGameplayMessageListenerData
{
    //...

    // 新增的字段
    uint64 HandleId;
};

UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    //...
protected:
    // 新增的字段
    uint64 HandleCounter = 0;
};

// 修改Register方法，返回一个结构体即可，具体代码会在最后提供

在Handle和Data这两个结构体中都包含一个HandleId，这个id由消息系统分配并由Handle和Data各自持有一份，在解绑时通过对比HandleId来确认是否为同一个注册的消息。

我们对外提供解绑方法：

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
void Unregister(FGameplayMessageHandle& Handle)
{
    // 检查句柄的合法性
    if (!Handle.IsValid())
	{
		return;
	}

    // 找到消息通道的监听者列表
	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除，在之前我们在广播时对数组进行拷贝避免了线程安全问题
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

在Handle中我们同样提供了解绑的方法，该方法对消息系统提供的解绑方法进行了一次封装，这样在解绑时我们可以直接调用这个Handle中的Unregister方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void Unregister()
{
    if(HandleId == 0)
    {
        return;
    }

  	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

至此我们便完成了消息系统的三个基本功能，接下来我们可以在一个类中进行测试：

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
USTRUCT(BlueprintType)
struct FTestMessageStruct
{
    GENERATED_BODY()
public:
    UPROPERTY(BlueprintReadOnly)
    int32 TestData;
}

// 声明一个Tag，在头文件中
UE_DECLARE_GAMEPLAY_TAG_EXTERN(PlayerTestTag);

// 在头文件中定义这个Tag
UE_DEFINE_GAMEPLAY_TAG_COMMENT(PlayerTestTag, "PlayerTestTag.Tag", "this is a test tag");

UCLASS()
class PROJECT_API ATestPlayer:public ACharacter
{
    //...

    FGameplayMessageHandle TestHandle;

    UFUNCTION(BlueprintCallable)
    void TestRegister()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                TestHandle = MessageSubsystem->Register(PlayerTestTag, this, &ATestPlayer::TestMessageCallback);
            }
        }
    }

    UFUNCTION(BlueprintCallable)
    void TestUnregister()
    {
        TestHandle.Unregister();
    }

    UFUNCTION(BlueprintCallable)
    void TestBroadcast()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                FTestMessageStruct TestMessage;
                TestMessage.TestData = 114514;
                MessageSubsystem->Broadcast(PlayerTestTag, TestMessage);
            }
        }
    }
}

我们在蓝图中分别调用这几个函数进行测试，可以看到消息正常发送和接受。

总结

这里我们实现了在C++中使用消息系统，但UE并不只有C++，消息系统需要同样支持蓝图调用才算完整，后面我们会对消息系统进行蓝图支持。

暂时完整的代码

代码中对获取方法提供了封装，使之更易于调用。
此外我们还可以使用宏对注册和广播进行封装，使之更加简洁易用，不过这里并未提供。
提供的代码与上文中的代码略有不同，主要在于参数传递时有一个UScriptStruct*类型的参数，这个是用于提供蓝图支持的，暂时可以忽略。

头文件

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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameplayTagContainer.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "GameplayMessageSubsystem.generated.h"

class UAsyncAction_ListenForGameplayMessage;
class UGameplayMessageSubsystem;

/*
 * 创建消息监听时返回的句柄
 */
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

/**
 * 保存消息监听者持有的数据
 */
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;

	/** 唯一的表示id，由Handle和Data各自保存一份用于查找 */
	uint64 HandleId;
};

/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};

DECLARE_LOG_CATEGORY_EXTERN(LogGameplayMessage, Log, All);

UCLASS()
class PROJECT_CTF_API UGameplayMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	// 提供蓝图支持
	friend UAsyncAction_ListenForGameplayMessage;
public:
	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;

	virtual void Initialize(FSubsystemCollectionBase& Collection) override;

	virtual void Deinitialize() override;

	static UGameplayMessageSubsystem* Get(const UObject* WorldContext);
	
	/// 对外提供的注册方法
	/// @tparam FMessageStructType 消息的数据类型
	/// @tparam Owner 消息的注册者
	/// @param Channel 消息的通道
	/// @param OwnerObject 注册者
	/// @param CallbackFunction 接收到消息的回调
	/// @return 监听的handle
	template<typename FMessageStructType, typename Owner = UObject>
	FGameplayMessageHandle RegisterListener(FGameplayTag Channel, Owner* OwnerObject, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&));

	/// 清理绑定
	/// @param Handle 创建监听时返回的唯一句柄
	void Unregister(FGameplayMessageHandle& Handle);

	/// 广播一条消息
	/// @tparam FMessageStructType 消息结构体类型
	/// @param Channel 消息通道
	/// @param MessagePayload 消息数据
	template<typename FMessageStructType>
	void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload);
protected:
	/// 实际完成注册的函数
	/// @param Channel 消息通道
	/// @param Callback 回调函数
	/// @param StructType 消息数据类型
	/// @return 监听的handle
	FGameplayMessageHandle RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback, const UScriptStruct* StructType);

	/// 广播消息的内部实现，便于蓝图支持
	/// @param Channel 消息通道
	/// @param StructType 具体的消息类型
	/// @param MessagePayload 消息数据
	void BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayload);
	
	/** 持有所有 通道-监听者 */
	TMap<FGameplayTag, FChannelListenerList> Listeners;

	/** 标识Handle计数器，用于分配唯一id */
	uint64 HandleCounter = 0;
};

template <typename FMessageStructType, typename Owner>
FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener(FGameplayTag Channel, Owner* OwnerObject,
	void(Owner::* CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
	TWeakObjectPtr<Owner> WeakOwner(OwnerObject);
	auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
	{
		// 检查注册者是否有效
		if (WeakOwner.Get())
		{
			(WeakOwner.Get()->*CallbackFunction)(Channel_, MessagePayload);
		}
	};

	/**
	 * 转换函数，将消息的发起者传入的参数转为符合条件类型并回调
	 * 其中StructType用于提供蓝图支持，便于在蓝图中使用监听回调
	 */
	auto ThunkCallback = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const UScriptStruct* MessageStructType, const void* MessagePayloadData)
	{
		Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
	};

	// 获取消息数据的类型
	const UScriptStruct* MessageStructType = FMessageStructType::StaticStruct();

	// 返回内部实现
	return RegisterListener_Internal(Channel, ThunkCallback, MessageStructType);
}

template <typename FMessageStructType>
void UGameplayMessageSubsystem::BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
	// 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

源文件

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
// Fill out your copyright notice in the Description page of Project Settings.

#include "GameplayMessageSubsystem.h"

DEFINE_LOG_CATEGORY(LogGameplayMessage);

void FGameplayMessageHandle::Unregister()
{
	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

bool UGameplayMessageSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	return true;
}

void UGameplayMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Listeners.Reset();
	Super::Initialize(Collection);
}

void UGameplayMessageSubsystem::Deinitialize()
{
	Listeners.Reset();
	Super::Deinitialize();
}

UGameplayMessageSubsystem* UGameplayMessageSubsystem::Get(const UObject* WorldContext)
{
	if (IsValid(WorldContext);UWorld* World = WorldContext->GetWorld())
	{
		return UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance());
	}
	return nullptr;
}

FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener_Internal(
	FGameplayTag Channel,
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback,
	const UScriptStruct* StructType)
{
	// 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
	Data.HandleId = ++HandleCounter;
	
	// 创建handle并返回
	return FGameplayMessageHandle(this, Channel, Data.HandleId);
}

void UGameplayMessageSubsystem::Unregister(FGameplayMessageHandle& Handle)
{
	if (!Handle.IsValid())
	{
		return;
	}

	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

void UGameplayMessageSubsystem::BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType,
	const void* MessagePayload)
{
	// 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}


展开全文 >>

UE消息系统（上）：无参消息广播

前言

消息系统允许对象之间进行通信而不需要知道对象的具体类型，只需要接受消息的对象完成注册即可接收从各个地方发送来的消息从而执行相关的逻辑。

与UE中的委托类似，但是使用委托在绑定时仍需要知道具体的对象，而消息则不需要，所以使用消息能更进一步完成解耦。

基本的实现方式

可以采取与委托类似的方式，不同的是可以将绑定的信息存储在一个容器中，当消息被发送时就从容器中查找相应的委托并执行逻辑。

定义最基本的结构体

首先在这个容器中存储了一个委托，其次需要一个唯一的标识符，所以相应的应该还有一个ID。

消息的最基本结构体定义完成后，还需要知道消息的具体类型，采用FGameplayTag作为消息类型的标识符。

定义委托：

1
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

所以消息结构体的基本构成为：

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageListenerHandle
{
public:
    FGameplayMessageListenerHandle()
    {

    }

    FMessageDelegate MessageDelegate;
    int64 HandleID;
    FGameplayTag Channel;
};

消息的存储容器

有了消息的基本结构体后，就需要一个容器来存放这些消息。之前定义了FGameplayTag作为消息类型，一个消息同时有一组接收者，因而采取map的形式维护消息类型与接收者之间的映射关系。

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageHandleWarpper
{
public:
    FGameplayMessageHandleWarpper()
    {

    }

    TArray<FGameplayMessageListenerHandle> Events;
};

TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

每个消息的唯一标识ID

使用一个静态成员变量作为标识ID，没当调用注册函数时就为其注册的Handle分配一个HandleID。

消息本身应提供的方法

同时消息本身应该具有合法性判断、解绑、委托执行的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct FGameplayMessageListenerHandle
{
public:
    bool IsValid() const { return HandleID > 0; }
    // 稍后实现
    void Unregister();
protected:
    void Broadcast()
    {
        if(HandleID > 0)
        {
            MessageDelegate.ExecuteIfBound();
        }
    }
};

消息系统的实现

消息系统在整个游戏中明显应该只存在一份，所以采用UE的子系统来实现，同时让消息结构体中持有一份该系统的弱引用：

1
2
3
4
5
6
7
8
9
class UMessageSubsystem:public UGameInstanceSubsystem
{
public:
    bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

    TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

    static TAtomic<int64> HandleID;
};

对于C++的实现

消息的注册

我们提供一个模板方法来完成对消息的注册，为了完成消息的注册，我们需要一些注册的基本信息：注册的消息类型、注册者以及注册的委托函数，所以需要三个基本参数：FGameplayTag、UserObject、Function。

最终提供一个静态方法完成注册：

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
template<typename UserClass>
FGameplayMessageHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* UserObject, FName FunctionName)
{
    if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
                    // 为其分配ID
					MessageHandler.HandleID = ++MessageHanderAlloc;
					// 完成委托的绑定
                    MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					// 确定消息类型
                    MessageHandler.Channel = Channel;
                    // 让该消息持有消息系统
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

消息的执行

在消息执行时只需要传入一个消息类型即可完成消息的发送，同样将其定义为静态方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

消息的解绑

直接对对象持有的消息本身进行解绑，之前我们对消息结构体中定义了Unregister方法，现在只需要实现该方法即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void FGameplayMessageListenerHandle::Unregister()
{
    if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
                // 提供线程安全的移除方法
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	} 
}

对于蓝图实现

蓝图与C++实现最大的区别在于无法直接使用FGameplayMessageHandle这个结构体，在蓝图与C++的交互中，结构体会以值传递的方式传递，即使定义了以引用的方式传递，在蓝图中的结构体进入C++时仍然会拷贝出一个副本，此时无法保证操作的一致性；而类类型在蓝图与C++的交互中是以引用的方式传递，此时可以保证操作的一致性，所以需要对消息结构在做一层类封装。

1
2
3
4
5
6
7
8
9
class UGameplayMessageAction: public UObject
{
public:
    FGameplayMessageListenerHandle ListenerHandler;

    // 用于给蓝图提供注册消息的方法，这也是不选用结构体的另一个原因：蓝图无法调用结构体中的方法
	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

蓝图消息的注册

同样提供静态方法进行注册，不同的是这次不传入函数名而是直接传入一个事件引脚，当发送消息时直接通过蓝图事件来执行，此时便不再需要传入UserObject：

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
UFUNCTION(BlueprintCallable, Category = "Message")
UGameplayMessageAction* K2_RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

蓝图消息的执行与C++消息的执行方式相同，直接调用BroadcastMessage即可。

蓝图消息的解绑

在注册消息时我们使用一个MessageAction接收返回值，并使用它的完成消息解绑：

1
2
3
4
void UGameplayMessageAction::Unregister()
{
    ListenerHandler.Unregister();
}

完整的代码

头文件部分：

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
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

USTRUCT(BlueprintType)
struct FGameplayMessageListenerHandle
{
public:
	friend UMessageSubsystem;

	FGameplayMessageListenerHandle():HandleID(-1)
	{

	}

	FGameplayMessageListenerHandle(UMessageSubsystem* _Subsystem, FGameplayTag _Channel, int64 _HandleID) :Subsystem(_Subsystem), Channel(_Channel), HandleID(_HandleID)
	{

	}

	void Unregister();
	bool IsValid() { return HandleID > 0; }

	FMessageDelegate MessageDelegate;
	TWeakObjectPtr<UMessageSubsystem> Subsystem;
	FGameplayTag Channel;
	int64 HandleID; 
protected:
	void Boardcast();
};

USTRUCT()
struct FMessageHandleWarpper
{
public:
    // 用于结束游戏时清理消息
	void Clear()
	{
		for (FGameplayMessageListenerHandle& Handler : Events)
		{
			Handler.Unregister();
		}
	}

	TArray<FGameplayMessageListenerHandle> Events;
};

UCLASS(BlueprintType)
class UGameplayMessageAction :public UObject
{
public:
	FGameplayMessageListenerHandle ListenerHandler;

	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

/**
 * 
 */
UCLASS()
class UMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	
public:
	bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

	virtual void Initialize(FSubsystemCollectionBase& Collection);

	virtual void Deinitialize();

	template<class UserClass>
	static FGameplayMessageListenerHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static UGameplayMessageAction* K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel);

	static TAtomic<int64> MessageHanderAlloc;

	UPROPERTY()
	TMap<FGameplayTag, FMessageHandleWarpper> Messages;
};

template<class UserClass>
inline FGameplayMessageListenerHandle UMessageSubsystem::RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
					MessageHandler.HandleID = ++MessageHanderAlloc;
					MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					MessageHandler.Channel = Channel;
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

源文件部分：

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

TAtomic<int64> UMessageSubsystem::MessageHanderAlloc = -1;

void UMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	MessageHanderAlloc = 0;
}

void UMessageSubsystem::Deinitialize()
{
	for (auto& Pair : Messages)
	{
		Pair.Value.Clear();
	}

	Messages.Empty();
	MessageHanderAlloc = -1;
}

UGameplayMessageAction* UMessageSubsystem::K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

void UMessageSubsystem::BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Unregister()
{
	if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Boardcast()
{
	if (HandleID > 0)
	{
		MessageDelegate.ExecuteIfBound();
	}
}

void UGameplayMessageAction::Unregister()
{
	ListenerHandler.Unregister();
}

测试

使用默认的主角类进行测试，在C++中提供以下函数并绑定一些按键进行：

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
   FGameplayMessageListenerHandle TestListenerHandler;

UFUNCTION(BlueprintCallable)
void TestAddListener()
   {
       TestListenerHandler = UETMessageSubsystem::RegisterGameplayMessageListener<AMainCharacter>(this, YourTestTag, this, "TestMessageFunc");
   }

UFUNCTION(BlueprintCallable)
void TestBroadcastListener()
   {      
    UETMessageSubsystem::BroadcastMessage(this, YourTestTag);
   }

UFUNCTION(BlueprintCallable)
void TestUnregisterListener()
   {
       TestListenerHandler.Unregister();
   }

UFUNCTION()
void TestMessageFunc()
   {
   	UE_LOG(LogTemp,Warning,TEXT("TestMessageFunc"));    
   }

在蓝图中则直接可以搜索K2_RegisterGameplayMessageListerner和BroadcastMessage进行绑定和广播，直接调用Action的Unregister()函数即可取消监听。

后续

后续会增加消息的参数传递功能，使其能够携带任意数量的参数进行传递。

展开全文 >>

增强输入与GAS

前言

前文介绍了GAS与增强输入的基本使用，本文将介绍如何将输入与GA进行绑定来完成解耦和扩展。

前置准备

绑定方法

技能与输入的绑定方法，查看BindAction的函数声明，可以看到在后面有一次额外的参数包，在绑定时可以将Tag做为参数在绑定时传入：

1
BindAction(IA, TriggerEvent, UserObject, BindFunc, Tag);

在触发影响的IA时就可以获取到对应的Tag:

1
2
3
4
void BindFunc(FGameplayTag Tag)
{
    //...
}

在初始化时可以通过将Tag和GA进行绑定，在触发输入时通过Tag来查找对应的GA。

技能的初始化

初始化时需要将GA和Tag进行绑定，所以考虑将对应关系放入一张数据表中，在玩家进行初始化时读入这张表完成绑定。

其基本的数据结构应包含一个GA和一个TagContainer，一个技能可能会有几种触发方式，所以提供Container来存储多个Tag。

1
2
3
4
5
6
7
8
9
10
11
12
USTRUCT(BlueprintType)
struct FAbilityAction
{
    GENERATED_BODY()

    // 使用Ability的CDO进行初始化
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSubclassOf<FGameplayAbility> Ability;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    FGameplayTagContainer Tags;
};

同时提供基本的表结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UCLASS()
class PROJECTE_API UAbilityAsset : public UDataAsset
{
    GENERATED_BODY()

public:
    UAbilityAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TArray<FAbilityAction> Abilities;
};

输入的初始化

同样使用数据表来存储输入关系，基本应该包含一个Tag和一个IA，其中Tag用于查找对应的GA。

所以输入的基本数据结构为：

1
2
3
4
5
6
7
8
9
10
11
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;
};

输入的表结构，其中提供查找方法和一个映射上下文：

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
UCLASS()
class PROJECTE_API UInputAsset : public UDataAsset
{
    GENERATED_BODY()
public:
    UInputAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    const UInputAction* FindInputActionByTag(FGameplayTag Tag) const
    {
        UInputAction* InputAction = nullptr;
        if(Tag.IsValid())
        {
            for(const FInputAction& IA: Actions)
            {
                if(IA.Action.Get() && IA.Tag == Tag)
                {
                    InputAction = IA.Action;
                    break;
                }
            }
        }

        return InputAction;
    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TArray<FInputAction> Actions;

    UPROPERTY(EdtiAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputMappingContext> InputMappingContext;
};

实现输入与GA的绑定

准备好两张表后就可以准备完成初始化与绑定了！

GA的初始化

在GameplayAbility的实例GameplayAbilitySpec中包含一个DynamicAbilityTag的TagContainer，使用其来查找对应的GA。

绑定函数：

1
2
3
4
5
6
7
8
9
10
void InitializeAbility()
{
    // 假设已经读取到了UAbilityAsset--->AbilityAsset
    for(FAbilityAction& GameplayAbilityAction: AbilityAsset->Abilities)
    {
        FGameplayAbilitySpec GameplayAbilitySpec = FGameplayAbilitySpec(GameplayAbilityAction.Ability);
        GameplayAbilitySpec.DynamicAbilityTags = GameplayAbilityAction.Tags;
        GiveAbility(GameplayAbilitySpec);
    }
}

输入的初始化

在绑定中，将输入分为两种，一种为GA输入；另一种为本地输入，包括玩家的基本移动等，所以在绑定时要对其进行区分，所以输入表中需要对结构进行改进，增加一个用于区分是否为技能的bool值；此外技能同样有长按与单次触发的类型，所以再增加一个bool值进行区分。

改进后的结构应为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bAbilityInput;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bTriggerEvent;
};

为了确保绑定可以通用，考虑将其作为增强输入组件的模板成员函数。对于本地输入的初始化只要从输入表中拿到对应的IA完成绑定即可；对于技能输入则需要增加一个扩展参数包。

所以玩家的本地输入绑定函数应为：

1
2
3
4
5
6
7
8
9
template<class UserClass, typename FuncType>
void BindNativeAction(const UInputAsset* InputAsset, const FGameplayTag& InputTag, ETriggerEvent TriggerEvent, UserClass* UserObject, FuncType InputFunc)
{
    check(InputAsset);
    if(const UInputAction* IA = InputAsset->FindInputActionByTag(InputTag))
    {
        BindAction(IA, TriggerEvent, UserObject, InputFunc);
    }
}

绑定技能的输入为：

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
template<class UserClass, typename Press, typename Release>
void BindAbilityAction(const UInputAsset* InputAsset, UserClass* UserObject, Press PressFunc, Relase ReleaseFunc, TArray<uint32>& BindHandles)
{
    check(InputAsset);
    for(const FInputAction& IA: InputAsset->Actions)
    {
        if(IA.Action.Get() && IA.bAbilityInput)
        {
            if(PressFunc)
            {
                if(IA.bTriggerEvent)
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Triggered, PressFunc, PressFunc, IA.Tag).GetHandle());
                }
                else
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Started, PressFunc, ReleaseFunc, IA.Tag).GetHandle());
                }
            }
            
            if(ReleaseFunc)
            {
                BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Completed, ReleaseFUnc, IA.Tag).GetHandle());
            }
        }
    }
}

触发IA与GA

对于玩家的本地输入，可以直接调用BindNativeAction进行绑定，有多少绑定多少，对于GA的绑定则只需要一次。

当IA触发以后则需要根据对应的Tag去寻找对应的GA，提供两个函数用来处理技能输入的按下与抬起：

在GAS中的处理

首先在ASC中提供两个函数用来处理技能输入的按下与抬起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void ProcessAbilityPressInput(FGameplayTag InputTag)
{
    if(FGameplayAbilitySpec& AbilitySpec:GetActivatableAbilities())
    {
        if(AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpec.Ability->ActivateAbility(AbilitySpec);
        }
    }
}

void ProcessAbilityReleaseInput(FGameplayTag InputTag)
{
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
        if (AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpecInputRelease(AbilitySpec);
        }
    }
}

在输入组件中的处理

随后可以在玩家的输入组件中调用这两个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void OnAbilityPressd(FGameplayTag InputTag)
{
    // 认为已经提供了相应的获取ASC的方法
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityPressInput(InputTag);
    }
}

void OnAbilityReleased(FGameplayTag InputTag)
{
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityReleaseInput(InputTag);
    }
}

最终绑定

最终在增强输入中提供初始化函数SetPlayerInput:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void SetPlayerInput()
{
    ACharacter* OwnerCharacter = Cast<ACharacter>(GetOwner());
    if(!IsValid(OwnerCharacter))
    {
        return;
    }

    if (APlayerController* LocalPC = Cast<APlayerController>(OwnerCharacter->Controller))
    {
        if (UEnhancedInputLocalPlayerSubsystem* LPSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LocalPC->GetLocalPlayer()))
        {
            if (InputAsset->InputMappingContext.Get())
            {
                LPSubsystem->ClearAllMappings();
                LPSubsystem->AddMappingContext(InputAsset->InputMappingContext,0);
            }
        }

        //BindNativeAction完成本地输入绑定

        BindAbilityAction(InputAsset, this, &ThisClass::OnAbilityPressd, &ThisClass::OnAbilityReleased, AbilityInputHandles);
    }
}

最终完成了IA与GA的绑定

管理GameplayTag

参考lyra工程使用namespace作为Tag管理，同样我们也提供一个名为GameplayTags的namespace：

1
2
3
4
5
6
7
8
namespace GameplayTags
{
    // 在头文件中这样声明
	PROJECTET_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(CharacterInputTag_Move);

    // 在cpp文件中这样定义，可以编辑器中外部使用
	UE_DEFINE_GAMEPLAY_TAG_COMMENT(CharacterInputTag_Move, "CharacterInput.Move", "Character Movement Input Tag");
}

使用ini管理资产文件

以上是直接将资产挂载在玩家身上，并不方便管理，所以可以考虑使用全局配置项来进行管理。

用UDeveloperSettings作为父类创建名为ProjectAssetSettings的子类，注意需要在uproject文件中新加一条”DeveloperSettings”的配置。

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
UCLASS(config = Game, defaultconfig, meta = (DisplayName = "Game Asset Config"))
class PROJECTET_API UProjectAssetSettings : public UDeveloperSettings
{
	GENERATED_BODY()
public:
	virtual FName GetCategoryName() const
    {
        return FName{ TEXT("Game Asset Config") };
    }

	virtual FName GetContainerName() const
    {
        return FName{ TEXT("Project") };
    }

    // 用于获取读取配置的方法，一般在游戏运行时不修改游戏配置，所以返回const
	UFUNCTION(BlueprintPure)
	static const UProjectAssetSettings* GetProjectAssetSettings()
    {
        const UProjectAssetSettings* Settings = GetDefault<UProjectAssetSettings>();
        return Settings;
    }

    //如果想要修改的话可以使用GetMutableDefault<UProjectAssetSettings>()来返回一个可修改的配置文件

    // 将输入资产与技能资产迁至这里，这里一般不会使用硬引用，ini文件加载时机很早，使用硬引用会导致读入的类为空
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TSoftObjectPtr<UInputAsset> InputAsset;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSoftObjectPtr<UAbilitAsset> AbilityAsset;
};

总结

通过以上步骤，我们将输入与技能进行了绑定，并且通过namespace管理Tag和ini文件管理了输入与技能的资产。

展开全文 >>

常用的排序算法

总结常用的排序算法

主要包括冒泡排序、堆排序、归并排序、快速排序四个。

冒泡排序

冒泡排序是一种很简单的原地排序算法，在每一轮遍历都将最大的元素（或者最小）放在数组的末尾
过程为：

  1. 比较相邻的元素，如果第一个比第二个大，就交换它们两个
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
  3. 针对所有的元素重复以上的步骤，除了最后一个
  4. 重复步骤1~3，直到排序完成
    平均时间复杂度：O(n^2)
1
2
3
4
5
6
7
8
9
10
11
void BubbleSort(vector<int>& nums)
{
    int n = nums.size();
    for(int i = 0; i < n ;i++){
        for(int j = 0; j < n - i - 1; j++){
            if(nums[j] > nums[j + 1]){
                swap(nums[j], nums[j + 1]);
            }
        }
    }
}

堆排序

堆排序是一种原地排序算法，依赖于堆实现
过程为：

  1. 将原数组调整为大顶堆（或小顶堆）
  2. 交换堆顶与数组末尾元素，再将剩余元素调整为大顶堆
  3. 不断重复步骤2直到数组有序
    每次调整堆的时间复杂度位O(logn)，一共需要调整n次，总时间复杂度位O(nlogn)
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
void Heapfiy(vector<int>& nums,int n,int i)
{
    int largest=i;
    int left=2*i+1;
    int right=2*i+2;
    while (true) {
        if (left < n && nums[left] > nums[largest]) {
            largest = left;
        }

        if (right < n && nums[right] > nums[largest]) {
            largest = right;
        }

        if (largest == i) {
            break;
        }

        swap(nums[i], nums[largest]);
        i = largest;
        left = 2 * i + 1;
        right = 2 * i + 2;
    }
}

void HeapSort(vector<int>& nums)
{
    int n=nums.size();
    // 构造大顶堆
    // 从最后一个非叶子节点开始
    for(int i=n/2-1;i>=0;i--){
        Heapfiy(nums,n,i);
    }

    // 交换堆顶元素并调整堆
    for(int i=n-1;i>=0;i--){
        swap(nums[0],nums[i]);
        Heapfiy(nums,i,0);
    }   
}

归并排序

归并依赖于递归操作
过程为：

  1. 将原数组分为左右两个子数组
  2. 将数组递归分为左右两个子数组
  3. 将左右两个子数组合并有有序数组
    评价时间复杂度为O(nlogn)
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
void Merge(vector<int>& nums,int left,int mid,int right)
{
    vector<int> temp(right-left+1);
    int i=left;
    int j=right;
    int k=0;
    while(i<=left && j<=right){
        // 将两个数组合并为一个有序数组
        if(nums[i]<=nums[j]){
            temp[k]=nums[i];
            i++;
        }else{
            temp[k]=nums[j];
            j++;
        }
        k++;
    }

    while(i<=left){
        temp[k++]=nums[i++];
    }

    while(j<=right){
        temp[k++]=nums[j++];
    }

    for(int t=0;t<k;t++){
        nums[left+t]=temp[t];
    }
}

void MergeSort(vector<int>& nums,int left,int right)
{
    if(left>=right){
        return;
    }
    int mid=left+(right-left)/2;
    MergeSort(nums,left,mid);
    MergeSort(nums,mid+1,right);
    Merge(nums,left,mid,right);
}

快速排序

快排是最常用的排序算法之一
过程为：

  1. 选择一个基准值（一般为第一个或最后一个），将原数组分为两个数组
  2. 比基准值小的元素放在基准值左边，比基准值大的元素放在右边
  3. 递归调用左右两个子数组，重复上述步骤
    平均时间复杂度为O(nlogn)
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
int partition(vector<int>& nums,int left,int right)
{
    int base=nums[left];
    while(left<right){
        while(left<right && nums[right]>=base){
            right--;
        }
        nums[left]=nums[right];
        while(left<right && nums[left]<=base){
            left++;
        }
        nums[right]=nums[left];
    }
    nums[left]=base;
    return left;    
}


void QuickSort(vector<int>& nums,int left,int right)
{
    if(left<right){
        int pos=partition(nums,left,right);
        QuickSort(nums,left,pos-1);
        QuickSort(nums,pos+1,right);       
    }
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++