[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


#if defined(GP2X_BUILD) || defined(PND_BUILD)

extern u32 fps_debug;

gui_action_type get_gui_input()
{
  gui_action_type new_button = CURSOR_NONE;
  u32 buttons = gpsp_plat_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;

  new_button = gpsp_plat_buttons_to_cursor(new_buttons);
  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;
}

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_plat_joystick_read();
  u32 i;

#ifdef GP2X_BUILD
  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;
  }

  last_buttons &= ~(GP2X_VOL_DOWN | GP2X_VOL_UP);
#endif

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

  for(i = 0; i < PLAT_BUTTON_COUNT; i++)
  {
    if(handled_buttons & button_plat_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:
        synchronize_flag ^= 1;
        return 0;

#ifdef GP2X_BUILD
      case BUTTON_ID_VOLUP:
        gp2x_sound_volume(1);
        break;

      case BUTTON_ID_VOLDOWN:
        gp2x_sound_volume(0);
        break;
#endif

      case BUTTON_ID_FPS:
        fps_debug ^= 1;
        break;
    }

    if(buttons & button_plat_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
43c24b30	350	#if defined(GP2X_BUILD) \|\| defined(PND_BUILD)
2823a4c8	351
ee0a3871	352	extern u32 fps_debug;
2823a4c8	353
	354	gui_action_type get_gui_input()
	355	{
	356	gui_action_type new_button = CURSOR_NONE;
43c24b30	357	u32 buttons = gpsp_plat_joystick_read();
2823a4c8	358	u32 new_buttons;
	359
	360	static u32 last_buttons = 0;
	361	static u64 button_repeat_timestamp;
	362
	363	delay_us(25000);
	364
	365	new_buttons = (last_buttons ^ buttons) & buttons;
	366	last_buttons = buttons;
	367
43c24b30	368	new_button = gpsp_plat_buttons_to_cursor(new_buttons);
2823a4c8	369	if(new_button != CURSOR_NONE)
	370	{
	371	get_ticks_us(&button_repeat_timestamp);
	372	button_repeat_state = BUTTON_HELD_INITIAL;
	373	button_repeat = new_buttons;
	374	cursor_repeat = new_button;
	375	}
	376	else
	377	{
	378	if(buttons & button_repeat)
	379	{
	380	u64 new_ticks;
	381	get_ticks_us(&new_ticks);
	382
	383	if(button_repeat_state == BUTTON_HELD_INITIAL)
	384	{
	385	if((new_ticks - button_repeat_timestamp) >
	386	BUTTON_REPEAT_START)
	387	{
	388	new_button = cursor_repeat;
	389	button_repeat_timestamp = new_ticks;
	390	button_repeat_state = BUTTON_HELD_REPEAT;
	391	}
	392	}
	393
	394	if(button_repeat_state == BUTTON_HELD_REPEAT)
	395	{
	396	if((new_ticks - button_repeat_timestamp) >
	397	BUTTON_REPEAT_CONTINUE)
	398	{
	399	new_button = cursor_repeat;
	400	button_repeat_timestamp = new_ticks;
	401	}
	402	}
	403	}
	404	}
	405
	406	return new_button;
	407	}
	408
2823a4c8	409	u32 button_id_to_gba_mask[] =
	410	{
	411	BUTTON_UP,
	412	BUTTON_DOWN,
	413	BUTTON_LEFT,
	414	BUTTON_RIGHT,
	415	BUTTON_A,
	416	BUTTON_B,
	417	BUTTON_L,
	418	BUTTON_R,
	419	BUTTON_START,
	420	BUTTON_SELECT,
	421	BUTTON_NONE,
	422	BUTTON_NONE,
	423	BUTTON_NONE,
	424	BUTTON_NONE
	425	};
	426
	427	u32 update_input()
	428	{
	429	static u32 rapidfire_flag = 1;
	430	static u32 last_buttons;
90206450	431	u32 handled_buttons;
2823a4c8	432	u32 button_id;
2823a4c8	433	u32 new_key = 0;
43c24b30	434	u32 buttons = gpsp_plat_joystick_read();
2823a4c8	435	u32 i;
2823a4c8	436
43c24b30	437	#ifdef GP2X_BUILD
2823a4c8	438	if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_VOL_UP))
	439	{
	440	buttons &= ~(GP2X_VOL_DOWN \| GP2X_VOL_UP);
	441	buttons \|= GP2X_VOL_MIDDLE;
	442	}
	443
4cdfc0bc	444	/* for Wiz */
	445	if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_SELECT))
	446	{
	447	buttons &= ~(GP2X_VOL_DOWN \| GP2X_SELECT);
	448	buttons \|= GP2X_VOL_MIDDLE;
	449	}
	450
43c24b30	451	last_buttons &= ~(GP2X_VOL_DOWN \| GP2X_VOL_UP);
	452	#endif
	453
	454	handled_buttons = (last_buttons ^ buttons) & buttons;
2823a4c8	455	last_buttons = buttons;
2823a4c8	456
eb3668fc	457	for(i = 0; i < PLAT_BUTTON_COUNT; i++)
2823a4c8	458	{
43c24b30	459	if(handled_buttons & button_plat_mask_to_config[i])
2823a4c8	460	button_id = gamepad_config_map[i];
	461	else
	462	button_id = BUTTON_ID_NONE;
	463
	464	switch(button_id)
	465	{
	466	case BUTTON_ID_MENU:
	467	{
	468	u16 *screen_copy = copy_screen();
	469	u32 ret_val = menu(screen_copy);
	470	free(screen_copy);
	471
	472	return ret_val;
	473	}
	474
	475	case BUTTON_ID_LOADSTATE:
	476	{
	477	u8 current_savestate_filename[512];
	478	get_savestate_filename_noshot(savestate_slot,
	479	current_savestate_filename);
	480	load_state(current_savestate_filename);
	481	return 1;
	482	}
	483
	484	case BUTTON_ID_SAVESTATE:
	485	{
	486	u8 current_savestate_filename[512];
	487	u16 *current_screen = copy_screen();
	488	get_savestate_filename_noshot(savestate_slot,
	489	current_savestate_filename);
	490	save_state(current_savestate_filename, current_screen);
	491	free(current_screen);
	492	return 0;
	493	}
	494
	495	case BUTTON_ID_FASTFORWARD:
2823a4c8	496	synchronize_flag ^= 1;
	497	return 0;
	498
43c24b30	499	#ifdef GP2X_BUILD
2823a4c8	500	case BUTTON_ID_VOLUP:
	501	gp2x_sound_volume(1);
	502	break;
	503
	504	case BUTTON_ID_VOLDOWN:
	505	gp2x_sound_volume(0);
	506	break;
43c24b30	507	#endif
2823a4c8	508
2823a4c8	509	case BUTTON_ID_FPS:
ee0a3871	510	fps_debug ^= 1;
2823a4c8	511	break;
	512	}
	513
43c24b30	514	if(buttons & button_plat_mask_to_config[i])
2823a4c8	515	{
	516	button_id = gamepad_config_map[i];
	517	if(button_id < BUTTON_ID_MENU)
	518	{
	519	new_key \|= button_id_to_gba_mask[button_id];
	520	}
	521	else
	522
	523	if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
	524	(button_id <= BUTTON_ID_RAPIDFIRE_L))
	525	{
	526	rapidfire_flag ^= 1;
	527	if(rapidfire_flag)
	528	{
	529	new_key \|= button_id_to_gba_mask[button_id -
	530	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
	531	}
	532	else
	533	{
	534	new_key &= ~button_id_to_gba_mask[button_id -
	535	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
	536	}
	537	}
	538	}
	539	}
	540
	541	if((new_key \| key) != key)
	542	trigger_key(new_key);
	543
	544	key = new_key;
	545
	546	io_registers[REG_P1] = (~key) & 0x3FF;
	547
	548	return 0;
	549	}
	550
	551	void init_input()
	552	{
	553
	554	}
	555
	556	#endif
	557
	558
	559
	560	#ifdef PC_BUILD
	561
	562	u32 key_map(SDLKey key_sym)
	563	{
	564	switch(key_sym)
	565	{
	566	case SDLK_LSHIFT:
	567	return BUTTON_L;
	568
	569	case SDLK_x:
	570	return BUTTON_R;
	571
	572	case SDLK_DOWN:
	573	return BUTTON_DOWN;
	574
	575	case SDLK_UP:
	576	return BUTTON_UP;
	577
	578	case SDLK_LEFT:
579	return BUTTON_LEFT;
580
581	case SDLK_RIGHT:
582	return BUTTON_RIGHT;
583
584	case SDLK_RETURN:
585	return BUTTON_START;
586
587	case SDLK_RSHIFT:
588	return BUTTON_SELECT;
589
590	case SDLK_LCTRL:
591	return BUTTON_B;
592
593	case SDLK_LALT:
594	return BUTTON_A;
595
596	default:
597	return BUTTON_NONE;
598	}
599	}
600
601	u32 joy_map(u32 button)
602	{
603	switch(button)
604	{
605	case 4:
606	return BUTTON_L;
607
608	case 5:
609	return BUTTON_R;
610
611	case 9:
612	return BUTTON_START;
613
614	case 8:
615	return BUTTON_SELECT;
616
617	case 0:
618	return BUTTON_B;
619
620	case 1:
621	return BUTTON_A;
622
623	default:
624	return BUTTON_NONE;
625	}
626	}
627
628	gui_action_type get_gui_input()
629	{
630	SDL_Event event;
631	gui_action_type gui_action = CURSOR_NONE;
632
633	delay_us(30000);
634
635	while(SDL_PollEvent(&event))
636	{
637	switch(event.type)
638	{
639	case SDL_QUIT:
640	quit();
641
642	case SDL_KEYDOWN:
643	{
644	switch(event.key.keysym.sym)
645	{
646	case SDLK_ESCAPE:
647	gui_action = CURSOR_EXIT;
648	break;
649
650	case SDLK_DOWN:
651	gui_action = CURSOR_DOWN;
652	break;
653
654	case SDLK_UP:
655	gui_action = CURSOR_UP;
656	break;
657
658	case SDLK_LEFT:
659	gui_action = CURSOR_LEFT;
660	break;
661
662	case SDLK_RIGHT:
663	gui_action = CURSOR_RIGHT;
664	break;
665
666	case SDLK_RETURN:
667	gui_action = CURSOR_SELECT;
668	break;
669
670	case SDLK_BACKSPACE:
671	gui_action = CURSOR_BACK;
672	break;
673	}
674	break;
675	}
676	}
677	}
678
679	return gui_action;
680	}
681
682	u32 update_input()
683	{
684	SDL_Event event;
685
686	while(SDL_PollEvent(&event))
687	{
688	switch(event.type)
689	{
690	case SDL_QUIT:
691	quit();
692
693	case SDL_KEYDOWN:
694	{
695	if(event.key.keysym.sym == SDLK_ESCAPE)
696	{
697	quit();
698	}
699
700	if(event.key.keysym.sym == SDLK_BACKSPACE)
701	{
702	u16 *screen_copy = copy_screen();
703	u32 ret_val = menu(screen_copy);
704	free(screen_copy);
705
706	return ret_val;
707	}
708	else
709
710	if(event.key.keysym.sym == SDLK_F1)
711	{
712	debug_on();
713	}
714	else
715
716	if(event.key.keysym.sym == SDLK_F2)
717	{
718	FILE *fp = fopen("palette_ram.bin", "wb");
719	printf("writing palette RAM\n");
720	fwrite(palette_ram, 1024, 1, fp);
721	fclose(fp);
722	printf("writing palette VRAM\n");
723	fp = fopen("vram.bin", "wb");
724	fwrite(vram, 1024 * 96, 1, fp);
725	fclose(fp);
726	printf("writing palette OAM RAM\n");
727	fp = fopen("oam_ram.bin", "wb");
728	fwrite(oam_ram, 1024, 1, fp);
729	fclose(fp);
730	printf("writing palette I/O registers\n");
731	fp = fopen("io_registers.bin", "wb");
732	fwrite(io_registers, 1024, 1, fp);
733	fclose(fp);
734	}
735	else
736
737	if(event.key.keysym.sym == SDLK_F3)
738	{
739	dump_translation_cache();
740	}
741	else
742
743	if(event.key.keysym.sym == SDLK_F5)
744	{
745	u8 current_savestate_filename[512];
746	u16 *current_screen = copy_screen();
747	get_savestate_filename_noshot(savestate_slot,
748	current_savestate_filename);
749	save_state(current_savestate_filename, current_screen);
750	free(current_screen);
751	}
752	else
753
754	if(event.key.keysym.sym == SDLK_F7)
755	{
756	u8 current_savestate_filename[512];
757	get_savestate_filename_noshot(savestate_slot,
758	current_savestate_filename);
759	load_state(current_savestate_filename);
760	debug_on();
761	return 1;
762	}
763	else
764
765	if(event.key.keysym.sym == SDLK_BACKQUOTE)
766	{
767	synchronize_flag ^= 1;
768	}
769	else
770	{
771	key \|= key_map(event.key.keysym.sym);
772	trigger_key(key);
773	}
774
775	break;
776	}
777
778	case SDL_KEYUP:
779	{
780	key &= ~(key_map(event.key.keysym.sym));
781	break;
782	}
783
784	case SDL_JOYBUTTONDOWN:
785	{
786	key \|= joy_map(event.jbutton.button);
787	trigger_key(key);
788	break;
789	}
790
791	case SDL_JOYBUTTONUP:
792	{
793	key &= ~(joy_map(event.jbutton.button));
794	break;
795	}
796	}
797	}
798
799	io_registers[REG_P1] = (~key) & 0x3FF;
800
801	return 0;
802	}
803
804	void init_input()
805	{
806	u32 joystick_count = SDL_NumJoysticks();
807
808	if(joystick_count > 0)
809	{
810	SDL_JoystickOpen(0);
811	SDL_JoystickEventState(SDL_ENABLE);
812	}
813	}
814
815	#endif
816
817
818	#define input_savestate_builder(type) \
819	void input_##type##_savestate(file_tag_type savestate_file) \
820	{ \
821	file_##type##_variable(savestate_file, key); \
822	} \
823
824	input_savestate_builder(read);
825	input_savestate_builder(write_mem);
826