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 /**
   9  * \brief What version to write as control version?
  10  */
  11 #define WRITE_CONTROL_VERSION 0
  12 /**
  13  * \brief System control: Frame sync flag
  14  */
  15 #define CONTROL_FRAME_SYNC 0
  16 /**
  17  * \brief System control: System reset button
  18  */
  19 #define CONTROL_SYSTEM_RESET 1
  20 /**
  21  * \brief High part of cycle count for system reset (multiplier 10000).
  22  */
  23 #define CONTROL_SYSTEM_RESET_CYCLES_HI 2
  24 /**
  25  * \brief Low part of cycle count for system reset (multiplier 1).
  26  */
  27 #define CONTROL_SYSTEM_RESET_CYCLES_LO 3
  28 /**
  29  * \brief Number of system controls.
  30  */
  31 #define MAX_SYSTEM_CONTROLS 4
  32 /**
  33  * \brief SNES has 2 controller ports.
  34  */
  35 #define MAX_PORTS 2
  36 /**
  37  * \brief Multitap can connect 4 controllers to a single port.
  38  */
  39 #define MAX_CONTROLLERS_PER_PORT 4
  40 /**
  41  * \brief Ordinary gamepad has 12 buttons/axis total (more than anything else supported).
  42  */
  43 #define CONTROLLER_CONTROLS 12
  44 /**
  45  * \brief The total number of controls (currently 100).
  46  */
  47 #define TOTAL_CONTROLS (MAX_SYSTEM_CONTROLS + MAX_PORTS * CONTROLLER_CONTROLS * MAX_CONTROLLERS_PER_PORT)
  48
  49 struct controls_t;
  50
  51
  52 /**
  53  * \brief Subfield information
  54  *
  55  * Information about single subfield in control field. Subfields can be either single buttons or single axes.
  56  */
  57 struct control_subfield
  58 {
  59 /**
  60  * \brief Index used for subfield in control field
  61  *
  62  * This is the index this subfield is accessed as in operator[] method of class controlfield.
  63  */
  64         unsigned index;
  65
  66 /**
  67  * \brief Type of subfield
  68  *
  69  * This type gives the type of the subfield, if it is a single button or single axis.
  70  */
  71         enum control_subfield_type {
  72 /**
  73  * \brief The subfield is a button.
  74  */
  75                 BUTTON,
  76
  77 /**
  78  * \brief The subfield is an axis.
  79  */
  80                 AXIS
  81         };
  82
  83 /**
  84  * \brief Type of subfield
  85  *
  86  * This gives the type of the subfield.
  87  */
  88         enum control_subfield_type type;
  89
  90 /**
  91  * \brief Make subfield structure
  92  *
  93  * Make subfield structure having specified index and type.
  94  *
  95  * \param _index The index to give to the subfield.
  96  * \param _type The type to to give to the subfield.
  97  */
  98         control_subfield(unsigned _index, enum control_subfield_type _type) throw();
  99 };
 100
 101 /**
 102  * \brief Field parser
 103  *
 104  * This class handles parsing fields consisting of subfields.
 105  */
 106 class controlfield
 107 {
 108 public:
 109 /**
 110  * \brief Create new field parser
 111  *
 112  * This constructor creates new field parser parsing field consisting of specified subfields.
 113  *
 114  * \param _subfields The subfields forming the field to parse.
 115  * \throws std::bad_alloc Not enough memory to complete the operation.
 116  */
 117         controlfield(std::vector<control_subfield> _subfields) throw(std::bad_alloc);
 118
 119 /**
 120  * \brief Update values of subfields
 121  *
 122  * Read in string representation of a field and update values of all subfields.
 123  *
 124  * \param str The string representation
 125  * \throws std::bad_alloc Not enough memory to complete the operation.
 126  */
 127         void set_field(const std::string& str) throw(std::bad_alloc);
 128
 129 /**
 130  * \brief Read data in specified subfield.
 131  *
 132  * This method takes in a subfield index and gives the current data for said subfield.
 133  *
 134  * \param index The subfield index to read (0-based indexing).
 135  * \throws std::logic_error Trying to access subfield index out of range
 136  * \return The current value for that subfield
 137  * \note If subfield index is in range but not mapped to any subfield, then 0 is returned.
 138  */
 139         short operator[](unsigned index) throw(std::logic_error);
 140
 141 /**
 142  * \brief Get number of valid subfield indices
 143  *
 144  * Obtain number of valid subfield indices. The indices are [0, N), where N is the return value of this method.
 145  *
 146  * \return The amount of accessable subfield indices.
 147  */
 148         unsigned indices() throw();
 149 private:
 150         std::vector<control_subfield> subfields;
 151         std::vector<short> values;
 152 };
 153
 154 /**
 155  * \brief System control field parser
 156  *
 157  * Subtype of controlfield (field parser) with fixed subfields of system field.
 158  */
 159 class controlfield_system : public controlfield
 160 {
 161 public:
 162 /**
 163  * \brief Create new field parser
 164  *
 165  * This creates new parser for system fields.
 166  *
 167  * \param version The version to parse, currently must be 0.
 168  * \throws std::bad_alloc Not enough memory.
 169  * \throws std::runtime_error Unknown version.
 170  */
 171         controlfield_system(unsigned version) throw(std::bad_alloc, std::runtime_error);
 172 };
 173
 174 /**
 175  * \brief Gamepad control field parser
 176  *
 177  * Subtype of controlfield (field parser) with fixed subfields of gamepad controller (12 buttons).
 178  */
 179 class controlfield_gamepad : public controlfield
 180 {
 181 public:
 182 /**
 183  * \brief Create new field parser
 184  *
 185  * This creates new parser for gamepad fields.
 186  *
 187  * \throws std::bad_alloc Not enough memory.
 188  */
 189         controlfield_gamepad() throw(std::bad_alloc);
 190 };
 191
 192 /**
 193  * \brief Mouse/Justifier control field parser
 194  *
 195  * Subtype of controlfield (field parser) with fixed subfields of mouse or justfier controller (2 axes, 2 buttons).
 196  */
 197 class controlfield_mousejustifier : public controlfield
 198 {
 199 public:
 200 /**
 201  * \brief Create new field parser
 202  *
 203  * This creates new parser for mouse or justifier fields.
 204  *
 205  * \throws std::bad_alloc Not enough memory.
 206  */
 207         controlfield_mousejustifier() throw(std::bad_alloc);
 208 };
 209
 210 /**
 211  * \brief Superscope control field parser
 212  *
 213  * Subtype of controlfield (field parser) with fixed subfields of superscope controller (2 axes, 4 buttons).
 214  */
 215 class controlfield_superscope : public controlfield
 216 {
 217 public:
 218 /**
 219  * \brief Create new field parser
 220  *
 221  * This creates new parser for superscope fields.
 222  *
 223  * \throws std::bad_alloc Not enough memory.
 224  */
 225         controlfield_superscope() throw(std::bad_alloc);
 226 };
 227
 228 /**
 229  * \brief Decoders
 230  */
 231 class cdecode
 232 {
 233 public:
 234 /**
 235  * \brief Port decoder type
 236  *
 237  * This is type of functions that perform decoding of port fields.
 238  *
 239  * \param port The number of port to decode.
 240  * \param line Field splitter, positioned so the first field of that port is read first.
 241  * \param controls Buffer to place the read controls to.
 242  * \throws std::bad_alloc Not enough memory.
 243  * \throws std::runtime_error Bad input.
 244  * \note This method needs to read all fields associated with the port.
 245  */
 246         typedef void (*fn_t)(unsigned port, fieldsplitter& line, short* controls);
 247
 248 /**
 249  * \brief System field decoder
 250  *
 251  * This is a decoder for the system field.
 252  *
 253  * \param line The line to decode from. Assumed to be positioned on the system field.
 254  * \param controls The buffer for controls read.
 255  * \param version The version of control structure to read.
 256  * \throws std::bad_alloc Not enough memory.
 257  * \throws std::runtime_error Invalid field or invalid version.
 258  * \note This can't be put into decoder_type as parameters are bit diffrent.
 259  */
 260         static void system(fieldsplitter& line, short* controls, unsigned version) throw(std::bad_alloc,
 261                 std::runtime_error);
 262
 263 /**
 264  * \brief Port decoder for type none.
 265  *
 266  * This is a port decoder for port type none.
 267  *
 268  * \param port The port number
 269  * \param line The line to decode. Assumed to be positioned on start of port data.
 270  * \param controls Buffer to decode the controls to.
 271  * \throws std::bad_alloc Can't happen.
 272  * \throws std::runtime_error Can't happen.
 273  */
 274         static void none(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 275                 std::runtime_error);
 276
 277 /**
 278  * \brief Port decoder for type gamepad.
 279  *
 280  * This is a port decoder for port type gamepad.
 281  *
 282  * \param port The port number
 283  * \param line The line to decode. Assumed to be positioned on start of port data.
 284  * \param controls Buffer to decode the controls to.
 285  * \throws std::bad_alloc Out of memory.
 286  * \throws std::runtime_error Invalid controller data.
 287  */
 288         static void gamepad(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 289                 std::runtime_error);
 290
 291 /**
 292  * \brief Port decoder for type multitap.
 293  *
 294  * This is a port decoder for port type multitap.
 295  *
 296  * \param port The port number
 297  * \param line The line to decode. Assumed to be positioned on start of port data.
 298  * \param controls Buffer to decode the controls to.
 299  * \throws std::bad_alloc Out of memory.
 300  * \throws std::runtime_error Invalid controller data.
 301  */
 302         static void multitap(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 303                 std::runtime_error);
 304
 305 /**
 306  * \brief Port decoder for type mouse.
 307  *
 308  * This is a port decoder for port type mouse.
 309  *
 310  * \param port The port number
 311  * \param line The line to decode. Assumed to be positioned on start of port data.
 312  * \param controls Buffer to decode the controls to.
 313  * \throws std::bad_alloc Out of memory.
 314  * \throws std::runtime_error Invalid controller data.
 315  */
 316         static void mouse(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 317                 std::runtime_error);
 318
 319 /**
 320  * \brief Port decoder for type superscope.
 321  *
 322  * This is a port decoder for port type superscope.
 323  *
 324  * \param port The port number
 325  * \param line The line to decode. Assumed to be positioned on start of port data.
 326  * \param controls Buffer to decode the controls to.
 327  * \throws std::bad_alloc Out of memory.
 328  * \throws std::runtime_error Invalid controller data.
 329  */
 330         static void superscope(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 331                 std::runtime_error);
 332
 333 /**
 334  * \brief Port decoder for type justifier.
 335  *
 336  * This is a port decoder for port type justifier.
 337  *
 338  * \param port The port number
 339  * \param line The line to decode. Assumed to be positioned on start of port data.
 340  * \param controls Buffer to decode the controls to.
 341  * \throws std::bad_alloc Out of memory.
 342  * \throws std::runtime_error Invalid controller data.
 343  */
 344         static void justifier(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 345                 std::runtime_error);
 346
 347 /**
 348  * \brief Port decoder for type justifiers.
 349  *
 350  * This is a port decoder for port type justifiers.
 351  *
 352  * \param port The port number
 353  * \param line The line to decode. Assumed to be positioned on start of port data.
 354  * \param controls Buffer to decode the controls to.
 355  * \throws std::bad_alloc Out of memory.
 356  * \throws std::runtime_error Invalid controller data.
 357  */
 358         static void justifiers(unsigned port, fieldsplitter& line, short* controls) throw(std::bad_alloc,
 359                 std::runtime_error);
 360 };
 361
 362 /**
 363  * \brief Decoders
 364  */
 365 class cencode
 366 {
 367 public:
 368 /**
 369  * \brief Port encoder type
 370  *
 371  * This is the type of functions that perform encoding of port fields.
 372  *
 373  * \param port To number of port to encode.
 374  * \param controls Buffer to read the controls from.
 375  * \throws std::bad_alloc Not enough memory.
 376  */
 377         typedef std::string (*fn_t)(unsigned port, const short* controls);
 378
 379 /**
 380  * \brief Encoder for system field
 381  *
 382  * This is encoder for the system field.
 383  *
 384  * \param controls The controls to encode.
 385  * \throws std::bad_alloc Out of memory.
 386  * \note This can't be put into encoder_type as parameters are bit diffrent.
 387  */
 388         static std::string system(const short* controls) throw(std::bad_alloc);
 389
 390 /**
 391  * \brief Port encoder for type none.
 392  *
 393  * This is a port encoder for port type none.
 394  *
 395  * \param port The port number
 396  * \param controls The controls to encode.
 397  * \return The encoded fields.
 398  * \throws std::bad_alloc Out of memory.
 399  */
 400         static std::string none(unsigned port, const short* controls) throw(std::bad_alloc);
 401
 402 /**
 403  * \brief Port encoder for type gamepad.
 404  *
 405  * This is a port encoder for port type gamepad.
 406  *
 407  * \param port The port number
 408  * \param controls The controls to encode.
 409  * \return The encoded fields.
 410  * \throws std::bad_alloc Out of memory.
 411  */
 412         static std::string gamepad(unsigned port, const short* controls) throw(std::bad_alloc);
 413
 414 /**
 415  * \brief Port encoder for type multitap.
 416  *
 417  * This is a port encoder for port type multitap.
 418  *
 419  * \param port The port number
 420  * \param controls The controls to encode.
 421  * \return The encoded fields.
 422  * \throws std::bad_alloc Out of memory.
 423  */
 424         static std::string multitap(unsigned port, const short* controls) throw(std::bad_alloc);
 425
 426 /**
 427  * \brief Port encoder for type mouse.
 428  *
 429  * This is a port encoder for port type mouse.
 430  *
 431  * \param port The port number
 432  * \param controls The controls to encode.
 433  * \return The encoded fields.
 434  * \throws std::bad_alloc Out of memory.
 435  */
 436         static std::string mouse(unsigned port, const short* controls) throw(std::bad_alloc);
 437
 438 /**
 439  * \brief Port encoder for type superscope.
 440  *
 441  * This is a port encoder for port type superscope.
 442  *
 443  * \param port The port number
 444  * \param controls The controls to encode.
 445  * \return The encoded fields.
 446  * \throws std::bad_alloc Out of memory.
 447  */
 448         static std::string superscope(unsigned port, const short* controls) throw(std::bad_alloc);
 449
 450 /**
 451  * \brief Port encoder for type justifier.
 452  *
 453  * This is a port encoder for port type justifier.
 454  *
 455  * \param port The port number
 456  * \param controls The controls to encode.
 457  * \return The encoded fields.
 458  * \throws std::bad_alloc Out of memory.
 459  */
 460         static std::string justifier(unsigned port, const short* controls) throw(std::bad_alloc);
 461
 462 /**
 463  * \brief Port encoder for type justifiers.
 464  *
 465  * This is a port encoder for port type justifiers.
 466  *
 467  * \param port The port number
 468  * \param controls The controls to encode.
 469  * \return The encoded fields.
 470  * \throws std::bad_alloc Out of memory.
 471  */
 472         static std::string justifiers(unsigned port, const short* controls) throw(std::bad_alloc);
 473 };
 474
 475 /**
 476  * \brief Controls for single (sub)frame
 477  *
 478  * This structure holds controls for single (sub)frame or instant of time.
 479  */
 480 struct controls_t
 481 {
 482 /**
 483  * \brief Create new controls structure
 484  *
 485  * Creates new controls structure. All buttons are released and all axes are 0 (neutral).
 486  *
 487  * \param sync If true, write 1 (pressed) to frame sync subfield, else write 0 (released). Default false.
 488  */
 489         controls_t(bool sync = false) throw();
 490
 491 /**
 492  * \brief Read in a line using specified decoders
 493  *
 494  * This constructor takes in a line of input, port decoders and system field version and decodes the controls.
 495  *
 496  * \param line The line to decode.
 497  * \param decoders The decoders for each port.
 498  * \param version Version for the system field.
 499  * \throws std::bad_alloc Not enough memory.
 500  * \throws std::runtime_error Invalid input line.
 501  */
 502         controls_t(const std::string& line, const std::vector<cdecode::fn_t>& decoders, unsigned version)
 503                 throw(std::bad_alloc, std::runtime_error);
 504 /**
 505  * \brief Encode line
 506  *
 507  * This method takes in port encoders and encodes the controls.
 508  *
 509  * \param encoders The encoders for each port.
 510  * \throws std::bad_alloc Not enough memory.
 511  */
 512         std::string tostring(const std::vector<cencode::fn_t>& encoders) const throw(std::bad_alloc);
 513
 514 /**
 515  * \brief Read control value by (port, controller, control) tuple.
 516  *
 517  * This method takes in controller (port, controller, control) tuple and returns reference to the value of that
 518  * control.
 519  *
 520  * \param port The port number
 521  * \param controller The controller number within that port.
 522  * \param control The control number within that controller.
 523  * \return Reference to control value.
 524  * \throws std::logic_error port, controller or control is invalid.
 525  */
 526         const short& operator()(unsigned port, unsigned controller, unsigned control) const throw(std::logic_error);
 527
 528 /**
 529  * \brief Read control value by system index.
 530  *
 531  * This method takes in system index and returns reference to the value of that control.
 532  *
 533  * \param control The system index of control.
 534  * \return Reference to control value.
 535  * \throws std::logic_error Invalid control index.
 536  */
 537         const short& operator()(unsigned control) const throw(std::logic_error);
 538
 539 /**
 540  * \brief Read control value by (port, controller, control) tuple.
 541  *
 542  * This method takes in controller (port, controller, control) tuple and returns reference to the value of that
 543  * control.
 544  *
 545  * \param port The port number
 546  * \param controller The controller number within that port.
 547  * \param control The control number within that controller.
 548  * \return Reference to control value.
 549  * \throws std::logic_error port, controller or control is invalid.
 550  */
 551         short& operator()(unsigned port, unsigned controller, unsigned control) throw(std::logic_error);
 552
 553 /**
 554  * \brief Read control value by system index.
 555  *
 556  * This method takes in system index and returns reference to the value of that control.
 557  *
 558  * \param control The system index of control.
 559  * \return Reference to control value.
 560  * \throws std::logic_error Invalid control index.
 561  */
 562         short& operator()(unsigned control) throw(std::logic_error);
 563
 564         controls_t operator^(controls_t other) throw();
 565
 566 /**
 567  * \brief Raw controller data
 568  *
 569  * This field contains the raw controller data. Avoid manipulating directly.
 570  */
 571         short controls[TOTAL_CONTROLS];
 572
 573 /**
 574  * \brief Equality
 575  */
 576         bool operator==(const controls_t& c) const throw();
 577 };
 578
 579 /**
 580  * \brief Type of port
 581  *
 582  * This enumeration gives the type of port.
 583  */
 584 enum porttype_t
 585 {
 586 /**
 587  * \brief No device
 588  */
 589         PT_NONE = 0,                    //Nothing connected to port.
 590 /**
 591  * \brief Gamepad
 592  */
 593         PT_GAMEPAD = 1,
 594 /**
 595  * \brief Multitap (with 4 gamepads connected)
 596  */
 597         PT_MULTITAP = 2,
 598 /**
 599  * \brief Mouse
 600  */
 601         PT_MOUSE = 3,
 602 /**
 603  * \brief Superscope (only allowed for port 2).
 604  */
 605         PT_SUPERSCOPE = 4,
 606 /**
 607  * \brief Justifier (only allowed for port 2).
 608  */
 609         PT_JUSTIFIER = 5,
 610 /**
 611  * \brief 2 Justifiers (only allowed for port 2).
 612  */
 613         PT_JUSTIFIERS = 6,
 614 /**
 615  * \brief Number of controller types.
 616  */
 617         PT_LAST_CTYPE = 6,
 618 /**
 619  * \brief Invalid controller type.
 620  */
 621         PT_INVALID = 7
 622 };
 623
 624 /**
 625  * \brief Type of port
 626  *
 627  * This enumeration gives the type of device.
 628  */
 629 enum devicetype_t
 630 {
 631 /**
 632  * \brief No device
 633  */
 634         DT_NONE = 0,
 635 /**
 636  * \brief Gamepad
 637  */
 638         DT_GAMEPAD = 1,
 639 /**
 640  * \brief Mouse
 641  */
 642         DT_MOUSE = 3,
 643 /**
 644  * \brief Superscope
 645  */
 646         DT_SUPERSCOPE = 4,
 647 /**
 648  * \brief Justifier.
 649  */
 650         DT_JUSTIFIER = 5
 651 };
 652
 653 /**
 654  * \brief Information about port type.
 655  */
 656 struct port_type
 657 {
 658         const char* name;
 659         cdecode::fn_t decoder;
 660         cencode::fn_t encoder;
 661         porttype_t ptype;
 662         unsigned devices;
 663         devicetype_t dtype;
 664         bool valid_port1;
 665         static const port_type& lookup(const std::string& name, bool port2 = true) throw(std::bad_alloc,
 666                 std::runtime_error);
 667 };
 668
 669
 670 /**
 671  * \brief Information about port types.
 672  */
 673 extern port_type port_types[];
 674
 675 /**
 676  * \brief Translate controller index to system index.
 677  *
 678  * This method takes in controller (port, controller, control) tuple and returns the system index corresponding to
 679  * that control.
 680  *
 681  * \param port The port number
 682  * \param controller The controller number within that port.
 683  * \param control The control number within that controller.
 684  * \return System control index.
 685  * \throws std::logic_error port, controller or control is invalid.
 686  */
 687 unsigned ccindex2(unsigned port, unsigned controller, unsigned control) throw(std::logic_error);
 688
 689 #endif