src/feature/gui/gui-runner.c (view raw)
1/* Copyright (c) 2013-2016 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "gui-runner.h"
7
8#include "core/core.h"
9#include "core/serialize.h"
10#include "feature/gui/gui-config.h"
11#include "gba/gba.h"
12#include "gba/input.h"
13#include "gba/interface.h"
14#include "util/gui/file-select.h"
15#include "util/gui/font.h"
16#include "util/gui/menu.h"
17#include "util/memory.h"
18#include "util/png-io.h"
19#include "util/vfs.h"
20
21#ifdef _3DS
22#include <3ds.h>
23#endif
24
25#include <sys/time.h>
26
27#define FPS_GRANULARITY 120
28#define FPS_BUFFER_SIZE 3
29
30enum {
31 RUNNER_CONTINUE = 1,
32 RUNNER_EXIT,
33 RUNNER_SAVE_STATE,
34 RUNNER_LOAD_STATE,
35 RUNNER_SCREENSHOT,
36 RUNNER_CONFIG,
37 RUNNER_RESET,
38 RUNNER_COMMAND_MASK = 0xFFFF,
39
40 RUNNER_STATE_1 = 0x10000,
41 RUNNER_STATE_2 = 0x20000,
42 RUNNER_STATE_3 = 0x30000,
43 RUNNER_STATE_4 = 0x40000,
44 RUNNER_STATE_5 = 0x50000,
45 RUNNER_STATE_6 = 0x60000,
46 RUNNER_STATE_7 = 0x70000,
47 RUNNER_STATE_8 = 0x80000,
48 RUNNER_STATE_9 = 0x90000,
49};
50
51static void _log(struct mLogger*, int category, enum mLogLevel level, const char* format, va_list args);
52
53static struct mGUILogger {
54 struct mLogger d;
55 struct VFile* vf;
56 int logLevel;
57} logger = {
58 .d = {
59 .log = _log
60 },
61 .vf = NULL,
62 .logLevel = 0
63};
64
65static void _drawBackground(struct GUIBackground* background, void* context) {
66 UNUSED(context);
67 struct mGUIBackground* gbaBackground = (struct mGUIBackground*) background;
68 if (gbaBackground->p->drawFrame) {
69 gbaBackground->p->drawFrame(gbaBackground->p, true);
70 }
71}
72
73static void _drawState(struct GUIBackground* background, void* id) {
74 struct mGUIBackground* gbaBackground = (struct mGUIBackground*) background;
75 int stateId = ((int) id) >> 16;
76 if (gbaBackground->p->drawScreenshot) {
77 unsigned w, h;
78 gbaBackground->p->core->desiredVideoDimensions(gbaBackground->p->core, &w, &h);
79 if (gbaBackground->screenshot && gbaBackground->screenshotId == (int) id) {
80 gbaBackground->p->drawScreenshot(gbaBackground->p, gbaBackground->screenshot, w, h, true);
81 return;
82 }
83 struct VFile* vf = mCoreGetState(gbaBackground->p->core, stateId, false);
84 uint32_t* pixels = gbaBackground->screenshot;
85 if (!pixels) {
86 pixels = anonymousMemoryMap(w * h * 4);
87 gbaBackground->screenshot = pixels;
88 }
89 bool success = false;
90 if (vf && isPNG(vf) && pixels) {
91 png_structp png = PNGReadOpen(vf, PNG_HEADER_BYTES);
92 png_infop info = png_create_info_struct(png);
93 png_infop end = png_create_info_struct(png);
94 if (png && info && end) {
95 success = PNGReadHeader(png, info);
96 success = success && PNGReadPixels(png, info, pixels, w, h, w);
97 success = success && PNGReadFooter(png, end);
98 }
99 PNGReadClose(png, info, end);
100 }
101 if (vf) {
102 vf->close(vf);
103 }
104 if (success) {
105 gbaBackground->p->drawScreenshot(gbaBackground->p, pixels, w, h, true);
106 gbaBackground->screenshotId = (int) id;
107 } else if (gbaBackground->p->drawFrame) {
108 gbaBackground->p->drawFrame(gbaBackground->p, true);
109 }
110 }
111}
112
113static void _updateLux(struct GBALuminanceSource* lux) {
114 UNUSED(lux);
115}
116
117static uint8_t _readLux(struct GBALuminanceSource* lux) {
118 struct mGUIRunnerLux* runnerLux = (struct mGUIRunnerLux*) lux;
119 int value = 0x16;
120 if (runnerLux->luxLevel > 0) {
121 value += GBA_LUX_LEVELS[runnerLux->luxLevel - 1];
122 }
123 return 0xFF - value;
124}
125
126void mGUIInit(struct mGUIRunner* runner, const char* port) {
127 GUIInit(&runner->params);
128 runner->port = port;
129 runner->core = NULL;
130 runner->luminanceSource.d.readLuminance = _readLux;
131 runner->luminanceSource.d.sample = _updateLux;
132 runner->luminanceSource.luxLevel = 0;
133 runner->background.d.draw = _drawBackground;
134 runner->background.p = runner;
135 runner->fps = 0;
136 runner->lastFpsCheck = 0;
137 runner->totalDelta = 0;
138 CircleBufferInit(&runner->fpsBuffer, FPS_BUFFER_SIZE * sizeof(uint32_t));
139
140 char path[PATH_MAX];
141 mCoreConfigDirectory(path, PATH_MAX);
142 strncat(path, PATH_SEP "log", PATH_MAX - strlen(path));
143 logger.vf = VFileOpen(path, O_CREAT | O_WRONLY | O_APPEND);
144 mLogSetDefaultLogger(&logger.d);
145}
146
147void mGUIDeinit(struct mGUIRunner* runner) {
148 if (runner->teardown) {
149 runner->teardown(runner);
150 }
151 CircleBufferDeinit(&runner->fpsBuffer);
152 if (logger.vf) {
153 logger.vf->close(logger.vf);
154 logger.vf = NULL;
155 }
156}
157
158static void _log(struct mLogger* logger, int category, enum mLogLevel level, const char* format, va_list args) {
159 struct mGUILogger* guiLogger = (struct mGUILogger*) logger;
160 if (!guiLogger->vf) {
161 return;
162 }
163 if (!(guiLogger->logLevel & level)) {
164 return;
165 }
166
167 char log[256] = {0};
168 vsnprintf(log, sizeof(log) - 1, format, args);
169 char log2[256] = {0};
170 size_t len = snprintf(log2, sizeof(log2) - 1, "%s: %s\n", mLogCategoryName(category), log);
171 if (len >= sizeof(log2)) {
172 len = sizeof(log2) - 1;
173 }
174 guiLogger->vf->write(guiLogger->vf, log2, len);
175}
176
177void mGUIRun(struct mGUIRunner* runner, const char* path) {
178 struct mGUIBackground drawState = {
179 .d = {
180 .draw = _drawState
181 },
182 .p = runner,
183 .screenshot = 0,
184 .screenshotId = 0
185 };
186 struct GUIMenu pauseMenu = {
187 .title = "Game Paused",
188 .index = 0,
189 .background = &runner->background.d
190 };
191 struct GUIMenu stateSaveMenu = {
192 .title = "Save state",
193 .index = 0,
194 .background = &drawState.d
195 };
196 struct GUIMenu stateLoadMenu = {
197 .title = "Load state",
198 .index = 0,
199 .background = &drawState.d
200 };
201 GUIMenuItemListInit(&pauseMenu.items, 0);
202 GUIMenuItemListInit(&stateSaveMenu.items, 9);
203 GUIMenuItemListInit(&stateLoadMenu.items, 9);
204 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Unpause", .data = (void*) RUNNER_CONTINUE };
205 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Save state", .submenu = &stateSaveMenu };
206 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Load state", .submenu = &stateLoadMenu };
207
208 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_1) };
209 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_2) };
210 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_3) };
211 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_4) };
212 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_5) };
213 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_6) };
214 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_7) };
215 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_8) };
216 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE_9) };
217
218 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_1) };
219 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_2) };
220 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_3) };
221 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_4) };
222 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_5) };
223 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_6) };
224 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_7) };
225 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_8) };
226 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE_9) };
227
228 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Take screenshot", .data = (void*) RUNNER_SCREENSHOT };
229 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Configure", .data = (void*) RUNNER_CONFIG };
230 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Reset game", .data = (void*) RUNNER_RESET };
231 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Exit game", .data = (void*) RUNNER_EXIT };
232
233 // TODO: Message box API
234 runner->params.drawStart();
235 if (runner->params.guiPrepare) {
236 runner->params.guiPrepare();
237 }
238 GUIFontPrint(runner->params.font, runner->params.width / 2, (GUIFontHeight(runner->params.font) + runner->params.height) / 2, GUI_ALIGN_HCENTER, 0xFFFFFFFF, "Loading...");
239 if (runner->params.guiFinish) {
240 runner->params.guiFinish();
241 }
242 runner->params.drawEnd();
243
244 bool found = false;
245 runner->core = mCoreFind(path);
246 if (runner->core) {
247 runner->core->init(runner->core);
248 mInputMapInit(&runner->core->inputMap, &GBAInputInfo);
249 mCoreInitConfig(runner->core, runner->port);
250 found = mCoreLoadFile(runner->core, path);
251 if (!found) {
252 runner->core->deinit(runner->core);
253 }
254 }
255
256 if (!found) {
257 int i;
258 for (i = 0; i < 240; ++i) {
259 runner->params.drawStart();
260 if (runner->params.guiPrepare) {
261 runner->params.guiPrepare();
262 }
263 GUIFontPrint(runner->params.font, runner->params.width / 2, (GUIFontHeight(runner->params.font) + runner->params.height) / 2, GUI_ALIGN_HCENTER, 0xFFFFFFFF, "Load failed!");
264 if (runner->params.guiFinish) {
265 runner->params.guiFinish();
266 }
267 runner->params.drawEnd();
268 }
269 return;
270 }
271 if (runner->core->platform(runner->core) == PLATFORM_GBA) {
272 ((struct GBA*) runner->core->board)->luminanceSource = &runner->luminanceSource.d;
273 }
274 if (runner->core->config.port && runner->keySources) {
275 size_t i;
276 for (i = 0; runner->keySources[i].id; ++i) {
277 mInputMapLoad(&runner->core->inputMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->core->config));
278 }
279 }
280 // TODO: Do we need to load more defaults?
281 mCoreConfigSetDefaultIntValue(&runner->core->config, "volume", 0x100);
282 mCoreConfigSetDefaultValue(&runner->core->config, "idleOptimization", "detect");
283 mCoreLoadConfig(runner->core);
284 logger.logLevel = runner->core->opts.logLevel;
285
286 mCoreAutoloadSave(runner->core);
287 if (runner->setup) {
288 runner->setup(runner);
289 }
290 runner->core->reset(runner->core);
291 bool running = true;
292 if (runner->gameLoaded) {
293 runner->gameLoaded(runner);
294 }
295 while (running) {
296 CircleBufferClear(&runner->fpsBuffer);
297 runner->totalDelta = 0;
298 runner->fps = 0;
299 struct timeval tv;
300 gettimeofday(&tv, 0);
301 runner->lastFpsCheck = 1000000LL * tv.tv_sec + tv.tv_usec;
302
303 while (true) {
304#ifdef _3DS
305 running = aptMainLoop();
306 if (!running) {
307 break;
308 }
309#endif
310 uint32_t guiKeys;
311 GUIPollInput(&runner->params, &guiKeys, 0);
312 if (guiKeys & (1 << GUI_INPUT_CANCEL)) {
313 break;
314 }
315 if (guiKeys & (1 << mGUI_INPUT_INCREASE_BRIGHTNESS)) {
316 if (runner->luminanceSource.luxLevel < 10) {
317 ++runner->luminanceSource.luxLevel;
318 }
319 }
320 if (guiKeys & (1 << mGUI_INPUT_DECREASE_BRIGHTNESS)) {
321 if (runner->luminanceSource.luxLevel > 0) {
322 --runner->luminanceSource.luxLevel;
323 }
324 }
325 if (guiKeys & (1 << mGUI_INPUT_SCREEN_MODE) && runner->incrementScreenMode) {
326 runner->incrementScreenMode(runner);
327 }
328 uint16_t keys = runner->pollGameInput(runner);
329 if (runner->prepareForFrame) {
330 runner->prepareForFrame(runner);
331 }
332 runner->core->setKeys(runner->core, keys);
333 runner->core->runFrame(runner->core);
334 if (runner->drawFrame) {
335 int drawFps = false;
336 mCoreConfigGetIntValue(&runner->core->config, "fpsCounter", &drawFps);
337
338 runner->params.drawStart();
339 runner->drawFrame(runner, false);
340 if (drawFps) {
341 if (runner->params.guiPrepare) {
342 runner->params.guiPrepare();
343 }
344 GUIFontPrintf(runner->params.font, 0, GUIFontHeight(runner->params.font), GUI_ALIGN_LEFT, 0x7FFFFFFF, "%.2f fps", runner->fps);
345 if (runner->params.guiFinish) {
346 runner->params.guiFinish();
347 }
348 }
349 runner->params.drawEnd();
350
351 if (runner->core->frameCounter(runner->core) % FPS_GRANULARITY == 0) {
352 if (drawFps) {
353 struct timeval tv;
354 gettimeofday(&tv, 0);
355 uint64_t t = 1000000LL * tv.tv_sec + tv.tv_usec;
356 uint64_t delta = t - runner->lastFpsCheck;
357 runner->lastFpsCheck = t;
358 if (delta > 0x7FFFFFFFLL) {
359 CircleBufferClear(&runner->fpsBuffer);
360 runner->fps = 0;
361 }
362 if (CircleBufferSize(&runner->fpsBuffer) == CircleBufferCapacity(&runner->fpsBuffer)) {
363 int32_t last;
364 CircleBufferRead32(&runner->fpsBuffer, &last);
365 runner->totalDelta -= last;
366 }
367 CircleBufferWrite32(&runner->fpsBuffer, delta);
368 runner->totalDelta += delta;
369 runner->fps = (CircleBufferSize(&runner->fpsBuffer) * FPS_GRANULARITY * 1000000.0f) / (runner->totalDelta * sizeof(uint32_t));
370 }
371 }
372 }
373 }
374
375 if (runner->paused) {
376 runner->paused(runner);
377 }
378 GUIInvalidateKeys(&runner->params);
379 uint32_t keys = 0xFFFFFFFF; // Huge hack to avoid an extra variable!
380 struct GUIMenuItem* item;
381 enum GUIMenuExitReason reason = GUIShowMenu(&runner->params, &pauseMenu, &item);
382 if (reason == GUI_MENU_EXIT_ACCEPT) {
383 switch (((int) item->data) & RUNNER_COMMAND_MASK) {
384 case RUNNER_EXIT:
385 running = false;
386 keys = 0;
387 break;
388 case RUNNER_RESET:
389 runner->core->reset(runner->core);
390 break;
391 case RUNNER_SAVE_STATE:
392 mCoreSaveState(runner->core, ((int) item->data) >> 16, SAVESTATE_SCREENSHOT);
393 break;
394 case RUNNER_LOAD_STATE:
395 mCoreLoadState(runner->core, ((int) item->data) >> 16, SAVESTATE_SCREENSHOT);
396 break;
397 case RUNNER_SCREENSHOT:
398 mCoreTakeScreenshot(runner->core);
399 break;
400 case RUNNER_CONFIG:
401 mGUIShowConfig(runner, runner->configExtra, runner->nConfigExtra);
402 mCoreLoadConfig(runner->core);
403 break;
404 case RUNNER_CONTINUE:
405 break;
406 }
407 }
408 int frames = 0;
409 GUIPollInput(&runner->params, 0, &keys);
410 while (keys && frames < 30) {
411 ++frames;
412 runner->params.drawStart();
413 runner->drawFrame(runner, true);
414 runner->params.drawEnd();
415 GUIPollInput(&runner->params, 0, &keys);
416 }
417 if (runner->unpaused) {
418 runner->unpaused(runner);
419 }
420 }
421 if (runner->gameUnloaded) {
422 runner->gameUnloaded(runner);
423 }
424 runner->core->unloadROM(runner->core);
425 drawState.screenshotId = 0;
426 if (drawState.screenshot) {
427 unsigned w, h;
428 runner->core->desiredVideoDimensions(runner->core, &w, &h);
429 mappedMemoryFree(drawState.screenshot, w * h * 4);
430 }
431
432 if (runner->core->config.port) {
433 if (runner->keySources) {
434 size_t i;
435 for (i = 0; runner->keySources[i].id; ++i) {
436 mInputMapSave(&runner->core->inputMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->core->config));
437 }
438 }
439 mCoreConfigSave(&runner->core->config);
440 }
441 runner->core->deinit(runner->core);
442
443 GUIMenuItemListDeinit(&pauseMenu.items);
444 GUIMenuItemListDeinit(&stateSaveMenu.items);
445 GUIMenuItemListDeinit(&stateLoadMenu.items);
446}
447
448void mGUIRunloop(struct mGUIRunner* runner) {
449 while (true) {
450 char path[PATH_MAX];
451 if (!GUISelectFile(&runner->params, path, sizeof(path), 0)) {
452 break;
453 }
454 mGUIRun(runner, path);
455 }
456}