static void _setup(struct GBAGUIRunner* runner) {
struct GBAOptions opts = {
.useBios = true,
.logLevel = 0,
.idleOptimization = IDLE_LOOP_DETECT
};
GBAConfigLoadDefaults(&runner->context.config, &opts);
runner->context.gba->logHandler = GBA3DSLog;
runner->context.gba->rotationSource = &rotation.d;
if (hasSound) {
runner->context.gba->stream = &stream;
}
GBAVideoSoftwareRendererCreate(&renderer);
renderer.outputBuffer = linearAlloc(256 * VIDEO_VERTICAL_PIXELS * 2);
renderer.outputBufferStride = 256;
runner->context.renderer = &renderer.d;
GBAAudioResizeBuffer(&runner->context.gba->audio, AUDIO_SAMPLES);
}
static void _gameLoaded(struct GBAGUIRunner* runner) {
if (runner->context.gba->memory.hw.devices & HW_TILT) {
HIDUSER_EnableAccelerometer();
}
if (runner->context.gba->memory.hw.devices & HW_GYRO) {
HIDUSER_EnableGyroscope();
}
#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
double ratio = GBAAudioCalculateRatio(1, 60, 1);
blip_set_rates(runner->context.gba->audio.left, GBA_ARM7TDMI_FREQUENCY, 0x8000 * ratio);
blip_set_rates(runner->context.gba->audio.right, GBA_ARM7TDMI_FREQUENCY, 0x8000 * ratio);
#endif
if (hasSound) {
memset(audioLeft, 0, AUDIO_SAMPLES * sizeof(int16_t));
memset(audioRight, 0, AUDIO_SAMPLES * sizeof(int16_t));
}
}
static void _gameUnloaded(struct GBAGUIRunner* runner) {
if (hasSound) {
CSND_SetPlayState(8, 0);
CSND_SetPlayState(9, 0);
csndExecCmds(false);
}
if (runner->context.gba->memory.hw.devices & HW_TILT) {
HIDUSER_DisableAccelerometer();
}
if (runner->context.gba->memory.hw.devices & HW_GYRO) {
HIDUSER_DisableGyroscope();
}
}
static void _drawFrame(struct GBAGUIRunner* runner, bool faded) {
GX_SetDisplayTransfer(0, renderer.outputBuffer, GX_BUFFER_DIM(256, VIDEO_VERTICAL_PIXELS), tex->data, GX_BUFFER_DIM(256, VIDEO_VERTICAL_PIXELS), 0x000002202);
GSPGPU_FlushDataCache(0, tex->data, 256 * VIDEO_VERTICAL_PIXELS * 2);
#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
if (!hasSound) {
blip_clear(runner->context.gba->audio.left);
blip_clear(runner->context.gba->audio.right);
}
#endif
gspWaitForPPF();
_drawStart();
sf2d_draw_texture_scale_blend(tex, 40, 296, 1, -1, 0xFFFFFF3F | (faded ? 0 : 0xC0));
_drawEnd();
}
int main(int argc, char** argv) {
struct SDLSoftwareRenderer renderer;
GBAVideoSoftwareRendererCreate(&renderer.d);
struct GBAInputMap inputMap;
GBAInputMapInit(&inputMap);
struct GBAConfig config;
GBAConfigInit(&config, PORT);
GBAConfigLoad(&config);
struct GBAOptions opts = {
.width = VIDEO_HORIZONTAL_PIXELS,
.height = VIDEO_VERTICAL_PIXELS,
.useBios = true,
.rewindEnable = true,
.audioBuffers = 512,
.videoSync = false,
.audioSync = true,
};
GBAConfigLoadDefaults(&config, &opts);
struct GBAArguments args;
struct GraphicsOpts graphicsOpts;
struct SubParser subparser;
initParserForGraphics(&subparser, &graphicsOpts);
bool parsed = parseArguments(&args, &config, argc, argv, &subparser);
if (!parsed || args.showHelp) {
usage(argv[0], subparser.usage);
freeArguments(&args);
GBAConfigFreeOpts(&opts);
GBAConfigDeinit(&config);
return !parsed;
}
GBAConfigMap(&config, &opts);
renderer.viewportWidth = opts.width;
renderer.viewportHeight = opts.height;
#if SDL_VERSION_ATLEAST(2, 0, 0)
renderer.player.fullscreen = opts.fullscreen;
renderer.player.windowUpdated = 0;
#else
renderer.fullscreen = opts.fullscreen;
#endif
renderer.ratio = graphicsOpts.multiplier;
if (renderer.ratio == 0) {
renderer.ratio = 1;
}
renderer.lockAspectRatio = opts.lockAspectRatio;
renderer.filter = opts.resampleVideo;
#ifdef BUILD_GL
GBASDLGLCreate(&renderer);
#elif defined(BUILD_GLES2)
GBASDLGLES2Create(&renderer);
#else
GBASDLSWCreate(&renderer);
#endif
if (!GBASDLInit(&renderer)) {
freeArguments(&args);
GBAConfigFreeOpts(&opts);
GBAConfigDeinit(&config);
return 1;
}
struct GBAThread context = {
.renderer = &renderer.d.d,
.userData = &renderer
};
context.debugger = createDebugger(&args, &context);
GBAMapOptionsToContext(&opts, &context);
GBAMapArgumentsToContext(&args, &context);
bool didFail = false;
renderer.audio.samples = context.audioBuffers;
renderer.audio.sampleRate = 44100;
if (opts.sampleRate) {
renderer.audio.sampleRate = opts.sampleRate;
}
if (!GBASDLInitAudio(&renderer.audio, &context)) {
didFail = true;
}
renderer.player.bindings = &inputMap;
GBASDLInitBindings(&inputMap);
GBASDLInitEvents(&renderer.events);
GBASDLEventsLoadConfig(&renderer.events, GBAConfigGetInput(&config));
GBASDLAttachPlayer(&renderer.events, &renderer.player);
GBASDLPlayerLoadConfig(&renderer.player, GBAConfigGetInput(&config));
context.overrides = GBAConfigGetOverrides(&config);
if (!didFail) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
GBASDLSetScreensaverSuspendable(&renderer.events, opts.suspendScreensaver);
GBASDLSuspendScreensaver(&renderer.events);
#endif
if (GBAThreadStart(&context)) {
renderer.runloop(&context, &renderer);
GBAThreadJoin(&context);
} else {
didFail = true;
printf("Could not run game. Are you sure the file exists and is a Game Boy Advance game?\n");
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
GBASDLResumeScreensaver(&renderer.events);
GBASDLSetScreensaverSuspendable(&renderer.events, false);
#endif
if (GBAThreadHasCrashed(&context)) {
didFail = true;
printf("The game crashed!\n");
}
}
freeArguments(&args);
GBAConfigFreeOpts(&opts);
GBAConfigDeinit(&config);
free(context.debugger);
GBASDLDetachPlayer(&renderer.events, &renderer.player);
GBAInputMapDeinit(&inputMap);
GBASDLDeinit(&renderer);
return didFail;
}
static bool GBASDLInit(struct SDLSoftwareRenderer* renderer) {
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("Could not initialize video: %s\n", SDL_GetError());
return false;
}
return renderer->init(renderer);
}
static void GBASDLDeinit(struct SDLSoftwareRenderer* renderer) {
GBASDLDeinitEvents(&renderer->events);
GBASDLDeinitAudio(&renderer->audio);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_DestroyWindow(renderer->window);
#endif
renderer->deinit(renderer);
SDL_Quit();
}
void retro_init(void) {
enum retro_pixel_format fmt;
#ifdef COLOR_16_BIT
#ifdef COLOR_5_6_5
fmt = RETRO_PIXEL_FORMAT_RGB565;
#else
#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
fmt = RETRO_PIXEL_FORMAT_0RGB1555;
#endif
#else
#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
fmt = RETRO_PIXEL_FORMAT_XRGB8888;
#endif
environCallback(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt);
struct retro_input_descriptor inputDescriptors[] = {
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "A" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "B" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "R" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "L" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3, "Brighten Solar Sensor" },
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3, "Darken Solar Sensor" }
};
environCallback(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, &inputDescriptors);
// TODO: RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME when BIOS booting is supported
struct retro_rumble_interface rumbleInterface;
if (environCallback(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumbleInterface)) {
rumbleCallback = rumbleInterface.set_rumble_state;
CircleBufferInit(&rumbleHistory, RUMBLE_PWM);
rumble.setRumble = _setRumble;
} else {
rumbleCallback = 0;
}
luxLevel = 0;
lux.readLuminance = _readLux;
lux.sample = _updateLux;
_updateLux(&lux);
struct retro_log_callback log;
if (environCallback(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
logCallback = log.log;
} else {
logCallback = 0;
}
stream.postAudioFrame = 0;
stream.postAudioBuffer = _postAudioBuffer;
stream.postVideoFrame = _postVideoFrame;
GBACreate(&gba);
ARMSetComponents(&cpu, &gba.d, 0, 0);
ARMInit(&cpu);
gba.logLevel = 0; // TODO: Settings
gba.logHandler = GBARetroLog;
gba.stream = &stream;
gba.idleOptimization = IDLE_LOOP_REMOVE; // TODO: Settings
if (rumbleCallback) {
gba.rumble = &rumble;
}
gba.luminanceSource = &lux;
rom = 0;
const char* sysDir = 0;
if (environCallback(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &sysDir)) {
char biosPath[PATH_MAX];
snprintf(biosPath, sizeof(biosPath), "%s%s%s", sysDir, PATH_SEP, "gba_bios.bin");
bios = VFileOpen(biosPath, O_RDONLY);
if (bios) {
GBALoadBIOS(&gba, bios);
}
}
GBAVideoSoftwareRendererCreate(&renderer);
renderer.outputBuffer = malloc(256 * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL);
renderer.outputBufferStride = 256;
GBAVideoAssociateRenderer(&gba.video, &renderer.d);
GBAAudioResizeBuffer(&gba.audio, SAMPLES);
#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
blip_set_rates(gba.audio.left, GBA_ARM7TDMI_FREQUENCY, 32768);
blip_set_rates(gba.audio.right, GBA_ARM7TDMI_FREQUENCY, 32768);
#endif
}
