controllerdata.hpp

   1 #ifndef _controllerdata__hpp__included__
   2 #define _controllerdata__hpp__included__
   3
   4 #include "fieldsplit.hpp"
   5 #include <vector>
   6 #include <stdexcept>
   7
   8 #define ENCODE_SPECIAL_NO_OUTPUT 0xFFFFFFFFU
   9
  10 /**
  11  * What version to write as control version?
  12  */
  13 #define WRITE_CONTROL_VERSION 0
  14 /**
  15  * System control: Frame sync flag
  16  */
  17 #define CONTROL_FRAME_SYNC 0
  18 /**
  19  * System control: System reset button
  20  */
  21 #define CONTROL_SYSTEM_RESET 1
  22 /**
  23  * High part of cycle count for system reset (multiplier 10000).
  24  */
  25 #define CONTROL_SYSTEM_RESET_CYCLES_HI 2
  26 /**
  27  * Low part of cycle count for system reset (multiplier 1).
  28  */
  29 #define CONTROL_SYSTEM_RESET_CYCLES_LO 3
  30 /**
  31  * Number of system controls.
  32  */
  33 #define MAX_SYSTEM_CONTROLS 4
  34 /**
  35  * SNES has 2 controller ports.
  36  */
  37 #define MAX_PORTS 2
  38 /**
  39  * Multitap can connect 4 controllers to a single port.
  40  */
  41 #define MAX_CONTROLLERS_PER_PORT 4
  42 /**
  43  * Ordinary gamepad has 12 buttons/axis total (more than anything else supported).
  44  */
  45 #define CONTROLLER_CONTROLS 12
  46 /**
  47  * The total number of controls (currently 100).
  48  */
  49 #define TOTAL_CONTROLS (MAX_SYSTEM_CONTROLS + MAX_PORTS * CONTROLLER_CONTROLS * MAX_CONTROLLERS_PER_PORT)
  50
  51 struct controls_t;
  52
  53 /**
  54  * Decoders
  55  */
  56 class cdecode
  57 {
  58 public:
  59 /**
  60  * This is type of functions that perform decoding of port fields.
  61  *
  62  * parameter port: The number of port to decode.
  63  * parameter line: The line to decode from.
  64  * parameter pos: Position on the line to start from.
  65  * parameter controls: Buffer to place the read controls to.
  66  * returns: End of fields (end of string or on '|') or start of next field (otherwise).
  67  * throws std::bad_alloc: Not enough memory.
  68  * throws std::runtime_error: Bad input.
  69  */
  70         typedef size_t (*fn_t)(unsigned port, const std::string& line, size_t pos, short* controls);
  71
  72 /**
  73  * This is a decoder for the system field. Note that this is not compatible with fn_t as parameters are diffrent.
  74  *
  75  * parameter port: The number of port to decode.
  76  * parameter line: The line to decode from.
  77  * parameter pos: Position on the line to start from.
  78  * parameter controls: Buffer to place the read controls to.
  79  * parameter version: The version of control structure to read.
  80  * returns: End of fields or start of next field.
  81  * throws std::bad_alloc: Not enough memory.
  82  * throws std::runtime_error: Bad input.
  83  */
  84         static size_t system(const std::string& line, size_t pos, short* controls, unsigned version)
  85                 throw(std::bad_alloc, std::runtime_error);
  86
  87 /**
  88  * This is a port decoder for port type none (see fn_t).
  89  */
  90         static size_t none(unsigned port, const std::string& line, size_t pos, short* controls)
  91                 throw(std::bad_alloc, std::runtime_error);
  92
  93 /**
  94  * This is a port decoder for port type gamepad (see fn_t).
  95  */
  96         static size_t gamepad(unsigned port, const std::string& line, size_t pos, short* controls)
  97                 throw(std::bad_alloc, std::runtime_error);
  98
  99 /**
 100  * This is a port decoder for port type multitap (see fn_t).
 101  */
 102         static size_t multitap(unsigned port, const std::string& line, size_t pos, short* controls)
 103                 throw(std::bad_alloc, std::runtime_error);
 104
 105 /**
 106  * This is a port decoder for port type mouse (see fn_t).
 107  */
 108         static size_t mouse(unsigned port, const std::string& line, size_t pos, short* controls)
 109                 throw(std::bad_alloc, std::runtime_error);
 110
 111 /**
 112  * This is a port decoder for port type superscope (see fn_t).
 113  */
 114         static size_t superscope(unsigned port, const std::string& line, size_t pos, short* controls)
 115                 throw(std::bad_alloc, std::runtime_error);
 116
 117 /**
 118  * This is a port decoder for port type justifier (see fn_t).
 119  */
 120         static size_t justifier(unsigned port, const std::string& line, size_t pos, short* controls)
 121                 throw(std::bad_alloc, std::runtime_error);
 122
 123 /**
 124  * This is a port decoder for port type justifiers (see fn_t).
 125  */
 126         static size_t justifiers(unsigned port, const std::string& line, size_t pos, short* controls)
 127                 throw(std::bad_alloc, std::runtime_error);
 128 };
 129
 130 /**
 131  * Encoders
 132  */
 133 class cencode
 134 {
 135 public:
 136 /**
 137  * This is the type of functions that perform encoding of port fields.
 138  *
 139  * parameter port: To number of port to encode.
 140  * parameter buffer: Buffer to store the encoded data to.
 141  * parameter pos: Position to start writing to.
 142  * parameter controls: Buffer to read the controls from.
 143  * returns: Position after written data, or ENCODE_SPECIAL_NO_OUTPUT if one wants no output, suppressing even the
 144  *      field terminator.
 145  * throws std::bad_alloc: Not enough memory.
 146  */
 147         typedef size_t (*fn_t)(unsigned port, char* buffer, size_t pos, const short* controls);
 148
 149 /**
 150  * This is encoder for the system field. Note that the parameters are bit diffrent and this can't be put into fn_t.
 151  *
 152  * parameter buffer: Buffer to store the encoded data to.
 153  * parameter pos: Position to start writing to.
 154  * parameter controls: Buffer to read the controls from.
 155  * returns: Position after written data, or ENCODE_SPECIAL_NO_OUTPUT if one wants no output, suppressing even the
 156  *      field terminator.
 157  * throws std::bad_alloc: Not enough memory.
 158  */
 159         static size_t system(char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 160
 161 /**
 162  * This is a port encoder for port type none. See fn_t.
 163  */
 164         static size_t none(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 165
 166 /**
 167  * This is a port encoder for port type gamepad. See fn_t.
 168  */
 169         static size_t gamepad(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 170
 171 /**
 172  * This is a port encoder for port type multitap. See fn_t.
 173  */
 174         static size_t multitap(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 175
 176 /**
 177  * This is a port encoder for port type mouse. See fn_t.
 178  */
 179         static size_t mouse(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 180
 181 /**
 182  * This is a port encoder for port type superscope. See fn_t.
 183  */
 184         static size_t superscope(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 185
 186 /**
 187  * This is a port encoder for port type justifier. See fn_t.
 188  */
 189         static size_t justifier(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 190
 191 /**
 192  * This is a port encoder for port type justifiers. See fn_t.
 193  */
 194         static size_t justifiers(unsigned port, char* buffer, size_t pos, const short* controls) throw(std::bad_alloc);
 195 };
 196
 197 /**
 198  * This structure holds controls for single (sub)frame or instant of time.
 199  */
 200 struct controls_t
 201 {
 202 /**
 203  * Creates new controls structure. All buttons are released and all axes are 0 (neutral).
 204  *
 205  * parameter sync: If true, write 1 (pressed) to frame sync subfield, else write 0 (released). Default false.
 206  */
 207         explicit controls_t(bool sync = false) throw();
 208
 209 /**
 210  * This constructor takes in a line of input, port decoders and system field version and decodes the controls.
 211  *
 212  * parameter line: The line to decode.
 213  * parameter decoders: The decoders for each port.
 214  * parameter version: Version for the system field.
 215  * throws std::bad_alloc: Not enough memory.
 216  * throws std::runtime_error: Invalid input line.
 217  */
 218         controls_t(const std::string& line, const std::vector<cdecode::fn_t>& decoders, unsigned version)
 219                 throw(std::bad_alloc, std::runtime_error);
 220 /**
 221  * This method takes in port encoders and encodes the controls.
 222  *
 223  * parameter encoders: The encoders for each port.
 224  * returns: The encoded controls.
 225  * throws std::bad_alloc: Not enough memory.
 226  */
 227         std::string tostring(const std::vector<cencode::fn_t>& encoders) const throw(std::bad_alloc);
 228
 229 /**
 230  * This method takes in controller (port, controller, control) tuple and returns reference to the value of that
 231  * control.
 232  *
 233  * parameter port: The port number
 234  * parameter controller: The controller number within that port.
 235  * parameter control: The control number within that controller.
 236  * returns: Reference to control value.
 237  * throws std::logic_error: port, controller or control is invalid.
 238  */
 239         const short& operator()(unsigned port, unsigned controller, unsigned control) const throw(std::logic_error);
 240
 241 /**
 242  * This method takes in control index and returns reference to the value of that control.
 243  *
 244  * parameter control: The control index number.
 245  * returns: Reference to control value.
 246  * throws std::logic_error: control index is invalid.
 247  */
 248         const short& operator()(unsigned control) const throw(std::logic_error);
 249
 250 /**
 251  * This method takes in controller (port, controller, control) tuple and returns reference to the value of that
 252  * control.
 253  *
 254  * parameter port: The port number
 255  * parameter controller: The controller number within that port.
 256  * parameter control: The control number within that controller.
 257  * returns: Reference to control value.
 258  * throws std::logic_error: port, controller or control is invalid.
 259  */
 260         short& operator()(unsigned port, unsigned controller, unsigned control) throw(std::logic_error);
 261
 262 /**
 263  * This method takes in control index and returns reference to the value of that control.
 264  *
 265  * parameter control: The control index number.
 266  * returns: Reference to control value.
 267  * throws std::logic_error: control index is invalid.
 268  */
 269         short& operator()(unsigned control) throw(std::logic_error);
 270
 271 /**
 272  * Perform XOR per-control.
 273  *
 274  * parameter other: The othe field to XOR with.
 275  * returns: The XOR result.
 276  */
 277         controls_t operator^(controls_t other) throw();
 278
 279 /**
 280  * This field contains the raw controller data. Avoid manipulating directly.
 281  */
 282         short controls[TOTAL_CONTROLS];
 283
 284 /**
 285  * Equality
 286  */
 287         bool operator==(const controls_t& c) const throw();
 288 };
 289
 290 /**
 291  * This enumeration gives the type of port.
 292  */
 293 enum porttype_t
 294 {
 295 /**
 296  * No device
 297  */
 298         PT_NONE = 0,                    //Nothing connected to port.
 299 /**
 300  * Gamepad
 301  */
 302         PT_GAMEPAD = 1,
 303 /**
 304  * Multitap (with 4 gamepads connected)
 305  */
 306         PT_MULTITAP = 2,
 307 /**
 308  * Mouse
 309  */
 310         PT_MOUSE = 3,
 311 /**
 312  * Superscope (only allowed for port 2).
 313  */
 314         PT_SUPERSCOPE = 4,
 315 /**
 316  * Justifier (only allowed for port 2).
 317  */
 318         PT_JUSTIFIER = 5,
 319 /**
 320  * 2 Justifiers (only allowed for port 2).
 321  */
 322         PT_JUSTIFIERS = 6,
 323 /**
 324  * Number of controller types.
 325  */
 326         PT_LAST_CTYPE = 6,
 327 /**
 328  * Invalid controller type.
 329  */
 330         PT_INVALID = PT_LAST_CTYPE + 1
 331 };
 332
 333 /**
 334  * This enumeration gives the type of device.
 335  */
 336 enum devicetype_t
 337 {
 338 /**
 339  * No device
 340  */
 341         DT_NONE = 0,
 342 /**
 343  * Gamepad (note that multitap controllers are gamepads)
 344  */
 345         DT_GAMEPAD = 1,
 346 /**
 347  * Mouse
 348  */
 349         DT_MOUSE = 3,
 350 /**
 351  * Superscope
 352  */
 353         DT_SUPERSCOPE = 4,
 354 /**
 355  * Justifier (note that justifiers is two of these).
 356  */
 357         DT_JUSTIFIER = 5
 358 };
 359
 360 /**
 361  * Information about port type.
 362  */
 363 struct port_type
 364 {
 365 /**
 366  * Name of type.
 367  */
 368         const char* name;
 369 /**
 370  * Decoder function.
 371  */
 372         cdecode::fn_t decoder;
 373 /**
 374  * Encoder function.
 375  */
 376         cencode::fn_t encoder;
 377 /**
 378  *  Port type value.
 379  */
 380         porttype_t ptype;
 381 /**
 382  *  Number of devices.
 383  */
 384         unsigned devices;
 385 /**
 386  *  Type of each connected device.
 387  */
 388         devicetype_t dtype;
 389 /**
 390  * True if valid for port1&2, false if valid for only for port 2.
 391  */
 392         bool valid_port1;
 393 /**
 394  * Lookup port type by name.
 395  */
 396         static const port_type& lookup(const std::string& name, bool port2 = true) throw(std::bad_alloc,
 397                 std::runtime_error);
 398 };
 399
 400
 401 /**
 402  * Information about port types, index by port type value (porttype_t).
 403  */
 404 extern port_type port_types[];
 405
 406 /**
 407  * This method takes in controller (port, controller, control) tuple and returns the system index corresponding to
 408  * that control.
 409  *
 410  * parameter port: The port number
 411  * parameter controller: The controller number within that port.
 412  * parameter control: The control number within that controller.
 413  * returns: The control index.
 414  * throws std::logic_error: port, controller or control is invalid.
 415  */
 416 unsigned ccindex2(unsigned port, unsigned controller, unsigned control) throw(std::logic_error);
 417
 418 #endif