mirror of
https://github.com/0ldsk00l/nestopia.git
synced 2025-04-02 10:31:51 -04:00
1008 lines
19 KiB
C++
1008 lines
19 KiB
C++
////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Nestopia - NES/Famicom emulator written in C++
|
|
//
|
|
// Copyright (C) 2003-2008 Martin Freij
|
|
//
|
|
// This file is part of Nestopia.
|
|
//
|
|
// Nestopia 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.
|
|
//
|
|
// Nestopia 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 Nestopia; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
//
|
|
////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef NST_API_INPUT_H
|
|
#define NST_API_INPUT_H
|
|
|
|
#include "NstApi.hpp"
|
|
|
|
#ifdef NST_PRAGMA_ONCE
|
|
#pragma once
|
|
#endif
|
|
|
|
#if NST_ICC >= 810
|
|
#pragma warning( push )
|
|
#pragma warning( disable : 304 444 )
|
|
#elif NST_MSVC >= 1200
|
|
#pragma warning( push )
|
|
#pragma warning( disable : 4512 )
|
|
#endif
|
|
|
|
namespace Nes
|
|
{
|
|
namespace Core
|
|
{
|
|
namespace Input
|
|
{
|
|
enum
|
|
{
|
|
NUM_PADS = 4,
|
|
NUM_CONTROLLERS = 27
|
|
};
|
|
|
|
class Controllers
|
|
{
|
|
template<typename T>
|
|
struct PollCaller1 : UserCallback<typename T::PollCallback>
|
|
{
|
|
bool operator () (T& t) const
|
|
{
|
|
return this->function ? this->function( this->userdata, t ) : true;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct PollCaller2 : UserCallback<typename T::PollCallback>
|
|
{
|
|
bool operator () (T& t,uint a) const
|
|
{
|
|
return this->function ? this->function( this->userdata, t, a ) : true;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
struct PollCaller3 : UserCallback<typename T::PollCallback>
|
|
{
|
|
bool operator () (T& t,uint a,uint b) const
|
|
{
|
|
return this->function ? this->function( this->userdata, t, a, b ) : true;
|
|
}
|
|
};
|
|
|
|
public:
|
|
|
|
Controllers() throw();
|
|
|
|
/**
|
|
* Standard NES pad.
|
|
*/
|
|
struct Pad
|
|
{
|
|
enum
|
|
{
|
|
A = 0x01,
|
|
B = 0x02,
|
|
SELECT = 0x04,
|
|
START = 0x08,
|
|
UP = 0x10,
|
|
DOWN = 0x20,
|
|
LEFT = 0x40,
|
|
RIGHT = 0x80
|
|
};
|
|
|
|
enum
|
|
{
|
|
MIC = 0x4
|
|
};
|
|
|
|
uint buttons;
|
|
uint mic;
|
|
uint allowSimulAxes;
|
|
|
|
Pad()
|
|
: buttons(0), mic(0), allowSimulAxes(false) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Pad&,uint);
|
|
|
|
static PollCaller2<Pad> callback;
|
|
};
|
|
|
|
/**
|
|
* Standard light gun.
|
|
*/
|
|
struct Zapper
|
|
{
|
|
uint x;
|
|
uint y;
|
|
uint fire;
|
|
|
|
Zapper()
|
|
: x(0), y(0), fire(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Zapper&);
|
|
|
|
static PollCaller1<Zapper> callback;
|
|
};
|
|
|
|
/**
|
|
* Arkanoid controller.
|
|
*/
|
|
struct Paddle
|
|
{
|
|
uint x;
|
|
uint button;
|
|
|
|
Paddle()
|
|
: x(0), button(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Paddle&);
|
|
|
|
static PollCaller1<Paddle> callback;
|
|
};
|
|
|
|
/**
|
|
* Power Pad / Family Fun Fittness.
|
|
*/
|
|
struct PowerPad
|
|
{
|
|
PowerPad() throw();
|
|
|
|
enum
|
|
{
|
|
NUM_SIDE_A_BUTTONS = 12,
|
|
NUM_SIDE_B_BUTTONS = 8
|
|
};
|
|
|
|
bool sideA[NUM_SIDE_A_BUTTONS];
|
|
bool sideB[NUM_SIDE_B_BUTTONS];
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,PowerPad&);
|
|
|
|
static PollCaller1<PowerPad> callback;
|
|
};
|
|
|
|
/**
|
|
* Power Glove.
|
|
*/
|
|
struct PowerGlove
|
|
{
|
|
PowerGlove() throw();
|
|
|
|
enum
|
|
{
|
|
DISTANCE_IN = 1,
|
|
DISTANCE_OUT = -1,
|
|
ROLL_LEFT = -1,
|
|
ROLL_RIGHT = 1
|
|
};
|
|
|
|
enum Gesture
|
|
{
|
|
GESTURE_OPEN = 0x00,
|
|
GESTURE_FINGER = 0x0F,
|
|
GESTURE_FIST = 0xFF
|
|
};
|
|
|
|
enum
|
|
{
|
|
SELECT = 0x1,
|
|
START = 0x2
|
|
};
|
|
|
|
uchar x;
|
|
uchar y;
|
|
schar distance;
|
|
schar wrist;
|
|
Gesture gesture;
|
|
uint buttons;
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,PowerGlove&);
|
|
|
|
static PollCaller1<PowerGlove> callback;
|
|
};
|
|
|
|
/**
|
|
* Mouse.
|
|
*/
|
|
struct Mouse
|
|
{
|
|
uint x;
|
|
uint y;
|
|
uint button;
|
|
|
|
Mouse()
|
|
: x(0), y(0), button(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Mouse&);
|
|
|
|
static PollCaller1<Mouse> callback;
|
|
};
|
|
|
|
/**
|
|
* Family Trainer.
|
|
*/
|
|
struct FamilyTrainer
|
|
{
|
|
FamilyTrainer() throw();
|
|
|
|
enum
|
|
{
|
|
NUM_SIDE_A_BUTTONS = 12,
|
|
NUM_SIDE_B_BUTTONS = 8
|
|
};
|
|
|
|
bool sideA[NUM_SIDE_A_BUTTONS];
|
|
bool sideB[NUM_SIDE_B_BUTTONS];
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,FamilyTrainer&);
|
|
|
|
static PollCaller1<FamilyTrainer> callback;
|
|
};
|
|
|
|
/**
|
|
* Family Keyboard.
|
|
*/
|
|
struct FamilyKeyboard
|
|
{
|
|
FamilyKeyboard() throw();
|
|
|
|
enum
|
|
{
|
|
NUM_PARTS = 9,
|
|
NUM_MODES = 2
|
|
};
|
|
|
|
uchar parts[NUM_PARTS+3];
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,FamilyKeyboard&,uint,uint);
|
|
|
|
static PollCaller3<FamilyKeyboard> callback;
|
|
};
|
|
|
|
/**
|
|
* Subor Keyboard.
|
|
*/
|
|
struct SuborKeyboard
|
|
{
|
|
SuborKeyboard() throw();
|
|
|
|
enum
|
|
{
|
|
NUM_PARTS = 10,
|
|
NUM_MODES = 2
|
|
};
|
|
|
|
uchar parts[NUM_PARTS+2];
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,SuborKeyboard&,uint,uint);
|
|
|
|
static PollCaller3<SuborKeyboard> callback;
|
|
};
|
|
|
|
/**
|
|
* Doremikko Keyboard.
|
|
*/
|
|
struct DoremikkoKeyboard
|
|
{
|
|
enum
|
|
{
|
|
PART_1 = 1,
|
|
PART_2 = 2,
|
|
PART_3 = 3,
|
|
PART_4 = 4,
|
|
PART_5 = 5,
|
|
PART_6 = 6,
|
|
PART_7 = 7,
|
|
MODE_A = 0,
|
|
MODE_A_0 = 0x02,
|
|
MODE_A_1 = 0x04,
|
|
MODE_A_2 = 0x08,
|
|
MODE_A_3 = 0x10,
|
|
MODE_B = 1,
|
|
MODE_B_0 = 0x02,
|
|
MODE_B_1 = 0x04
|
|
};
|
|
|
|
uint keys;
|
|
|
|
DoremikkoKeyboard()
|
|
: keys(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,DoremikkoKeyboard&,uint,uint);
|
|
|
|
static PollCaller3<DoremikkoKeyboard> callback;
|
|
};
|
|
|
|
/**
|
|
* Hori Track.
|
|
*/
|
|
struct HoriTrack
|
|
{
|
|
enum
|
|
{
|
|
BUTTON_A = Pad::A,
|
|
BUTTON_B = Pad::B,
|
|
BUTTON_SELECT = Pad::SELECT,
|
|
BUTTON_START = Pad::START,
|
|
BUTTON_UP = Pad::UP,
|
|
BUTTON_DOWN = Pad::DOWN,
|
|
BUTTON_LEFT = Pad::LEFT,
|
|
BUTTON_RIGHT = Pad::RIGHT
|
|
};
|
|
|
|
enum
|
|
{
|
|
MODE_REVERSED = 0x1,
|
|
MODE_LOWSPEED = 0x2
|
|
};
|
|
|
|
uint x;
|
|
uint y;
|
|
uint buttons;
|
|
uint mode;
|
|
|
|
HoriTrack()
|
|
: x(0), y(0), buttons(0), mode(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,HoriTrack&);
|
|
|
|
static PollCaller1<HoriTrack> callback;
|
|
};
|
|
|
|
/**
|
|
* Pachinko.
|
|
*/
|
|
struct Pachinko
|
|
{
|
|
enum
|
|
{
|
|
BUTTON_A = Pad::A,
|
|
BUTTON_B = Pad::B,
|
|
BUTTON_SELECT = Pad::SELECT,
|
|
BUTTON_START = Pad::START,
|
|
BUTTON_UP = Pad::UP,
|
|
BUTTON_DOWN = Pad::DOWN,
|
|
BUTTON_LEFT = Pad::LEFT,
|
|
BUTTON_RIGHT = Pad::RIGHT
|
|
};
|
|
|
|
enum
|
|
{
|
|
MIN_THROTTLE = -64,
|
|
MAX_THROTTLE = +63
|
|
};
|
|
|
|
uint buttons;
|
|
int throttle;
|
|
|
|
Pachinko()
|
|
: buttons(0), throttle(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Pachinko&);
|
|
|
|
static PollCaller1<Pachinko> callback;
|
|
};
|
|
|
|
/**
|
|
* VS System input.
|
|
*/
|
|
struct VsSystem
|
|
{
|
|
enum
|
|
{
|
|
COIN_1 = 0x20,
|
|
COIN_2 = 0x40
|
|
};
|
|
|
|
uint insertCoin;
|
|
|
|
VsSystem()
|
|
: insertCoin(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,VsSystem&);
|
|
|
|
static PollCaller1<VsSystem> callback;
|
|
};
|
|
|
|
/**
|
|
* Oeka Kids Tablet.
|
|
*/
|
|
struct OekaKidsTablet
|
|
{
|
|
uint x;
|
|
uint y;
|
|
uint button;
|
|
|
|
OekaKidsTablet()
|
|
: x(0), y(0), button(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,OekaKidsTablet&);
|
|
|
|
static PollCaller1<OekaKidsTablet> callback;
|
|
};
|
|
|
|
/**
|
|
* Konami Hyper Shot.
|
|
*/
|
|
struct KonamiHyperShot
|
|
{
|
|
enum
|
|
{
|
|
PLAYER1_BUTTON_1 = 0x02,
|
|
PLAYER1_BUTTON_2 = 0x04,
|
|
PLAYER2_BUTTON_1 = 0x08,
|
|
PLAYER2_BUTTON_2 = 0x10
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
KonamiHyperShot()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,KonamiHyperShot&);
|
|
|
|
static PollCaller1<KonamiHyperShot> callback;
|
|
};
|
|
|
|
/**
|
|
* Bandai Hyper Shot
|
|
*/
|
|
struct BandaiHyperShot
|
|
{
|
|
uint x;
|
|
uint y;
|
|
uint fire;
|
|
uint move;
|
|
|
|
BandaiHyperShot()
|
|
: x(0), y(0), fire(0), move(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,BandaiHyperShot&);
|
|
|
|
static PollCaller1<BandaiHyperShot> callback;
|
|
};
|
|
|
|
/**
|
|
* Crazy Climber.
|
|
*/
|
|
struct CrazyClimber
|
|
{
|
|
enum
|
|
{
|
|
RIGHT = 0x10,
|
|
LEFT = 0x20,
|
|
UP = 0x40,
|
|
DOWN = 0x80
|
|
};
|
|
|
|
uint left;
|
|
uint right;
|
|
|
|
CrazyClimber()
|
|
: left(0), right(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,CrazyClimber&);
|
|
|
|
static PollCaller1<CrazyClimber> callback;
|
|
};
|
|
|
|
/**
|
|
* Mahjong.
|
|
*/
|
|
struct Mahjong
|
|
{
|
|
enum
|
|
{
|
|
PART_1 = 0x02,
|
|
PART_1_I = 0x80,
|
|
PART_1_J = 0x40,
|
|
PART_1_K = 0x20,
|
|
PART_1_L = 0x10,
|
|
PART_1_M = 0x08,
|
|
PART_1_N = 0x04,
|
|
PART_2 = 0x04,
|
|
PART_2_A = 0x80,
|
|
PART_2_B = 0x40,
|
|
PART_2_C = 0x20,
|
|
PART_2_D = 0x10,
|
|
PART_2_E = 0x08,
|
|
PART_2_F = 0x04,
|
|
PART_2_G = 0x02,
|
|
PART_2_H = 0x01,
|
|
PART_3 = 0x06,
|
|
PART_3_START = 0x80,
|
|
PART_3_SELECT = 0x40,
|
|
PART_3_KAN = 0x20,
|
|
PART_3_PON = 0x10,
|
|
PART_3_CHI = 0x08,
|
|
PART_3_REACH = 0x04,
|
|
PART_3_RON = 0x02,
|
|
NUM_PARTS = 3
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
Mahjong()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,Mahjong&,uint);
|
|
|
|
static PollCaller2<Mahjong> callback;
|
|
};
|
|
|
|
/**
|
|
* Konami Exciting Boxing.
|
|
*/
|
|
struct ExcitingBoxing
|
|
{
|
|
enum
|
|
{
|
|
PART_1 = 0x00,
|
|
PART_1_RIGHT_HOOK = 0x10,
|
|
PART_1_LEFT_MOVE = 0x08,
|
|
PART_1_RIGHT_MOVE = 0x04,
|
|
PART_1_LEFT_HOOK = 0x02,
|
|
PART_2 = 0x02,
|
|
PART_2_STRAIGHT = 0x10,
|
|
PART_2_RIGHT_JAB = 0x08,
|
|
PART_2_BODY = 0x04,
|
|
PART_2_LEFT_JAB = 0x02,
|
|
NUM_PARTS = 2
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
ExcitingBoxing()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,ExcitingBoxing&,uint);
|
|
|
|
static PollCaller2<ExcitingBoxing> callback;
|
|
};
|
|
|
|
/**
|
|
* Top Rider bike.
|
|
*/
|
|
struct TopRider
|
|
{
|
|
enum
|
|
{
|
|
BRAKE = 0x01,
|
|
ACCEL = 0x02,
|
|
SELECT = 0x04,
|
|
START = 0x08,
|
|
SHIFT_GEAR = 0x10,
|
|
REAR = 0x20,
|
|
STEER_LEFT = 0x40,
|
|
STEER_RIGHT = 0x80
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
TopRider()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,TopRider&);
|
|
|
|
static PollCaller1<TopRider> callback;
|
|
};
|
|
|
|
/**
|
|
* Pokkun Moguraa.
|
|
*/
|
|
struct PokkunMoguraa
|
|
{
|
|
enum
|
|
{
|
|
ROW_1 = 0x04,
|
|
ROW_2 = 0x02,
|
|
ROW_3 = 0x01,
|
|
NUM_ROWS = 3,
|
|
BUTTON_1 = 0x02,
|
|
BUTTON_2 = 0x04,
|
|
BUTTON_3 = 0x08,
|
|
BUTTON_4 = 0x10
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
PokkunMoguraa()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,PokkunMoguraa&,uint);
|
|
|
|
static PollCaller2<PokkunMoguraa> callback;
|
|
};
|
|
|
|
/**
|
|
* Party Tap.
|
|
*/
|
|
struct PartyTap
|
|
{
|
|
enum
|
|
{
|
|
UNIT_1 = 0x04,
|
|
UNIT_2 = 0x08,
|
|
UNIT_3 = 0x10,
|
|
UNIT_4 = 0x20,
|
|
UNIT_5 = 0x40,
|
|
UNIT_6 = 0x80
|
|
};
|
|
|
|
uint units;
|
|
|
|
PartyTap()
|
|
: units(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,PartyTap&);
|
|
|
|
static PollCaller1<PartyTap> callback;
|
|
};
|
|
|
|
/**
|
|
* Bandai Karaoke Studio.
|
|
*/
|
|
struct KaraokeStudio
|
|
{
|
|
enum
|
|
{
|
|
A = 0x1,
|
|
B = 0x2,
|
|
MIC = 0x4
|
|
};
|
|
|
|
uint buttons;
|
|
|
|
KaraokeStudio()
|
|
: buttons(0) {}
|
|
|
|
typedef bool (NST_CALLBACK *PollCallback) (void*,KaraokeStudio&);
|
|
|
|
static PollCaller1<KaraokeStudio> callback;
|
|
};
|
|
|
|
Pad pad[NUM_PADS];
|
|
Zapper zapper;
|
|
Paddle paddle;
|
|
PowerPad powerPad;
|
|
PowerGlove powerGlove;
|
|
Mouse mouse;
|
|
FamilyTrainer familyTrainer;
|
|
FamilyKeyboard familyKeyboard;
|
|
SuborKeyboard suborKeyboard;
|
|
DoremikkoKeyboard doremikkoKeyboard;
|
|
HoriTrack horiTrack;
|
|
Pachinko pachinko;
|
|
VsSystem vsSystem;
|
|
OekaKidsTablet oekaKidsTablet;
|
|
KonamiHyperShot konamiHyperShot;
|
|
BandaiHyperShot bandaiHyperShot;
|
|
CrazyClimber crazyClimber;
|
|
Mahjong mahjong;
|
|
ExcitingBoxing excitingBoxing;
|
|
TopRider topRider;
|
|
PokkunMoguraa pokkunMoguraa;
|
|
PartyTap partyTap;
|
|
KaraokeStudio karaokeStudio;
|
|
};
|
|
}
|
|
}
|
|
|
|
namespace Api
|
|
{
|
|
/**
|
|
* Controller input interface.
|
|
*/
|
|
class Input : public Base
|
|
{
|
|
struct ControllerCaller;
|
|
struct AdapterCaller;
|
|
|
|
public:
|
|
|
|
/**
|
|
* Interface constructor.
|
|
*
|
|
* @param instance emulator instance
|
|
*/
|
|
template<typename T>
|
|
Input(T& instance)
|
|
: Base(instance) {}
|
|
|
|
enum
|
|
{
|
|
NUM_CONTROLLERS = Core::Input::NUM_CONTROLLERS,
|
|
NUM_PADS = Core::Input::NUM_PADS
|
|
};
|
|
|
|
/**
|
|
* Adapter type.
|
|
*/
|
|
enum Adapter
|
|
{
|
|
/**
|
|
* NES adapter.
|
|
*/
|
|
ADAPTER_NES,
|
|
/**
|
|
* Famicom adapter.
|
|
*/
|
|
ADAPTER_FAMICOM
|
|
};
|
|
|
|
/**
|
|
* Controller type.
|
|
*/
|
|
enum Type
|
|
{
|
|
/**
|
|
* Unconnected.
|
|
*/
|
|
UNCONNECTED,
|
|
/**
|
|
* Standard pad #1
|
|
*/
|
|
PAD1,
|
|
/**
|
|
* Standard pad #2
|
|
*/
|
|
PAD2,
|
|
/**
|
|
* Standard pad #3
|
|
*/
|
|
PAD3,
|
|
/**
|
|
* Standard pad #4
|
|
*/
|
|
PAD4,
|
|
/**
|
|
* Zapper.
|
|
*/
|
|
ZAPPER,
|
|
/**
|
|
* Arkanoid paddle.
|
|
*/
|
|
PADDLE,
|
|
/**
|
|
* Powerpad.
|
|
*/
|
|
POWERPAD,
|
|
/**
|
|
* Powerglove.
|
|
*/
|
|
POWERGLOVE,
|
|
/**
|
|
* Mouse.
|
|
*/
|
|
MOUSE,
|
|
/**
|
|
* R.O.B.
|
|
*/
|
|
ROB,
|
|
/**
|
|
* Family Trainer.
|
|
*/
|
|
FAMILYTRAINER,
|
|
/**
|
|
* Family keyboard.
|
|
*/
|
|
FAMILYKEYBOARD,
|
|
/**
|
|
* Subor keyboard.
|
|
*/
|
|
SUBORKEYBOARD,
|
|
/**
|
|
* Doremikko keyboard.
|
|
*/
|
|
DOREMIKKOKEYBOARD,
|
|
/**
|
|
* Horitrack.
|
|
*/
|
|
HORITRACK,
|
|
/**
|
|
* Pachinko.
|
|
*/
|
|
PACHINKO,
|
|
/**
|
|
* Oeka Kids tablet.
|
|
*/
|
|
OEKAKIDSTABLET,
|
|
/**
|
|
* Konami hypershot.
|
|
*/
|
|
KONAMIHYPERSHOT,
|
|
/**
|
|
* Bandai hypershot.
|
|
*/
|
|
BANDAIHYPERSHOT,
|
|
/**
|
|
* Crazy Climber.
|
|
*/
|
|
CRAZYCLIMBER,
|
|
/**
|
|
* Mahjong.
|
|
*/
|
|
MAHJONG,
|
|
/**
|
|
* Exciting Boxing.
|
|
*/
|
|
EXCITINGBOXING,
|
|
/**
|
|
* Top Rider bike.
|
|
*/
|
|
TOPRIDER,
|
|
/**
|
|
* Pokkun Moguraa.
|
|
*/
|
|
POKKUNMOGURAA,
|
|
/**
|
|
* Party Tap.
|
|
*/
|
|
PARTYTAP,
|
|
/**
|
|
* Turbo File.
|
|
*/
|
|
TURBOFILE,
|
|
/**
|
|
* Barcode World.
|
|
*/
|
|
BARCODEWORLD
|
|
};
|
|
|
|
enum
|
|
{
|
|
PORT_1,
|
|
PORT_2,
|
|
PORT_3,
|
|
PORT_4,
|
|
EXPANSION_PORT,
|
|
NUM_PORTS
|
|
};
|
|
|
|
/**
|
|
* Controllers context.
|
|
*/
|
|
typedef Core::Input::Controllers Controllers;
|
|
|
|
/**
|
|
* Connects the most suited controller for a game into a port.
|
|
*
|
|
* @param port controller port
|
|
* @return result code
|
|
*/
|
|
Result AutoSelectController(uint port) throw();
|
|
|
|
/**
|
|
* Connects the most suited controllers for a game into all ports.
|
|
*
|
|
* @return result code
|
|
*/
|
|
Result AutoSelectControllers() throw();
|
|
|
|
/**
|
|
* Connects the most suited adapter for a game.
|
|
*/
|
|
Result AutoSelectAdapter() throw();
|
|
|
|
/**
|
|
* Connects a controller to a port.
|
|
*
|
|
* @param port port
|
|
* @param type controller
|
|
* @result result code
|
|
*/
|
|
Result ConnectController(uint port,Type type) throw();
|
|
|
|
/**
|
|
* Connects an adapter.
|
|
*
|
|
* @param type adapter
|
|
* @return result code
|
|
*/
|
|
Result ConnectAdapter(Adapter type) throw();
|
|
|
|
/**
|
|
* Returns the current connected controller.
|
|
*
|
|
* @param port port
|
|
* @return controller
|
|
*/
|
|
Type GetConnectedController(uint port) const throw();
|
|
|
|
/**
|
|
* Returns the current connected adapter.
|
|
*
|
|
* @return adapter
|
|
*/
|
|
Adapter GetConnectedAdapter() const throw();
|
|
|
|
/**
|
|
* Checks if a specific controller is connected.
|
|
*
|
|
* @param type controller
|
|
* @return true if connected
|
|
*/
|
|
bool IsControllerConnected(Type type) const throw();
|
|
|
|
/**
|
|
* Controller event callback prototype.
|
|
*
|
|
* Will be invoked every time a new controller is connected to a port.
|
|
*
|
|
* @param userData optional user data
|
|
* @param port port
|
|
* @param type controller
|
|
*/
|
|
typedef void (NST_CALLBACK *ControllerCallback) (UserData userData,uint port,Type type);
|
|
|
|
/**
|
|
* Adapter event callback prototype.
|
|
*
|
|
* Will be invoked every time a new adapter is connected.
|
|
*
|
|
* @param userData optional user data
|
|
* @param adapter adapter type
|
|
*/
|
|
typedef void (NST_CALLBACK *AdapterCallback) (UserData userData,Adapter adapter);
|
|
|
|
/**
|
|
* Controller event callback manager.
|
|
*
|
|
* Static object used for adding the user defined callback.
|
|
*/
|
|
static ControllerCaller controllerCallback;
|
|
|
|
/**
|
|
* Adapter event callback manager.
|
|
*
|
|
* Static object used for adding the user defined callback.
|
|
*/
|
|
static AdapterCaller adapterCallback;
|
|
};
|
|
|
|
/**
|
|
* Controller event callback invoker.
|
|
*
|
|
* Used internally by the core.
|
|
*/
|
|
struct Input::ControllerCaller : Core::UserCallback<Input::ControllerCallback>
|
|
{
|
|
void operator () (uint port,Type type) const
|
|
{
|
|
if (function)
|
|
function( userdata, port, type );
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Adapter event callback invoker.
|
|
*
|
|
* Used internally by the core.
|
|
*/
|
|
struct Input::AdapterCaller : Core::UserCallback<Input::AdapterCallback>
|
|
{
|
|
void operator () (Adapter adapter) const
|
|
{
|
|
if (function)
|
|
function( userdata, adapter );
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
#if NST_MSVC >= 1200 || NST_ICC >= 810
|
|
#pragma warning( pop )
|
|
#endif
|
|
|
|
#endif
|