bool UDozerGameViewportClient::InputKey(FViewport* Viewport,
int32 ControllerId,
FKey Key,
EInputEvent Event,
float AmountDepressed,
bool bGamepad){
Super::InputKey(Viewport, ControllerId, Key, Event, AmountDepressed, bGamepad);
if (ControllerId == 0){
if (Key.GetDisplayName().ToString().Equals(TEXT("Up"))){
Super::InputKey(Viewport, 1, FKey("W"), Event, AmountDepressed, bGamepad);
}
else if (Key.GetDisplayName().ToString().Equals(TEXT("Down"))){
Super::InputKey(Viewport, 1, FKey("S"), Event, AmountDepressed, bGamepad);
}
else if (Key.GetDisplayName().ToString().Equals(TEXT("Left"))){
Super::InputKey(Viewport, 1, FKey("A"), Event, AmountDepressed, bGamepad);
}
else if (Key.GetDisplayName().ToString().Equals(TEXT("Right"))){
Super::InputKey(Viewport, 1, FKey("D"), Event, AmountDepressed, bGamepad);
}
}
return true;
}
FReply FSceneViewport::OnKeyDown( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent )
{
// Start a new reply state
CurrentReplyState = FReply::Handled();
FKey Key = InKeyEvent.GetKey();
KeyStateMap.Add( Key, true );
//@todo Slate Viewports: FWindowsViewport checks for Alt+Enter or F11 and toggles fullscreen. Unknown if fullscreen via this method will be needed for slate viewports.
if( ViewportClient && GetSizeXY() != FIntPoint::ZeroValue )
{
// Switch to the viewport clients world before processing input
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
if (!ViewportClient->InputKey(this, InKeyEvent.GetUserIndex(), Key, InKeyEvent.IsRepeat() ? IE_Repeat : IE_Pressed, 1.0f, Key.IsGamepadKey()))
{
CurrentReplyState = FReply::Unhandled();
}
}
return CurrentReplyState;
}
FReply FSceneViewport::OnKeyUp( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent )
{
// Start a new reply state
CurrentReplyState = FReply::Handled();
FKey Key = InKeyEvent.GetKey();
KeyStateMap.Add( Key, false );
if( ViewportClient && GetSizeXY() != FIntPoint::ZeroValue )
{
// Switch to the viewport clients world before processing input
FScopedConditionalWorldSwitcher WorldSwitcher( ViewportClient );
if (!ViewportClient->InputKey(this, InKeyEvent.GetUserIndex(), Key, IE_Released, 1.0f, Key.IsGamepadKey()))
{
CurrentReplyState = FReply::Unhandled();
}
}
return CurrentReplyState;
}
FReply FSceneViewport::OnAnalogValueChanged(const FGeometry& MyGeometry, const FAnalogInputEvent& InAnalogInputEvent)
{
// Start a new reply state
CurrentReplyState = FReply::Handled();
FKey Key = InAnalogInputEvent.GetKey();
KeyStateMap.Add(Key, true);
if (ViewportClient)
{
// Switch to the viewport clients world before processing input
FScopedConditionalWorldSwitcher WorldSwitcher(ViewportClient);
if (!ViewportClient->InputAxis(this, InAnalogInputEvent.GetUserIndex(), Key, Key == EKeys::Gamepad_RightY ? -InAnalogInputEvent.GetAnalogValue() : InAnalogInputEvent.GetAnalogValue(), FApp::GetDeltaTime(), 1, Key.IsGamepadKey()))
{
CurrentReplyState = FReply::Unhandled();
}
}
return CurrentReplyState;
}
bool UBomberManViewportClient::InputKey(FViewport * Viewport, int32 ControllerId, FKey Key, EInputEvent EventType, float AmountDepressed, bool bGamepad)
{
if (IgnoreInput() || bGamepad || Key.IsMouseButton())
{
return Super::InputKey(Viewport, ControllerId, Key, EventType, AmountDepressed, bGamepad);
}
else
{
// Propagate keyboard events to all players
UEngine* const Engine = GetOuterUEngine();
int32 const NumPlayers = Engine ? Engine->GetNumGamePlayers(this) : 0;
bool bRetVal = false;
for (int32 i = 0; i < NumPlayers; i++)
{
bRetVal = Super::InputKey(Viewport, i, Key, EventType, AmountDepressed, bGamepad) || bRetVal;
}
return bRetVal;
}
}
bool UBomberManViewportClient::InputAxis(FViewport* Viewport, int32 ControllerId, FKey Key, float Delta, float DeltaTime, int32 NumSamples, bool bGamepad)
{
if (IgnoreInput() || bGamepad || Key.IsMouseButton())
{
return Super::InputAxis(Viewport, ControllerId, Key, Delta, DeltaTime, NumSamples, bGamepad);
}
else
{
// Propagate axis events to all players
UEngine* const Engine = GetOuterUEngine();
int32 const NumPlayers = Engine ? Engine->GetNumGamePlayers(this) : 0;
bool bRetVal = false;
for (int32 i = 0; i < NumPlayers; i++)
{
bRetVal = Super::InputAxis(Viewport, i, Key, Delta, DeltaTime, NumSamples, bGamepad) || bRetVal;
}
return bRetVal;
}
}
void SFlareKeyBind::SetKey(FKey NewKey, bool bCanReset, bool bNotify)
{
if (Key.IsValid())
{
FKey CurrentKey = *Key;
if (NewKey == *Key && bCanReset)
{
NewKey = FKey();
}
*Key = NewKey;
KeyText->SetText(NewKey == FKey() ? FString() : NewKey.ToString());
bWaitingForKey = false;
FSlateApplication::Get().GetPlatformApplication().Get()->Cursor->Show(true);
FSlateApplication::Get().ClearKeyboardFocus(EKeyboardFocusCause::SetDirectly);
if (bNotify)
{
OnKeyBindingChanged.ExecuteIfBound( CurrentKey , NewKey );
}
}
}
FText UKismetInputLibrary::Key_GetDisplayName(const FKey& Key)
{
return Key.GetDisplayName();
}
bool UKismetInputLibrary::Key_IsModifierKey(const FKey& Key)
{
return Key.IsModifierKey();
}
void FCEFWebBrowserWindow::PopulateCefKeyEvent(const FKeyEvent& InKeyEvent, CefKeyEvent& OutKeyEvent)
{
#if PLATFORM_MAC
OutKeyEvent.native_key_code = InKeyEvent.GetKeyCode();
FKey Key = InKeyEvent.GetKey();
if (Key == EKeys::BackSpace)
{
OutKeyEvent.unmodified_character = kBackspaceCharCode;
}
else if (Key == EKeys::Tab)
{
OutKeyEvent.unmodified_character = kTabCharCode;
}
else if (Key == EKeys::Enter)
{
OutKeyEvent.unmodified_character = kReturnCharCode;
}
else if (Key == EKeys::Pause)
{
OutKeyEvent.unmodified_character = NSPauseFunctionKey;
}
else if (Key == EKeys::Escape)
{
OutKeyEvent.unmodified_character = kEscapeCharCode;
}
else if (Key == EKeys::PageUp)
{
OutKeyEvent.unmodified_character = NSPageUpFunctionKey;
}
else if (Key == EKeys::PageDown)
{
OutKeyEvent.unmodified_character = NSPageDownFunctionKey;
}
else if (Key == EKeys::End)
{
OutKeyEvent.unmodified_character = NSEndFunctionKey;
}
else if (Key == EKeys::Home)
{
OutKeyEvent.unmodified_character = NSHomeFunctionKey;
}
else if (Key == EKeys::Left)
{
OutKeyEvent.unmodified_character = NSLeftArrowFunctionKey;
}
else if (Key == EKeys::Up)
{
OutKeyEvent.unmodified_character = NSUpArrowFunctionKey;
}
else if (Key == EKeys::Right)
{
OutKeyEvent.unmodified_character = NSRightArrowFunctionKey;
}
else if (Key == EKeys::Down)
{
OutKeyEvent.unmodified_character = NSDownArrowFunctionKey;
}
else if (Key == EKeys::Insert)
{
OutKeyEvent.unmodified_character = NSInsertFunctionKey;
}
else if (Key == EKeys::Delete)
{
OutKeyEvent.unmodified_character = kDeleteCharCode;
}
else if (Key == EKeys::F1)
{
OutKeyEvent.unmodified_character = NSF1FunctionKey;
}
else if (Key == EKeys::F2)
{
OutKeyEvent.unmodified_character = NSF2FunctionKey;
}
else if (Key == EKeys::F3)
{
OutKeyEvent.unmodified_character = NSF3FunctionKey;
}
else if (Key == EKeys::F4)
{
OutKeyEvent.unmodified_character = NSF4FunctionKey;
}
else if (Key == EKeys::F5)
{
OutKeyEvent.unmodified_character = NSF5FunctionKey;
}
else if (Key == EKeys::F6)
{
OutKeyEvent.unmodified_character = NSF6FunctionKey;
}
else if (Key == EKeys::F7)
{
OutKeyEvent.unmodified_character = NSF7FunctionKey;
}
else if (Key == EKeys::F8)
{
OutKeyEvent.unmodified_character = NSF8FunctionKey;
}
else if (Key == EKeys::F9)
{
OutKeyEvent.unmodified_character = NSF9FunctionKey;
}
else if (Key == EKeys::F10)
{
OutKeyEvent.unmodified_character = NSF10FunctionKey;
}
else if (Key == EKeys::F11)
{
OutKeyEvent.unmodified_character = NSF11FunctionKey;
}
else if (Key == EKeys::F12)
{
OutKeyEvent.unmodified_character = NSF12FunctionKey;
}
else if (Key == EKeys::CapsLock)
{
OutKeyEvent.unmodified_character = 0;
OutKeyEvent.native_key_code = kVK_CapsLock;
}
else if (Key.IsModifierKey())
{
// Setting both unmodified_character and character to 0 tells CEF that it needs to generate a NSFlagsChanged event instead of NSKeyDown/Up
OutKeyEvent.unmodified_character = 0;
// CEF expects modifier key codes as one of the Carbon kVK_* key codes.
if (Key == EKeys::LeftCommand)
{
OutKeyEvent.native_key_code = kVK_Command;
}
else if (Key == EKeys::LeftShift)
{
OutKeyEvent.native_key_code = kVK_Shift;
}
else if (Key == EKeys::LeftAlt)
{
OutKeyEvent.native_key_code = kVK_Option;
}
else if (Key == EKeys::LeftControl)
{
OutKeyEvent.native_key_code = kVK_Control;
}
else if (Key == EKeys::RightCommand)
{
// There isn't a separate code for the right hand command key defined, but CEF seems to use the unused value before the left command keycode
OutKeyEvent.native_key_code = kVK_Command-1;
}
else if (Key == EKeys::RightShift)
{
OutKeyEvent.native_key_code = kVK_RightShift;
}
else if (Key == EKeys::RightAlt)
{
OutKeyEvent.native_key_code = kVK_RightOption;
}
else if (Key == EKeys::RightControl)
{
OutKeyEvent.native_key_code = kVK_RightControl;
}
}
else
{
OutKeyEvent.unmodified_character = InKeyEvent.GetCharacter();
}
OutKeyEvent.character = OutKeyEvent.unmodified_character;
#else
OutKeyEvent.windows_key_code = InKeyEvent.GetKeyCode();
#endif
OutKeyEvent.modifiers = GetCefKeyboardModifiers(InKeyEvent);
}
bool UKismetInputLibrary::Key_IsMouseButton(const FKey& Key)
{
return Key.IsMouseButton();
}
bool UKismetInputLibrary::Key_IsGamepadKey(const FKey& Key)
{
return Key.IsGamepadKey();
}
void FDirectInputJoystick::EventButtonReleased(const TSharedPtr<FGenericApplicationMessageHandler>& MessageHandler, EDirectInputPadKeyNames ePadName, FKey DIKey)
{
if(!IsRelease(ePadName-DIGamePad_Button1)) return;
MessageHandler->OnControllerButtonReleased(DIKey.GetFName(), GetPlayerIndex(), false);
}
FVector UInputComponent::GetVectorAxisValue( const FKey AxisKey ) const
{
FVector AxisValue;
bool bFound = false;
for (const FInputVectorAxisBinding& AxisBinding : VectorAxisBindings)
{
if (AxisBinding.AxisKey == AxisKey)
{
AxisValue = AxisBinding.AxisValue;
bFound = true;
break;
}
}
if (!bFound)
{
UE_LOG(LogPlayerController, Warning, TEXT("Request for value of vector axis key '%s' returning 0 as it is not bound on this input component."), *AxisKey.ToString());
}
return AxisValue;
}
void FDirectInputJoystick::EventAnalog(const TSharedPtr<FGenericApplicationMessageHandler>& MessageHandler, float Analog, EDirectInputPadKeyNames ePadName, FKey DIKey)
{
MessageHandler->OnControllerAnalog(DIKey.GetFName(), GetPlayerIndex(), Analog);
}
void FBlueprintSpawnNodeCommands::RegisterCommands()
{
const FString ConfigSection = TEXT("BlueprintSpawnNodes");
const FString SettingName = TEXT("Node");
TArray< FString > NodeSpawns;
GConfig->GetArray(*ConfigSection, *SettingName, NodeSpawns, GEditorPerProjectIni);
for(int32 x = 0; x < NodeSpawns.Num(); ++x)
{
FString ClassName;
if(!FParse::Value(*NodeSpawns[x], TEXT("Class="), ClassName))
{
// Could not find a class name, cannot continue with this line
continue;
}
FString CommandLabel;
UClass* FoundClass = FindObject<UClass>(ANY_PACKAGE, *ClassName, true);
TSharedPtr< FNodeSpawnInfo > InfoPtr;
if(FoundClass && FoundClass->IsChildOf(UEdGraphNode::StaticClass()))
{
// The class name matches that of a UEdGraphNode, so setup a spawn info that can generate UEdGraphNode graph actions
UEdGraphNode* GraphNode = Cast<UEdGraphNode>(FoundClass->GetDefaultObject());
CommandLabel = GraphNode->GetNodeTitle(ENodeTitleType::ListView).ToString();
if(CommandLabel.Len() == 0)
{
CommandLabel = FoundClass->GetName();
}
InfoPtr = MakeShareable( new FEdGraphNodeSpawnInfo( FoundClass ) );
}
else if(UFunction* FoundFunction = FindObject<UFunction>(ANY_PACKAGE, *ClassName, true))
{
// The class name matches that of a function, so setup a spawn info that can generate function graph actions
InfoPtr = MakeShareable( new FFunctionNodeSpawnInfo((UFunction*)FoundFunction));
CommandLabel = FoundFunction->GetName();
}
else
{
// Check for a macro graph that matches the passed in class name
for (TObjectIterator<UBlueprint> BlueprintIt; BlueprintIt; ++BlueprintIt)
{
UBlueprint* MacroBP = *BlueprintIt;
if(MacroBP->BlueprintType == BPTYPE_MacroLibrary)
{
// getting 'top-level' of the macros
for (TArray<UEdGraph*>::TIterator GraphIt(MacroBP->MacroGraphs); GraphIt; ++GraphIt)
{
UEdGraph* MacroGraph = *GraphIt;
// The class name matches that of a macro, so setup a spawn info that can generate macro graph actions
if(MacroGraph->GetName() == ClassName)
{
CommandLabel = MacroGraph->GetName();
InfoPtr = MakeShareable( new FMacroNodeSpawnInfo(MacroGraph));
}
}
}
}
}
// If spawn info was created, setup a UI Command for keybinding.
if(InfoPtr.IsValid())
{
TSharedPtr< FUICommandInfo > CommandInfo;
FKey Key;
bool bShift = false;
bool bCtrl = false;
bool bAlt = false;
bool bCmd = false;
// Parse the keybinding information
FString KeyString;
if( FParse::Value(*NodeSpawns[x], TEXT("Key="), KeyString) )
{
Key = *KeyString;
}
if( Key.IsValid() )
{
FParse::Bool(*NodeSpawns[x], TEXT("Shift="), bShift);
FParse::Bool(*NodeSpawns[x], TEXT("Alt="), bAlt);
FParse::Bool(*NodeSpawns[x], TEXT("Ctrl="), bCtrl);
FParse::Bool(*NodeSpawns[x], TEXT("Cmd="), bCmd);
}
FInputChord Chord(Key, EModifierKey::FromBools(bCtrl, bAlt, bShift, bCmd));
FText CommandLabelText = FText::FromString( CommandLabel );
FText Description = FText::Format( NSLOCTEXT("BlueprintEditor", "NodeSpawnDescription", "Hold down the bound keys and left click in the graph panel to spawn a {0} node."), CommandLabelText );
FUICommandInfo::MakeCommandInfo( this->AsShared(), CommandInfo, FName(*NodeSpawns[x]), CommandLabelText, Description, FSlateIcon(FEditorStyle::GetStyleSetName(), *FString::Printf(TEXT("%s.%s"), *this->GetContextName().ToString(), *NodeSpawns[x])), EUserInterfaceActionType::Button, Chord );
InfoPtr->CommandInfo = CommandInfo;
NodeCommands.Add(InfoPtr);
}
}
TSharedPtr<FNodeSpawnInfo> AddActorRefAction = MakeShareable(new FActorRefSpawnInfo);
UI_COMMAND(AddActorRefAction->CommandInfo, "Add Selected Actor Reference(s)", "Spawns node(s) which reference the currently selected actor(s) in the level.", EUserInterfaceActionType::Button, FInputChord(EKeys::R));
NodeCommands.Add(AddActorRefAction);
}
bool UKismetInputLibrary::Key_IsKeyboardKey(const FKey& Key)
{
return Key.IsBindableInBlueprints() && (Key.IsGamepadKey() == false && Key.IsMouseButton() == false);
}
bool UKismetInputLibrary::Key_IsVectorAxis(const FKey& Key)
{
return Key.IsVectorAxis();
}
bool UKismetInputLibrary::Key_IsFloatAxis(const FKey& Key)
{
return Key.IsFloatAxis();
}
