qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-11 07:42:18 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/include/QF/input/binding.h

370 lines
12 KiB
C
Raw Normal View History

[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
/*
binding.h
Input Mapping Table management
Copyright (C) 2001 Zephaniah E. Hull <warp@babylon.d2dc.net>
Copyright (C) 2021 Bill Currie <bill@taniwha.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
#ifndef __QF_input_binding_h
#define __QF_input_binding_h
#ifndef __QFCC__
[input] Add listeners to buttons The listener is invoked when the button state changes.
2021-11-25 08:52:27 +00:00
#include "QF/listener.h"
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
#include "QF/mathlib.h"
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#endif
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
/*** Recipe for converting an axis to a floating point value.
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
Absolute axes are converted to the 0..1 range for unbalanced axes, and
the -1..1 range for balanced axes, and then scaled.
Relative axes are simply converted to floating point and scaled as they
have no fixed limits.
Relative axes should have \a minzone and \a maxzone set to 0, or weird
things will happen.
\a min and \a max normally come from the system. \a min and \a max being
equal indicates the axis is relative.
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
\a deadzone applies only to balanced axes, thus it doubles as a flag
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
for balanced (>= 0) or unbalanced (< 0). However, relative axes are always
balanced and so \a deadzone < 0 is the same as 0 for relative axes.
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
\a curve is applied after the input has been converted to a float, and the
0..1 or -1..1 ranges for absolute axes.
\a scale is applied after \a curve for absolute axes, but before \a curve
for relative axes.
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
*/
typedef struct in_recipe_s {
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
int min; ///< Axis minimum value (from system)
int max; ///< Axis maximum value (from system)
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
int minzone; ///< Size of deadzone near axis minimum
int maxzone; ///< Size of deadzone near axis maximum
int deadzone; ///< Size of deadzone near axis center (balanced)
float curve; ///< Power factor for absolute axes
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
float scale; ///< Final scale factor
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
} in_recipe_t;
typedef enum {
ina_set, ///< write the axis value to the destination
ina_accumulate, ///< add the axis value to the destination
} in_axis_mode;
/*** Logical axis.
Logical axes are the inputs defined by the game on which axis inputs
(usually "physical" axes) can act. Depending on the mode, the physical
axis value is either written as-is, or added to the existing value. It is
the responsibility of the code using the axis to clear the value for
accumulated inputs.
*/
typedef struct in_axis_s {
float value; ///< converted value of the axis
in_axis_mode mode; ///< method used for updating the destination
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
float abs_input; ///< input from an absolute axis (eg, joystick)
float rel_input; ///< input from a relative axis (eg, mouse)
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#ifndef __QFCC__
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
struct axis_listener_set_s *listeners;
[input] Move name and description into in_axis_t Like with in_button_t, it makes creating static axes a little easier.
2021-11-10 06:48:22 +00:00
const char *name;
const char *description;
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#endif
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
} in_axis_t;
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#ifndef __QFCC__
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
typedef struct axis_listener_set_s LISTENER_SET_TYPE (in_axis_t)
axis_listener_set_t;
/*** Function type for axis listeners.
*/
typedef void (*axis_listener_t) (void *data, const in_axis_t *axis);
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#endif
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
/*** Current state of the logical button.
Captures the current state and any transitions during the last frame.
Not all combinations are valid (inb_edge_up|inb_down and inb_edge_down
(no inb_down) are not valid states), but inb_edge_up|inb_edge_down )with
or without inb_down) is valid as it represents a double transition during
the frame.
*/
typedef enum {
inb_down = 1<<0, ///< button is held
inb_edge_down = 1<<1, ///< button pressed this frame
inb_edge_up = 1<<2, ///< button released this frame
} in_button_state;
/*** Logical button.
Logical buttons are the inputs defined by the game on which button inputs
(usually "physical" buttons) can act. Up to two button inputs can be
bound to a logical button. The logical button acts as an or gate where
either input will put the logical button in the pressed state, and both
inputs must be inactive for the logical button to be released.
*/
typedef struct in_button_s {
int down[2]; ///< button ids holding this button down
int state; ///< in_button_state
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#ifndef __QFCC__
[input] Add listeners to buttons The listener is invoked when the button state changes.
2021-11-25 08:52:27 +00:00
struct button_listener_set_s *listeners;
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
const char *name;
[input] Move button name and description This puts the name and description into the button itself, making it much easier to look them up.
2021-11-01 04:54:16 +00:00
const char *description;
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#endif
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
} in_button_t;
[ruamoko] Replace rua_key with rua_input And create rua_game to coordinate other game builtins. Menus are broken for key handling, but have been since the input rewrite anyway. rua_input adds the ability to create buttons and axes (but not destroy them). More work needs to be done to flesh things out, though.
2021-12-20 15:47:13 +00:00
#ifndef __QFCC__
[input] Add listeners to buttons The listener is invoked when the button state changes.
2021-11-25 08:52:27 +00:00
typedef struct button_listener_set_s LISTENER_SET_TYPE (in_button_t)
button_listener_set_t;
/*** Function type for button listeners.
*/
typedef void (*button_listener_t) (void *data, const in_button_t *button);
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
typedef struct in_axisbinding_s {
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
in_recipe_t *recipe;
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
in_axis_t *axis;
} in_axisbinding_t;
typedef enum {
inb_button,
inb_command,
} in_button_type;
typedef struct in_buttonbinding_s {
in_button_type type;
union {
[input] Implement imt creation, binding, etc Much testing is needed, but the bulk of imt management is implemented. Axis bindings are not properly implemented yet, though.
2021-11-08 07:54:52 +00:00
in_button_t *button;
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
char *command;
};
} in_buttonbinding_t;
/*** Represent the button's activity in the last frame as a float.
The detected activity is:
steady off (up)
steady on (down)
off to on (up to down) transition
on to off )down to up) transition
pulse on (off-on-off or up-down-up)
pulse off (on-off-on or down-up-down)
Any additional transitions are treated as a pulse appropriate for the
final state of the button.
\param button Pointer to the button being tested.
\return Float value between 0 (off/up) and 1 (on/down)
\note The edge transitions are cleared, so for each frame, this
is a one-shot function (ie, it is NOT idempotent).
*/
GNU89INLINE inline float IN_ButtonState (in_button_t *button);
/*** Test whether a button has been pressed in the last frame.
Both steady-state on, and brief clicks are detected.
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
\param button Pointer to the button being tested.
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
\return True if the button is currently held or was pulsed on
in the last frame.
\note The edge transitions are cleared, so for each frame, this
is a one-shot function (ie, it is NOT idempotent).
*/
GNU89INLINE inline int IN_ButtonPressed (in_button_t *button);
/*** Test whether a button was released in the last frame.
Valid only if the button is still released. A pulsed off does not
count as being released as the button is still held.
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
\param button Pointer to the button being tested.
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
\return True if the button is currently released and the release
was in the last frame.
\note The edge transitions are cleared, so for each frame, this
is a one-shot function (ie, it is NOT idempotent).
*/
GNU89INLINE inline int IN_ButtonReleased (in_button_t *button);
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
/*** Update the axis value based on its mode and clear its relative input.
The absolute and relative inputs are separate because absolute inputs
usually get written when the input actually changes (and thus must not
be cleared each frame), while relative inputs indicate a per-frame delta
and thus must be cleared each frame.
\param axis Pointer to the axis being updated.
\return The resulting output value of the axis.
\note The relative input (\a rel_input) is zeroed.
*/
GNU89INLINE inline float IN_UpdateAxis (in_axis_t *axis);
/*** Update and clamp the axis value (see IN_UpdateAxis())
Like IN_UpdateAxis(), but clamps the final output to the specified range.
This is most useful for \a ina_accumulate axes, but can be used to ensure
\a ina_set axes never exceed a given range.
The absolute and relative inputs are separate because absolute inputs
usually get written when the input actually changes (and thus must not
be cleared each frame), while relative inputs indicate a per-frame delta
and thus must be cleared each frame.
\param axis Pointer to the axis being updated.
\param minval The minimum value to which the axis output will be clamped.
\param minval The minimum value to which the axis output will be clamped.
\return The resulting output value of the axis.
\note The relative input (\a rel_input) is zeroed. The absolute
input is not affected by the clamping, only the output
\a value.
*/
GNU89INLINE inline float IN_ClampAxis (in_axis_t *axis,
float minval, float maxval);
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
#ifndef IMPLEMENT_INPUT_Funcs
GNU89INLINE inline
#else
VISIBLE
#endif
float
IN_ButtonState (in_button_t *button)
{
static const float state_values[8] = {
// held down for the entire frame
[inb_down] = 1,
// released this frame
[inb_edge_up] = 0, // instant falloff
// pressed this frame
[inb_edge_down|inb_down] = 0.5,
// pressed and released this frame
[inb_edge_down|inb_edge_up] = 0.25,
// released and pressed this frame
[inb_edge_down|inb_edge_up|inb_down] = 0.75,
};
int state = button->state;
button->state &= inb_down; // clear edges, preserve pressed
return state_values[state & (inb_down|inb_edge_down|inb_edge_up)];
}
#ifndef IMPLEMENT_INPUT_Funcs
GNU89INLINE inline
#else
VISIBLE
#endif
int
IN_ButtonPressed (in_button_t *button)
{
int state = button->state;
button->state &= inb_down; // clear edges, preserve pressed
// catch even press and release that occurs between frames
return (state & (inb_down | inb_edge_down)) != 0;
}
#ifndef IMPLEMENT_INPUT_Funcs
GNU89INLINE inline
#else
VISIBLE
#endif
int
IN_ButtonReleased (in_button_t *button)
{
int state = button->state;
button->state &= inb_down; // clear edges, preserve pressed
// catch only full release (a pulsed on does count as a release)
return (state & (inb_down | inb_edge_up)) == inb_edge_up;
}
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
#ifndef IMPLEMENT_INPUT_Funcs
GNU89INLINE inline
#else
VISIBLE
#endif
float
IN_UpdateAxis (in_axis_t *axis)
{
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
float prev_value = axis->value;
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
switch (axis->mode) {
case ina_set:
axis->value = axis->abs_input + axis->rel_input;
break;
case ina_accumulate:
axis->value += axis->abs_input + axis->rel_input;
break;
}
axis->rel_input = 0;
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
if (axis->value != prev_value && axis->listeners) {
LISTENER_INVOKE (axis->listeners, axis);
}
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
return axis->value;
}
#ifndef IMPLEMENT_INPUT_Funcs
GNU89INLINE inline
#else
VISIBLE
#endif
float
IN_ClampAxis (in_axis_t *axis, float minval, float maxval)
{
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
float prev_value = axis->value;
switch (axis->mode) {
case ina_set:
axis->value = axis->abs_input + axis->rel_input;
break;
case ina_accumulate:
axis->value += axis->abs_input + axis->rel_input;
break;
}
axis->rel_input = 0;
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
axis->value = bound (minval, axis->value, maxval);
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
if (axis->value != prev_value && axis->listeners) {
LISTENER_INVOKE (axis->listeners, axis);
}
[input] Separate absolute and relative axis inputs Combining absolute and relative inputs at the binding does not work well because absolute inputs generally update only when the physical input updates, so clearing the axis input each frame results in a brief pulse from the physical input, but relative inputs must be cleared each frame (where frame here is each time the axis is read) but must accumulate the relative updates between frames. Other than the axis mode being incorrect, this seems to work quite nicely.
2021-11-23 13:04:17 +00:00
return axis->value;
}
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
void IN_ButtonAction (in_button_t *buttin, int id, int pressed);
[input] Move button name and description This puts the name and description into the button itself, making it much easier to look them up.
2021-11-01 04:54:16 +00:00
int IN_RegisterButton (in_button_t *button);
[input] Move name and description into in_axis_t Like with in_button_t, it makes creating static axes a little easier.
2021-11-10 06:48:22 +00:00
int IN_RegisterAxis (in_axis_t *axis);
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
in_button_t *IN_FindButton (const char *name);
[input] Implement axis binding Each axis binding has its own recipe (meaning the same input axis can be interpreted differently for each binding) Recipes are specified with field=value pairs after the axis name. Valid fields are minzone, maxzone, deadzone, curve and scale, with deadzone doubling as a balanced/unbalanced flag. The default recipe has no zones, is balanced, and curve and scale are 1.
2021-11-11 06:51:47 +00:00
in_axis_t *IN_FindAxis (const char *name);
[input] Add listeners to buttons The listener is invoked when the button state changes.
2021-11-25 08:52:27 +00:00
void IN_ButtonAddListener (in_button_t *button, button_listener_t listener,
void *data);
void IN_ButtonRemoveListener (in_button_t *button, button_listener_t listener,
void *data);
[input] Add axis listeners The listener is invoked when the axis value changes due to IN_UpdateAxis or IN_ClampAxis updating the axis. This does mean the listener invocation make be somewhat delayed. I am a tad uncertain about this design thus it being a separate commit.
2021-11-25 08:55:22 +00:00
void IN_AxisAddListener (in_axis_t *axis, axis_listener_t listener,
void *data);
void IN_AxisRemoveListener (in_axis_t *axis, axis_listener_t listener,
void *data);
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
[input] Split binding event handler There's now an internal event handler for taking care of device addition and removal, and a public event handler for dealing with device input events in various contexts In particular, so the clients can check for the escape key.
2021-11-16 00:37:39 +00:00
struct IE_event_s;
int IN_Binding_HandleEvent (const struct IE_event_s *ie_event);
[input] Get bindings actually working The mouse bound to movement axes works (though signs are all over the place, so movement direction is a little off), and binding F10 (key 68) to quit works :)
2021-11-11 15:24:04 +00:00
void IN_Binding_Activate (void);
[input] Make a start on the new binding system Input Mapping Tables are still at the core as they are a good concept, however they include both axis and button mappings, and the size is not hard-coded, but dependent on the known devices. Not much actually works yet (nq segfaults when a key is pressed).
2021-11-03 10:02:39 +00:00
void IN_Binding_Init (void);
[input] Save/load config to/from plist configs While the console command line is quite good for setting everything up, the devices being bound do need to be present when the commands are executed (due to needing extra data provided by the devices). Thus property lists that store the extra data (button and axis counts, device names/ids, connection names, etc) seems to be the best solution.
2021-11-14 01:17:05 +00:00
struct plitem_s;
void IN_Binding_SaveConfig (struct plitem_s *config);
void IN_Binding_LoadConfig (struct plitem_s *config);
[input] Make a start on the new binding system Input Mapping Tables are still at the core as they are a good concept, however they include both axis and button mappings, and the size is not hard-coded, but dependent on the known devices. Not much actually works yet (nq segfaults when a key is pressed).
2021-11-03 10:02:39 +00:00
[input] Move in_event.h and binding defs They now live in the include QF/input directory. This cleans up include/QF a little, and input.h as well.
2021-11-01 04:05:05 +00:00
#endif
#endif//__QF_input_binding_h
Reference in a new issue Copy permalink