# common
OBJS += platform/common/main.o platform/common/emu.o platform/common/upscale.o \
- platform/common/menu_pico.o platform/common/config_file.o
+ platform/common/menu_pico.o platform/common/keyboard.o platform/common/config_file.o
# libpicofe
OBJS += platform/libpicofe/input.o platform/libpicofe/readpng.o \
#define POPT_DIS_FM_SSGEG (1<<23)\r
#define POPT_EN_FM_DAC (1<<24) //x00 0000\r
#define POPT_EN_FM_FILTER (1<<25)\r
-#define POPT_EN_PICO_KBD (1<<26)\r
+#define POPT_EN_KBD (1<<26)\r
\r
#define PAHW_MCD (1<<0)\r
#define PAHW_32X (1<<1)\r
static u32 PicoRead8_pico_kb(u32 a)
{
u32 d = 0;
- if (!(PicoIn.opt & POPT_EN_PICO_KBD)) {
+ if (!(PicoIn.opt & POPT_EN_KBD)) {
elprintf(EL_PICOHW, "kb: r @%06X %04X = %04X\n", SekPc, a, d);
return d;
}
currentConfig.max_skip = atoi(val);
return 1;
+ case MA_CTRL_KEYBOARD:
+ currentConfig.keyboard = 0;
+ if (strcasecmp(val, "virtual") == 0)
+ currentConfig.keyboard = 1;
+ return 1;
+
/* PSP */
case MA_OPT3_VSYNC:
// XXX: use enum
#include "../libpicofe/readpng.h"\r
#include "../libpicofe/plat.h"\r
#include "emu.h"\r
+#include "keyboard.h"\r
#include "input_pico.h"\r
#include "menu_pico.h"\r
#include "config_file.h"\r
int flip_after_sync;\r
int engineState = PGS_Menu;\r
\r
-static int kbd_mode;\r
+int kbd_mode;\r
+struct vkbd *vkbd;\r
\r
static int pico_page;\r
static int pico_w, pico_h;\r
emu_status_msg("Input: D-Pad");\r
}\r
\r
- PicoPicohw.kb.active = (PicoIn.opt & POPT_EN_PICO_KBD ? kbd_mode : 0);\r
+ PicoPicohw.kb.active = (PicoIn.opt & POPT_EN_KBD ? kbd_mode : 0);\r
\r
if (pico_inp_mode == 0)\r
return;\r
}\r
if (which & PEV_SWITCH_KBD)\r
{\r
- kbd_mode = !kbd_mode;\r
- emu_status_msg("Keyboard %s", kbd_mode ? "on" : "off");\r
+ if (! (PicoIn.opt & POPT_EN_KBD)) {\r
+ kbd_mode = 0;\r
+ emu_status_msg("Keyboard not enabled");\r
+ } else {\r
+ kbd_mode = !kbd_mode;\r
+ emu_status_msg("Keyboard %s", kbd_mode ? "on" : "off");\r
+ }\r
+ if (! kbd_mode)\r
+ plat_video_clear_buffers();\r
}\r
if (which & PEV_RESET)\r
emu_reset_game();\r
int actions[IN_BINDTYPE_COUNT] = { 0, };\r
int actions_kbd[IN_BIND_LAST] = { 0, };\r
int pl_actions[4];\r
+ int count_kbd = 0;\r
int events, i;\r
\r
in_update(actions);\r
\r
if (kbd_mode) {\r
int mask = (PicoIn.AHW & PAHW_PICO ? 0xf : 0x0);\r
- in_update_kbd(actions_kbd);\r
+ if (currentConfig.keyboard == 0)\r
+ count_kbd = in_update_kbd(actions_kbd);\r
+ else if (currentConfig.keyboard == 1)\r
+ count_kbd = vkbd_update(vkbd, pl_actions[0], actions_kbd);\r
\r
// FIXME: Only passthrough joystick input to avoid collisions\r
// with PS/2 bindings. Ideally we should check if the device this\r
\r
// update keyboard input, actions only updated if keyboard mode active\r
PicoIn.kbd = 0;\r
- for (i = 0; i < IN_BIND_LAST; i++) {\r
+ for (i = 0; i < count_kbd; i++) {\r
if (actions_kbd[i]) {\r
- unsigned int action = actions_kbd[i];\r
- unsigned int key = (action & 0xff);\r
+ unsigned int key = (actions_kbd[i] & 0xff);\r
if (key == PEVB_KBD_LSHIFT || key == PEVB_KBD_RSHIFT ||\r
key == PEVB_KBD_CTRL || key == PEVB_KBD_FUNC) {\r
- PicoIn.kbd = (PicoIn.kbd & 0x00ff) | (action << 8);\r
+ PicoIn.kbd = (PicoIn.kbd & 0x00ff) | (key << 8);\r
} else {\r
- PicoIn.kbd = (PicoIn.kbd & 0xff00) | action;\r
+ PicoIn.kbd = (PicoIn.kbd & 0xff00) | key;\r
}\r
}\r
}\r
\r
plat_target_gamma_set(currentConfig.gamma, 0);\r
\r
+ vkbd = NULL;\r
+ if (currentConfig.keyboard == 1) {\r
+ if (PicoIn.AHW & PAHW_SMS) vkbd = &vkbd_sc3000;\r
+ else if (PicoIn.AHW & PAHW_PICO) vkbd = &vkbd_pico;\r
+ }\r
+ PicoIn.opt &= ~POPT_EN_KBD;\r
+ if ((currentConfig.EmuOpt & EOPT_PICO_KBD) || (PicoIn.AHW & PAHW_SMS))\r
+ PicoIn.opt |= POPT_EN_KBD;\r
+\r
pemu_loop_prep();\r
}\r
\r
#define EOPT_WIZ_TEAR_FIX (1<<19)
#define EOPT_EXT_FRMLIMIT (1<<20) // no internal frame limiter (limited by snd, etc)
#define EOPT_PICO_PEN (1<<21)
+#define EOPT_PICO_KBD (1<<22)
enum {
EOPT_SCALE_NONE = 0,
int filter; // EOPT_FILTER_* video filter
int ghosting;
int analog_deadzone;
+ int keyboard;
int msh2_khz;
int ssh2_khz;
int overclock_68k;
extern unsigned char *movie_data;
extern int reset_timing;
extern int flip_after_sync;
+extern int kbd_mode;
+extern struct vkbd *vkbd;
#define PICO_PEN_ADJUST_X 1
#define PICO_PEN_ADJUST_Y 1
-#include "input_pico.h"
+/*
+ * PicoDrive
+ * (C) irixxxx, 2025
+ *
+ * keyboard support for Pico and SC-3000/SK-1100
+ */
-// keyboard description
-struct key {
- int xpos;
- char *lower, *upper;
- int key;
-};
+#include <pico/pico_int.h>
+
+#include "keyboard.h"
+#include "input_pico.h"
+#include "../libpicofe/menu.h"
+#include "../libpicofe/plat.h"
+#include "emu.h" // for menuscreen hack
// pico
static struct key kbd_pico_row1[] = {
{ 34, "romaji", "romaji", PEVB_KBD_ROMAJI },
{ 0 },
};
-static struct key *kbd_pico[] =
+
+struct key *kbd_pico[] =
{ kbd_pico_row1, kbd_pico_row2, kbd_pico_row3, kbd_pico_row4, kbd_pico_row5, NULL };
};
static struct key kbd_sc3000_row2[] = {
{ 0, "func", "func", PEVB_KBD_FUNC },
- { 5, "q", "Q", PEVB_KBD_q },
- { 8, "w", "W", PEVB_KBD_w },
- { 11, "e", "E", PEVB_KBD_e },
- { 14, "r", "R", PEVB_KBD_r },
- { 17, "t", "T", PEVB_KBD_t },
- { 20, "y", "Y", PEVB_KBD_y },
- { 23, "u", "U", PEVB_KBD_u },
- { 26, "i", "I", PEVB_KBD_i },
- { 29, "o", "O", PEVB_KBD_o },
- { 32, "p", "P", PEVB_KBD_p },
+ { 5, "Q", "q", PEVB_KBD_q },
+ { 8, "W", "w", PEVB_KBD_w },
+ { 11, "E", "e", PEVB_KBD_e },
+ { 14, "R", "r", PEVB_KBD_r },
+ { 17, "T", "t", PEVB_KBD_t },
+ { 20, "Y", "y", PEVB_KBD_y },
+ { 23, "U", "u", PEVB_KBD_u },
+ { 26, "I", "i", PEVB_KBD_i },
+ { 29, "O", "o", PEVB_KBD_o },
+ { 32, "P", "p", PEVB_KBD_p },
{ 35, "@", "`", PEVB_KBD_AT },
{ 38, "[", "{", PEVB_KBD_LEFTBRACKET },
{ 50, "^", "^", PEVB_KBD_UP },
};
static struct key kbd_sc3000_row3[] = {
{ 0, "ctrl", "ctrl", PEVB_KBD_CAPSLOCK },
- { 6, "a", "A", PEVB_KBD_a },
- { 9, "s", "S", PEVB_KBD_s },
- { 12, "d", "D", PEVB_KBD_d },
- { 15, "f", "F", PEVB_KBD_f },
- { 18, "g", "G", PEVB_KBD_g },
- { 21, "h", "H", PEVB_KBD_h },
- { 24, "j", "J", PEVB_KBD_j },
- { 27, "k", "K", PEVB_KBD_k },
- { 30, "l", "L", PEVB_KBD_l },
+ { 6, "A", "a", PEVB_KBD_a },
+ { 9, "S", "s", PEVB_KBD_s },
+ { 12, "D", "d", PEVB_KBD_d },
+ { 15, "F", "f", PEVB_KBD_f },
+ { 18, "G", "g", PEVB_KBD_g },
+ { 21, "H", "h", PEVB_KBD_h },
+ { 24, "J", "j", PEVB_KBD_j },
+ { 27, "K", "k", PEVB_KBD_k },
+ { 30, "L", "l", PEVB_KBD_l },
{ 33, ";", "+", PEVB_KBD_SEMICOLON },
{ 36, ":", "*", PEVB_KBD_COLON },
{ 39, "]", "}", PEVB_KBD_RIGHTBRACKET },
};
static struct key kbd_sc3000_row4[] = {
{ 0, "shift", "shift", PEVB_KBD_LSHIFT },
- { 7, "z", "Z", PEVB_KBD_z },
- { 10, "x", "X", PEVB_KBD_x },
- { 13, "c", "C", PEVB_KBD_c },
- { 16, "v", "V", PEVB_KBD_v },
- { 19, "b", "B", PEVB_KBD_b },
- { 22, "n", "N", PEVB_KBD_n },
- { 25, "m", "M", PEVB_KBD_m },
+ { 7, "Z", "z", PEVB_KBD_z },
+ { 10, "X", "x", PEVB_KBD_x },
+ { 13, "C", "c", PEVB_KBD_c },
+ { 16, "V", "v", PEVB_KBD_v },
+ { 19, "B", "b", PEVB_KBD_b },
+ { 22, "N", "n", PEVB_KBD_n },
+ { 25, "M", "m", PEVB_KBD_m },
{ 28, ",", "<", PEVB_KBD_COMMA },
{ 31, ".", ">", PEVB_KBD_PERIOD },
{ 34, "/", "?", PEVB_KBD_SLASH },
{ 0 },
};
static struct key kbd_sc3000_row5[] = {
- { 8, "graph", "graph", PEVB_KBD_SOUND },
+ { 7, "graph", "graph", PEVB_KBD_SOUND },
{ 14, "kana", "kana", PEVB_KBD_CJK },
{ 22, "space", "space", PEVB_KBD_SPACE },
{ 31, "clr", "home", PEVB_KBD_HOME },
{ 0 },
};
-static struct key *kbd_sc3000[] =
+struct key *kbd_sc3000[] =
{ kbd_sc3000_row1, kbd_sc3000_row2, kbd_sc3000_row3, kbd_sc3000_row4, kbd_sc3000_row5, NULL };
-static void kbd_draw(struct key *desc[], int shift, int xoffs, int yoffs, struct key *hi)
+struct vkbd vkbd_pico = { kbd_pico, { {3,0}, {-1,-1} } };
+struct vkbd vkbd_sc3000 = { kbd_sc3000, { {1,0}, {2,0}, {3,0}, {3,12} } };
+
+int vkbd_find_xpos(struct key *keys, int xpos)
+{
+ int i;
+
+ for (i = 0; keys[i].lower && keys[i].xpos < xpos; i++)
+ ;
+
+ if (i == 0) return i;
+ else if (keys[i].lower == NULL) return i-1;
+ else if (keys[i].xpos - xpos < xpos - keys[i-1].xpos) return i;
+ else return i-1;
+}
+
+void vkbd_draw(struct vkbd *vkbd)
{
- int i, j;
+ int i, j, k;
struct key *key;
- for (i = 0; desc[i]; i++) {
- for (j = 0, key = &desc[i][j]; key->lower; j++, key++) {
- int color = (key != hi ? PXMAKE(0xa0, 0xa0, 0xa0) :
- PXMAKE(0xff, 0xff, 0xff));
- char *text = (shift ? key->upper : key->lower);
- smalltext_out16(xoffs + key->xpos*me_sfont_w, yoffs + i*me_sfont_h, text, color);
+// HACK: smalltext_out is only available on menuscreen :-/
+g_menuscreen_ptr = (u16 *)g_screen_ptr;
+g_menuscreen_pp = g_screen_ppitch;
+g_menuscreen_w = g_screen_width;
+g_menuscreen_h = g_screen_height;
+if (g_screen_width >= 320) {
+ g_menuscreen_ptr = (u16 *)g_screen_ptr + (g_screen_width-320)/2;
+ g_menuscreen_w = 320;
+}
+
+ for (i = 0; vkbd->kbd[i]; i++) {
+ // darken background
+ for (j = 0; j < me_sfont_h; j++) {
+ u16 *p = (u16 *)g_menuscreen_ptr + (i*me_sfont_h+j)*g_menuscreen_pp;
+ for (k = 0; k < g_menuscreen_w; k++) {
+ u16 v = *p;
+ *p++ = PXMASKH(v,1)>>1;
+ }
+ }
+ // draw keyboard
+ for (j = 0, key = &vkbd->kbd[i][j]; key->lower; j++, key++) {
+ int is_meta = 0;
+ int is_current = vkbd->x == j && vkbd->y == i;
+ for (k = 0; k < VKBD_METAS && vkbd->meta[k][0] != -1 && !is_meta; k++)
+ is_meta |= (vkbd->meta_state & (1<<k)) &&
+ i == vkbd->meta[k][0] && j == vkbd->meta[k][1];
+ int color = is_current ? PXMAKE(0xff, 0xff, 0xff) :
+ is_meta ? PXMAKE(0xc8, 0xc8, 0xc8) :
+ PXMAKE(0xa0, 0xa0, 0xa0);
+ char *text = (vkbd->shift ? key->upper : key->lower);
+ int xpos = key->xpos*me_sfont_w * g_menuscreen_w/320;
+ smalltext_out16(xpos, i*me_sfont_h, text, color);
}
}
}
+
+int vkbd_update(struct vkbd *vkbd, int input, int *actions)
+{
+ int pressed = (input ^ vkbd->prev_input) & input;
+ struct key *key = &vkbd->kbd[vkbd->y][vkbd->x];
+ int count = 0;
+ int is_meta, i;
+
+ // process input keys
+ if (pressed & (1<<GBTN_UP)) {
+ if (--vkbd->y < 0) while (vkbd->kbd[vkbd->y+1]) vkbd->y++;
+ vkbd->x = vkbd_find_xpos(vkbd->kbd[vkbd->y], key->xpos);
+ }
+ if (pressed & (1<<GBTN_DOWN)) {
+ if (vkbd->kbd[++vkbd->y] == NULL) vkbd->y = 0;
+ vkbd->x = vkbd_find_xpos(vkbd->kbd[vkbd->y], key->xpos);
+ }
+ if (pressed & (1<<GBTN_LEFT)) {
+ if (--vkbd->x < 0) while (vkbd->kbd[vkbd->y][vkbd->x+1].lower) vkbd->x++;
+ }
+ if (pressed & (1<<GBTN_RIGHT)) {
+ if (vkbd->kbd[vkbd->y][++vkbd->x].lower == NULL) vkbd->x = 0;
+ }
+ if (pressed & (1<<GBTN_C)) {
+ vkbd->top = !vkbd->top;
+ }
+ if (pressed & (1<<GBTN_B)) {
+ vkbd->shift = !vkbd->shift;
+ }
+
+ if (pressed & (1<<GBTN_A)) {
+ for (i = 0; i < VKBD_METAS; i++)
+ if (vkbd->y == vkbd->meta[i][0] && vkbd->x == vkbd->meta[i][1])
+ vkbd->meta_state = (vkbd->meta_state ^ (1<<i)) & (1<<i);
+ }
+
+ // compute pressed virtual keys: meta keys + current char key
+ for (i = 0, is_meta = 0; i < VKBD_METAS && vkbd->meta[i][0] != -1; i++) {
+ is_meta |= vkbd->y == vkbd->meta[i][0] && vkbd->x == vkbd->meta[i][1];
+
+ if (vkbd->meta_state & (1<<i))
+ actions[count++] = vkbd->kbd[vkbd->meta[i][0]][vkbd->meta[i][1]].key;
+ }
+ if (!is_meta && (input & (1<<GBTN_A)))
+ actions[count++] = vkbd->kbd[vkbd->y][vkbd->x].key;
+
+ vkbd->prev_input = input;
+
+ return count;
+}
+
+struct vkbd *vkbd_init(int is_pico)
+{
+ struct vkbd *vkbd = is_pico ? &vkbd_pico : &vkbd_sc3000;
+ memset(vkbd->meta+1, 0, sizeof(*vkbd) - sizeof(vkbd->kbd) - sizeof(vkbd->meta));
+ return vkbd;
+}
--- /dev/null
+// keyboard support for Pico/SC-3000
+
+// keyboard description
+struct key {
+ int xpos;
+ char *lower, *upper;
+ int key;
+};
+
+extern struct key *kbd_pico[];
+extern struct key *kbd_sc3000[];
+
+#define VKBD_METAS 4
+struct vkbd {
+ struct key **kbd;
+ int meta[VKBD_METAS][2]; // meta keys (shift, ctrl, etc)
+
+ int top; // top or bottom?
+ int shift; // shifted or normal view?
+
+ int x,y; // current key
+ int meta_state;
+ int prev_input;
+};
+
+extern struct vkbd vkbd_pico;
+extern struct vkbd vkbd_sc3000;
+
+int vkbd_find_xpos(struct key *keys, int xpos);
+void vkbd_draw(struct vkbd *vkbd);
+int vkbd_update(struct vkbd *vkbd, int input, int *actions);
+
#include "emu.h"
#include "menu_pico.h"
#include "input_pico.h"
+#include "keyboard.h"
#include "version.h"
#include "../libpicofe/plat.h"
return name;
}
-#include "keyboard.c"
-
-static int find_xpos(struct key *keys, int xpos)
+static void kbd_draw(struct key *desc[], int shift, int xoffs, int yoffs, struct key *hi)
{
- int i;
-
- for (i = 0; keys[i].lower && keys[i].xpos < xpos; i++)
- ;
+ int i, j;
+ struct key *key;
- if (i == 0) return i;
- else if (keys[i].lower == NULL) return i-1;
- else if (keys[i].xpos - xpos < xpos - keys[i-1].xpos) return i;
- else return i-1;
+ for (i = 0; desc[i]; i++) {
+ for (j = 0, key = &desc[i][j]; key->lower; j++, key++) {
+ int color = (key != hi ? PXMAKE(0xa0, 0xa0, 0xa0) :
+ PXMAKE(0xff, 0xff, 0xff));
+ char *text = (shift ? key->upper : key->lower);
+ smalltext_out16(xoffs + key->xpos*me_sfont_w, yoffs + i*me_sfont_h, text, color);
+ }
+ }
}
int key_config_kbd_loop(int id, int keys)
if (inp & PBTN_UP) {
if (--keyy < 0) while (kbd[keyy+1]) keyy++;
- keyx = find_xpos(kbd[keyy], key->xpos);
+ keyx = vkbd_find_xpos(kbd[keyy], key->xpos);
}
if (inp & PBTN_DOWN) {
if (kbd[++keyy] == NULL) keyy = 0;
- keyx = find_xpos(kbd[keyy], key->xpos);
+ keyx = vkbd_find_xpos(kbd[keyy], key->xpos);
}
if (inp & PBTN_LEFT) {
if (--keyx < 0) while (kbd[keyy][keyx+1].lower) keyx++;
if (inp & PBTN_R) {
toggle = !toggle;
kbd = (toggle ? kbd_sc3000 : kbd_pico);
- keyx = find_xpos(kbd[keyy], key->xpos);
+ keyx = vkbd_find_xpos(kbd[keyy], key->xpos);
}
if (inp & PBTN_MOK) {
const char *indev0_names[] = { "none", "3 button pad", "6 button pad", "Team player", "4 way play", NULL };
const char *indev1_names[] = { "none", "3 button pad", "6 button pad", NULL };
+static char h_play12[55];
+static char h_kbd[55];
static char h_play34[] = "Works only for Mega Drive/CD/32X games having\n"
"support for Team player, 4 way play, or J-cart";
+static char player[] = "Player 1";
+
+static const char *mgn_nothing(int id, int *offs)
+{
+ return "";
+}
+
+static int key_config_players(int id, int keys)
+{
+ int pid = player[strlen(player)-1] - '0';
+
+ if (keys & PBTN_LEFT)
+ if (--pid < 1) pid = 4;
+ if (keys & PBTN_RIGHT)
+ if (++pid > 4) pid = 1;
+
+ player[strlen(player)-1] = pid + '0';
+ e_menu_keyconfig[0].help = (pid >= 3 ? h_play34 : h_play12);
+
+ if (keys & PBTN_MOK)
+ key_config_loop(me_ctrl_actions, array_size(me_ctrl_actions) - 1, pid-1);
+
+ return 0;
+}
+
+static const char *mgn_keyboard(int id, int *offs)
+{
+ static char *kbds[] = { "physical", "virtual" };
+ if (currentConfig.keyboard < 0 || currentConfig.keyboard > 1)
+ return kbds[0];
+ return kbds[currentConfig.keyboard];
+}
+
+static int key_config_keyboard(int id, int keys)
+{
+ int kid = currentConfig.keyboard;
+
+ if (keys & PBTN_LEFT)
+ if (--kid < 0) kid = 1;
+ if (keys & PBTN_RIGHT)
+ if (++kid > 1) kid = 0;
+
+ currentConfig.keyboard = kid;
+
+ e_menu_keyconfig[2].help = (currentConfig.keyboard == 0 ? h_kbd : NULL);
+
+ if (keys & PBTN_MOK)
+ if (currentConfig.keyboard == 1)
+ key_config_kbd_loop(MA_CTRL_KEYBOARD, 0);
+
+ return 0;
+}
+
static menu_entry e_menu_keyconfig[] =
{
- mee_handler_id("Player 1", MA_CTRL_PLAYER1, key_config_loop_wrap),
- mee_handler_id("Player 2", MA_CTRL_PLAYER2, key_config_loop_wrap),
- mee_handler_id_h("Player 3", MA_CTRL_PLAYER3, key_config_loop_wrap, h_play34),
- mee_handler_id_h("Player 4", MA_CTRL_PLAYER4, key_config_loop_wrap, h_play34),
+ mee_cust_nosave(player, MA_CTRL_PLAYER1, key_config_players, mgn_nothing),
mee_handler_id("Emulator hotkeys", MA_CTRL_EMU, key_config_loop_wrap),
- mee_handler_id("Keyboard mapping", MA_CTRL_KEYBOARD, key_config_kbd_loop),
+ mee_cust_h ("Keyboard", MA_CTRL_KEYBOARD, key_config_keyboard, mgn_keyboard, h_kbd),
mee_enum ("Input device 1", MA_OPT_INPUT_DEV0, currentConfig.input_dev0, indev0_names),
mee_enum ("Input device 2", MA_OPT_INPUT_DEV1, currentConfig.input_dev1, indev1_names),
mee_range ("Turbo rate", MA_CTRL_TURBO_RATE, currentConfig.turbo_rate, 1, 30),
for (it += x; x && e_menu_keyconfig[x].name; x++)
e_menu_keyconfig[x].enabled = x < it;
+ char l[20], r[20];
+ snprintf(l,sizeof(l),"%s", in_get_key_name(-1, -PBTN_LEFT));
+ snprintf(r,sizeof(r),"%s", in_get_key_name(-1, -PBTN_RIGHT));
+ snprintf(h_play12, sizeof(h_play12), "%s/%s - select, %s - configure", l, r, in_get_key_name(-1, -PBTN_MOK));
+ snprintf(h_kbd, sizeof(h_kbd), "%s - configure", in_get_key_name(-1, -PBTN_MOK));
+
+ player[strlen(player)-1] = '1';
+ e_menu_keyconfig[0].help = h_play12;
+ e_menu_keyconfig[2].help = (currentConfig.keyboard == 0 ? h_kbd : NULL);
+
me_loop_d(e_menu_keyconfig, &sel, menu_draw_prep, NULL);
PicoSetInputDevice(0, currentConfig.input_dev0);
mee_onoff_h ("FM filter", MA_OPT_FM_FILTER, PicoIn.opt, POPT_EN_FM_FILTER, h_fmfilter),
mee_onoff_h ("FM DAC noise", MA_OPT2_ENABLE_YM_DAC, PicoIn.opt, POPT_EN_FM_DAC, h_dacnoise),
mee_onoff_h ("Pen button shows screen", MA_OPT_PICO_PEN, currentConfig.EmuOpt, EOPT_PICO_PEN, h_picopen),
- mee_onoff ("Pico Keyboard", MA_OPT_PICO_KBD, PicoIn.opt, POPT_EN_PICO_KBD),
+ mee_onoff ("Pico keyboard", MA_OPT_PICO_KBD, currentConfig.EmuOpt, EOPT_PICO_KBD),
mee_end,
};
plat_target.hwfilters != NULL);
me_enable(e_menu_gfx_options, MA_OPT2_GAMMA,
- plat_target.gamma_set != NULL);
+ plat_target.gamma_set != NULL);
i = me_id2offset(e_menu_options, MA_OPT_CPU_CLOCKS);
e_menu_options[i].enabled = 0;
#include "../common/menu_pico.h"\r
#include "../common/arm_utils.h"\r
#include "../common/emu.h"\r
+#include "../common/keyboard.h"\r
#include "../common/config_file.h"\r
#include "../common/version.h"\r
#include "plat.h"\r
if (pico_inp_mode /*== 2 || overlay*/)\r
draw_pico_ptr();\r
}\r
+ // draw virtual keyboard on display\r
+ if (kbd_mode && currentConfig.keyboard == 1 && vkbd)\r
+ vkbd_draw(vkbd);\r
}\r
\r
void plat_video_flip(void)\r
gp2x_memset_all_buffers(0, 0, 320*240*2);\r
}\r
\r
+void plat_video_clear_buffers(void)\r
+{\r
+ if (!is_16bit_mode())\r
+ gp2x_memset_all_buffers(0, 0xe0, 320*240);\r
+ else\r
+ gp2x_memset_all_buffers(0, 0, 320*240*2);\r
+}\r
+\r
void plat_video_toggle_renderer(int change, int is_menu_call)\r
{\r
change_renderer(change);\r
-Subproject commit c567bf4c74221fccf1cd91f8faac8542aab63b28
+Subproject commit 81d2580006b56ede8e559b7a7f608ebb5ebbe6ae
#include "../common/emu.h"\r
#include "../common/arm_utils.h"\r
#include "../common/upscale.h"\r
+#include "../common/keyboard.h"\r
#include "../common/version.h"\r
\r
#include <pico/pico_int.h>\r
draw_pico_ptr();\r
}\r
\r
+ // draw virtual keyboard on display\r
+ if (kbd_mode && currentConfig.keyboard == 1 && vkbd)\r
+ vkbd_draw(vkbd);\r
+\r
if (notice)\r
emu_osd_text16(4, g_screen_height - 8, notice);\r
if (currentConfig.EmuOpt & EOPT_SHOW_FPS)\r
#include "../common/emu.h"\r
#include "../common/arm_utils.h"\r
#include "../common/input_pico.h"\r
+#include "../common/keyboard.h"\r
#include "../common/version.h"\r
#include "../libpicofe/input.h"\r
#include "../libpicofe/menu.h"\r
}\r
if ((PicoIn.AHW & PAHW_MCD) && (currentConfig.EmuOpt & EOPT_EN_CD_LEDS))\r
draw_cd_leds();\r
+ // draw virtual keyboard on display\r
+ if (kbd_mode && currentConfig.keyboard == 1 && vkbd)\r
+ vkbd_draw(vkbd);\r
}\r
\r
void plat_video_flip(void)\r
xenv_update(NULL, NULL, NULL, NULL);\r
}\r
\r
+void plat_video_clear_buffers(void)\r
+{\r
+ vout_fbdev_clear(layer_fb);\r
+}\r
+\r
// pnd doesn't use multiple renderers, but we have to handle this since it's\r
// called on 32x enable and PicoDrawSetOutFormat() sets up the 32x layers\r
void plat_video_toggle_renderer(int change, int is_menu)\r
#include "../libpicofe/menu.h"
#include "../common/input_pico.h"
#include "../common/emu.h"
+#include "../common/keyboard.h"
#include <pico/pico_int.h>
draw_pico_ptr();
}
+ // draw virtual keyboard on display
+ if (kbd_mode && currentConfig.keyboard == 1 && vkbd)
+ vkbd_draw(vkbd);
+
osd_buf_cnt = 0;
if (notice) osd_text(4, notice);
if (emu_opt & 2) osd_text(OSD_FPS_X, fps);
FlushCache(WRITEBACK_DCACHE);
}
+/* clear all video buffers to remove remnants in borders */
+void plat_video_clear_buffers(void)
+{
+ // not needed since output buffer is cleared in flip anyway
+}
+
/* display a completed frame buffer and prepare a new render buffer */
void plat_video_flip(void)
{
#include "asm_utils.h"
#include "../common/emu.h"
#include "../common/input_pico.h"
+#include "../common/keyboard.h"
#include "platform/libpicofe/input.h"
#include "platform/libpicofe/menu.h"
#include "platform/libpicofe/plat.h"
draw_pico_ptr();
}
+ // draw virtual keyboard on display
+ if (kbd_mode && currentConfig.keyboard == 1 && vkbd)
+ vkbd_draw(vkbd);
+
osd_buf_cnt = 0;
if (notice)
osd_text(4, notice);
emu_cmn_forced_frame(no_scale, do_emu, g_screen_ptr);
}
+/* clear all video buffers to remove remnants in borders */
+void plat_video_clear_buffers(void)
+{
+ // not needed since output buffer is cleared in flip anyway
+}
+
/* change the platform output rendering */
void plat_video_toggle_renderer(int change, int is_menu_call)
{
notaz.gp2x.de / picodrive.git / commitdiff