Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Answers 技术讨论 › 技术讨论 Technology Answers › Unreal源码学习（二）用户输入
返回列表 发新帖
查看: 456|回复: 0

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

[复制链接]
发表于 2020-11-25 09:08 | 显示全部楼层 |阅读模式
本篇文章主要明确从用户触发输入到引擎触发指定事件的主要逻辑。


为了跨平台，在虚幻中定义了一个通用的事件处理接口：
  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 状态集进行数据对比，并触发具体的输入事件。
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-9-19 11:54 , Processed in 0.144319 second(s), 23 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表