qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-23 12:52:46 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/libs/video/targets/joy_win.c

551 lines
14 KiB
C
Raw Normal View History

initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
/*
first steps
2001-04-11 19:56:01 +00:00
joy_win.c
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
first steps
2001-04-11 19:56:01 +00:00
Joystick device driver for Win32
Copyright (C) 2000 Jeff Teunissen <deek@dusknet.dhs.org>
Copyright (C) 2000 Jukka Sorjonen <jukka.sorjone@asikkala.fi>
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
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
*/
Stomped out lots of typos and case inconsistencies. fixme, Fixme, FIXME!
2001-02-21 23:45:49 +00:00
// FIXME: THIS IS NOT FINISHED YET
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
re-arrange things so __attribute__ and __builtin_expect are properly autoconfiscated so rcsid will continue to work with gcc 3.3
2003-01-15 15:31:36 +00:00
first steps
2001-04-11 19:56:01 +00:00
#include <math.h>
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
various win32 compile fixes for the latest mingw (not fully working due to LPCWAVEFORMATEX)
2002-10-11 20:47:17 +00:00
#include "winquake.h"
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
scripted fixups for the QF include move
2001-03-27 23:36:02 +00:00
#include "QF/cmd.h"
#include "QF/cvar.h"
clients now build (sdl, sgl, wgl), but don't link yet
2001-04-10 22:09:41 +00:00
#include "QF/input.h"
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
#include "QF/joystick.h"
scripted fixups for the QF include move
2001-03-27 23:36:02 +00:00
#include "QF/keys.h"
#include "QF/qargs.h"
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
#include "QF/sys.h"
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
Whitespace.
2001-08-27 01:00:03 +00:00
#include "compat.h"
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// Joystick variables and structures
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_sensitivity;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_sensitivity_cvar = {
.name = "joy_sensitivity",
.description =
"Joystick sensitivity",
.default_value = "1",
.flags = CVAR_ARCHIVE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_sensitivity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// joystick defines and variables
// where should defines be moved?
#define JOY_ABSOLUTE_AXIS 0x00000000 // control like a joystick
#define JOY_RELATIVE_AXIS 0x00000010 // control like a mouse, spinner,
// trackball
#define JOY_AXIS_X 0
#define JOY_AXIS_Y 1
#define JOY_AXIS_Z 2
#define JOY_AXIS_R 3
#define JOY_AXIS_U 4
#define JOY_AXIS_V 5
enum _ControlList {
AxisNada = 0, AxisForward, AxisLook, AxisSide, AxisTurn
};
DWORD dwAxisFlags[JOY_MAX_AXES] = {
Whitespace.
2001-08-27 01:00:03 +00:00
JOY_RETURNX, JOY_RETURNY, JOY_RETURNZ, JOY_RETURNR, JOY_RETURNU,
JOY_RETURNV
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
};
DWORD dwAxisMap[JOY_MAX_AXES];
DWORD dwControlMap[JOY_MAX_AXES];
PDWORD pdwRawValue[JOY_MAX_AXES];
JOYINFOEX ji;
// none of these cvars are saved over a session
// this means that advanced controller configuration needs to be executed
Whitespace.
2001-08-27 01:00:03 +00:00
// each time. this avoids any problems with getting back to a default usage or
// when changing from one controller to another. this way at least something
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// works.
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
char *in_joystick;
static cvar_t in_joystick_cvar = {
.name = "joystick",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_ARCHIVE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = 0, .value = &in_joystick },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
char *joy_name;
static cvar_t joy_name_cvar = {
.name = "joyname",
.description =
"FIXME: No Description",
.default_value = "joystick",
.flags = CVAR_NONE,
.value = { .type = 0, .value = &joy_name },
};
int joy_advanced;
static cvar_t joy_advanced_cvar = {
.name = "joyadvanced",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advanced },
};
int joy_advaxisx;
static cvar_t joy_advaxisx_cvar = {
.name = "joyadvaxisx",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisx },
};
int joy_advaxisy;
static cvar_t joy_advaxisy_cvar = {
.name = "joyadvaxisy",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisy },
};
int joy_advaxisz;
static cvar_t joy_advaxisz_cvar = {
.name = "joyadvaxisz",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisz },
};
int joy_advaxisr;
static cvar_t joy_advaxisr_cvar = {
.name = "joyadvaxisr",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisr },
};
int joy_advaxisu;
static cvar_t joy_advaxisu_cvar = {
.name = "joyadvaxisu",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisu },
};
int joy_advaxisv;
static cvar_t joy_advaxisv_cvar = {
.name = "joyadvaxisv",
.description =
"FIXME: No Description",
.default_value = "0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_advaxisv },
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_forwardthreshold;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_forwardthreshold_cvar = {
.name = "joyforwardthreshold",
.description =
"FIXME: No Description",
.default_value = "0.15",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_forwardthreshold },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_sidethreshold;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_sidethreshold_cvar = {
.name = "joysidethreshold",
.description =
"FIXME: No Description",
.default_value = "0.15",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_sidethreshold },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_pitchthreshold;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_pitchthreshold_cvar = {
.name = "joypitchthreshold",
.description =
"FIXME: No Description",
.default_value = "0.15",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_pitchthreshold },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_yawthreshold;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_yawthreshold_cvar = {
.name = "joyyawthreshold",
.description =
"FIXME: No Description",
.default_value = "0.15",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_yawthreshold },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_forwardsensitivity;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_forwardsensitivity_cvar = {
.name = "joyforwardsensitivity",
.description =
"FIXME: No Description",
.default_value = "-1.0",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_forwardsensitivity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_sidesensitivity;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_sidesensitivity_cvar = {
.name = "joysidesensitivity",
.description =
"FIXME: No Description",
.default_value = "-1.0",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_sidesensitivity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_pitchsensitivity;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_pitchsensitivity_cvar = {
.name = "joypitchsensitivity",
.description =
"FIXME: No Description",
.default_value = "1.0",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_pitchsensitivity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_yawsensitivity;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_yawsensitivity_cvar = {
.name = "joyyawsensitivity",
.description =
"FIXME: No Description",
.default_value = "-1.0",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_yawsensitivity },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
int joy_wwhack1;
static cvar_t joy_wwhack1_cvar = {
.name = "joywwhack1",
.description =
"FIXME: No Description",
.default_value = "0.0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_wwhack1 },
};
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
float joy_wwhack2;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
static cvar_t joy_wwhack2_cvar = {
.name = "joywwhack2",
.description =
"FIXME: No Description",
.default_value = "0.0",
.flags = CVAR_NONE,
[cvar] Clean up most misinterpreted cvar types The misinterpretations were due to either the cvar not being accessed directly by the engine, but via only the callback, or the cvars were accesssed only by progs (in which case, they should be float). The remainder are a potential enum (hud gravity) and a "too hard basket" (rcon password: need to figure out how I want to handle secret strings).
2022-04-24 11:04:06 +00:00
.value = { .type = &cexpr_float, .value = &joy_wwhack2 },
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
};
int joy_debug;
static cvar_t joy_debug_cvar = {
.name = "joy_debug",
.description =
"FIXME: No Description",
.default_value = "0.0",
.flags = CVAR_NONE,
.value = { .type = &cexpr_int, .value = &joy_debug },
};
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
qboolean joy_advancedinit, joy_haspov;
DWORD joy_oldbuttonstate, joy_oldpovstate;
int joy_id;
DWORD joy_flags;
DWORD joy_numbuttons;
win32 compile fixes
2003-08-13 18:17:30 +00:00
#if 0
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static PDWORD
win32 compile fixes
2002-11-08 23:13:52 +00:00
RawValuePointer (int axis)
{
switch (axis) {
case JOY_AXIS_X:
return &ji.dwXpos;
case JOY_AXIS_Y:
return &ji.dwYpos;
case JOY_AXIS_Z:
return &ji.dwZpos;
case JOY_AXIS_R:
return &ji.dwRpos;
case JOY_AXIS_U:
return &ji.dwUpos;
case JOY_AXIS_V:
return &ji.dwVpos;
}
return NULL;
}
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static qboolean
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
_JOY_Read (void)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
memset (&ji, 0, sizeof (ji));
ji.dwSize = sizeof (ji);
ji.dwFlags = joy_flags;
if (joyGetPosEx (joy_id, &ji) == JOYERR_NOERROR) {
// HACK HACK HACK -- there's a bug in the Logitech Wingman Warrior's
// DInput driver that causes it to make 32668 the center point
// instead
// of 32768
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (joy_wwhack1) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
ji.dwUpos += 100;
}
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (joy_debug) {
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
if (ji.dwXpos) Sys_Printf("X: %ld\n",ji.dwXpos);
if (ji.dwYpos) Sys_Printf("Y: %ld\n",ji.dwYpos);
if (ji.dwZpos) Sys_Printf("Z: %ld\n",ji.dwZpos);
if (ji.dwRpos) Sys_Printf("R: %ld\n",ji.dwRpos);
if (ji.dwUpos) Sys_Printf("U: %ld\n",ji.dwUpos);
if (ji.dwVpos) Sys_Printf("V: %ld\n",ji.dwVpos);
if (ji.dwButtons) Sys_Printf("B: %ld\n",ji.dwButtons);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
return true;
} else { // read error
return false;
}
}
win32 compile fixes
2003-08-13 18:17:30 +00:00
#endif
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
void
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
JOY_Read (void)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
win32 compile fixes This is an imperfect revision of history.
2004-11-06 02:21:00 +00:00
DWORD i;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
DWORD buttonstate, povstate;
first steps
2001-04-11 19:56:01 +00:00
if (!joy_found) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
return;
}
// loop through the joystick buttons
// key a joystick event or auxillary event for higher number buttons for
// each state change
buttonstate = ji.dwButtons;
for (i = 0; i < joy_numbuttons; i++) {
if ((buttonstate & (1 << i)) && !(joy_oldbuttonstate & (1 << i))) {
put a couple externs back for win32. they need a bit more thought on how to arrange things.
2001-10-29 16:45:03 +00:00
Key_Event (QFJ_BUTTON1 + i, 0, true);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
if (!(buttonstate & (1 << i)) && (joy_oldbuttonstate & (1 << i))) {
put a couple externs back for win32. they need a bit more thought on how to arrange things.
2001-10-29 16:45:03 +00:00
Key_Event (QFJ_BUTTON1 + i, 0, false);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
joy_oldbuttonstate = buttonstate;
if (joy_haspov) {
// convert POV information into 4 bits of state information
// this avoids any potential problems related to moving from one
// direction to another without going through the center position
povstate = 0;
if (ji.dwPOV != JOY_POVCENTERED) {
if (ji.dwPOV == JOY_POVFORWARD)
povstate |= 0x01;
if (ji.dwPOV == JOY_POVRIGHT)
povstate |= 0x02;
if (ji.dwPOV == JOY_POVBACKWARD)
povstate |= 0x04;
if (ji.dwPOV == JOY_POVLEFT)
povstate |= 0x08;
}
// determine which bits have changed and key an auxillary event for
// each change
for (i = 0; i < 4; i++) {
if ((povstate & (1 << i)) && !(joy_oldpovstate & (1 << i))) {
put a couple externs back for win32. they need a bit more thought on how to arrange things.
2001-10-29 16:45:03 +00:00
Key_Event (QFJ_BUTTON29 + i, -1, true);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
if (!(povstate & (1 << i)) && (joy_oldpovstate & (1 << i))) {
put a couple externs back for win32. they need a bit more thought on how to arrange things.
2001-10-29 16:45:03 +00:00
Key_Event (QFJ_BUTTON29 + i, -1, false);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
}
joy_oldpovstate = povstate;
}
}
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static int
win32 compile fixes
2002-11-08 23:13:52 +00:00
JOY_StartupJoystick (void)
{
int /* i, */ numdevs;
JOYCAPS jc;
MMRESULT mmr = !JOYERR_NOERROR;
// assume no joystick
joy_found = false;
// abort startup if user requests no joystick
if (COM_CheckParm ("-nojoy"))
return -1;
// verify joystick driver is present
if ((numdevs = joyGetNumDevs ()) == 0) {
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
Sys_Printf ("\njoystick not found -- driver not present\n\n");
win32 compile fixes
2002-11-08 23:13:52 +00:00
return -1;
}
// cycle through the joystick ids for the first valid one
for (joy_id = 0; joy_id < numdevs; joy_id++) {
memset (&ji, 0, sizeof (ji));
ji.dwSize = sizeof (ji);
ji.dwFlags = JOY_RETURNCENTERED;
if ((mmr = joyGetPosEx (joy_id, &ji)) == JOYERR_NOERROR)
break;
}
// abort startup if we didn't find a valid joystick
if (mmr != JOYERR_NOERROR) {
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
Sys_Printf ("\njoystick not found -- no valid joysticks (%x)\n\n",
win32 compile fixes
2002-11-08 23:13:52 +00:00
mmr);
return -1;
}
// get the capabilities of the selected joystick
// abort startup if command fails
memset (&jc, 0, sizeof (jc));
if ((mmr = joyGetDevCaps (joy_id, &jc, sizeof (jc))) != JOYERR_NOERROR) {
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
Sys_Printf
win32 compile fixes
2002-11-08 23:13:52 +00:00
("\njoystick not found -- invalid joystick capabilities (%x)\n\n",
mmr);
return -1;
}
// save the joystick's number of buttons and POV status
joy_numbuttons = jc.wNumButtons;
joy_haspov = jc.wCaps & JOYCAPS_HASPOV;
// old button and POV states default to no buttons pressed
joy_oldbuttonstate = joy_oldpovstate = 0;
// mark the joystick as available and advanced initialization not
// completed
// this is needed as cvars are not available during initialization
joy_advancedinit = false;
joy_found = true;
// FIXME: do this right
joy_active = true;
nuke Con_Printf and Con_DPrintf and use Sys_* instead
2007-11-06 10:17:14 +00:00
Sys_Printf ("\njoystick detected\n\n");
win32 compile fixes
2002-11-08 23:13:52 +00:00
return 0;
}
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
int
JOY_Open (void)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
return JOY_StartupJoystick();
Whitespace.
2001-08-27 01:00:03 +00:00
// Cmd_AddCommand ("joyadvancedupdate", JOY_AdvancedUpdate_f, "FIXME: This "
compile fixes for win32 and take the pruning shears to *sys*.c in qw and nq (they're not done yet, though)
2001-08-29 17:45:53 +00:00
// "appears to update the joystick poll? No Description");
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
void
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
JOY_Close (void)
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
{
}
win32 compile fixes
2003-08-13 18:17:30 +00:00
#if 0
make gcc more anal about prototypes, string constants and function visibility (ie, global functions must have a prototype)
2003-01-06 18:28:13 +00:00
static void
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
JOY_AdvancedUpdate_f (void)
{
// called once by JOY_ReadJoystick and by user whenever an update is
// needed
// cvars are now available
int i;
DWORD dwTemp;
// initialize all the maps
for (i = 0; i < JOY_MAX_AXES; i++) {
dwAxisMap[i] = AxisNada;
dwControlMap[i] = JOY_ABSOLUTE_AXIS;
pdwRawValue[i] = RawValuePointer (i);
}
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (joy_advanced) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// default joystick initialization
audit the usage of "only" There are still a few iffy places (notably around certain prepositions), but the relevant sentences are now much easier to read.
2010-01-13 06:42:26 +00:00
// only 2 axes with joystick control
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_X] = AxisTurn;
// dwControlMap[JOY_AXIS_X] = JOY_ABSOLUTE_AXIS;
dwAxisMap[JOY_AXIS_Y] = AxisForward;
// dwControlMap[JOY_AXIS_Y] = JOY_ABSOLUTE_AXIS;
} else {
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
if (strcmp (joy_name, "joystick") != 0) {
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
// notify user of advanced controller
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
Sys_Printf ("\n%s configured\n\n", joy_name);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
}
// advanced initialization here
// data supplied by user via joy_axisn cvars
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisx;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_X] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_X] = dwTemp & JOY_RELATIVE_AXIS;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisy;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_Y] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_Y] = dwTemp & JOY_RELATIVE_AXIS;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisz;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_Z] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_Z] = dwTemp & JOY_RELATIVE_AXIS;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisr;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_R] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_R] = dwTemp & JOY_RELATIVE_AXIS;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisu;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_U] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_U] = dwTemp & JOY_RELATIVE_AXIS;
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
dwTemp = joy_advaxisv;
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
dwAxisMap[JOY_AXIS_V] = dwTemp & 0x0000000f;
dwControlMap[JOY_AXIS_V] = dwTemp & JOY_RELATIVE_AXIS;
}
// compute the axes to collect from DirectInput
joy_flags = JOY_RETURNCENTERED | JOY_RETURNBUTTONS | JOY_RETURNPOV;
for (i = 0; i < JOY_MAX_AXES; i++) {
if (dwAxisMap[i] != AxisNada) {
joy_flags |= dwAxisFlags[i];
}
}
}
void
JOY_Init_Cvars(void)
{
// joystick variables
[cvar] Make cvars properly typed This is an extremely extensive patch as it hits every cvar, and every usage of the cvars. Cvars no longer store the value they control, instead, they use a cexpr value object to reference the value and specify the value's type (currently, a null type is used for strings). Non-string cvars are passed through cexpr, allowing expressions in the cvars' settings. Also, cvars have returned to an enhanced version of the original (id quake) registration scheme. As a minor benefit, relevant code having direct access to the cvar-controlled variables is probably a slight optimization as it removed a pointer dereference, and the variables can be located for data locality. The static cvar descriptors are made private as an additional safety layer, though there's nothing stopping external modification via Cvar_FindVar (which is needed for adding listeners). While not used yet (partly due to working out the design), cvars can have a validation function. Registering a cvar allows a primary listener (and its data) to be specified: it will always be called first when the cvar is modified. The combination of proper listeners and direct access to the controlled variable greatly simplifies the more complex cvar interactions as much less null checking is required, and there's no need for one cvar's callback to call another's. nq-x11 is known to work at least well enough for the demos. More testing will come.
2022-04-23 03:22:45 +00:00
Cvar_Register (&joy_device_cvar, 0, 0);
Cvar_Register (&joy_enable_cvar, 0, 0);
Cvar_Register (&joy_sensitivity_cvar, 0, 0);
Cvar_Register (&in_joystick_cvar, 0, 0);
Cvar_Register (&joy_name_cvar, 0, 0);
Cvar_Register (&joy_advanced_cvar, 0, 0);
Cvar_Register (&joy_advaxisx_cvar, 0, 0);
Cvar_Register (&joy_advaxisy_cvar, 0, 0);
Cvar_Register (&joy_advaxisz_cvar, 0, 0);
Cvar_Register (&joy_advaxisr_cvar, 0, 0);
Cvar_Register (&joy_advaxisu_cvar, 0, 0);
Cvar_Register (&joy_advaxisv_cvar, 0, 0);
Cvar_Register (&joy_forwardthreshold_cvar, 0, 0);
Cvar_Register (&joy_sidethreshold_cvar, 0, 0);
Cvar_Register (&joy_pitchthreshold_cvar, 0, 0);
Cvar_Register (&joy_yawthreshold_cvar, 0, 0);
Cvar_Register (&joy_forwardsensitivity_cvar, 0, 0);
Cvar_Register (&joy_sidesensitivity_cvar, 0, 0);
Cvar_Register (&joy_pitchsensitivity_cvar, 0, 0);
Cvar_Register (&joy_yawsensitivity_cvar, 0, 0);
Cvar_Register (&joy_wwhack1_cvar, 0, 0);
Cvar_Register (&joy_wwhack2_cvar, 0, 0);
Cvar_Register (&joy_debug_cvar, 0, 0);
initial checkin of most recent newtree and nuq(?) source
2001-02-19 21:15:25 +00:00
return;
}
joy_win.c now builds, but very likely does not work AT ALL. also fix qw's in_win.c for the new input api
2001-04-11 21:06:37 +00:00
#endif
Reference in a new issue Copy permalink