void scene_run(){
while(scene_curr or scene_next){
gfx_vsync_busywait(); // TODO use interupts instead
// change scene if needed
if (scene_curr != scene_next){
scene_change();
continue; // skip frame on change to give drawfunc full vblank time
}
// drawing must be done in vblank phase
if (scene_curr and scene_curr->drawfunc){
scene_curr->drawfunc();
scene_vcount_draw = gfx_reg_vcount;
}
// updateing state can be done in vdraw phase as well
input_poll();
if (scene_curr and scene_curr->tickfunc){
scene_curr->tickfunc();
scene_vcount_tick = gfx_reg_vcount;
}
scene_frame++;
scene_total_frames++;
}
}
static inline void run_tick()
{
input_poll();
// input handling for a few global things
if (justpushed(ESCKEY))
{
if (settings->instant_quit)
{
game.running = false;
}
else if (!game.paused) // no pause from Options
{
game.pause(GP_PAUSED);
}
}
else if (justpushed(F3KEY))
{
game.pause(GP_OPTIONS);
}
// freeze frame
game.tick();
Replay::DrawStatus();
org_run();
//platform_sync_to_vblank();
screen->Flip();
memcpy(lastinputs, inputs, sizeof(lastinputs));
}
void AppMinimized(void)
{
stat("Game minimized or lost focus--pausing...");
#ifdef _SDL_MIXER
Mix_Pause(-1);
Mix_PauseMusic();
#else
SDL_PauseAudio(1);
#endif
for(;;)
{
if ((SDL_GetAppState() & VISFLAGS) == VISFLAGS)
{
break;
}
input_poll();
SDL_Delay(20);
}
#ifdef _SDL_MIXER
Mix_Resume(-1);
Mix_ResumeMusic();
#else
SDL_PauseAudio(0);
#endif
stat("Focus regained, resuming play...");
}
bool core_run(void)
{
switch (core_poll_type)
{
case POLL_TYPE_EARLY:
input_poll();
break;
case POLL_TYPE_LATE:
core_input_polled = false;
break;
}
if (core.retro_run)
core.retro_run();
if (core_poll_type == POLL_TYPE_LATE && !core_input_polled)
input_poll();
return true;
}
// This is a replacement for the old `WaitForChar` function in os_unix.c
static InbufPollResult inbuf_poll(int ms)
{
if (input_ready() || input_poll(ms)) {
return kInputAvail;
}
return input_eof ? kInputEof : kInputNone;
}
static void input_map_key(char* keyName, short* key) {
printf("Press %s\n", keyName);
currentKey = key;
currentAbs = NULL;
*key = -1;
if (!input_poll(input_handle_mapping_event))
exit(1);
usleep(250000);
input_drain();
}
static void input_map_abs(char* keyName, short* abs, bool* reverse) {
printf("Move %s\n", keyName);
currentKey = NULL;
currentAbs = abs;
currentReverse = reverse;
*abs = -1;
if (!input_poll(input_handle_mapping_event))
exit(1);
usleep(250000);
input_drain();
}
static int16_t core_input_state_poll(unsigned port,
unsigned device, unsigned idx, unsigned id)
{
if (current_core.poll_type == POLL_TYPE_LATE)
{
if (!current_core.input_polled)
input_poll();
current_core.input_polled = true;
}
return input_state(port, device, idx, id);
}
static void input_map_abskey(char* keyName, short* key, short* abs, bool* reverse) {
printf("Press %s\n", keyName);
currentKey = key;
currentAbs = abs;
currentReverse = reverse;
*key = -1;
*abs = -1;
*currentReverse = false;
if (!input_poll(input_handle_mapping_event))
exit(1);
usleep(250000);
input_drain();
}
// This is a replacement for the old `WaitForChar` function in os_unix.c
static InbufPollResult inbuf_poll(int32_t ms)
{
if (input_available()) {
return kInputAvail;
}
if (input_poll(ms)) {
return eof && rstream_available(read_stream) == 0 ?
kInputEof :
kInputAvail;
}
return kInputNone;
}
bool core_run(void)
{
#ifdef HAVE_NETWORKING
if (!netplay_driver_ctl(RARCH_NETPLAY_CTL_PRE_FRAME, NULL))
{
/* Paused due to netplay. We must poll and display something so that a
* netplay peer pausing doesn't just hang. */
input_poll();
video_driver_cached_frame();
return true;
}
#endif
switch (current_core.poll_type)
{
case POLL_TYPE_EARLY:
input_poll();
break;
case POLL_TYPE_LATE:
current_core.input_polled = false;
break;
default:
break;
}
current_core.retro_run();
if (current_core.poll_type == POLL_TYPE_LATE && !current_core.input_polled)
input_poll();
#ifdef HAVE_NETWORKING
netplay_driver_ctl(RARCH_NETPLAY_CTL_POST_FRAME, NULL);
#endif
return true;
}
static void execute_elf(void *arg) {
int fd, size, i, j;
void *entry;
//extern void *end;
void *elf_begin = ((void *)(&end)) + 4*1024;
uint8_t *tmp = elf_begin;
printf("Load file to RAM\n");
fd = fat_open(path, O_RDONLY);
size = fat_fsize(fd);
for(j = 512; j < size; j += 512) {
fat_read_sect(fd);
for(i = 0; i < 512; i++) {
*tmp++ = fat_buf[i];
}
}
fat_read_sect(fd);
for(i = 0; i < j - size; i++) {
*tmp++ = fat_buf[i];
}
fat_close(fd);
printf("File loaded\n");
printf("Highest addr used is 0x%X\n", tmp);
//input_poll();
mmu040_init();
terminal_clear();
printf("MMU Init\n");
if(!(entry = elf_load(elf_begin, do_debug))) {
printf("Failed to load ELF\n");
input_poll();
return;
}
printf("ELF load successful, entry is 0x%X, press any key\n", entry);
//input_poll();
//printf("Here we have 0x%X\n", *((uint32_t *) entry));
//input_poll();
mmu_disable();
if(do_debug) {
char *argv[] = {"debug"};
mmu_enable_and_jump(entry, 1, argv);
} else {
mmu_enable_and_jump(entry, 0, NULL);
}
}
void AppMinimized(void)
{
stat("Game minimized or lost focus--pausing...");
SDL_PauseAudio(1);
for(;;)
{
if ((SDL_GetAppState() & VISFLAGS) == VISFLAGS)
{
break;
}
input_poll();
SDL_Delay(20);
}
SDL_PauseAudio(0);
stat("Focus regained, resuming play...");
}
void AppMinimized(void)
{
stat("Game minimized or lost focus--pausing...");
SDL_PauseAudio(1);
for(;;)
{
if (Graphics::WindowVisible())
{
break;
}
input_poll();
SDL_Delay(20);
}
SDL_PauseAudio(0);
stat("Focus regained, resuming play...");
}
int emu_mainloop()
{
u8 *line = (u8*)mem_alloc(512);
int i,p;
u64 t,total,frames;
//initialize the palette in case the rom isnt loaded first
for(i=0;i<512;i++) {
if(i < 32 && running == 0)
video_updatepalette(i,i);
line[i] = i;
}
//begin the main loop
log_printf("emu_mainloop: starting main loop...\n");
total = 0;
frames = 0;
while(quit == 0) {
t = system_gettick();
system_checkevents();
input_poll();
video_startframe();
if(running && nes->cart) {
nes_frame();
}
else {
for(i=0;i<240;i++) {
for(p=0;p<256;p++)
video_updatepixel(i,p,line[p]);
}
}
video_endframe();
total += system_gettick() - t;
frames++;
}
log_printf("fps: %f (%d frames)\n",(double)frames / (double)total * system_getfrequency(),frames);
mem_free(line);
return(0);
}
void input_loop() {
// After grabbing, the only way to quit via the keyboard
// is via the special key combo that the input handling
// code looks for. For this reason, we wait to grab until
// we're ready to take input events. Ctrl+C works up until
// this point.
for (int i = 0; i < numDevices; i++) {
if (ioctl(devices[i].fd, EVIOCGRAB, 1) < 0) {
fprintf(stderr, "EVIOCGRAB failed with error %d\n", errno);
}
}
// Any new input devices detected after this point will be grabbed immediately
grabbingDevices = true;
// Handle input events until the quit combo is pressed
input_poll(input_handle_event);
// Drain any remaining input events so they aren't sent to the terminal
usleep(250000);
input_drain();
}
void speed_test(void)
{
SDL_Rect textrect;
uint32_t end = 0;
fps = 0;
ClearScreen(255, 0, 0);
game.running = true;
while(game.running)
{
if (SDL_GetTicks() >= end)
{
SDLS_VRAMSurface->h = 320;
SDLS_VRAMSurface->cliprect.h = 320;
textrect.x = 5;
textrect.y = 250;
textrect.w = 100;
textrect.h = 10;
SDL_FillRect(SDLS_VRAMSurface, &textrect, 0);
char buffer[80];
sprintf(buffer, "%d fps ", fps);
direct_text_draw(5, 250, buffer);
SDLS_VRAMSurface->h = 240;
SDLS_VRAMSurface->cliprect.h = 240;
input_poll();
fps = 0;
end = SDL_GetTicks() + 1000;
}
screen->Flip();
fps++;
}
}
void org_test_miniloop(void)
{
uint32_t start = 0, curtime;
uint32_t counter;
stat("Starting org test");
font_draw(5, 5, "ORG test in progress...", 0, &greenfont);
font_draw(5, 15, "Logging statistics to nx.log", 0, &greenfont);
font_draw(5, 25, "Press any button to quit", 0, &greenfont);
screen->Flip();
music_set_enabled(1);
music(32);
last_sdl_key = -1;
for(;;)
{
org_run();
if (++counter > 1024)
{
counter = 0;
curtime = SDL_GetTicks();
if ((curtime - start) >= 100)
{
start = curtime;
input_poll();
if (last_sdl_key != -1)
return;
}
}
}
}
int main(void) {
u32 i, j;
busy_wait_vsync();
display_control_init();
while(1) {
busy_wait_vsync();
input_poll();
if(input_hit_status.A) {
REG_DISPLAY_CONTROL.mode = 3;
REG_DISPLAY_CONTROL.render_background2 = TRUE;
for(i = 0 ; i < panty_24bpp_data_height ; i++) {
for(j = 0 ; j < panty_24bpp_data_width ; j++) {
M3_MEM_VIDEO[i * SCREEN_WIDTH + j] =
panty_24bpp_data[i * panty_24bpp_data_width + j];
}
}
}
else if(input_hit_status.B) {
REG_DISPLAY_CONTROL.mode = 4;
REG_DISPLAY_CONTROL.render_background2 = TRUE;
REG_DISPLAY_CONTROL.render_page = 0;
for(i = 0 ; i < panty_8bpp_palette_size ; i++) {
MEM_PALBLOCK_8BPP[PALBLOCK_8BPP_BACKGROUND][i] =
panty_8bpp_palette[i];
}
for(i = 0 ; i < panty_8bpp_data_height ; i++) {
for(j = 0 ; j < panty_8bpp_data_width ; j++) {
m4_vid_page[i * SCREEN_WIDTH / 2 + j] =
panty_8bpp_data[i * panty_8bpp_data_width + j];
}
}
}
else if(input_hit_status.L) {
REG_DISPLAY_CONTROL.mode = 1;
REG_DISPLAY_CONTROL.render_background2 = TRUE;
REG_BACKGROUND2_CONTROL.charblock_index = 0;
REG_BACKGROUND2_CONTROL.screenblock_index = 16;
REG_BACKGROUND2_CONTROL.size = AFFINE_SIZE_32_32;
REG_BACKGROUND2_CONTROL.palette_bpp = PALETTE_8BPP;
REG_BACKGROUND2_OFFSET.Y = 0;
REG_BACKGROUND2_OFFSET.Y = 0;
REG_BACKGROUND2_AFFINE.attr0 = 256;
REG_BACKGROUND2_AFFINE.attr1 = 0;
REG_BACKGROUND2_AFFINE.attr2 = 0;
REG_BACKGROUND2_AFFINE.attr3 = 256;
REG_BACKGROUND2_AFFINE.dx = 0;
REG_BACKGROUND2_AFFINE.dy = 0;
for(i = 0 ; i < panty_8bpp_tiled_palette_size ; i++) {
MEM_PALBLOCK_8BPP[PALBLOCK_8BPP_BACKGROUND][i] =
panty_8bpp_tiled_palette[i];
}
for(i = 0 ; i < panty_8bpp_tiled_tiles_size ; i++) {
MEM_TILE_8BPP[0][i] = panty_8bpp_tiled_tiles[i];
}
u32 *mem_map = (u32 *)(MEM_MAP[16]);
for(i = 0 ; i < panty_8bpp_tiled_tiles_height ; i++) {
for(j = 0 ; j < panty_8bpp_tiled_tiles_width/4+1 ; j++) {
u32 pixel = 0;
u32 base_tile = i * panty_8bpp_tiled_tiles_width + j * 4;
pixel += ((base_tile + 0) & 0xFF) << 0;
pixel += ((base_tile + 1) & 0xFF) << 8;
pixel += ((base_tile + 2) & 0xFF) << 16;
pixel += ((base_tile + 3) & 0xFF) << 24;
mem_map[i * 8 + j] = pixel;
}
}
}
else if(input_hit_status.R) {
REG_DISPLAY_CONTROL.mode = 0;
REG_DISPLAY_CONTROL.render_background2 = TRUE;
REG_BACKGROUND2_CONTROL.charblock_index = 0;
REG_BACKGROUND2_CONTROL.screenblock_index = 16;
REG_BACKGROUND2_CONTROL.size = REGULAR_SIZE_32_32;
REG_BACKGROUND2_CONTROL.palette_bpp = PALETTE_4BPP;
REG_BACKGROUND2_OFFSET.Y = 0;
REG_BACKGROUND2_OFFSET.Y = 0;
REG_BACKGROUND2_AFFINE.attr0 = 256;
REG_BACKGROUND2_AFFINE.attr1 = 0;
REG_BACKGROUND2_AFFINE.attr2 = 0;
REG_BACKGROUND2_AFFINE.attr3 = 256;
REG_BACKGROUND2_AFFINE.dx = 0;
REG_BACKGROUND2_AFFINE.dy = 0;
for(i = 0 ; i < font_palette_size ; i++) {
MEM_PALBLOCK_4BPP[PALBLOCK_4BPP_BACKGROUND][i] =
font_palette[i];
}
for(i = 0 ; i < font_tiles_size ; i++) {
MEM_TILE_4BPP[0][i] = font_tiles[i];
}
u32 *mem_map = (u32 *)(MEM_MAP[16]);
for(i = 0 ; i < 3 ; i++) {
for(j = 0 ; j < 15 ; j++) {
u32 index = i * 30 + 2 * j;
u32 pixel = index + ((index + 1) << 16);
mem_map[i * 16 + j] = pixel;
}
}
mem_map[48] = 0x005B005A;
mem_map[49] = 0x005D005C;
mem_map[50] = 0x0000005E;
}
}
}
bool core_ctl(enum core_ctl_state state, void *data)
{
static bool has_set_input_descriptors = false;
static struct retro_callbacks retro_ctx;
switch (state)
{
case CORE_CTL_RETRO_CHEAT_SET:
{
retro_ctx_cheat_info_t *info = (retro_ctx_cheat_info_t*)data;
core.retro_cheat_set(info->index, info->enabled, info->code);
}
break;
case CORE_CTL_RETRO_CHEAT_RESET:
core.retro_cheat_reset();
break;
case CORE_CTL_RETRO_API_VERSION:
{
retro_ctx_api_info_t *api = (retro_ctx_api_info_t*)data;
api->version = core.retro_api_version();
}
break;
case CORE_CTL_SET_POLL_TYPE:
{
unsigned *poll_type = (unsigned*)data;
core_poll_type = *poll_type;
}
break;
case CORE_CTL_RETRO_SYMBOLS_INIT:
{
enum rarch_core_type *core_type = (enum rarch_core_type*)data;
if (!core_type)
return false;
init_libretro_sym(*core_type, &core);
}
break;
case CORE_CTL_RETRO_SET_CONTROLLER_PORT_DEVICE:
{
retro_ctx_controller_info_t *pad = (retro_ctx_controller_info_t*)data;
if (!pad)
return false;
core.retro_set_controller_port_device(pad->port, pad->device);
}
break;
case CORE_CTL_RETRO_GET_MEMORY:
{
retro_ctx_memory_info_t *info = (retro_ctx_memory_info_t*)data;
if (!info)
return false;
info->size = core.retro_get_memory_size(info->id);
info->data = core.retro_get_memory_data(info->id);
}
break;
case CORE_CTL_RETRO_LOAD_GAME:
{
retro_ctx_load_content_info_t *load_info =
(retro_ctx_load_content_info_t*)data;
if (!load_info)
return false;
if (load_info->special)
return core.retro_load_game_special(load_info->special->id, load_info->info, load_info->content->size);
return core.retro_load_game(*load_info->content->elems[0].data ? load_info->info : NULL);
}
case CORE_CTL_RETRO_GET_SYSTEM_INFO:
{
struct retro_system_info *system = (struct retro_system_info*)data;
if (!system)
return false;
core.retro_get_system_info(system);
}
break;
case CORE_CTL_RETRO_UNSERIALIZE:
{
retro_ctx_serialize_info_t *info = (retro_ctx_serialize_info_t*)data;
if (!info)
return false;
if (!core.retro_unserialize(info->data_const, info->size))
return false;
}
break;
case CORE_CTL_RETRO_SERIALIZE:
{
retro_ctx_serialize_info_t *info = (retro_ctx_serialize_info_t*)data;
if (!info)
return false;
if (!core.retro_serialize(info->data, info->size))
return false;
}
break;
case CORE_CTL_RETRO_SERIALIZE_SIZE:
{
retro_ctx_size_info_t *info = (retro_ctx_size_info_t *)data;
if (!info)
return false;
info->size = core.retro_serialize_size();
}
break;
case CORE_CTL_RETRO_CTX_FRAME_CB:
{
retro_ctx_frame_info_t *info = (retro_ctx_frame_info_t*)data;
if (!info || !retro_ctx.frame_cb)
return false;
retro_ctx.frame_cb(
info->data, info->width, info->height, info->pitch);
}
break;
case CORE_CTL_RETRO_CTX_POLL_CB:
if (!retro_ctx.poll_cb)
return false;
retro_ctx.poll_cb();
break;
case CORE_CTL_RETRO_SET_ENVIRONMENT:
{
retro_ctx_environ_info_t *info = (retro_ctx_environ_info_t*)data;
if (!info)
return false;
core.retro_set_environment(info->env);
}
break;
case CORE_CTL_RETRO_GET_SYSTEM_AV_INFO:
{
struct retro_system_av_info *av_info = (struct retro_system_av_info*)data;
if (!av_info)
return false;
core.retro_get_system_av_info(av_info);
}
break;
case CORE_CTL_RETRO_RESET:
core.retro_reset();
break;
case CORE_CTL_RETRO_INIT:
core.retro_init();
break;
case CORE_CTL_RETRO_DEINIT:
core.retro_deinit();
uninit_libretro_sym(&core);
break;
case CORE_CTL_RETRO_UNLOAD_GAME:
video_driver_ctl(RARCH_DISPLAY_CTL_DEINIT_HW_CONTEXT, NULL);
audio_driver_ctl(RARCH_AUDIO_CTL_STOP, NULL);
core.retro_unload_game();
break;
case CORE_CTL_RETRO_RUN:
switch (core_poll_type)
{
case POLL_TYPE_EARLY:
input_poll();
break;
case POLL_TYPE_LATE:
core_input_polled = false;
break;
}
if (core.retro_run)
core.retro_run();
if (core_poll_type == POLL_TYPE_LATE && !core_input_polled)
input_poll();
break;
case CORE_CTL_SET_CBS:
return retro_set_default_callbacks(data);
case CORE_CTL_SET_CBS_REWIND:
retro_set_rewind_callbacks();
break;
case CORE_CTL_INIT:
{
settings_t *settings = config_get_ptr();
core_poll_type = settings->input.poll_type_behavior;
if (!core_ctl(CORE_CTL_VERIFY_API_VERSION, NULL))
return false;
if (!retro_init_libretro_cbs(&retro_ctx))
return false;
core_ctl(CORE_CTL_RETRO_GET_SYSTEM_AV_INFO,
video_viewport_get_system_av_info());
runloop_ctl(RUNLOOP_CTL_SET_FRAME_LIMIT, NULL);
}
break;
case CORE_CTL_DEINIT:
return retro_uninit_libretro_cbs(&retro_ctx);
case CORE_CTL_VERIFY_API_VERSION:
{
unsigned api_version = core.retro_api_version();
RARCH_LOG("Version of libretro API: %u\n", api_version);
RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION);
if (api_version != RETRO_API_VERSION)
{
RARCH_WARN("%s\n", msg_hash_to_str(MSG_LIBRETRO_ABI_BREAK));
return false;
}
}
break;
case CORE_CTL_HAS_SET_INPUT_DESCRIPTORS:
return has_set_input_descriptors;
case CORE_CTL_SET_INPUT_DESCRIPTORS:
has_set_input_descriptors = true;
break;
case CORE_CTL_UNSET_INPUT_DESCRIPTORS:
has_set_input_descriptors = false;
break;
case CORE_CTL_NONE:
default:
break;
}
return true;
}
void select_file_action(void *arg) {
int selected = *((int *) arg);
int i, j, k, fd, size;
volatile uint8_t *tmp;
switch(selected) {
case 0:
fd = fat_open(path, O_RDONLY);
size = fat_fsize(fd);
for(j = 0; j < size; j += 512) {
terminal_clear();
fat_read_sect(fd);
for(i = 0; i < 512; i++) {
if(fat_buf[i] < 32 || fat_buf[i] > 126)
printf("?");
else
printf("%c", fat_buf[i]);
}
input_poll();
}
fat_close(fd);
break;
case 1:
fd = fat_open(path, O_RDONLY);
size = fat_fsize(fd);
for(j = 0; j < size; j += 512) {
terminal_clear();
printf("\nSector %u\n", j >> 9);
fat_read_sect(fd);
for(i = 0; i < 256; i+=16) {
tmp =((uint8_t *) fat_buf) + i;
printf("%04x\t%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\t\t",
j + i,
tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7],
tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14], tmp[15]
);
for(k = 0; k < 16; k++) {
if(tmp[k] < 32 || tmp[k] > 126)
printf(".");
else
printf("%c", tmp[k]);
}
printf("\n");
}
input_poll();
terminal_clear();
printf("\nSector %u\n", j >> 9);
for(i = 256; i < 512; i+=16) {
tmp =((uint8_t *) fat_buf) + i;
printf("%04x\t%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\t\t",
j + i,
tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7],
tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14], tmp[15]
);
for(k = 0; k < 16; k++) {
if(tmp[k] < 32 || tmp[k] > 126)
printf(".");
else
printf("%c", tmp[k]);
}
printf("\n");
}
input_poll();
}
fat_close(fd);
break;
case 2:
{
void *addr, *entry;
fd = fat_open(path, O_RDONLY);
if(hexload(get_byte, fd, hexload_write_byte, NULL, &entry) < 0) {
printf("Invalid hex file");
fat_close(fd);
input_poll();
break;
}
fat_close(fd);
fd = fat_open(path, O_RDONLY);
if(hexload(get_byte, fd, hexload_verify_byte, NULL, &addr) < 0) {
printf("Hexload validate error at 0x%X\n", addr);
fat_close(fd);
input_poll();
break;
}
__asm__ __volatile__ ("cpusha %dc\n");
goto *addr;
fat_close(fd);
input_poll();
}
break;
case 4:
fd = fat_open(path, O_RDONLY);
size = fat_fsize(fd);
tmp = MEM_VGA_RAM;
for(j = 512; j < size; j += 512) {
fat_read_sect(fd);
for(i = 0; i < 512; i++) {
*tmp++ = fat_buf[i];
}
}
fat_read_sect(fd);
for(i = 0; i < j - size; i++) {
*tmp++ = fat_buf[i];
}
fat_close(fd);
input_poll();
terminal_clear();
break;
case 5:
load_hex_to_rom(path);
input_poll();
break;
case 6:
terminal_clear();
printf("Loading WAV to RAM\n");
fd = fat_open(path, O_RDONLY);
size = fat_fsize(fd);
tmp = (volatile uint8_t *) SDRAM_BASE;
printf("0/%u kB", size >> 10);
for(j = 0; j < size; j += 512) {
fat_read_sect(fd);
for(i = 0; i < 512; i++) {
*tmp++ = fat_buf[i];
}
printf("\r%u/%u kB", j >> 10, size >> 10);
}
fat_close(fd);
printf("\n");
wav_play((uint8_t *) SDRAM_BASE);
printf("Press any key\n");
input_poll();
terminal_clear();
}
}
static void input_poll_maybe(void)
{
if (core_poll_type == POLL_TYPE_NORMAL)
input_poll();
}
// Check for CTRL-C typed by reading all available characters.
// In cooked mode we should get SIGINT, no need to check.
void os_breakcheck(void)
{
if (curr_tmode == TMODE_RAW && input_poll(0))
fill_input_buf(false);
}
int emu_mainloop_test(char *script)
{
u64 t,total,frames;
char line[1024],*rom,*test,*p;
memfile_t *file;
int testrunning = 0;
log_printf("emu_mainloop_test: starting automated tests from '%s'\n",script);
if((file = memfile_open(script,"rb")) == 0) {
log_printf("emu_mainloop_test: error opening test script '%s'\n",script);
return(0);
}
//begin the main loop
total = 0;
frames = 0;
while(quit == 0) {
if(nes->movie.mode & (MOVIE_CRCFAIL | MOVIE_CRCPASS)) {
if(nes->movie.mode & MOVIE_CRCFAIL)
log_printf("emu_mainloop_test: test over. failed. (rom = '%s')\n",rom);
if(nes->movie.mode & MOVIE_CRCPASS)
log_printf("emu_mainloop_test: test over. passed. (rom = '%s')\n",rom);
testrunning = 0;
}
if(testrunning == 0) {
do {
if(memfile_gets(line,1024,file) == 0) {
quit++;
p = 0;
break;
}
p = str_eatwhitespace(line);
log_printf("line: %s",p);
} while(*p == '#');
if(p == 0)
break;
rom = str_eatwhitespace(strtok(p,";\r\n"));
test = str_eatwhitespace(strtok(0,";\r\n"));
log_printf("rom, test = '%s', '%s'\n",rom,test);
if(emu_event(E_LOADROM,(void*)rom) == 0) {
if(emu_event(E_LOADMOVIE,(void*)test) == 0) {
emu_event(E_PLAYMOVIE,0);
testrunning = 1;
}
}
}
t = system_gettick();
system_checkevents();
input_poll();
video_startframe();
if(running && nes->cart) {
nes_frame();
}
video_endframe();
total += system_gettick() - t;
frames++;
}
log_printf("fps: %f (%d frames)\n",(double)frames / (double)total * system_getfrequency(),frames);
memfile_close(file);
return(0);
}
static void core_input_state_poll_maybe(void)
{
if (current_core.poll_type == POLL_TYPE_NORMAL)
input_poll();
}
int main(void) {
object_block_t object_buffer = { { {0, 0} }, };
object_attrblock_pt object_attribute_buffer =
(object_attrblock_pt)object_buffer;
u32 count = 0;
bool_t changed = FALSE;
busy_wait_vsync();
display_control_init();
REG_DISPLAY_CONTROL.render_object = TRUE;
memset(MEM_PALBLOCK,0,sizeof(palblock_t));
MEM_PALBLOCK_4BPP[PALBLOCK_4BPP_OBJECT+0][1] = RGB15_RED;
MEM_PALBLOCK_4BPP[PALBLOCK_4BPP_OBJECT+0][2] = RGB15_GREEN;
MEM_PALBLOCK_4BPP[PALBLOCK_4BPP_OBJECT+1][1] = RGB15_BLUE;
MEM_PALBLOCK_4BPP[PALBLOCK_4BPP_OBJECT+1][2] = RGB15_PURPLE;
memset(MEM_TILE,0,CHARBLOCK_MAX * sizeof(charblock_4bpp_t));
memset(MEM_TILE[CHARBLOCK_OBJECT]+0,0x11,sizeof(tile_t));
memset(MEM_TILE[CHARBLOCK_OBJECT]+3,0x22,sizeof(tile_t));
object_init(object_buffer,OBJECT_MAX);
object_copy(MEM_OBJECT,object_buffer,OBJECT_MAX);
object_attribute_buffer[0].X = 50;
object_attribute_buffer[0].Y = 30;
object_attribute_buffer[0].size = SIZE_16;
object_attribute_buffer[0].palblock_index = 0;
object_attribute_buffer[0].mode = MODE_NORMAL;
object_copy(MEM_OBJECT,object_buffer,1);
while(1) {
busy_wait_vsync();
count = (count + 1) % 1;
if(0 == count) {
changed = FALSE;
input_poll();
if(input_active()) {
object_attribute_setX(object_attribute_buffer,
object_attribute_buffer[0].X +
input_tribool_horizontal());
object_attribute_setY(object_attribute_buffer,
object_attribute_buffer[0].Y +
input_tribool_vertical());
changed = TRUE;
}
if(input_hit_status.A) {
object_attribute_buffer[0].palblock_index ^= 1;
changed = TRUE;
}
if(input_released_status.A) {
object_attribute_buffer[0].palblock_index ^= 1;
changed = TRUE;
}
if(input_hit_status.L) {
object_attribute_buffer[0].horizontal_flip ^= 1;
changed = TRUE;
}
if(input_released_status.L) {
object_attribute_buffer[0].horizontal_flip ^= 1;
changed = TRUE;
}
if(input_hit_status.R) {
object_attribute_buffer[0].vertical_flip ^= 1;
changed = TRUE;
}
if(input_released_status.R) {
object_attribute_buffer[0].vertical_flip ^= 1;
changed = TRUE;
}
if(changed) {
object_copy(MEM_OBJECT,object_buffer,1);
}
}
}
}
static inline void run_tick()
{
static bool can_tick = true;
static bool last_freezekey = false;
static bool last_framekey = false;
static int frameskip = 0;
input_poll();
// input handling for a few global things
if (justpushed(ESCKEY))
{
if (settings->instant_quit)
{
game.running = false;
}
else if (!game.paused) // no pause from Options
{
game.pause(GP_PAUSED);
}
}
else if (justpushed(F3KEY))
{
game.pause(GP_OPTIONS);
}
// freeze frame
if (settings->enable_debug_keys)
{
if (inputs[FREEZE_FRAME_KEY] && !last_freezekey)
{
can_tick = true;
freezeframe ^= 1;
framecount = 0;
}
if (inputs[FRAME_ADVANCE_KEY] && !last_framekey)
{
can_tick = true;
if (!freezeframe)
{
freezeframe = 1;
framecount = 0;
}
}
last_freezekey = inputs[FREEZE_FRAME_KEY];
last_framekey = inputs[FRAME_ADVANCE_KEY];
}
// fast-forward key (F5)
if (inputs[FFWDKEY] && (settings->enable_debug_keys || Replay::IsPlaying()))
{
game.ffwdtime = 2;
}
if (can_tick)
{
game.tick();
if (freezeframe)
{
char buf[1024];
sprintf(buf, "[] Tick %d", framecount++);
font_draw_shaded(4, (SCREEN_HEIGHT-GetFontHeight()-4), buf, 0, &greenfont);
can_tick = false;
}
else
{
Replay::DrawStatus();
}
if (settings->show_fps)
{
update_fps();
}
if (!flipacceltime)
{
//platform_sync_to_vblank();
screen->Flip();
}
else
{
flipacceltime--;
if (--frameskip < 0)
{
screen->Flip();
frameskip = 256;
}
}
memcpy(lastinputs, inputs, sizeof(lastinputs));
}
else
{ // frame is frozen; don't hog CPU
SDL_Delay(20);
}
// immediately after a game tick is when we have the most amount of time before
// the game needs to run again. so now's as good a time as any for some
// BGM audio processing, wouldn't you say?
org_run();
}
int main(void) {
u32 count=0;
// u32 test=0;
color_t clean = RGB15_BLACK;
color_t up = RGB15_RED;
color_t hit = RGB15_BLUE;
color_t released = RGB15_PURPLE;
color_t down = RGB15_GREEN;
input_status_t previous_change = {0,0,0,0,0,0,0,0,0,0};
busy_wait_vsync();
display_control_init();
REG_DISPLAY_CONTROL.mode = 3;
REG_DISPLAY_CONTROL.render_background2 = TRUE;
m3_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],up);
m3_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],up);
m3_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],up);
m3_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],up);
m3_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],up);
m3_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],up);
m3_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],up);
m3_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],up);
m3_circle(A_coord[0],A_coord[1],A_coord[2],up);
m3_circle(B_coord[0],B_coord[1],B_coord[2],up);
while(1) {
count = (count + 1) % 10;
busy_wait_vsync();
if(0 == count) {
input_poll();
if(*((u32 *)&input_changed_status)) {
*((u32 *)&previous_change) = *((u32 *)&input_changed_status);
if(input_hit_status.A) {
m3_circle(A_coord[0],A_coord[1],A_coord[2],hit);
}
else if(input_released_status.A) {
m3_filled_circle(A_coord[0],A_coord[1],A_coord[2],clean);
m3_circle(A_coord[0],A_coord[1],A_coord[2],released);
}
if(input_hit_status.B) {
m3_circle(B_coord[0],B_coord[1],B_coord[2],hit);
}
else if(input_released_status.B) {
m3_filled_circle(B_coord[0],B_coord[1],B_coord[2],clean);
m3_circle(B_coord[0],B_coord[1],B_coord[2],released);
}
if(input_hit_status.L) {
m3_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],hit);
}
else if(input_released_status.L) {
m3_filled_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],clean);
m3_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],released);
}
if(input_hit_status.R) {
m3_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],hit);
}
else if(input_released_status.R) {
m3_filled_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],clean);
m3_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],released);
}
if(input_hit_status.start) {
m3_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],hit);
}
else if(input_released_status.start) {
m3_filled_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],clean);
m3_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],released);
}
if(input_hit_status.select) {
m3_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],hit);
}
else if(input_released_status.select) {
m3_filled_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],clean);
m3_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],released);
}
if(input_hit_status.up) {
m3_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],hit);
}
else if(input_released_status.up) {
m3_filled_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],clean);
m3_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],released);
}
if(input_hit_status.down) {
m3_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],hit);
}
else if(input_released_status.down) {
m3_filled_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],clean);
m3_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],released);
}
if(input_hit_status.left) {
m3_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],hit);
}
else if(input_released_status.left) {
m3_filled_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],clean);
m3_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],released);
}
if(input_hit_status.right) {
m3_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],hit);
}
else if(input_released_status.right) {
m3_filled_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],clean);
m3_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],released);
}
}
else {
if(previous_change.A) {
if(KEY_UP == input_current_status.A) {
m3_circle(A_coord[0],A_coord[1],A_coord[2],up);
}
else {
m3_filled_circle(A_coord[0],A_coord[1],A_coord[2],down);
}
}
if(previous_change.B) {
if(KEY_UP == input_current_status.B) {
m3_circle(B_coord[0],B_coord[1],B_coord[2],up);
}
else {
m3_filled_circle(B_coord[0],B_coord[1],B_coord[2],down);
}
}
if(previous_change.L) {
if(KEY_UP == input_current_status.L) {
m3_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],up);
}
else {
m3_filled_rect(L_coord[0],L_coord[1],L_coord[2],L_coord[3],down);
}
}
if(previous_change.R) {
if(KEY_UP == input_current_status.R) {
m3_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],up);
}
else {
m3_filled_rect(R_coord[0],R_coord[1],R_coord[2],R_coord[3],down);
}
}
if(previous_change.start) {
if(KEY_UP == input_current_status.start) {
m3_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],up);
}
else {
m3_filled_rect(start_coord[0],start_coord[1],start_coord[2],start_coord[3],down);
}
}
if(previous_change.select) {
if(KEY_UP == input_current_status.select) {
m3_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],up);
}
else {
m3_filled_rect(select_coord[0],select_coord[1],select_coord[2],select_coord[3],down);
}
}
if(previous_change.up) {
if(KEY_UP == input_current_status.up) {
m3_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],up);
}
else {
m3_filled_rect(up_coord[0],up_coord[1],up_coord[2],up_coord[3],down);
}
}
if(previous_change.down) {
if(KEY_UP == input_current_status.down) {
m3_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],up);
}
else {
m3_filled_rect(down_coord[0],down_coord[1],down_coord[2],down_coord[3],down);
}
}
if(previous_change.right) {
if(KEY_UP == input_current_status.right) {
m3_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],up);
}
else {
m3_filled_rect(right_coord[0],right_coord[1],right_coord[2],right_coord[3],down);
}
}
if(previous_change.left) {
if(KEY_UP == input_current_status.left) {
m3_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],up);
}
else {
m3_filled_rect(left_coord[0],left_coord[1],left_coord[2],left_coord[3],down);
}
}
*((u32 *)&previous_change) = 0;
}
}
}
}
