[gpsp.git] / input.c

/* gameplaySP
 *
 * Copyright (C) 2006 Exophase <exophase@gmail.com>
 *
 * 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 the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "common.h"

// Special thanks to psp298 for the analog->dpad code!

void trigger_key(u32 key)
{
  u32 p1_cnt = io_registers[REG_P1CNT];
  u32 p1;

  if((p1_cnt >> 14) & 0x01)
  {
    u32 key_intersection = (p1_cnt & key) & 0x3FF;

    if(p1_cnt >> 15)
    {
      if(key_intersection == (p1_cnt & 0x3FF))
        raise_interrupt(IRQ_KEYPAD);
    }
    else
    {
      if(key_intersection)
        raise_interrupt(IRQ_KEYPAD);
    }
  }
}

u32 key = 0;

u32 global_enable_analog = 1;
u32 analog_sensitivity_level = 4;

typedef enum
{
  BUTTON_NOT_HELD,
  BUTTON_HELD_INITIAL,
  BUTTON_HELD_REPEAT
} button_repeat_state_type;


// These define autorepeat values (in microseconds), tweak as necessary.

#define BUTTON_REPEAT_START    200000
#define BUTTON_REPEAT_CONTINUE 50000

button_repeat_state_type button_repeat_state = BUTTON_NOT_HELD;
u32 button_repeat = 0;
gui_action_type cursor_repeat = CURSOR_NONE;


#ifdef PSP_BUILD

u32 gamepad_config_map[16] =
{
  BUTTON_ID_MENU,               // Triangle
  BUTTON_ID_A,                  // Circle
  BUTTON_ID_B,                  // Cross
  BUTTON_ID_START,              // Square
  BUTTON_ID_L,                  // Ltrigger
  BUTTON_ID_R,                  // Rtrigger
  BUTTON_ID_DOWN,               // Down
  BUTTON_ID_LEFT,               // Left
  BUTTON_ID_UP,                 // Up
  BUTTON_ID_RIGHT,              // Right
  BUTTON_ID_SELECT,             // Select
  BUTTON_ID_START,              // Start
  BUTTON_ID_UP,                 // Analog up
  BUTTON_ID_DOWN,               // Analog down
  BUTTON_ID_LEFT,               // Analog left
  BUTTON_ID_RIGHT               // Analog right
};

#define PSP_ALL_BUTTON_MASK 0xFFFF

gui_action_type get_gui_input()
{
  SceCtrlData ctrl_data;
  gui_action_type new_button = CURSOR_NONE;
  u32 new_buttons;

  static u32 last_buttons = 0;
  static u64 button_repeat_timestamp;

  delay_us(25000);

  sceCtrlPeekBufferPositive(&ctrl_data, 1);
  ctrl_data.Buttons &= PSP_ALL_BUTTON_MASK;
  new_buttons = (last_buttons ^ ctrl_data.Buttons) & ctrl_data.Buttons;
  last_buttons = ctrl_data.Buttons;

  if(new_buttons & PSP_CTRL_LEFT)
    new_button = CURSOR_LEFT;

  if(new_buttons & PSP_CTRL_RIGHT)
    new_button = CURSOR_RIGHT;

  if(new_buttons & PSP_CTRL_UP)
    new_button = CURSOR_UP;

  if(new_buttons & PSP_CTRL_DOWN)
    new_button = CURSOR_DOWN;

  if(new_buttons & PSP_CTRL_START)
    new_button = CURSOR_SELECT;

  if(new_buttons & PSP_CTRL_CIRCLE)
    new_button = CURSOR_SELECT;

  if(new_buttons & PSP_CTRL_CROSS)
    new_button = CURSOR_EXIT;

  if(new_buttons & PSP_CTRL_SQUARE)
    new_button = CURSOR_BACK;

  if(new_button != CURSOR_NONE)
  {
    get_ticks_us(&button_repeat_timestamp);
    button_repeat_state = BUTTON_HELD_INITIAL;
    button_repeat = new_buttons;
    cursor_repeat = new_button;
  }
  else
  {
    if(ctrl_data.Buttons & button_repeat)
    {
      u64 new_ticks;
      get_ticks_us(&new_ticks);

      if(button_repeat_state == BUTTON_HELD_INITIAL)
      {
        if((new_ticks - button_repeat_timestamp) >
         BUTTON_REPEAT_START)
        {
          new_button = cursor_repeat;
          button_repeat_timestamp = new_ticks;
          button_repeat_state = BUTTON_HELD_REPEAT;
        }
      }

      if(button_repeat_state == BUTTON_HELD_REPEAT)
      {
        if((new_ticks - button_repeat_timestamp) >
         BUTTON_REPEAT_CONTINUE)
        {
          new_button = cursor_repeat;
          button_repeat_timestamp = new_ticks;
        }
      }
    }
  }

  return new_button;
}

#define PSP_CTRL_ANALOG_UP    (1 << 28)
#define PSP_CTRL_ANALOG_DOWN  (1 << 29)
#define PSP_CTRL_ANALOG_LEFT  (1 << 30)
#define PSP_CTRL_ANALOG_RIGHT (1 << 31)

u32 button_psp_mask_to_config[] =
{
  PSP_CTRL_TRIANGLE,
  PSP_CTRL_CIRCLE,
  PSP_CTRL_CROSS,
  PSP_CTRL_SQUARE,
  PSP_CTRL_LTRIGGER,
  PSP_CTRL_RTRIGGER,
  PSP_CTRL_DOWN,
  PSP_CTRL_LEFT,
  PSP_CTRL_UP,
  PSP_CTRL_RIGHT,
  PSP_CTRL_SELECT,
  PSP_CTRL_START,
  PSP_CTRL_ANALOG_UP,
  PSP_CTRL_ANALOG_DOWN,
  PSP_CTRL_ANALOG_LEFT,
  PSP_CTRL_ANALOG_RIGHT
};

u32 button_id_to_gba_mask[] =
{
  BUTTON_UP,
  BUTTON_DOWN,
  BUTTON_LEFT,
  BUTTON_RIGHT,
  BUTTON_A,
  BUTTON_B,
  BUTTON_L,
  BUTTON_R,
  BUTTON_START,
  BUTTON_SELECT,
  BUTTON_NONE,
  BUTTON_NONE,
  BUTTON_NONE,
  BUTTON_NONE
};

gui_action_type get_gui_input_fs_hold(u32 button_id)
{
  gui_action_type new_button = get_gui_input();
  if((last_buttons & button_psp_mask_to_config[button_id]) == 0)
    return CURSOR_BACK;

  return new_button;
}

u32 rapidfire_flag = 1;

u32 update_input()
{
  SceCtrlData ctrl_data;
  u32 buttons;
  u32 non_repeat_buttons;
  u32 button_id;
  u32 i;
  u32 new_key = 0;
  u32 analog_sensitivity = 92 - (analog_sensitivity_level * 4);
  u32 inv_analog_sensitivity = 256 - analog_sensitivity;

  sceCtrlPeekBufferPositive(&ctrl_data, 1);

  buttons = ctrl_data.Buttons;

  if(global_enable_analog)
  {
    if(ctrl_data.Lx < analog_sensitivity)
      buttons |= PSP_CTRL_ANALOG_LEFT;

    if(ctrl_data.Lx > inv_analog_sensitivity)
      buttons |= PSP_CTRL_ANALOG_RIGHT;

    if(ctrl_data.Ly < analog_sensitivity)
      buttons |= PSP_CTRL_ANALOG_UP;

    if(ctrl_data.Ly > inv_analog_sensitivity)
      buttons |= PSP_CTRL_ANALOG_DOWN;
  }

  non_repeat_buttons = (last_buttons ^ buttons) & buttons;
  last_buttons = buttons;

  for(i = 0; i < 16; i++)
  {
    if(non_repeat_buttons & button_psp_mask_to_config[i])
      button_id = gamepad_config_map[i];
    else
      button_id = BUTTON_ID_NONE;

    switch(button_id)
    {
      case BUTTON_ID_MENU:
      {
        u16 *screen_copy = copy_screen();
        u32 ret_val = menu(screen_copy);
        free(screen_copy);

        return ret_val;
      }

      case BUTTON_ID_LOADSTATE:
      {
        u8 current_savestate_filename[512];
        get_savestate_filename_noshot(savestate_slot,
         current_savestate_filename);
        load_state(current_savestate_filename);
        return 1;
      }

      case BUTTON_ID_SAVESTATE:
      {
        u8 current_savestate_filename[512];
        u16 *current_screen = copy_screen();
        get_savestate_filename_noshot(savestate_slot,
         current_savestate_filename);
        save_state(current_savestate_filename, current_screen);
        free(current_screen);
        return 0;
      }

      case BUTTON_ID_FASTFORWARD:
        print_string("FASTFORWARD", 0xFFFF, 0x0000, 0, 50);
        synchronize_flag ^= 1;
        return 0;
    }

    if(buttons & button_psp_mask_to_config[i])
    {
      button_id = gamepad_config_map[i];
      if(button_id < BUTTON_ID_MENU)
      {
        new_key |= button_id_to_gba_mask[button_id];
      }
      else

      if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
       (button_id <= BUTTON_ID_RAPIDFIRE_L))
      {
        rapidfire_flag ^= 1;
        if(rapidfire_flag)
        {
          new_key |= button_id_to_gba_mask[button_id -
           BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
        }
        else
        {
          new_key &= ~button_id_to_gba_mask[button_id -
           BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
        }
      }
    }
  }

  if((new_key | key) != key)
    trigger_key(new_key);

  key = new_key;

  io_registers[REG_P1] = (~key) & 0x3FF;

  return 0;
}

void init_input()
{
  sceCtrlSetSamplingCycle(0);
  sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
}

#endif


#ifdef GP2X_BUILD

// GP2X SDL requires a user made input method
#include <sys/mman.h>
#include <sys/ioctl.h>
#include "gp2x/gp2x.h"

u32 gamepad_config_map[16] =
{
  BUTTON_ID_UP,                 // Up
  BUTTON_ID_LEFT,               // Left
  BUTTON_ID_DOWN,               // Down
  BUTTON_ID_RIGHT,              // Right
  BUTTON_ID_START,              // Start
  BUTTON_ID_SELECT,             // Select
  BUTTON_ID_L,                  // Ltrigger
  BUTTON_ID_R,                  // Rtrigger
  BUTTON_ID_FPS,                // A
  BUTTON_ID_A,                  // B
  BUTTON_ID_B,                  // X
  BUTTON_ID_MENU,               // Y
  BUTTON_ID_VOLDOWN,            // Vol down
  BUTTON_ID_VOLUP,              // Vol up
  BUTTON_ID_FPS,                // Push
  BUTTON_ID_MENU                // Vol middle
};

extern u32 fps_debug;
extern u32 gpsp_gp2x_joystick_read(void);

gui_action_type get_gui_input()
{
  gui_action_type new_button = CURSOR_NONE;
  u32 buttons = gpsp_gp2x_joystick_read();
  u32 new_buttons;

  static u32 last_buttons = 0;
  static u64 button_repeat_timestamp;

  delay_us(25000);

  new_buttons = (last_buttons ^ buttons) & buttons;
  last_buttons = buttons;

  if(new_buttons & GP2X_A)
    new_button = CURSOR_BACK;

  if(new_buttons & GP2X_X)
    new_button = CURSOR_EXIT;

  if(new_buttons & GP2X_B)
    new_button = CURSOR_SELECT;

  if(new_buttons & GP2X_UP)
    new_button = CURSOR_UP;

  if(new_buttons & GP2X_DOWN)
    new_button = CURSOR_DOWN;

  if(new_buttons & GP2X_LEFT)
    new_button = CURSOR_LEFT;

  if(new_buttons & GP2X_RIGHT)
    new_button = CURSOR_RIGHT;

  if(new_buttons & GP2X_L)
    new_button = CURSOR_L;

  if(new_buttons & GP2X_R)
    new_button = CURSOR_R;


  if(new_button != CURSOR_NONE)
  {
    get_ticks_us(&button_repeat_timestamp);
    button_repeat_state = BUTTON_HELD_INITIAL;
    button_repeat = new_buttons;
    cursor_repeat = new_button;
  }
  else
  {
    if(buttons & button_repeat)
    {
      u64 new_ticks;
      get_ticks_us(&new_ticks);

      if(button_repeat_state == BUTTON_HELD_INITIAL)
      {
        if((new_ticks - button_repeat_timestamp) >
         BUTTON_REPEAT_START)
        {
          new_button = cursor_repeat;
          button_repeat_timestamp = new_ticks;
          button_repeat_state = BUTTON_HELD_REPEAT;
        }
      }

      if(button_repeat_state == BUTTON_HELD_REPEAT)
      {
        if((new_ticks - button_repeat_timestamp) >
         BUTTON_REPEAT_CONTINUE)
        {
          new_button = cursor_repeat;
          button_repeat_timestamp = new_ticks;
        }
      }
    }
  }

  return new_button;
}

#define GP2X_VOL_MIDDLE (1 << 24)

u32 button_gp2x_mask_to_config[] =
{
  GP2X_UP,
  GP2X_LEFT,
  GP2X_DOWN,
  GP2X_RIGHT,
  GP2X_START,
  GP2X_SELECT,
  GP2X_L,
  GP2X_R,
  GP2X_A,
  GP2X_B,
  GP2X_X,
  GP2X_Y,
  GP2X_VOL_DOWN,
  GP2X_VOL_UP,
  GP2X_PUSH,
  GP2X_VOL_MIDDLE
};

u32 button_id_to_gba_mask[] =
{
  BUTTON_UP,
  BUTTON_DOWN,
  BUTTON_LEFT,
  BUTTON_RIGHT,
  BUTTON_A,
  BUTTON_B,
  BUTTON_L,
  BUTTON_R,
  BUTTON_START,
  BUTTON_SELECT,
  BUTTON_NONE,
  BUTTON_NONE,
  BUTTON_NONE,
  BUTTON_NONE
};

u32 update_input()
{
  static u32 rapidfire_flag = 1;
  static u32 last_buttons;
  u32 handled_buttons;
  u32 button_id;
  u32 new_key = 0;
  u32 buttons = gpsp_gp2x_joystick_read();
  u32 i;

  if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_VOL_UP))
  {
    buttons &= ~(GP2X_VOL_DOWN | GP2X_VOL_UP);
    buttons |= GP2X_VOL_MIDDLE;
  }

  /* for Wiz */
  if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_SELECT))
  {
    buttons &= ~(GP2X_VOL_DOWN | GP2X_SELECT);
    buttons |= GP2X_VOL_MIDDLE;
  }

  handled_buttons = ((last_buttons ^ buttons) | GP2X_VOL_DOWN | GP2X_VOL_UP) & buttons;
  last_buttons = buttons;

  for(i = 0; i < 16; i++)
  {
    if(handled_buttons & button_gp2x_mask_to_config[i])
      button_id = gamepad_config_map[i];
    else
      button_id = BUTTON_ID_NONE;

    switch(button_id)
    {
      case BUTTON_ID_MENU:
      {
        u16 *screen_copy = copy_screen();
        u32 ret_val = menu(screen_copy);
        free(screen_copy);

        return ret_val;
      }

      case BUTTON_ID_LOADSTATE:
      {
        u8 current_savestate_filename[512];
        get_savestate_filename_noshot(savestate_slot,
         current_savestate_filename);
        load_state(current_savestate_filename);
        return 1;
      }

      case BUTTON_ID_SAVESTATE:
      {
        u8 current_savestate_filename[512];
        u16 *current_screen = copy_screen();
        get_savestate_filename_noshot(savestate_slot,
         current_savestate_filename);
        save_state(current_savestate_filename, current_screen);
        free(current_screen);
        return 0;
      }

      case BUTTON_ID_FASTFORWARD:
        print_string("FASTFORWARD", 0xFFFF, 0x0000, 0, 50);
        synchronize_flag ^= 1;
        return 0;

      case BUTTON_ID_VOLUP:
        gp2x_sound_volume(1);
        break;

      case BUTTON_ID_VOLDOWN:
        gp2x_sound_volume(0);
        break;

      case BUTTON_ID_FPS:
        fps_debug ^= 1;
        break;
    }

    if(buttons & button_gp2x_mask_to_config[i])
    {
      button_id = gamepad_config_map[i];
      if(button_id < BUTTON_ID_MENU)
      {
        new_key |= button_id_to_gba_mask[button_id];
      }
      else

      if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
       (button_id <= BUTTON_ID_RAPIDFIRE_L))
      {
        rapidfire_flag ^= 1;
        if(rapidfire_flag)
        {
          new_key |= button_id_to_gba_mask[button_id -
           BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
        }
        else
        {
          new_key &= ~button_id_to_gba_mask[button_id -
           BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
        }
      }
    }
  }

  if((new_key | key) != key)
    trigger_key(new_key);

  key = new_key;

  io_registers[REG_P1] = (~key) & 0x3FF;

  return 0;
}

void init_input()
{

}

#endif


#ifdef PC_BUILD

u32 key_map(SDLKey key_sym)
{
  switch(key_sym)
  {
    case SDLK_LSHIFT:
      return BUTTON_L;

    case SDLK_x:
      return BUTTON_R;

    case SDLK_DOWN:
      return BUTTON_DOWN;

    case SDLK_UP:
      return BUTTON_UP;

    case SDLK_LEFT:
      return BUTTON_LEFT;

    case SDLK_RIGHT:
      return BUTTON_RIGHT;

    case SDLK_RETURN:
      return BUTTON_START;

    case SDLK_RSHIFT:
      return BUTTON_SELECT;

    case SDLK_LCTRL:
      return BUTTON_B;

    case SDLK_LALT:
      return BUTTON_A;

    default:
      return BUTTON_NONE;
  }
}

u32 joy_map(u32 button)
{
  switch(button)
  {
    case 4:
      return BUTTON_L;

    case 5:
      return BUTTON_R;

    case 9:
      return BUTTON_START;

    case 8:
      return BUTTON_SELECT;

    case 0:
      return BUTTON_B;

    case 1:
      return BUTTON_A;

    default:
      return BUTTON_NONE;
  }
}

gui_action_type get_gui_input()
{
  SDL_Event event;
  gui_action_type gui_action = CURSOR_NONE;

  delay_us(30000);

  while(SDL_PollEvent(&event))
  {
    switch(event.type)
    {
      case SDL_QUIT:
        quit();

      case SDL_KEYDOWN:
      {
        switch(event.key.keysym.sym)
        {
          case SDLK_ESCAPE:
            gui_action = CURSOR_EXIT;
            break;

          case SDLK_DOWN:
            gui_action = CURSOR_DOWN;
            break;

          case SDLK_UP:
            gui_action = CURSOR_UP;
            break;

          case SDLK_LEFT:
            gui_action = CURSOR_LEFT;
            break;

          case SDLK_RIGHT:
            gui_action = CURSOR_RIGHT;
            break;

          case SDLK_RETURN:
            gui_action = CURSOR_SELECT;
            break;

          case SDLK_BACKSPACE:
            gui_action = CURSOR_BACK;
            break;
        }
        break;
      }
    }
  }

  return gui_action;
}

u32 update_input()
{
  SDL_Event event;

  while(SDL_PollEvent(&event))
  {
    switch(event.type)
    {
      case SDL_QUIT:
        quit();

      case SDL_KEYDOWN:
      {
        if(event.key.keysym.sym == SDLK_ESCAPE)
        {
          quit();
        }

        if(event.key.keysym.sym == SDLK_BACKSPACE)
        {
          u16 *screen_copy = copy_screen();
          u32 ret_val = menu(screen_copy);
          free(screen_copy);

          return ret_val;
        }
        else

        if(event.key.keysym.sym == SDLK_F1)
        {
          debug_on();
        }
        else

        if(event.key.keysym.sym == SDLK_F2)
        {
          FILE *fp = fopen("palette_ram.bin", "wb");
          printf("writing palette RAM\n");
          fwrite(palette_ram, 1024, 1, fp);
          fclose(fp);
          printf("writing palette VRAM\n");
          fp = fopen("vram.bin", "wb");
          fwrite(vram, 1024 * 96, 1, fp);
          fclose(fp);
          printf("writing palette OAM RAM\n");
          fp = fopen("oam_ram.bin", "wb");
          fwrite(oam_ram, 1024, 1, fp);
          fclose(fp);
          printf("writing palette I/O registers\n");
          fp = fopen("io_registers.bin", "wb");
          fwrite(io_registers, 1024, 1, fp);
          fclose(fp);
        }
        else

        if(event.key.keysym.sym == SDLK_F3)
        {
          dump_translation_cache();
        }
        else

        if(event.key.keysym.sym == SDLK_F5)
        {
          u8 current_savestate_filename[512];
          u16 *current_screen = copy_screen();
          get_savestate_filename_noshot(savestate_slot,
           current_savestate_filename);
          save_state(current_savestate_filename, current_screen);
          free(current_screen);
        }
        else

        if(event.key.keysym.sym == SDLK_F7)
        {
          u8 current_savestate_filename[512];
          get_savestate_filename_noshot(savestate_slot,
           current_savestate_filename);
          load_state(current_savestate_filename);
          debug_on();
          return 1;
        }
        else

        if(event.key.keysym.sym == SDLK_BACKQUOTE)
        {
          synchronize_flag ^= 1;
        }
        else
        {
          key |= key_map(event.key.keysym.sym);
          trigger_key(key);
        }

        break;
      }

      case SDL_KEYUP:
      {
        key &= ~(key_map(event.key.keysym.sym));
        break;
      }

      case SDL_JOYBUTTONDOWN:
      {
        key |= joy_map(event.jbutton.button);
        trigger_key(key);
        break;
      }

      case SDL_JOYBUTTONUP:
      {
        key &= ~(joy_map(event.jbutton.button));
        break;
      }
    }
  }

  io_registers[REG_P1] = (~key) & 0x3FF;

  return 0;
}

void init_input()
{
  u32 joystick_count = SDL_NumJoysticks();

  if(joystick_count > 0)
  {
    SDL_JoystickOpen(0);
    SDL_JoystickEventState(SDL_ENABLE);
  }
}

#endif


#define input_savestate_builder(type)                                         \
void input_##type##_savestate(file_tag_type savestate_file)                   \
{                                                                             \
  file_##type##_variable(savestate_file, key);                                \
}                                                                             \

input_savestate_builder(read);
input_savestate_builder(write_mem);
Commit	Line	Data
2823a4c8	1	/* gameplaySP
	2	*
	3	* Copyright (C) 2006 Exophase <exophase@gmail.com>
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation; either version 2 of
	8	* the License, or (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19
	20	#include "common.h"
	21
	22	// Special thanks to psp298 for the analog->dpad code!
	23
	24	void trigger_key(u32 key)
	25	{
	26	u32 p1_cnt = io_registers[REG_P1CNT];
	27	u32 p1;
	28
	29	if((p1_cnt >> 14) & 0x01)
	30	{
	31	u32 key_intersection = (p1_cnt & key) & 0x3FF;
	32
	33	if(p1_cnt >> 15)
	34	{
	35	if(key_intersection == (p1_cnt & 0x3FF))
	36	raise_interrupt(IRQ_KEYPAD);
	37	}
	38	else
	39	{
	40	if(key_intersection)
	41	raise_interrupt(IRQ_KEYPAD);
	42	}
	43	}
	44	}
	45
	46	u32 key = 0;
	47
	48	u32 global_enable_analog = 1;
	49	u32 analog_sensitivity_level = 4;
	50
	51	typedef enum
	52	{
	53	BUTTON_NOT_HELD,
	54	BUTTON_HELD_INITIAL,
	55	BUTTON_HELD_REPEAT
	56	} button_repeat_state_type;
	57
	58
	59	// These define autorepeat values (in microseconds), tweak as necessary.
	60
	61	#define BUTTON_REPEAT_START 200000
	62	#define BUTTON_REPEAT_CONTINUE 50000
	63
	64	button_repeat_state_type button_repeat_state = BUTTON_NOT_HELD;
65	u32 button_repeat = 0;
66	gui_action_type cursor_repeat = CURSOR_NONE;
67
68
69	#ifdef PSP_BUILD
70
71	u32 gamepad_config_map[16] =
72	{
73	BUTTON_ID_MENU, // Triangle
74	BUTTON_ID_A, // Circle
75	BUTTON_ID_B, // Cross
76	BUTTON_ID_START, // Square
77	BUTTON_ID_L, // Ltrigger
78	BUTTON_ID_R, // Rtrigger
79	BUTTON_ID_DOWN, // Down
80	BUTTON_ID_LEFT, // Left
81	BUTTON_ID_UP, // Up
82	BUTTON_ID_RIGHT, // Right
83	BUTTON_ID_SELECT, // Select
84	BUTTON_ID_START, // Start
85	BUTTON_ID_UP, // Analog up
86	BUTTON_ID_DOWN, // Analog down
87	BUTTON_ID_LEFT, // Analog left
88	BUTTON_ID_RIGHT // Analog right
89	};
90
91	#define PSP_ALL_BUTTON_MASK 0xFFFF
92
93	gui_action_type get_gui_input()
94	{
95	SceCtrlData ctrl_data;
96	gui_action_type new_button = CURSOR_NONE;
97	u32 new_buttons;
98
99	static u32 last_buttons = 0;
100	static u64 button_repeat_timestamp;
101
102	delay_us(25000);
103
104	sceCtrlPeekBufferPositive(&ctrl_data, 1);
105	ctrl_data.Buttons &= PSP_ALL_BUTTON_MASK;
106	new_buttons = (last_buttons ^ ctrl_data.Buttons) & ctrl_data.Buttons;
107	last_buttons = ctrl_data.Buttons;
108
109	if(new_buttons & PSP_CTRL_LEFT)
110	new_button = CURSOR_LEFT;
111
112	if(new_buttons & PSP_CTRL_RIGHT)
113	new_button = CURSOR_RIGHT;
114
115	if(new_buttons & PSP_CTRL_UP)
116	new_button = CURSOR_UP;
117
118	if(new_buttons & PSP_CTRL_DOWN)
119	new_button = CURSOR_DOWN;
120
121	if(new_buttons & PSP_CTRL_START)
122	new_button = CURSOR_SELECT;
123
124	if(new_buttons & PSP_CTRL_CIRCLE)
125	new_button = CURSOR_SELECT;
126
127	if(new_buttons & PSP_CTRL_CROSS)
128	new_button = CURSOR_EXIT;
129
130	if(new_buttons & PSP_CTRL_SQUARE)
131	new_button = CURSOR_BACK;
132
133	if(new_button != CURSOR_NONE)
134	{
135	get_ticks_us(&button_repeat_timestamp);
136	button_repeat_state = BUTTON_HELD_INITIAL;
137	button_repeat = new_buttons;
138	cursor_repeat = new_button;
139	}
140	else
141	{
142	if(ctrl_data.Buttons & button_repeat)
143	{
144	u64 new_ticks;
145	get_ticks_us(&new_ticks);
146
147	if(button_repeat_state == BUTTON_HELD_INITIAL)
148	{
149	if((new_ticks - button_repeat_timestamp) >
150	BUTTON_REPEAT_START)
151	{
152	new_button = cursor_repeat;
153	button_repeat_timestamp = new_ticks;
154	button_repeat_state = BUTTON_HELD_REPEAT;
155	}
156	}
157
158	if(button_repeat_state == BUTTON_HELD_REPEAT)
159	{
160	if((new_ticks - button_repeat_timestamp) >
161	BUTTON_REPEAT_CONTINUE)
162	{
163	new_button = cursor_repeat;
164	button_repeat_timestamp = new_ticks;
165	}
166	}
167	}
168	}
169
170	return new_button;
171	}
172
173	#define PSP_CTRL_ANALOG_UP (1 << 28)
174	#define PSP_CTRL_ANALOG_DOWN (1 << 29)
175	#define PSP_CTRL_ANALOG_LEFT (1 << 30)
176	#define PSP_CTRL_ANALOG_RIGHT (1 << 31)
177
178	u32 button_psp_mask_to_config[] =
179	{
180	PSP_CTRL_TRIANGLE,
181	PSP_CTRL_CIRCLE,
182	PSP_CTRL_CROSS,
183	PSP_CTRL_SQUARE,
184	PSP_CTRL_LTRIGGER,
185	PSP_CTRL_RTRIGGER,
186	PSP_CTRL_DOWN,
187	PSP_CTRL_LEFT,
188	PSP_CTRL_UP,
189	PSP_CTRL_RIGHT,
190	PSP_CTRL_SELECT,
191	PSP_CTRL_START,
192	PSP_CTRL_ANALOG_UP,
193	PSP_CTRL_ANALOG_DOWN,
194	PSP_CTRL_ANALOG_LEFT,
195	PSP_CTRL_ANALOG_RIGHT
196	};
197
198	u32 button_id_to_gba_mask[] =
199	{
200	BUTTON_UP,
201	BUTTON_DOWN,
202	BUTTON_LEFT,
203	BUTTON_RIGHT,
204	BUTTON_A,
205	BUTTON_B,
206	BUTTON_L,
207	BUTTON_R,
208	BUTTON_START,
209	BUTTON_SELECT,
210	BUTTON_NONE,
211	BUTTON_NONE,
212	BUTTON_NONE,
213	BUTTON_NONE
214	};
215
216	gui_action_type get_gui_input_fs_hold(u32 button_id)
217	{
218	gui_action_type new_button = get_gui_input();
219	if((last_buttons & button_psp_mask_to_config[button_id]) == 0)
220	return CURSOR_BACK;
221
222	return new_button;
223	}
224
225	u32 rapidfire_flag = 1;
226
227	u32 update_input()
228	{
229	SceCtrlData ctrl_data;
230	u32 buttons;
231	u32 non_repeat_buttons;
232	u32 button_id;
233	u32 i;
234	u32 new_key = 0;
235	u32 analog_sensitivity = 92 - (analog_sensitivity_level * 4);
236	u32 inv_analog_sensitivity = 256 - analog_sensitivity;
237
238	sceCtrlPeekBufferPositive(&ctrl_data, 1);
239
240	buttons = ctrl_data.Buttons;
241
242	if(global_enable_analog)
243	{
244	if(ctrl_data.Lx < analog_sensitivity)
245	buttons \|= PSP_CTRL_ANALOG_LEFT;
246
247	if(ctrl_data.Lx > inv_analog_sensitivity)
248	buttons \|= PSP_CTRL_ANALOG_RIGHT;
249
250	if(ctrl_data.Ly < analog_sensitivity)
251	buttons \|= PSP_CTRL_ANALOG_UP;
252
253	if(ctrl_data.Ly > inv_analog_sensitivity)
254	buttons \|= PSP_CTRL_ANALOG_DOWN;
255	}
256
257	non_repeat_buttons = (last_buttons ^ buttons) & buttons;
258	last_buttons = buttons;
259
260	for(i = 0; i < 16; i++)
261	{
262	if(non_repeat_buttons & button_psp_mask_to_config[i])
263	button_id = gamepad_config_map[i];
264	else
265	button_id = BUTTON_ID_NONE;
266
267	switch(button_id)
268	{
269	case BUTTON_ID_MENU:
270	{
271	u16 *screen_copy = copy_screen();
272	u32 ret_val = menu(screen_copy);
273	free(screen_copy);
274
275	return ret_val;
276	}
277
278	case BUTTON_ID_LOADSTATE:
279	{
280	u8 current_savestate_filename[512];
281	get_savestate_filename_noshot(savestate_slot,
282	current_savestate_filename);
283	load_state(current_savestate_filename);
284	return 1;
285	}
286
287	case BUTTON_ID_SAVESTATE:
288	{
289	u8 current_savestate_filename[512];
290	u16 *current_screen = copy_screen();
291	get_savestate_filename_noshot(savestate_slot,
292	current_savestate_filename);
293	save_state(current_savestate_filename, current_screen);
294	free(current_screen);
295	return 0;
296	}
297
298	case BUTTON_ID_FASTFORWARD:
299	print_string("FASTFORWARD", 0xFFFF, 0x0000, 0, 50);
300	synchronize_flag ^= 1;
301	return 0;
302	}
303
304	if(buttons & button_psp_mask_to_config[i])
305	{
306	button_id = gamepad_config_map[i];
307	if(button_id < BUTTON_ID_MENU)
308	{
309	new_key \|= button_id_to_gba_mask[button_id];
310	}
311	else
312
313	if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
314	(button_id <= BUTTON_ID_RAPIDFIRE_L))
315	{
316	rapidfire_flag ^= 1;
317	if(rapidfire_flag)
318	{
319	new_key \|= button_id_to_gba_mask[button_id -
320	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
321	}
322	else
323	{
324	new_key &= ~button_id_to_gba_mask[button_id -
325	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
326	}
327	}
328	}
329	}
330
331	if((new_key \| key) != key)
332	trigger_key(new_key);
333
334	key = new_key;
335
336	io_registers[REG_P1] = (~key) & 0x3FF;
337
338	return 0;
339	}
340
341	void init_input()
342	{
343	sceCtrlSetSamplingCycle(0);
344	sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
345	}
346
347	#endif
348
349
350	#ifdef GP2X_BUILD
351
352	// GP2X SDL requires a user made input method
353	#include <sys/mman.h>
354	#include <sys/ioctl.h>
355	#include "gp2x/gp2x.h"
356
357	u32 gamepad_config_map[16] =
358	{
359	BUTTON_ID_UP, // Up
360	BUTTON_ID_LEFT, // Left
361	BUTTON_ID_DOWN, // Down
362	BUTTON_ID_RIGHT, // Right
363	BUTTON_ID_START, // Start
364	BUTTON_ID_SELECT, // Select
365	BUTTON_ID_L, // Ltrigger
366	BUTTON_ID_R, // Rtrigger
5a01fba6	367	BUTTON_ID_FPS, // A
2823a4c8	368	BUTTON_ID_A, // B
2823a4c8	369	BUTTON_ID_B, // X
5a01fba6	370	BUTTON_ID_MENU, // Y
2823a4c8	371	BUTTON_ID_VOLDOWN, // Vol down
	372	BUTTON_ID_VOLUP, // Vol up
	373	BUTTON_ID_FPS, // Push
	374	BUTTON_ID_MENU // Vol middle
	375	};
	376
ee0a3871	377	extern u32 fps_debug;
4742480d	378	extern u32 gpsp_gp2x_joystick_read(void);
2823a4c8	379
	380	gui_action_type get_gui_input()
	381	{
	382	gui_action_type new_button = CURSOR_NONE;
	383	u32 buttons = gpsp_gp2x_joystick_read();
	384	u32 new_buttons;
	385
	386	static u32 last_buttons = 0;
	387	static u64 button_repeat_timestamp;
	388
	389	delay_us(25000);
	390
	391	new_buttons = (last_buttons ^ buttons) & buttons;
	392	last_buttons = buttons;
	393
	394	if(new_buttons & GP2X_A)
	395	new_button = CURSOR_BACK;
	396
	397	if(new_buttons & GP2X_X)
	398	new_button = CURSOR_EXIT;
	399
	400	if(new_buttons & GP2X_B)
	401	new_button = CURSOR_SELECT;
	402
	403	if(new_buttons & GP2X_UP)
	404	new_button = CURSOR_UP;
	405
	406	if(new_buttons & GP2X_DOWN)
	407	new_button = CURSOR_DOWN;
	408
	409	if(new_buttons & GP2X_LEFT)
	410	new_button = CURSOR_LEFT;
	411
	412	if(new_buttons & GP2X_RIGHT)
	413	new_button = CURSOR_RIGHT;
	414
42c81190	415	if(new_buttons & GP2X_L)
	416	new_button = CURSOR_L;
	417
	418	if(new_buttons & GP2X_R)
	419	new_button = CURSOR_R;
	420
2823a4c8	421
	422	if(new_button != CURSOR_NONE)
	423	{
	424	get_ticks_us(&button_repeat_timestamp);
	425	button_repeat_state = BUTTON_HELD_INITIAL;
	426	button_repeat = new_buttons;
	427	cursor_repeat = new_button;
	428	}
	429	else
	430	{
	431	if(buttons & button_repeat)
	432	{
	433	u64 new_ticks;
	434	get_ticks_us(&new_ticks);
	435
	436	if(button_repeat_state == BUTTON_HELD_INITIAL)
	437	{
	438	if((new_ticks - button_repeat_timestamp) >
	439	BUTTON_REPEAT_START)
	440	{
	441	new_button = cursor_repeat;
	442	button_repeat_timestamp = new_ticks;
	443	button_repeat_state = BUTTON_HELD_REPEAT;
	444	}
	445	}
	446
	447	if(button_repeat_state == BUTTON_HELD_REPEAT)
	448	{
	449	if((new_ticks - button_repeat_timestamp) >
	450	BUTTON_REPEAT_CONTINUE)
	451	{
	452	new_button = cursor_repeat;
	453	button_repeat_timestamp = new_ticks;
	454	}
	455	}
	456	}
	457	}
	458
	459	return new_button;
	460	}
	461
	462	#define GP2X_VOL_MIDDLE (1 << 24)
	463
	464	u32 button_gp2x_mask_to_config[] =
	465	{
	466	GP2X_UP,
	467	GP2X_LEFT,
	468	GP2X_DOWN,
	469	GP2X_RIGHT,
	470	GP2X_START,
	471	GP2X_SELECT,
	472	GP2X_L,
	473	GP2X_R,
	474	GP2X_A,
	475	GP2X_B,
	476	GP2X_X,
	477	GP2X_Y,
	478	GP2X_VOL_DOWN,
	479	GP2X_VOL_UP,
	480	GP2X_PUSH,
	481	GP2X_VOL_MIDDLE
	482	};
	483
	484	u32 button_id_to_gba_mask[] =
485	{
486	BUTTON_UP,
487	BUTTON_DOWN,
488	BUTTON_LEFT,
489	BUTTON_RIGHT,
490	BUTTON_A,
491	BUTTON_B,
492	BUTTON_L,
493	BUTTON_R,
494	BUTTON_START,
495	BUTTON_SELECT,
496	BUTTON_NONE,
497	BUTTON_NONE,
498	BUTTON_NONE,
499	BUTTON_NONE
500	};
501
502	u32 update_input()
503	{
504	static u32 rapidfire_flag = 1;
505	static u32 last_buttons;
90206450	506	u32 handled_buttons;
2823a4c8	507	u32 button_id;
	508	u32 new_key = 0;
	509	u32 buttons = gpsp_gp2x_joystick_read();
	510	u32 i;
	511
	512	if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_VOL_UP))
	513	{
	514	buttons &= ~(GP2X_VOL_DOWN \| GP2X_VOL_UP);
	515	buttons \|= GP2X_VOL_MIDDLE;
	516	}
	517
4cdfc0bc	518	/* for Wiz */
	519	if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_SELECT))
	520	{
	521	buttons &= ~(GP2X_VOL_DOWN \| GP2X_SELECT);
	522	buttons \|= GP2X_VOL_MIDDLE;
	523	}
	524
90206450	525	handled_buttons = ((last_buttons ^ buttons) \| GP2X_VOL_DOWN \| GP2X_VOL_UP) & buttons;
2823a4c8	526	last_buttons = buttons;
	527
	528	for(i = 0; i < 16; i++)
	529	{
90206450	530	if(handled_buttons & button_gp2x_mask_to_config[i])
2823a4c8	531	button_id = gamepad_config_map[i];
	532	else
	533	button_id = BUTTON_ID_NONE;
	534
	535	switch(button_id)
	536	{
	537	case BUTTON_ID_MENU:
	538	{
	539	u16 *screen_copy = copy_screen();
	540	u32 ret_val = menu(screen_copy);
	541	free(screen_copy);
	542
	543	return ret_val;
	544	}
	545
	546	case BUTTON_ID_LOADSTATE:
	547	{
	548	u8 current_savestate_filename[512];
	549	get_savestate_filename_noshot(savestate_slot,
	550	current_savestate_filename);
	551	load_state(current_savestate_filename);
	552	return 1;
	553	}
	554
	555	case BUTTON_ID_SAVESTATE:
	556	{
	557	u8 current_savestate_filename[512];
	558	u16 *current_screen = copy_screen();
	559	get_savestate_filename_noshot(savestate_slot,
	560	current_savestate_filename);
	561	save_state(current_savestate_filename, current_screen);
	562	free(current_screen);
	563	return 0;
	564	}
	565
	566	case BUTTON_ID_FASTFORWARD:
	567	print_string("FASTFORWARD", 0xFFFF, 0x0000, 0, 50);
	568	synchronize_flag ^= 1;
	569	return 0;
	570
	571	case BUTTON_ID_VOLUP:
	572	gp2x_sound_volume(1);
	573	break;
	574
	575	case BUTTON_ID_VOLDOWN:
	576	gp2x_sound_volume(0);
	577	break;
	578
	579	case BUTTON_ID_FPS:
ee0a3871	580	fps_debug ^= 1;
2823a4c8	581	break;
	582	}
	583
	584	if(buttons & button_gp2x_mask_to_config[i])
	585	{
	586	button_id = gamepad_config_map[i];
	587	if(button_id < BUTTON_ID_MENU)
	588	{
	589	new_key \|= button_id_to_gba_mask[button_id];
	590	}
	591	else
	592
	593	if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
	594	(button_id <= BUTTON_ID_RAPIDFIRE_L))
	595	{
	596	rapidfire_flag ^= 1;
	597	if(rapidfire_flag)
	598	{
	599	new_key \|= button_id_to_gba_mask[button_id -
	600	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
	601	}
	602	else
	603	{
	604	new_key &= ~button_id_to_gba_mask[button_id -
	605	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
	606	}
	607	}
	608	}
	609	}
	610
	611	if((new_key \| key) != key)
	612	trigger_key(new_key);
	613
	614	key = new_key;
	615
	616	io_registers[REG_P1] = (~key) & 0x3FF;
	617
	618	return 0;
	619	}
	620
	621	void init_input()
	622	{
	623
	624	}
	625
	626	#endif
	627
	628
	629
	630	#ifdef PC_BUILD
	631
	632	u32 key_map(SDLKey key_sym)
	633	{
	634	switch(key_sym)
	635	{
	636	case SDLK_LSHIFT:
	637	return BUTTON_L;
	638
	639	case SDLK_x:
	640	return BUTTON_R;
	641
	642	case SDLK_DOWN:
	643	return BUTTON_DOWN;
	644
645	case SDLK_UP:
646	return BUTTON_UP;
647
648	case SDLK_LEFT:
649	return BUTTON_LEFT;
650
651	case SDLK_RIGHT:
652	return BUTTON_RIGHT;
653
654	case SDLK_RETURN:
655	return BUTTON_START;
656
657	case SDLK_RSHIFT:
658	return BUTTON_SELECT;
659
660	case SDLK_LCTRL:
661	return BUTTON_B;
662
663	case SDLK_LALT:
664	return BUTTON_A;
665
666	default:
667	return BUTTON_NONE;
668	}
669	}
670
671	u32 joy_map(u32 button)
672	{
673	switch(button)
674	{
675	case 4:
676	return BUTTON_L;
677
678	case 5:
679	return BUTTON_R;
680
681	case 9:
682	return BUTTON_START;
683
684	case 8:
685	return BUTTON_SELECT;
686
687	case 0:
688	return BUTTON_B;
689
690	case 1:
691	return BUTTON_A;
692
693	default:
694	return BUTTON_NONE;
695	}
696	}
697
698	gui_action_type get_gui_input()
699	{
700	SDL_Event event;
701	gui_action_type gui_action = CURSOR_NONE;
702
703	delay_us(30000);
704
705	while(SDL_PollEvent(&event))
706	{
707	switch(event.type)
708	{
709	case SDL_QUIT:
710	quit();
711
712	case SDL_KEYDOWN:
713	{
714	switch(event.key.keysym.sym)
715	{
716	case SDLK_ESCAPE:
717	gui_action = CURSOR_EXIT;
718	break;
719
720	case SDLK_DOWN:
721	gui_action = CURSOR_DOWN;
722	break;
723
724	case SDLK_UP:
725	gui_action = CURSOR_UP;
726	break;
727
728	case SDLK_LEFT:
729	gui_action = CURSOR_LEFT;
730	break;
731
732	case SDLK_RIGHT:
733	gui_action = CURSOR_RIGHT;
734	break;
735
736	case SDLK_RETURN:
737	gui_action = CURSOR_SELECT;
738	break;
739
740	case SDLK_BACKSPACE:
741	gui_action = CURSOR_BACK;
742	break;
743	}
744	break;
745	}
746	}
747	}
748
749	return gui_action;
750	}
751
752	u32 update_input()
753	{
754	SDL_Event event;
755
756	while(SDL_PollEvent(&event))
757	{
758	switch(event.type)
759	{
760	case SDL_QUIT:
761	quit();
762
763	case SDL_KEYDOWN:
764	{
765	if(event.key.keysym.sym == SDLK_ESCAPE)
766	{
767	quit();
768	}
769
770	if(event.key.keysym.sym == SDLK_BACKSPACE)
771	{
772	u16 *screen_copy = copy_screen();
773	u32 ret_val = menu(screen_copy);
774	free(screen_copy);
775
776	return ret_val;
777	}
778	else
779
780	if(event.key.keysym.sym == SDLK_F1)
781	{
782	debug_on();
783	}
784	else
785
786	if(event.key.keysym.sym == SDLK_F2)
787	{
788	FILE *fp = fopen("palette_ram.bin", "wb");
789	printf("writing palette RAM\n");
790	fwrite(palette_ram, 1024, 1, fp);
791	fclose(fp);
792	printf("writing palette VRAM\n");
793	fp = fopen("vram.bin", "wb");
794	fwrite(vram, 1024 * 96, 1, fp);
795	fclose(fp);
796	printf("writing palette OAM RAM\n");
797	fp = fopen("oam_ram.bin", "wb");
798	fwrite(oam_ram, 1024, 1, fp);
799	fclose(fp);
800	printf("writing palette I/O registers\n");
801	fp = fopen("io_registers.bin", "wb");
802	fwrite(io_registers, 1024, 1, fp);
803	fclose(fp);
804	}
805	else
806
807	if(event.key.keysym.sym == SDLK_F3)
808	{
809	dump_translation_cache();
810	}
811	else
812
813	if(event.key.keysym.sym == SDLK_F5)
814	{
815	u8 current_savestate_filename[512];
816	u16 *current_screen = copy_screen();
817	get_savestate_filename_noshot(savestate_slot,
818	current_savestate_filename);
819	save_state(current_savestate_filename, current_screen);
820	free(current_screen);
821	}
822	else
823
824	if(event.key.keysym.sym == SDLK_F7)
825	{
826	u8 current_savestate_filename[512];
827	get_savestate_filename_noshot(savestate_slot,
828	current_savestate_filename);
829	load_state(current_savestate_filename);
830	debug_on();
831	return 1;
832	}
833	else
834
835	if(event.key.keysym.sym == SDLK_BACKQUOTE)
836	{
837	synchronize_flag ^= 1;
838	}
839	else
840	{
841	key \|= key_map(event.key.keysym.sym);
842	trigger_key(key);
843	}
844
845	break;
846	}
847
848	case SDL_KEYUP:
849	{
850	key &= ~(key_map(event.key.keysym.sym));
851	break;
852	}
853
854	case SDL_JOYBUTTONDOWN:
855	{
856	key \|= joy_map(event.jbutton.button);
857	trigger_key(key);
858	break;
859	}
860
861	case SDL_JOYBUTTONUP:
862	{
863	key &= ~(joy_map(event.jbutton.button));
864	break;
865	}
866	}
867	}
868
869	io_registers[REG_P1] = (~key) & 0x3FF;
870
871	return 0;
872	}
873
874	void init_input()
875	{
876	u32 joystick_count = SDL_NumJoysticks();
877
878	if(joystick_count > 0)
879	{
880	SDL_JoystickOpen(0);
881	SDL_JoystickEventState(SDL_ENABLE);
882	}
883	}
884
885	#endif
886
887
888	#define input_savestate_builder(type) \
889	void input_##type##_savestate(file_tag_type savestate_file) \
890	{ \
891	file_##type##_variable(savestate_file, key); \
892	} \
893
894	input_savestate_builder(read);
895	input_savestate_builder(write_mem);
896