Unreal源码学习（二）用户输入

TopMark

本篇文章主要明确从用户触发输入到引擎触发指定事件的主要逻辑。


为了跨平台，在虚幻中定义了一个通用的事件处理接口：

1. class FGenericApplicationMessageHandler
2. {
3. public:
4.         ...
5.         
6.         virtual bool OnKeyChar( const TCHAR Character, const bool IsRepeat )
7.         virtual bool OnKeyDown( const int32 KeyCode, const uint32 CharacterCode, const bool IsRepeat )
8.         virtual bool OnKeyUp( const int32 KeyCode, const uint32 CharacterCode, const bool IsRepeat )
9.         virtual void OnInputLanguageChanged()
10.         virtual bool OnMouseDown( const TSharedPtr< FGenericWindow >& Window, const EMouseButtons::Type Button )
12.         ...
13. };

复制代码

篇幅原因就不全贴出来了。
在这当中定义了键盘，鼠标，屏幕触摸，Gamepad等一系列的事件。

我们以键盘输入为例：
在引擎初始化时会为我们创建 FSceneViewport 和 UGameViewportClient：

1. ..void UGameEngine::Init(IEngineLoop* InEngineLoop)
2. {
3.         ...
5.         // Initialize the viewport client.
6.         UGameViewportClient* ViewportClient = NULL;
7.         if(GIsClient)
8.         {
9.                 ViewportClient = NewObject<UGameViewportClient>(this, GameViewportClientClass);
10.                 ViewportClient->Init(*GameInstance->GetWorldContext(), GameInstance);
11.                 GameViewport = ViewportClient;
12.                 GameInstance->GetWorldContext()->GameViewport = ViewportClient;
13.         }
15.         LastTimeLogsFlushed = FPlatformTime::Seconds();
17.         // Attach the viewport client to a new viewport.
18.         if(ViewportClient)
19.         {
20.                 // This must be created before any gameplay code adds widgets
21.                 bool bWindowAlreadyExists = GameViewportWindow.IsValid();
22.                 if (!bWindowAlreadyExists)
23.                 {
24.                         UE_LOG(LogEngine, Log, TEXT("GameWindow did not exist.  Was created"));
25.                         GameViewportWindow = CreateGameWindow();
26.                 }
28.                 CreateGameViewport( ViewportClient );
30.                 if( !bWindowAlreadyExists )
31.                 {
32.                         SwitchGameWindowToUseGameViewport();
33.                 }
35.                 FString Error;
36.                 if(ViewportClient->SetupInitialLocalPlayer(Error) == NULL)
37.                 {
38.                         UE_LOG(LogEngine, Fatal,TEXT("%s"),*Error);
39.                 }
41.                 UGameViewportClient::OnViewportCreated().Broadcast();
42.         }
44.         UE_LOG(LogInit, Display, TEXT("Game Engine Initialized.") );
46.         // for IsInitialized()
47.         bIsInitialized = true;
48. }

复制代码

当我们按下键盘的某个按键，会触发 FSceneViewport 的 OnKeyDown 的代码，这里面会把我们输入事件经由 UGameViewportClient 和 PlayerController 的 InputKey 方法最后传递到  UplayerInput::InputKey 方法中：

1. bool UPlayerInput::InputKey(FKey Key, EInputEvent Event, float AmountDepressed, bool bGamepad)
2. {
3.         // first event associated with this key, add it to the map
4.         FKeyState& KeyState = KeyStateMap.FindOrAdd(Key);
5.         UWorld* World = GetWorld();
6.         check(World);
8.         switch(Event)
9.         {
10.         case IE_Pressed:
11.         case IE_Repeat:
12.                 KeyState.RawValueAccumulator.X = AmountDepressed;
13.                 KeyState.EventAccumulator[Event].Add(++EventCount);
14.                 if (KeyState.bDownPrevious == false)
15.                 {
16.                         // check for doubleclick
17.                         // note, a tripleclick will currently count as a 2nd double click.
18.                         const float WorldRealTimeSeconds = World->GetRealTimeSeconds();
19.                         if ((WorldRealTimeSeconds - KeyState.LastUpDownTransitionTime) < GetDefault<UInputSettings>()->DoubleClickTime)
20.                         {
21.                                 KeyState.EventAccumulator[IE_DoubleClick].Add(++EventCount);
22.                         }
24.                         // just went down
25.                         KeyState.LastUpDownTransitionTime = WorldRealTimeSeconds;
26.                 }
27.                 break;
28.         case IE_Released:
29.                 KeyState.RawValueAccumulator.X = 0.f;
30.                 KeyState.EventAccumulator[IE_Released].Add(++EventCount);
31.                 break;
32.         case IE_DoubleClick:
33.                 KeyState.RawValueAccumulator.X = AmountDepressed;
34.                 KeyState.EventAccumulator[IE_Pressed].Add(++EventCount);
35.                 KeyState.EventAccumulator[IE_DoubleClick].Add(++EventCount);
36.                 break;
37.         }
38.         ...
39.         return true;
40. }

复制代码

可以看到，这里面并不会直接调用具体事件，而是维护了一个 KeyStateMap 的状态集。
具体的触发事件的逻辑是在 PlayerInput::ProcessInputStack 中每帧处理:

1. void UPlayerInput::ProcessInputStack(const TArray<UInputComponent*>& InputComponentStack, const float DeltaTime, const bool bGamePaused)
2. {
3.         ...
5.         static TArray<FAxisDelegateDetails> AxisDelegates;
6.         static TArray<FVectorAxisDelegateDetails> VectorAxisDelegates;
7.         static TArray<FDelegateDispatchDetails> NonAxisDelegates;
8.         static TArray<FKey> KeysToConsume;
9.         static TArray<FDelegateDispatchDetails> FoundChords;
10.         static TArray<TPair<FKey, FKeyState*>> KeysWithEvents;
11.         static TArray<TSharedPtr<FInputActionBinding>> PotentialActions;
13.         // must be called non-recursively and on the game thread
14.         check(IsInGameThread() && !AxisDelegates.Num() && !VectorAxisDelegates.Num() && !NonAxisDelegates.Num() && !KeysToConsume.Num() && !FoundChords.Num() && !EventIndices.Num() && !KeysWithEvents.Num() && !PotentialActions.Num());
16.         // @todo, if input is coming in asynchronously, we should buffer anything that comes in during playerinput() and not include it
17.         // in this processing batch
19.         APlayerController* PlayerController = GetOuterAPlayerController();
21.         PlayerController->PreProcessInput(DeltaTime, bGamePaused);
23.         // copy data from accumulators to the real values
24.         for (TMap<FKey,FKeyState>::TIterator It(KeyStateMap); It; ++It)
25.         {
26.                 bool bKeyHasEvents = false;
27.                 FKeyState* const KeyState = &It.Value();
28.                 const FKey& Key = It.Key();
30.                 for (uint8 EventIndex = 0; EventIndex < IE_MAX; ++EventIndex)
31.                 {
32.                         KeyState->EventCounts[EventIndex].Reset();
33.                         Exchange(KeyState->EventCounts[EventIndex], KeyState->EventAccumulator[EventIndex]);
35.                         if (!bKeyHasEvents && KeyState->EventCounts[EventIndex].Num() > 0)
36.                         {
37.                                 KeysWithEvents.Emplace(Key, KeyState);
38.                                 bKeyHasEvents = true;
39.                         }
40.                 }
42.                 if ( (KeyState->SampleCountAccumulator > 0) || Key.ShouldUpdateAxisWithoutSamples() )
43.                 {
44.                         if (KeyState->PairSampledAxes)
45.                         {
46.                                 // Paired keys sample only the axes that have changed, leaving unaltered axes in their previous state
47.                                 for (int32 Axis = 0; Axis < 3; ++Axis)
48.                                 {
49.                                         if (KeyState->PairSampledAxes & (1 << Axis))
50.                                         {
51.                                                 KeyState->RawValue[Axis] = KeyState->RawValueAccumulator[Axis];
52.                                         }
53.                                 }
54.                         }
55.                         else
56.                         {
57.                                 // Unpaired keys just take the whole accumulator
58.                                 KeyState->RawValue = KeyState->RawValueAccumulator;
59.                         }
61.                         // if we had no samples, we'll assume the state hasn't changed
62.                         // except for some axes, where no samples means the mouse stopped moving
63.                         if (KeyState->SampleCountAccumulator == 0)
64.                         {
65.                                 KeyState->EventCounts[IE_Released].Add(++EventCount);
66.                                 if (!bKeyHasEvents)
67.                                 {
68.                                         KeysWithEvents.Emplace(Key, KeyState);
69.                                         bKeyHasEvents = true;
70.                                 }
71.                         }
72.                 }
73.                 ...
74.         }
75.         EventCount = 0;
77.         struct FDelegateDispatchDetailsSorter
78.         {
79.                 bool operator()( const FDelegateDispatchDetails& A, const FDelegateDispatchDetails& B ) const
80.                 {
81.                         return (A.EventIndex == B.EventIndex ? A.FoundIndex < B.FoundIndex : A.EventIndex < B.EventIndex);
82.                 }
83.         };
85.         int32 StackIndex = InputComponentStack.Num()-1;
87.         // Walk the stack, top to bottom
88.         for ( ; StackIndex >= 0; --StackIndex)
89.         {
90.                 UInputComponent* const IC = InputComponentStack[StackIndex];
91.                 if (IC)
92.                 {
93.                         check(!KeysToConsume.Num() && !FoundChords.Num() && !EventIndices.Num() && !PotentialActions.Num());
95.                         IC->ConditionalBuildKeyMap(this);
97.                         for (const TPair<FKey,FKeyState*>& KeyWithEvent : KeysWithEvents)
98.                         {
99.                                 if (!KeyWithEvent.Value->bConsumed)
100.                                 {
101.                                         FGetActionsBoundToKey::Get(IC, this, KeyWithEvent.Key, PotentialActions);
102.                                 }
103.                         }
105.                         for (const TSharedPtr<FInputActionBinding>& ActionBinding : PotentialActions)
106.                         {
107.                                 GetChordsForAction(*ActionBinding.Get(), bGamePaused, FoundChords, KeysToConsume);
108.                         }
110.                         PotentialActions.Reset();
112.                         for (const FInputKeyBinding& KeyBinding : IC->KeyBindings)
113.                         {
114.                                 GetChordForKey(KeyBinding, bGamePaused, FoundChords, KeysToConsume);
115.                         }
117.                         FoundChords.Sort(FDelegateDispatchDetailsSorter());
119.                         ...
121.                 }
122.         }
124.        
126.         // Dispatch the delegates in the order they occurred
127.         NonAxisDelegates.Sort(FDelegateDispatchDetailsSorter());
128.         for (const FDelegateDispatchDetails& Details : NonAxisDelegates)
129.         {
130.                 if (Details.ActionDelegate.IsBound())
131.                 {
132.                         Details.ActionDelegate.Execute(Details.Chord.Key);
133.                 }
134.                 else if (Details.TouchDelegate.IsBound())
135.                 {
136.                         Details.TouchDelegate.Execute(Details.FingerIndex, Details.TouchLocation);
137.                 }
138.                 else if (Details.GestureDelegate.IsBound())
139.                 {
140.                         Details.GestureDelegate.Execute(Details.GestureValue);
141.                 }
142.         }
143.         ...
145.         PlayerController->PostProcessInput(DeltaTime, bGamePaused);
147.         FinishProcessingPlayerInput();
148.         AxisDelegates.Reset();
149.         VectorAxisDelegates.Reset();
150.         NonAxisDelegates.Reset();
151.         TouchEventLocations.Reset();
152.         KeysWithEvents.Reset();
153. }

复制代码

参与的核心对象就是前文提到的 KeyStateMap 和 InputComponent。其中 InputComponent 保存着我们具体的输入配置。经过一系列的数据过滤操作，选出要触发的具体事件，在方法的最后统一触发。
总结

引擎自己定义了一套平台无关的系统信息回调接口。我们通过输入设备触发的输入事件会由此进入引擎并将触发状态维护在 PlayerInput 的 KeyStateMap 状态集中。引擎每帧依据 InputComponent 的输入绑定信息与 KeyStateMap 状态集进行数据对比，并触发具体的输入事件。