Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
S
Suyu
Manage
Activity
Members
Labels
Plan
Issues
0
Issue boards
Milestones
Wiki
Code
Merge requests
0
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package Registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Terms and privacy
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
many-archive
Suyu
Commits
29ae42f3
There was an error fetching the commit references. Please try again later.
Commit
29ae42f3
authored
3 years ago
by
german77
Committed by
Narr the Reg
3 years ago
Browse files
Options
Downloads
Patches
Plain Diff
input_common: Rewrite main and add the new drivers
parent
6d108f0d
No related branches found
No related tags found
No related merge requests found
Changes
2
Hide whitespace changes
Inline
Side-by-side
Showing
2 changed files
src/input_common/main.cpp
+279
-11
279 additions, 11 deletions
src/input_common/main.cpp
src/input_common/main.h
+51
-38
51 additions, 38 deletions
src/input_common/main.h
with
330 additions
and
49 deletions
src/input_common/main.cpp
+
279
−
11
View file @
29ae42f3
...
...
@@ -4,54 +4,265 @@
#include
<memory>
#include
<thread>
#include
"common/input.h"
#include
"common/param_package.h"
#include
"common/settings.h"
#include
"input_common/drivers/gc_adapter.h"
#include
"input_common/drivers/keyboard.h"
#include
"input_common/drivers/mouse.h"
#include
"input_common/drivers/tas_input.h"
#include
"input_common/drivers/touch_screen.h"
#include
"input_common/drivers/udp_client.h"
#include
"input_common/helpers/stick_from_buttons.h"
#include
"input_common/helpers/touch_from_buttons.h"
#include
"input_common/input_engine.h"
#include
"input_common/input_mapping.h"
#include
"input_common/input_poller.h"
#include
"input_common/main.h"
#ifdef HAVE_SDL2
#include
"input_common/
sdl/sdl
.h"
#include
"input_common/
drivers/sdl_driver
.h"
#endif
namespace
InputCommon
{
struct
InputSubsystem
::
Impl
{
void
Initialize
()
{
mapping_factory
=
std
::
make_shared
<
MappingFactory
>
();
MappingCallback
mapping_callback
{[
this
](
MappingData
data
)
{
RegisterInput
(
data
);
}};
keyboard
=
std
::
make_shared
<
Keyboard
>
(
"keyboard"
);
keyboard
->
SetMappingCallback
(
mapping_callback
);
keyboard_factory
=
std
::
make_shared
<
InputFactory
>
(
keyboard
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
keyboard
->
GetEngineName
(),
keyboard_factory
);
mouse
=
std
::
make_shared
<
Mouse
>
(
"mouse"
);
mouse
->
SetMappingCallback
(
mapping_callback
);
mouse_factory
=
std
::
make_shared
<
InputFactory
>
(
mouse
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
mouse
->
GetEngineName
(),
mouse_factory
);
touch_screen
=
std
::
make_shared
<
TouchScreen
>
(
"touch"
);
touch_screen_factory
=
std
::
make_shared
<
InputFactory
>
(
touch_screen
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
touch_screen
->
GetEngineName
(),
touch_screen_factory
);
gcadapter
=
std
::
make_shared
<
GCAdapter
>
(
"gcpad"
);
gcadapter
->
SetMappingCallback
(
mapping_callback
);
gcadapter_factory
=
std
::
make_shared
<
InputFactory
>
(
gcadapter
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
gcadapter
->
GetEngineName
(),
gcadapter_factory
);
udp_client
=
std
::
make_shared
<
CemuhookUDP
::
UDPClient
>
(
"cemuhookudp"
);
udp_client
->
SetMappingCallback
(
mapping_callback
);
udp_client_factory
=
std
::
make_shared
<
InputFactory
>
(
udp_client
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
udp_client
->
GetEngineName
(),
udp_client_factory
);
tas_input
=
std
::
make_shared
<
TasInput
::
Tas
>
(
"tas"
);
tas_input
->
SetMappingCallback
(
mapping_callback
);
tas_input_factory
=
std
::
make_shared
<
InputFactory
>
(
tas_input
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
tas_input
->
GetEngineName
(),
tas_input_factory
);
#ifdef HAVE_SDL2
sdl
=
std
::
make_shared
<
SDLDriver
>
(
"sdl"
);
sdl
->
SetMappingCallback
(
mapping_callback
);
sdl_factory
=
std
::
make_shared
<
InputFactory
>
(
sdl
);
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
sdl
->
GetEngineName
(),
sdl_factory
);
#endif
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
"touch_from_button"
,
std
::
make_shared
<
TouchFromButton
>
());
Input
::
RegisterFactory
<
Input
::
InputDevice
>
(
"analog_from_button"
,
std
::
make_shared
<
StickFromButton
>
());
}
void
Shutdown
()
{
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
keyboard
->
GetEngineName
());
keyboard
.
reset
();
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
mouse
->
GetEngineName
());
mouse
.
reset
();
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
touch_screen
->
GetEngineName
());
touch_screen
.
reset
();
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
gcadapter
->
GetEngineName
());
gcadapter
.
reset
();
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
udp_client
->
GetEngineName
());
udp_client
.
reset
();
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
tas_input
->
GetEngineName
());
tas_input
.
reset
();
#ifdef HAVE_SDL2
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
sdl
->
GetEngineName
());
sdl
.
reset
();
#endif
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
"touch_from_button"
);
Input
::
UnregisterFactory
<
Input
::
InputDevice
>
(
"analog_from_button"
);
}
[[
nodiscard
]]
std
::
vector
<
Common
::
ParamPackage
>
GetInputDevices
()
const
{
std
::
vector
<
Common
::
ParamPackage
>
devices
=
{
Common
::
ParamPackage
{{
"display"
,
"Any"
},
{
"class"
,
"any"
}},
Common
::
ParamPackage
{{
"display"
,
"Keyboard/Mouse"
},
{
"class"
,
"keyboard"
}},
Common
::
ParamPackage
{{
"display"
,
"Any"
},
{
"engine"
,
"any"
}},
};
return
{};
auto
keyboard_devices
=
keyboard
->
GetInputDevices
();
devices
.
insert
(
devices
.
end
(),
keyboard_devices
.
begin
(),
keyboard_devices
.
end
());
auto
mouse_devices
=
mouse
->
GetInputDevices
();
devices
.
insert
(
devices
.
end
(),
mouse_devices
.
begin
(),
mouse_devices
.
end
());
auto
gcadapter_devices
=
gcadapter
->
GetInputDevices
();
devices
.
insert
(
devices
.
end
(),
gcadapter_devices
.
begin
(),
gcadapter_devices
.
end
());
auto
tas_input_devices
=
tas_input
->
GetInputDevices
();
devices
.
insert
(
devices
.
end
(),
tas_input_devices
.
begin
(),
tas_input_devices
.
end
());
#ifdef HAVE_SDL2
auto
sdl_devices
=
sdl
->
GetInputDevices
();
devices
.
insert
(
devices
.
end
(),
sdl_devices
.
begin
(),
sdl_devices
.
end
());
#endif
return
devices
;
}
[[
nodiscard
]]
AnalogMapping
GetAnalogMappingForDevice
(
const
Common
::
ParamPackage
&
params
)
const
{
if
(
!
params
.
Has
(
"
class
"
)
||
params
.
Get
(
"
class
"
,
""
)
==
"any"
)
{
if
(
!
params
.
Has
(
"
engine
"
)
||
params
.
Get
(
"
engine
"
,
""
)
==
"any"
)
{
return
{};
}
const
std
::
string
engine
=
params
.
Get
(
"engine"
,
""
);
if
(
engine
==
gcadapter
->
GetEngineName
())
{
return
gcadapter
->
GetAnalogMappingForDevice
(
params
);
}
if
(
engine
==
tas_input
->
GetEngineName
())
{
return
tas_input
->
GetAnalogMappingForDevice
(
params
);
}
#ifdef HAVE_SDL2
if
(
engine
==
sdl
->
GetEngineName
())
{
return
sdl
->
GetAnalogMappingForDevice
(
params
);
}
#endif
return
{};
}
[[
nodiscard
]]
ButtonMapping
GetButtonMappingForDevice
(
const
Common
::
ParamPackage
&
params
)
const
{
if
(
!
params
.
Has
(
"
class
"
)
||
params
.
Get
(
"
class
"
,
""
)
==
"any"
)
{
if
(
!
params
.
Has
(
"
engine
"
)
||
params
.
Get
(
"
engine
"
,
""
)
==
"any"
)
{
return
{};
}
const
std
::
string
engine
=
params
.
Get
(
"engine"
,
""
);
if
(
engine
==
gcadapter
->
GetEngineName
())
{
return
gcadapter
->
GetButtonMappingForDevice
(
params
);
}
if
(
engine
==
tas_input
->
GetEngineName
())
{
return
tas_input
->
GetButtonMappingForDevice
(
params
);
}
#ifdef HAVE_SDL2
if
(
engine
==
sdl
->
GetEngineName
())
{
return
sdl
->
GetButtonMappingForDevice
(
params
);
}
#endif
return
{};
}
[[
nodiscard
]]
MotionMapping
GetMotionMappingForDevice
(
const
Common
::
ParamPackage
&
params
)
const
{
if
(
!
params
.
Has
(
"
class
"
)
||
params
.
Get
(
"
class
"
,
""
)
==
"any"
)
{
if
(
!
params
.
Has
(
"
engine
"
)
||
params
.
Get
(
"
engine
"
,
""
)
==
"any"
)
{
return
{};
}
const
std
::
string
engine
=
params
.
Get
(
"engine"
,
""
);
if
(
engine
==
gcadapter
->
GetEngineName
())
{
return
gcadapter
->
GetMotionMappingForDevice
(
params
);
}
#ifdef HAVE_SDL2
if
(
engine
==
sdl
->
GetEngineName
())
{
return
sdl
->
GetMotionMappingForDevice
(
params
);
}
#endif
return
{};
}
std
::
string
GetButtonName
(
const
Common
::
ParamPackage
&
params
)
const
{
if
(
!
params
.
Has
(
"engine"
)
||
params
.
Get
(
"engine"
,
""
)
==
"any"
)
{
return
"Unknown"
;
}
const
std
::
string
engine
=
params
.
Get
(
"engine"
,
""
);
if
(
engine
==
mouse
->
GetEngineName
())
{
return
mouse
->
GetUIName
(
params
);
}
if
(
engine
==
gcadapter
->
GetEngineName
())
{
return
gcadapter
->
GetUIName
(
params
);
}
if
(
engine
==
udp_client
->
GetEngineName
())
{
return
udp_client
->
GetUIName
(
params
);
}
if
(
engine
==
tas_input
->
GetEngineName
())
{
return
tas_input
->
GetUIName
(
params
);
}
#ifdef HAVE_SDL2
if
(
engine
==
sdl
->
GetEngineName
())
{
return
sdl
->
GetUIName
(
params
);
}
#endif
return
"Bad engine"
;
}
bool
IsController
(
const
Common
::
ParamPackage
&
params
)
{
const
std
::
string
engine
=
params
.
Get
(
"engine"
,
""
);
if
(
engine
==
mouse
->
GetEngineName
())
{
return
true
;
}
if
(
engine
==
gcadapter
->
GetEngineName
())
{
return
true
;
}
if
(
engine
==
tas_input
->
GetEngineName
())
{
return
true
;
}
#ifdef HAVE_SDL2
if
(
engine
==
sdl
->
GetEngineName
())
{
return
true
;
}
#endif
return
false
;
}
void
BeginConfiguration
()
{
keyboard
->
BeginConfiguration
();
mouse
->
BeginConfiguration
();
gcadapter
->
BeginConfiguration
();
udp_client
->
BeginConfiguration
();
#ifdef HAVE_SDL2
sdl
->
BeginConfiguration
();
#endif
}
void
EndConfiguration
()
{
keyboard
->
EndConfiguration
();
mouse
->
EndConfiguration
();
gcadapter
->
EndConfiguration
();
udp_client
->
EndConfiguration
();
#ifdef HAVE_SDL2
sdl
->
EndConfiguration
();
#endif
}
void
RegisterInput
(
MappingData
data
)
{
mapping_factory
->
RegisterInput
(
data
);
}
std
::
shared_ptr
<
MappingFactory
>
mapping_factory
;
std
::
shared_ptr
<
Keyboard
>
keyboard
;
std
::
shared_ptr
<
InputFactory
>
keyboard_factory
;
std
::
shared_ptr
<
Mouse
>
mouse
;
std
::
shared_ptr
<
InputFactory
>
mouse_factory
;
std
::
shared_ptr
<
GCAdapter
>
gcadapter
;
std
::
shared_ptr
<
InputFactory
>
gcadapter_factory
;
std
::
shared_ptr
<
TouchScreen
>
touch_screen
;
std
::
shared_ptr
<
InputFactory
>
touch_screen_factory
;
std
::
shared_ptr
<
CemuhookUDP
::
UDPClient
>
udp_client
;
std
::
shared_ptr
<
InputFactory
>
udp_client_factory
;
std
::
shared_ptr
<
TasInput
::
Tas
>
tas_input
;
std
::
shared_ptr
<
InputFactory
>
tas_input_factory
;
#ifdef HAVE_SDL2
std
::
shared_ptr
<
SDLDriver
>
sdl
;
std
::
shared_ptr
<
InputFactory
>
sdl_factory
;
#endif
};
InputSubsystem
::
InputSubsystem
()
:
impl
{
std
::
make_unique
<
Impl
>
()}
{}
...
...
@@ -66,6 +277,38 @@ void InputSubsystem::Shutdown() {
impl
->
Shutdown
();
}
Keyboard
*
InputSubsystem
::
GetKeyboard
()
{
return
impl
->
keyboard
.
get
();
}
const
Keyboard
*
InputSubsystem
::
GetKeyboard
()
const
{
return
impl
->
keyboard
.
get
();
}
Mouse
*
InputSubsystem
::
GetMouse
()
{
return
impl
->
mouse
.
get
();
}
const
Mouse
*
InputSubsystem
::
GetMouse
()
const
{
return
impl
->
mouse
.
get
();
}
TouchScreen
*
InputSubsystem
::
GetTouchScreen
()
{
return
impl
->
touch_screen
.
get
();
}
const
TouchScreen
*
InputSubsystem
::
GetTouchScreen
()
const
{
return
impl
->
touch_screen
.
get
();
}
TasInput
::
Tas
*
InputSubsystem
::
GetTas
()
{
return
impl
->
tas_input
.
get
();
}
const
TasInput
::
Tas
*
InputSubsystem
::
GetTas
()
const
{
return
impl
->
tas_input
.
get
();
}
std
::
vector
<
Common
::
ParamPackage
>
InputSubsystem
::
GetInputDevices
()
const
{
return
impl
->
GetInputDevices
();
}
...
...
@@ -82,12 +325,37 @@ MotionMapping InputSubsystem::GetMotionMappingForDevice(const Common::ParamPacka
return
impl
->
GetMotionMappingForDevice
(
device
);
}
std
::
string
InputSubsystem
::
GetButtonName
(
const
Common
::
ParamPackage
&
params
)
const
{
const
std
::
string
toggle
=
params
.
Get
(
"toggle"
,
false
)
?
"~"
:
""
;
const
std
::
string
inverted
=
params
.
Get
(
"inverted"
,
false
)
?
"!"
:
""
;
const
std
::
string
button_name
=
impl
->
GetButtonName
(
params
);
std
::
string
axis_direction
=
""
;
if
(
params
.
Has
(
"axis"
))
{
axis_direction
=
params
.
Get
(
"invert"
,
"+"
);
}
return
fmt
::
format
(
"{}{}{}{}"
,
toggle
,
inverted
,
button_name
,
axis_direction
);
}
bool
InputSubsystem
::
IsController
(
const
Common
::
ParamPackage
&
params
)
const
{
return
impl
->
IsController
(
params
);
}
void
InputSubsystem
::
ReloadInputDevices
()
{
impl
->
udp_client
.
get
()
->
ReloadSockets
();
}
void
InputSubsystem
::
BeginMapping
(
Polling
::
InputType
type
)
{
impl
->
BeginConfiguration
();
impl
->
mapping_factory
->
BeginMapping
(
type
);
}
const
Common
::
ParamPackage
InputSubsystem
::
GetNextInput
()
const
{
return
impl
->
mapping_factory
->
GetNextInput
();
}
std
::
vector
<
std
::
unique_ptr
<
Polling
::
DevicePoller
>>
InputSubsystem
::
GetPollers
([
[
maybe_unused
]]
Polling
::
DeviceType
type
)
const
{
return
{}
;
void
InputSubsystem
::
StopMapping
()
const
{
impl
->
EndConfiguration
();
impl
->
mapping_factory
->
StopMapping
()
;
}
std
::
string
GenerateKeyboardParam
(
int
key_code
)
{
...
...
This diff is collapsed.
Click to expand it.
src/input_common/main.h
+
51
−
38
View file @
29ae42f3
...
...
@@ -25,47 +25,26 @@ namespace Settings::NativeMotion {
enum
Values
:
int
;
}
namespace
MouseInput
{
namespace
InputCommon
{
class
Keyboard
;
class
Mouse
;
}
class
TouchScreen
;
struct
MappingData
;
}
// namespace InputCommon
namespace
TasInput
{
namespace
InputCommon
::
TasInput
{
class
Tas
;
}
}
// namespace InputCommon::TasInput
namespace
InputCommon
{
namespace
Polling
{
enum
class
DeviceType
{
Button
,
AnalogPreferred
,
Motion
};
/// Type of input desired for mapping purposes
enum
class
InputType
{
None
,
Button
,
Stick
,
Motion
,
Touch
};
/**
* A class that can be used to get inputs from an input device like controllers without having to
* poll the device's status yourself
*/
class
DevicePoller
{
public:
virtual
~
DevicePoller
()
=
default
;
/// Setup and start polling for inputs, should be called before GetNextInput
/// If a device_id is provided, events should be filtered to only include events from this
/// device id
virtual
void
Start
(
const
std
::
string
&
device_id
=
""
)
=
0
;
/// Stop polling
virtual
void
Stop
()
=
0
;
/**
* Every call to this function returns the next input recorded since calling Start
* @return A ParamPackage of the recorded input, which can be used to create an InputDevice.
* If there has been no input, the package is empty
*/
virtual
Common
::
ParamPackage
GetNextInput
()
=
0
;
};
}
// namespace Polling
/**
* Given a ParamPackage for a Device returned from `GetInputDevices`, attempt to get the default
* mapping for the device.
This is currently only implemented for the SDL backend devices.
* mapping for the device.
*/
using
AnalogMapping
=
std
::
unordered_map
<
Settings
::
NativeAnalog
::
Values
,
Common
::
ParamPackage
>
;
using
ButtonMapping
=
std
::
unordered_map
<
Settings
::
NativeButton
::
Values
,
Common
::
ParamPackage
>
;
...
...
@@ -88,10 +67,34 @@ public:
/// Unregisters all built-in input device factories and shuts them down.
void
Shutdown
();
/// Retrieves the underlying keyboard device.
[[
nodiscard
]]
Keyboard
*
GetKeyboard
();
/// Retrieves the underlying keyboard device.
[[
nodiscard
]]
const
Keyboard
*
GetKeyboard
()
const
;
/// Retrieves the underlying mouse device.
[[
nodiscard
]]
Mouse
*
GetMouse
();
/// Retrieves the underlying mouse device.
[[
nodiscard
]]
const
Mouse
*
GetMouse
()
const
;
/// Retrieves the underlying touch screen device.
[[
nodiscard
]]
TouchScreen
*
GetTouchScreen
();
/// Retrieves the underlying touch screen device.
[[
nodiscard
]]
const
TouchScreen
*
GetTouchScreen
()
const
;
/// Retrieves the underlying tas input device.
[[
nodiscard
]]
TasInput
::
Tas
*
GetTas
();
/// Retrieves the underlying tas input device.
[[
nodiscard
]]
const
TasInput
::
Tas
*
GetTas
()
const
;
/**
* Returns all available input devices that this Factory can create a new device with.
* Each returned ParamPackage should have a `display` field used for display, a
class
field
for
* backends to determine if this backend is meant to service the request and any other
* Each returned ParamPackage should have a `display` field used for display, a
`engine`
field
*
for
backends to determine if this backend is meant to service the request and any other
* information needed to identify this in the backend later.
*/
[[
nodiscard
]]
std
::
vector
<
Common
::
ParamPackage
>
GetInputDevices
()
const
;
...
...
@@ -105,23 +108,33 @@ public:
/// Retrieves the motion mappings for the given device.
[[
nodiscard
]]
MotionMapping
GetMotionMappingForDevice
(
const
Common
::
ParamPackage
&
device
)
const
;
/// Reloads the input devices
/// Returns a string contaning the name of the button from the input engine.
[[
nodiscard
]]
std
::
string
GetButtonName
(
const
Common
::
ParamPackage
&
params
)
const
;
/// Returns true if device is a controller.
[[
nodiscard
]]
bool
IsController
(
const
Common
::
ParamPackage
&
params
)
const
;
/// Reloads the input devices.
void
ReloadInputDevices
();
/// Get all DevicePoller from all backends for a specific device type
[[
nodiscard
]]
std
::
vector
<
std
::
unique_ptr
<
Polling
::
DevicePoller
>>
GetPollers
(
Polling
::
DeviceType
type
)
const
;
/// Start polling from all backends for a desired input type.
void
BeginMapping
(
Polling
::
InputType
type
);
/// Returns an input event with mapping information.
[[
nodiscard
]]
const
Common
::
ParamPackage
GetNextInput
()
const
;
/// Stop polling from all backends.
void
StopMapping
()
const
;
private:
struct
Impl
;
std
::
unique_ptr
<
Impl
>
impl
;
};
/// Generates a serialized param package for creating a keyboard button device
/// Generates a serialized param package for creating a keyboard button device
.
std
::
string
GenerateKeyboardParam
(
int
key_code
);
/// Generates a serialized param package for creating an analog device taking input from keyboard
/// Generates a serialized param package for creating an analog device taking input from keyboard
.
std
::
string
GenerateAnalogParamFromKeys
(
int
key_up
,
int
key_down
,
int
key_left
,
int
key_right
,
int
key_modifier
,
float
modifier_scale
);
}
// namespace InputCommon
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment