#include "../libpcsxcore/cdriso.h"
#include "../libpcsxcore/cheat.h"
#include "../libpcsxcore/r3000a.h"
+#include "../libpcsxcore/gpu.h"
+#include "../libpcsxcore/database.h"
#include "../plugins/dfsound/out.h"
#include "../plugins/dfsound/spu_config.h"
#include "cspace.h"
static void *vout_buf;
static void *vout_buf_ptr;
-static int vout_width, vout_height;
+static int vout_width = 256, vout_height = 240, vout_pitch = 256;
static int vout_fb_dirty;
static int psx_w, psx_h;
static bool vout_can_dupe;
static bool show_advanced_gpu_unai_settings = true;
#endif
static float mouse_sensitivity = 1.0f;
+static unsigned int disk_current_index;
typedef enum
{
int multitap1 = 0;
int multitap2 = 0;
int in_enable_vibration = 1;
+int in_enable_crosshair[2] = { 0, 0 };
// NegCon adjustment parameters
// > The NegCon 'twist' action is somewhat awkward when mapped
fb.height = vout_height;
fb.access_flags = RETRO_MEMORY_ACCESS_WRITE;
- if (environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, &fb) && fb.format == RETRO_PIXEL_FORMAT_RGB565)
- vout_buf_ptr = (uint16_t *)fb.data;
+ vout_pitch = vout_width;
+ if (environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, &fb) && fb.format == RETRO_PIXEL_FORMAT_RGB565) {
+ vout_buf_ptr = fb.data;
+ if (fb.pitch / 2 != vout_pitch && fb.pitch != vout_width * 2)
+ SysPrintf("got unusual pitch %zd for resolution %dx%d\n", fb.pitch, vout_width, vout_height);
+ vout_pitch = fb.pitch / 2;
+ }
else
vout_buf_ptr = vout_buf;
}
}
#endif
+// Function to add crosshairs
+static void addCrosshair(int port, int crosshair_color, unsigned short *buffer, int bufferStride, int pos_x, int pos_y, int thickness, int size_x, int size_y) {
+ for (port = 0; port < 2; port++) {
+ // Draw the horizontal line of the crosshair
+ for (int i = pos_y - thickness / 2; i <= pos_y + thickness / 2; i++) {
+ for (int j = pos_x - size_x / 2; j <= pos_x + size_x / 2; j++) {
+ if ((i + vout_height) >= 0 && (i + vout_height) < bufferStride && j >= 0 && j < bufferStride && in_enable_crosshair[port] > 0)
+ buffer[i * bufferStride + j] = crosshair_color;
+ }
+ }
+
+ // Draw the vertical line of the crosshair
+ for (int i = pos_x - thickness / 2; i <= pos_x + thickness / 2; i++) {
+ for (int j = pos_y - size_y / 2; j <= pos_y + size_y / 2; j++) {
+ if (i >= 0 && i < bufferStride && (j + vout_height) >= 0 && (j + vout_height) < bufferStride && in_enable_crosshair[port] > 0)
+ buffer[j * bufferStride + i] = crosshair_color;
+ }
+ }
+ }
+}
+
+struct CrosshairInfo {
+ int pos_x, pos_y, thickness, size_x, size_y;
+};
+
+// Calculate size and position of crosshairs
+static void CrosshairDimensions(int port, struct CrosshairInfo *info) {
+ int gunx = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_X);
+ int guny = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_Y);
+ if (gunx == 32767) // Prevent crosshairs from wrapping around right side of screen to left
+ info->pos_x = (gunx + 32767.0f) * vout_width / 65534.0f - 0.5f;
+ else
+ info->pos_x = (gunx + 32767.0f) * vout_width / 65534.0f;
+ info->pos_y = (guny + 32767.0f) * vout_height / 65534.0f - vout_height;
+ info->thickness = pl_rearmed_cbs.gpu_neon.enhancement_enable ? 4 : 2;
+ info->size_x = psx_w * (pl_rearmed_cbs.gpu_neon.enhancement_enable ? 2 : 1) / 40.0f;
+ info->size_y = psx_h * (pl_rearmed_cbs.gpu_neon.enhancement_enable ? 2 : 1) * (4.0f / 3.0f) / 40.0f;
+}
+
static void vout_flip(const void *vram, int stride, int bgr24,
int x, int y, int w, int h, int dims_changed)
{
unsigned short *dest = vout_buf_ptr;
const unsigned short *src = vram;
- int dstride = vout_width, h1 = h;
+ int dstride = vout_pitch, h1 = h;
+ int port = 0;
- if (vram == NULL || dims_changed)
+ if (vram == NULL || dims_changed || (in_enable_crosshair[0] + in_enable_crosshair[1]) > 0)
{
memset(vout_buf_ptr, 0, dstride * vout_height * 2);
// blanking
}
}
+ for (port = 0; port < 2; port++) {
+ if (in_enable_crosshair[port] > 0 && (in_type[port] == PSE_PAD_TYPE_GUNCON || in_type[port] == PSE_PAD_TYPE_GUN))
+ {
+ struct CrosshairInfo crosshairInfo;
+ CrosshairDimensions(port, &crosshairInfo);
+ addCrosshair(port, in_enable_crosshair[port], dest, dstride, crosshairInfo.pos_x, crosshairInfo.pos_y, crosshairInfo.thickness, crosshairInfo.size_x, crosshairInfo.size_y);
+ }
+ }
+
out:
#ifndef FRONTEND_SUPPORTS_RGB565
- convert(vout_buf_ptr, vout_width * vout_height * 2);
+ convert(vout_buf_ptr, vout_pitch * vout_height * 2);
#endif
vout_fb_dirty = 1;
pl_rearmed_cbs.flip_cnt++;
{ NULL, 0x12800000, 0x010000, MAP_TAG_OTHER }, // 0x1f800000
{ NULL, 0x12c00000, 0x080000, MAP_TAG_OTHER }, // 0x1fc00000
{ NULL, 0x11000000, 0x800000, MAP_TAG_LUTS }, // 0x08000000
- { NULL, 0x12000000, 0x200000, MAP_TAG_VRAM }, // 0x00000000
+ { NULL, 0x12000000, 0x201000, MAP_TAG_VRAM }, // 0x00000000
};
void *pl_3ds_mmap(unsigned long addr, size_t size, int is_fixed,
if ((custom_map->size == size) && (custom_map->tag == tag))
{
uint32_t ptr_aligned, tmp;
+ void *ret;
custom_map->buffer = malloc(size + 0x1000);
ptr_aligned = (((u32)custom_map->buffer) + 0xFFF) & ~0xFFF;
exit(1);
}
- return (void *)custom_map->target_map;
+ ret = (void *)custom_map->target_map;
+ memset(ret, 0, size);
+ return ret;
}
}
}
- return malloc(size);
+ return calloc(size, 1);
}
void pl_3ds_munmap(void *ptr, size_t size, enum psxMapTag tag)
typedef struct
{
void *buffer;
- uint32_t target_map;
size_t size;
enum psxMapTag tag;
+ int used;
} psx_map_t;
-void *addr = NULL;
+static void *addr = NULL;
psx_map_t custom_psx_maps[] = {
- { NULL, NULL, 0x210000, MAP_TAG_RAM }, // 0x80000000
- { NULL, NULL, 0x010000, MAP_TAG_OTHER }, // 0x1f800000
- { NULL, NULL, 0x080000, MAP_TAG_OTHER }, // 0x1fc00000
- { NULL, NULL, 0x800000, MAP_TAG_LUTS }, // 0x08000000
- { NULL, NULL, 0x200000, MAP_TAG_VRAM }, // 0x00000000
+ { NULL, 0x800000, MAP_TAG_LUTS },
+ { NULL, 0x080000, MAP_TAG_OTHER },
+ { NULL, 0x010000, MAP_TAG_OTHER },
+ { NULL, 0x201000, MAP_TAG_VRAM },
+ { NULL, 0x802000, MAP_TAG_VRAM }, // enhanced renderer
+ { NULL, 0x210000, MAP_TAG_RAM },
};
int init_vita_mmap()
addr = malloc(64 * 1024 * 1024);
if (addr == NULL)
return -1;
- tmpaddr = ((u32)(addr + 0xFFFFFF)) & ~0xFFFFFF;
- custom_psx_maps[0].buffer = tmpaddr + 0x2000000;
- custom_psx_maps[1].buffer = tmpaddr + 0x1800000;
- custom_psx_maps[2].buffer = tmpaddr + 0x1c00000;
- custom_psx_maps[3].buffer = tmpaddr + 0x0000000;
+ tmpaddr = (void *)(((size_t)addr + 0xFFFFFF) & ~0xFFFFFF);
+ custom_psx_maps[0].buffer = tmpaddr + 0x0000000;
+ custom_psx_maps[1].buffer = tmpaddr + 0x0800000;
+ custom_psx_maps[2].buffer = tmpaddr + 0x0880000;
+ custom_psx_maps[3].buffer = tmpaddr + 0x0900000;
custom_psx_maps[4].buffer = tmpaddr + 0x1000000;
+ custom_psx_maps[5].buffer = tmpaddr + 0x2000000;
+ memset(tmpaddr, 0, 0x2210000);
#if 0
for(n = 0; n < 5; n++){
sceClibPrintf("addr reserved %x\n",custom_psx_maps[n].buffer);
void deinit_vita_mmap()
{
+ size_t i;
+ for (i = 0; i < sizeof(custom_psx_maps) / sizeof(custom_psx_maps[0]); i++) {
+ custom_psx_maps[i].buffer = NULL;
+ custom_psx_maps[i].used = 0;
+ }
free(addr);
}
for (; custom_map->size; custom_map++)
{
- if ((custom_map->size == size) && (custom_map->tag == tag))
+ if (custom_map->size == size && custom_map->tag == tag && !custom_map->used)
{
+ custom_map->used = 1;
return custom_map->buffer;
}
}
- return malloc(size);
+ return calloc(size, 1);
}
void pl_vita_munmap(void *ptr, size_t size, enum psxMapTag tag)
{
if ((custom_map->buffer == ptr))
{
+ custom_map->used = 0;
return;
}
}
.pl_vout_close = vout_close,
.mmap = pl_mmap,
.munmap = pl_munmap,
+ .gpu_state_change = gpu_state_change,
/* from psxcounters */
.gpu_hcnt = &hSyncCount,
.gpu_frame_count = &frame_counter,
}
}
+//Percentage distance of screen to adjust for Konami Gun
+static float KonamiGunAdjustX = 0;
+static float KonamiGunAdjustY = 0;
+
void pl_gun_byte2(int port, unsigned char byte)
{
+ int irq_count = 4;
+ float justifier_multiplier = 0;
+ int justifier_width = psx_w;
+ int justifier_height = psx_h;
+ int justifier_offscreen = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_IS_OFFSCREEN);
+ int justifier_reload = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD);
+
+ if (justifier_width == 256)
+ justifier_multiplier = is_pal_mode ? .157086f : .158532f;
+ else if (justifier_width == 320)
+ justifier_multiplier = is_pal_mode ? .196358f : .198166f;
+ else if (justifier_width == 384)
+ justifier_multiplier = is_pal_mode ? .224409f : .226475f;
+ else if (justifier_width == 512)
+ justifier_multiplier = is_pal_mode ? .314173f : .317065f;
+ else // (justifier_width == 640)
+ justifier_multiplier = is_pal_mode ? .392717f : .396332f;
+
+ int gunx = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_X);
+ int guny = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_Y);
+
+ //Default offset of +105 for X and -12 for Y is chosen to obtain alignment in Die Hard Trilogy, which has no calibration feature
+ int gunx_scaled = ((gunx + 32767.0f) / 65534.0f + KonamiGunAdjustX) * justifier_width / justifier_multiplier + 105.0f;
+ int guny_scaled = ((guny + 32767.0f) / 65534.0f + KonamiGunAdjustY) * justifier_height - 12.0f;
+
+ if ((byte & 0x10) && !justifier_offscreen && !justifier_reload)
+ {
+ psxScheduleIrq10(irq_count, gunx_scaled, guny_scaled);
+ }
}
/* sound calls */
drv->feed = snd_feed;
}
-#define RETRO_DEVICE_PSE_STANDARD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 0)
-#define RETRO_DEVICE_PSE_ANALOG RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 0)
-#define RETRO_DEVICE_PSE_DUALSHOCK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 1)
-#define RETRO_DEVICE_PSE_NEGCON RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 2)
-#define RETRO_DEVICE_PSE_GUNCON RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_LIGHTGUN, 0)
-#define RETRO_DEVICE_PSE_MOUSE RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE, 0)
+#define RETRO_DEVICE_PSE_STANDARD RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD, 0)
+#define RETRO_DEVICE_PSE_ANALOG RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 0)
+#define RETRO_DEVICE_PSE_DUALSHOCK RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 1)
+#define RETRO_DEVICE_PSE_NEGCON RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG, 2)
+#define RETRO_DEVICE_PSE_GUNCON RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_LIGHTGUN, 0)
+#define RETRO_DEVICE_PSE_JUSTIFIER RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_LIGHTGUN, 1)
+#define RETRO_DEVICE_PSE_MOUSE RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE, 0)
static char *get_pse_pad_label[] = {
"none", "mouse", "negcon", "konami gun", "standard", "analog", "guncon", "dualshock"
};
-static const struct retro_controller_description pads[7] =
+static const struct retro_controller_description pads[8] =
{
- { "standard", RETRO_DEVICE_JOYPAD },
- { "analog", RETRO_DEVICE_PSE_ANALOG },
- { "dualshock", RETRO_DEVICE_PSE_DUALSHOCK },
- { "negcon", RETRO_DEVICE_PSE_NEGCON },
- { "guncon", RETRO_DEVICE_PSE_GUNCON },
- { "mouse", RETRO_DEVICE_PSE_MOUSE },
+ { "standard", RETRO_DEVICE_JOYPAD },
+ { "analog", RETRO_DEVICE_PSE_ANALOG },
+ { "dualshock", RETRO_DEVICE_PSE_DUALSHOCK },
+ { "negcon", RETRO_DEVICE_PSE_NEGCON },
+ { "guncon", RETRO_DEVICE_PSE_GUNCON },
+ { "konami gun", RETRO_DEVICE_PSE_JUSTIFIER },
+ { "mouse", RETRO_DEVICE_PSE_MOUSE },
{ NULL, 0 },
};
"pcsx_rearmed_negcon_deadzone",
"pcsx_rearmed_negcon_response",
"pcsx_rearmed_input_sensitivity",
+ "pcsx_rearmed_crosshair1",
+ "pcsx_rearmed_crosshair2",
+ "pcsx_rearmed_konamigunadjustx",
+ "pcsx_rearmed_konamigunadjusty",
"pcsx_rearmed_gunconadjustx",
"pcsx_rearmed_gunconadjusty",
"pcsx_rearmed_gunconadjustratiox",
case RETRO_DEVICE_PSE_GUNCON:
in_type[port] = PSE_PAD_TYPE_GUNCON;
break;
+ case RETRO_DEVICE_PSE_JUSTIFIER:
+ in_type[port] = PSE_PAD_TYPE_GUN;
+ break;
case RETRO_DEVICE_NONE:
default:
in_type[port] = PSE_PAD_TYPE_NONE;
void retro_get_system_av_info(struct retro_system_av_info *info)
{
- unsigned geom_height = vout_height > 0 ? vout_height : 240;
- unsigned geom_width = vout_width > 0 ? vout_width : 320;
+ unsigned geom_height = vout_height;
+ unsigned geom_width = vout_width;
memset(info, 0, sizeof(*info));
info->timing.fps = is_pal_mode ? 50.0 : 60.0;
bool retro_serialize(void *data, size_t size)
{
- int ret = SaveState(data);
+ int ret;
+ CdromFrontendId = disk_current_index;
+ ret = SaveState(data);
return ret == 0 ? true : false;
}
+static bool disk_set_image_index(unsigned int index);
+
bool retro_unserialize(const void *data, size_t size)
{
- int ret = LoadState(data);
- return ret == 0 ? true : false;
+ int ret;
+ CdromFrontendId = -1;
+ ret = LoadState(data);
+ if (ret)
+ return false;
+ if (CdromFrontendId != -1 && CdromFrontendId != disk_current_index)
+ disk_set_image_index(CdromFrontendId);
+ return true;
}
/* cheats */
static unsigned int disk_initial_index;
static char disk_initial_path[PATH_MAX];
static bool disk_ejected;
-static unsigned int disk_current_index;
static unsigned int disk_count;
static struct disks_state
{
#endif
}
+static void show_notification(const char *msg_str,
+ unsigned duration_ms, unsigned priority)
+{
+ if (msg_interface_version >= 1)
+ {
+ struct retro_message_ext msg = {
+ msg_str,
+ duration_ms,
+ 3,
+ RETRO_LOG_WARN,
+ RETRO_MESSAGE_TARGET_ALL,
+ RETRO_MESSAGE_TYPE_NOTIFICATION,
+ -1
+ };
+ environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE_EXT, &msg);
+ }
+ else
+ {
+ struct retro_message msg = {
+ msg_str,
+ 180
+ };
+ environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &msg);
+ }
+}
+
static void retro_audio_buff_status_cb(
bool active, unsigned occupancy, bool underrun_likely)
{
{ port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_TRIGGER, "Gun Trigger" }, \
{ port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD, "Gun Reload" }, \
{ port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_A, "Gun Aux A" }, \
- { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_B, "Gun Aux B" },
+ { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_B, "Gun Aux B" }, \
+ { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_START, "Gun Start" },
JOYP(0)
JOYP(1)
set_retro_memmap();
retro_set_audio_buff_status_cb();
+ if (check_unsatisfied_libcrypt())
+ show_notification("LibCrypt protected game with missing SBI detected", 3000, 3);
+
return true;
}
};
#define RETRO_PSX_MAP_LEN (sizeof(retro_psx_map) / sizeof(retro_psx_map[0]))
-//Percentage distance of screen to adjust
+//Percentage distance of screen to adjust for Guncon
static int GunconAdjustX = 0;
static int GunconAdjustY = 0;
-//Used when out by a percentage
+//Used when out by a percentage with Guncon
static float GunconAdjustRatioX = 1;
static float GunconAdjustRatioY = 1;
spu_config.iUseInterpolation = 0;
}
+#if P_HAVE_PTHREAD
var.value = NULL;
var.key = "pcsx_rearmed_spu_thread";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
else
spu_config.iUseThread = 0;
}
+#endif
+#if 0 // currently disabled, see USE_READ_THREAD in libpcsxcore/cdriso.c
if (P_HAVE_PTHREAD) {
var.value = NULL;
var.key = "pcsx_rearmed_async_cd";
}
}
}
+#endif
var.value = NULL;
var.key = "pcsx_rearmed_noxadecoding";
{
if (strcmp(var.value, "game") == 0)
pl_rearmed_cbs.screen_centering_type = 1;
- else if (strcmp(var.value, "manual") == 0)
+ else if (strcmp(var.value, "borderless") == 0)
pl_rearmed_cbs.screen_centering_type = 2;
+ else if (strcmp(var.value, "manual") == 0)
+ pl_rearmed_cbs.screen_centering_type = 3;
else // auto
pl_rearmed_cbs.screen_centering_type = 0;
}
}
#endif // GPU_UNAI
+ var.value = NULL;
+ var.key = "pcsx_rearmed_crosshair1";
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ if (strcmp(var.value, "disabled") == 0)
+ in_enable_crosshair[0] = 0;
+ else if (strcmp(var.value, "blue") == 0)
+ in_enable_crosshair[0] = 0x1F;
+ else if (strcmp(var.value, "green") == 0)
+ in_enable_crosshair[0] = 0x7E0;
+ else if (strcmp(var.value, "red") == 0)
+ in_enable_crosshair[0] = 0xF800;
+ else if (strcmp(var.value, "white") == 0)
+ in_enable_crosshair[0] = 0xFFFF;
+ }
+
+ var.value = NULL;
+ var.key = "pcsx_rearmed_crosshair2";
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ if (strcmp(var.value, "disabled") == 0)
+ in_enable_crosshair[1] = 0;
+ else if (strcmp(var.value, "blue") == 0)
+ in_enable_crosshair[1] = 0x1F;
+ else if (strcmp(var.value, "green") == 0)
+ in_enable_crosshair[1] = 0x7E0;
+ else if (strcmp(var.value, "red") == 0)
+ in_enable_crosshair[1] = 0xF800;
+ else if (strcmp(var.value, "white") == 0)
+ in_enable_crosshair[1] = 0xFFFF;
+ }
+
//This adjustment process gives the user the ability to manually align the mouse up better
//with where the shots are in the emulator.
+ var.value = NULL;
+ var.key = "pcsx_rearmed_konamigunadjustx";
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ KonamiGunAdjustX = atof(var.value) / 100.0f;
+ }
+
+ var.value = NULL;
+ var.key = "pcsx_rearmed_konamigunadjusty";
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ KonamiGunAdjustY = atof(var.value) / 100.0f;
+ }
+
var.value = NULL;
var.key = "pcsx_rearmed_gunconadjustx";
mouse_sensitivity = atof(var.value);
}
+ if (found_bios)
+ {
+ var.value = NULL;
+ var.key = "pcsx_rearmed_show_bios_bootlogo";
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ Config.SlowBoot = 0;
+ if (strcmp(var.value, "enabled") == 0)
+ Config.SlowBoot = 1;
+ }
+ }
+
if (in_flight)
{
// inform core things about possible config changes
/* dfinput_activate(); */
}
- else
- {
- //not yet running
-
- //bootlogo display hack
- if (found_bios)
- {
- var.value = NULL;
- var.key = "pcsx_rearmed_show_bios_bootlogo";
- if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
- {
- Config.SlowBoot = 0;
- rebootemu = 0;
- if (strcmp(var.value, "enabled") == 0)
- {
- Config.SlowBoot = 1;
- rebootemu = 1;
- }
- }
- }
- }
update_option_visibility();
}
static void update_input_guncon(int port, int ret)
{
//ToDo:
- //Core option for cursors for both players
//Separate pointer and lightgun control types
//Mouse range is -32767 -> 32767
}
+static void update_input_justifier(int port, int ret)
+{
+ //ToDo:
+ //Separate pointer and lightgun control types
+
+ //RetroArch lightgun range is -32767 -> 32767 on both axes (positive Y is down)
+
+ //JUSTIFIER has 3 controls, Trigger,Special,Start which equal Square,Cross,Start
+
+ // Trigger
+ if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_TRIGGER) || input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD))
+ in_keystate[port] |= (1 << DKEY_SQUARE);
+
+ // Special
+ if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_A))
+ in_keystate[port] |= (1 << DKEY_CROSS);
+
+ // Start
+ if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_START))
+ in_keystate[port] |= (1 << DKEY_START);
+
+}
+
static void update_input_negcon(int port, int ret)
{
int lsx;
case PSE_PAD_TYPE_GUNCON:
update_input_guncon(i, ret);
break;
+ case PSE_PAD_TYPE_GUN:
+ update_input_justifier(i, ret);
+ break;
case PSE_PAD_TYPE_NEGCON:
update_input_negcon(i, ret);
break;
LoadCdrom();
}
+ set_vout_fb();
print_internal_fps();
/* Check whether current frame should
}
video_cb((vout_fb_dirty || !vout_can_dupe || !duping_enable) ? vout_buf_ptr : NULL,
- vout_width, vout_height, vout_width * 2);
+ vout_width, vout_height, vout_pitch * 2);
vout_fb_dirty = 0;
-
- set_vout_fb();
}
static bool try_use_bios(const char *path, bool preferred_only)
if (!found_bios)
{
const char *msg_str;
+ unsigned duration;
if (useHLE)
{
- msg_str = "BIOS set to \'hle\' in core options - real BIOS will be ignored";
+ msg_str = "BIOS set to \'hle\'";
SysPrintf("Using HLE BIOS.\n");
+ // shorter as the user probably intentionally wants to use HLE
+ duration = 700;
}
else
{
msg_str = "No PlayStation BIOS file found - add for better compatibility";
SysPrintf("No BIOS files found.\n");
+ duration = 3000;
}
-
- if (msg_interface_version >= 1)
- {
- struct retro_message_ext msg = {
- msg_str,
- 3000,
- 3,
- RETRO_LOG_WARN,
- RETRO_MESSAGE_TARGET_ALL,
- RETRO_MESSAGE_TYPE_NOTIFICATION,
- -1
- };
- environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE_EXT, &msg);
- }
- else
- {
- struct retro_message msg = {
- msg_str,
- 180
- };
- environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &msg);
- }
+ show_notification(msg_str, duration, 2);
}
}
#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && P_HAVE_POSIX_MEMALIGN
if (posix_memalign(&vout_buf, 16, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2) != 0)
vout_buf = (void *) 0;
+ else
+ memset(vout_buf, 0, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
#else
- vout_buf = malloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
+ vout_buf = calloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT, 2);
#endif
vout_buf_ptr = vout_buf;
notaz.gp2x.de / pcsx_rearmed.git / blobdiff