[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_NONE,               // A
  BUTTON_ID_A,                  // B
  BUTTON_ID_B,                  // X
  BUTTON_ID_NONE,               // Y
  BUTTON_ID_VOLDOWN,            // Vol down
  BUTTON_ID_VOLUP,              // Vol up
  BUTTON_ID_FPS,                // Push
  BUTTON_ID_MENU                // Vol middle
};

extern u32 gp2x_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_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;
  }

  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:
        gp2x_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
367	BUTTON_ID_NONE, // A
368	BUTTON_ID_A, // B
369	BUTTON_ID_B, // X
370	BUTTON_ID_NONE, // Y
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
377	extern u32 gp2x_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
	415
	416	if(new_button != CURSOR_NONE)
	417	{
	418	get_ticks_us(&button_repeat_timestamp);
	419	button_repeat_state = BUTTON_HELD_INITIAL;
	420	button_repeat = new_buttons;
	421	cursor_repeat = new_button;
	422	}
	423	else
	424	{
	425	if(buttons & button_repeat)
	426	{
	427	u64 new_ticks;
	428	get_ticks_us(&new_ticks);
	429
	430	if(button_repeat_state == BUTTON_HELD_INITIAL)
	431	{
	432	if((new_ticks - button_repeat_timestamp) >
	433	BUTTON_REPEAT_START)
	434	{
	435	new_button = cursor_repeat;
	436	button_repeat_timestamp = new_ticks;
	437	button_repeat_state = BUTTON_HELD_REPEAT;
	438	}
	439	}
	440
	441	if(button_repeat_state == BUTTON_HELD_REPEAT)
	442	{
443	if((new_ticks - button_repeat_timestamp) >
444	BUTTON_REPEAT_CONTINUE)
445	{
446	new_button = cursor_repeat;
447	button_repeat_timestamp = new_ticks;
448	}
449	}
450	}
451	}
452
453	return new_button;
454	}
455
456	#define GP2X_VOL_MIDDLE (1 << 24)
457
458	u32 button_gp2x_mask_to_config[] =
459	{
460	GP2X_UP,
461	GP2X_LEFT,
462	GP2X_DOWN,
463	GP2X_RIGHT,
464	GP2X_START,
465	GP2X_SELECT,
466	GP2X_L,
467	GP2X_R,
468	GP2X_A,
469	GP2X_B,
470	GP2X_X,
471	GP2X_Y,
472	GP2X_VOL_DOWN,
473	GP2X_VOL_UP,
474	GP2X_PUSH,
475	GP2X_VOL_MIDDLE
476	};
477
478	u32 button_id_to_gba_mask[] =
479	{
480	BUTTON_UP,
481	BUTTON_DOWN,
482	BUTTON_LEFT,
483	BUTTON_RIGHT,
484	BUTTON_A,
485	BUTTON_B,
486	BUTTON_L,
487	BUTTON_R,
488	BUTTON_START,
489	BUTTON_SELECT,
490	BUTTON_NONE,
491	BUTTON_NONE,
492	BUTTON_NONE,
493	BUTTON_NONE
494	};
495
496	u32 update_input()
497	{
498	static u32 rapidfire_flag = 1;
499	static u32 last_buttons;
90206450	500	u32 handled_buttons;
2823a4c8	501	u32 button_id;
	502	u32 new_key = 0;
	503	u32 buttons = gpsp_gp2x_joystick_read();
	504	u32 i;
	505
	506	if((buttons & GP2X_VOL_DOWN) && (buttons & GP2X_VOL_UP))
	507	{
	508	buttons &= ~(GP2X_VOL_DOWN \| GP2X_VOL_UP);
	509	buttons \|= GP2X_VOL_MIDDLE;
	510	}
	511
90206450	512	handled_buttons = ((last_buttons ^ buttons) \| GP2X_VOL_DOWN \| GP2X_VOL_UP) & buttons;
2823a4c8	513	last_buttons = buttons;
	514
	515	for(i = 0; i < 16; i++)
	516	{
90206450	517	if(handled_buttons & button_gp2x_mask_to_config[i])
2823a4c8	518	button_id = gamepad_config_map[i];
	519	else
	520	button_id = BUTTON_ID_NONE;
	521
	522	switch(button_id)
	523	{
	524	case BUTTON_ID_MENU:
	525	{
	526	u16 *screen_copy = copy_screen();
	527	u32 ret_val = menu(screen_copy);
	528	free(screen_copy);
	529
	530	return ret_val;
	531	}
	532
	533	case BUTTON_ID_LOADSTATE:
	534	{
	535	u8 current_savestate_filename[512];
	536	get_savestate_filename_noshot(savestate_slot,
	537	current_savestate_filename);
	538	load_state(current_savestate_filename);
	539	return 1;
	540	}
	541
	542	case BUTTON_ID_SAVESTATE:
	543	{
	544	u8 current_savestate_filename[512];
	545	u16 *current_screen = copy_screen();
	546	get_savestate_filename_noshot(savestate_slot,
	547	current_savestate_filename);
	548	save_state(current_savestate_filename, current_screen);
	549	free(current_screen);
	550	return 0;
	551	}
	552
	553	case BUTTON_ID_FASTFORWARD:
	554	print_string("FASTFORWARD", 0xFFFF, 0x0000, 0, 50);
	555	synchronize_flag ^= 1;
	556	return 0;
	557
	558	case BUTTON_ID_VOLUP:
	559	gp2x_sound_volume(1);
	560	break;
	561
	562	case BUTTON_ID_VOLDOWN:
	563	gp2x_sound_volume(0);
	564	break;
	565
	566	case BUTTON_ID_FPS:
	567	gp2x_fps_debug ^= 1;
	568	break;
	569	}
	570
	571	if(buttons & button_gp2x_mask_to_config[i])
	572	{
	573	button_id = gamepad_config_map[i];
	574	if(button_id < BUTTON_ID_MENU)
	575	{
	576	new_key \|= button_id_to_gba_mask[button_id];
	577	}
	578	else
	579
	580	if((button_id >= BUTTON_ID_RAPIDFIRE_A) &&
	581	(button_id <= BUTTON_ID_RAPIDFIRE_L))
582	{
583	rapidfire_flag ^= 1;
584	if(rapidfire_flag)
585	{
586	new_key \|= button_id_to_gba_mask[button_id -
587	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
588	}
589	else
590	{
591	new_key &= ~button_id_to_gba_mask[button_id -
592	BUTTON_ID_RAPIDFIRE_A + BUTTON_ID_A];
593	}
594	}
595	}
596	}
597
598	if((new_key \| key) != key)
599	trigger_key(new_key);
600
601	key = new_key;
602
603	io_registers[REG_P1] = (~key) & 0x3FF;
604
605	return 0;
606	}
607
608	void init_input()
609	{
610
611	}
612
613	#endif
614
615
616
617	#ifdef PC_BUILD
618
619	u32 key_map(SDLKey key_sym)
620	{
621	switch(key_sym)
622	{
623	case SDLK_LSHIFT:
624	return BUTTON_L;
625
626	case SDLK_x:
627	return BUTTON_R;
628
629	case SDLK_DOWN:
630	return BUTTON_DOWN;
631
632	case SDLK_UP:
633	return BUTTON_UP;
634
635	case SDLK_LEFT:
636	return BUTTON_LEFT;
637
638	case SDLK_RIGHT:
639	return BUTTON_RIGHT;
640
641	case SDLK_RETURN:
642	return BUTTON_START;
643
644	case SDLK_RSHIFT:
645	return BUTTON_SELECT;
646
647	case SDLK_LCTRL:
648	return BUTTON_B;
649
650	case SDLK_LALT:
651	return BUTTON_A;
652
653	default:
654	return BUTTON_NONE;
655	}
656	}
657
658	u32 joy_map(u32 button)
659	{
660	switch(button)
661	{
662	case 4:
663	return BUTTON_L;
664
665	case 5:
666	return BUTTON_R;
667
668	case 9:
669	return BUTTON_START;
670
671	case 8:
672	return BUTTON_SELECT;
673
674	case 0:
675	return BUTTON_B;
676
677	case 1:
678	return BUTTON_A;
679
680	default:
681	return BUTTON_NONE;
682	}
683	}
684
685	gui_action_type get_gui_input()
686	{
687	SDL_Event event;
688	gui_action_type gui_action = CURSOR_NONE;
689
690	delay_us(30000);
691
692	while(SDL_PollEvent(&event))
693	{
694	switch(event.type)
695	{
696	case SDL_QUIT:
697	quit();
698
699	case SDL_KEYDOWN:
700	{
701	switch(event.key.keysym.sym)
702	{
703	case SDLK_ESCAPE:
704	gui_action = CURSOR_EXIT;
705	break;
706
707	case SDLK_DOWN:
708	gui_action = CURSOR_DOWN;
709	break;
710
711	case SDLK_UP:
712	gui_action = CURSOR_UP;
713	break;
714
715	case SDLK_LEFT:
716	gui_action = CURSOR_LEFT;
717	break;
718
719	case SDLK_RIGHT:
720	gui_action = CURSOR_RIGHT;
721	break;
722
723	case SDLK_RETURN:
724	gui_action = CURSOR_SELECT;
725	break;
726
727	case SDLK_BACKSPACE:
728	gui_action = CURSOR_BACK;
729	break;
730	}
731	break;
732	}
733	}
734	}
735
736	return gui_action;
737	}
738
739	u32 update_input()
740	{
741	SDL_Event event;
742
743	while(SDL_PollEvent(&event))
744	{
745	switch(event.type)
746	{
747	case SDL_QUIT:
748	quit();
749
750	case SDL_KEYDOWN:
751	{
752	if(event.key.keysym.sym == SDLK_ESCAPE)
753	{
754	quit();
755	}
756
757	if(event.key.keysym.sym == SDLK_BACKSPACE)
758	{
759	u16 *screen_copy = copy_screen();
760	u32 ret_val = menu(screen_copy);
761	free(screen_copy);
762
763	return ret_val;
764	}
765	else
766
767	if(event.key.keysym.sym == SDLK_F1)
768	{
769	debug_on();
770	}
771	else
772
773	if(event.key.keysym.sym == SDLK_F2)
774	{
775	FILE *fp = fopen("palette_ram.bin", "wb");
776	printf("writing palette RAM\n");
777	fwrite(palette_ram, 1024, 1, fp);
778	fclose(fp);
779	printf("writing palette VRAM\n");
780	fp = fopen("vram.bin", "wb");
781	fwrite(vram, 1024 * 96, 1, fp);
782	fclose(fp);
783	printf("writing palette OAM RAM\n");
784	fp = fopen("oam_ram.bin", "wb");
785	fwrite(oam_ram, 1024, 1, fp);
786	fclose(fp);
787	printf("writing palette I/O registers\n");
788	fp = fopen("io_registers.bin", "wb");
789	fwrite(io_registers, 1024, 1, fp);
790	fclose(fp);
791	}
792	else
793
794	if(event.key.keysym.sym == SDLK_F3)
795	{
796	dump_translation_cache();
797	}
798	else
799
800	if(event.key.keysym.sym == SDLK_F5)
801	{
802	u8 current_savestate_filename[512];
803	u16 *current_screen = copy_screen();
804	get_savestate_filename_noshot(savestate_slot,
805	current_savestate_filename);
806	save_state(current_savestate_filename, current_screen);
807	free(current_screen);
808	}
809	else
810
811	if(event.key.keysym.sym == SDLK_F7)
812	{
813	u8 current_savestate_filename[512];
814	get_savestate_filename_noshot(savestate_slot,
815	current_savestate_filename);
816	load_state(current_savestate_filename);
817	debug_on();
818	return 1;
819	}
820	else
821
822	if(event.key.keysym.sym == SDLK_BACKQUOTE)
823	{
824	synchronize_flag ^= 1;
825	}
826	else
827	{
828	key \|= key_map(event.key.keysym.sym);
829	trigger_key(key);
830	}
831
832	break;
833	}
834
835	case SDL_KEYUP:
836	{
837	key &= ~(key_map(event.key.keysym.sym));
838	break;
839	}
840
841	case SDL_JOYBUTTONDOWN:
842	{
843	key \|= joy_map(event.jbutton.button);
844	trigger_key(key);
845	break;
846	}
847
848	case SDL_JOYBUTTONUP:
849	{
850	key &= ~(joy_map(event.jbutton.button));
851	break;
852	}
853	}
854	}
855
856	io_registers[REG_P1] = (~key) & 0x3FF;
857
858	return 0;
859	}
860
861	void init_input()
862	{
863	u32 joystick_count = SDL_NumJoysticks();
864
865	if(joystick_count > 0)
866	{
867	SDL_JoystickOpen(0);
868	SDL_JoystickEventState(SDL_ENABLE);
869	}
870	}
871
872	#endif
873
874
875	#define input_savestate_builder(type) \
876	void input_##type##_savestate(file_tag_type savestate_file) \
877	{ \
878	file_##type##_variable(savestate_file, key); \
879	} \
880
881	input_savestate_builder(read);
882	input_savestate_builder(write_mem);
883