src/gui.c

   1 /*
   2  Copyright 2010, Volca
   3  Licenced under Academic Free License version 3.0
   4  Review OpenUsbLd README & LICENSE files for further details.
   5  */
   6
   7 #include "include/usbld.h"
   8 #include "include/gui.h"
   9 #include "include/renderman.h"
  10 #include "include/menusys.h"
  11 #include "include/fntsys.h"
  12 #include "include/ioman.h"
  13 #include "include/lang.h"
  14 #include "include/themes.h"
  15 #include "include/pad.h"
  16 #include "include/util.h"
  17 #include "include/config.h"
  18 #include "include/system.h"
  19 #include "include/ethsupport.h"
  20
  21 #include <stdlib.h>
  22 #include <libvux.h>
  23
  24 static int gScheduledOps;
  25 static int gCompletedOps;
  26 static int gTerminate;
  27 static int gInitComplete;
  28
  29 static gui_callback_t gFrameHook;
  30
  31 static s32 gSemaId;
  32 static s32 gGUILockSemaId;
  33 static ee_sema_t gQueueSema;
  34
  35 static int screenWidth;
  36 static float wideScreenScale;
  37 static int screenHeight;
  38
  39 // forward decl.
  40 static void guiShow();
  41
  42 #ifdef __DEBUG
  43
  44 #include <timer.h>
  45
  46 #define CLOCKS_PER_MILISEC 147456
  47
  48 // debug version displays an FPS meter
  49 static u32 curtime = 0;
  50 static u32 time_since_last = 0;
  51 static u32 time_render = 0;
  52
  53 #endif
  54
  55 struct gui_update_list_t {
  56         struct gui_update_t* item;
  57         struct gui_update_list_t* next;
  58 };
  59
  60 struct gui_update_list_t *gUpdateList;
  61 struct gui_update_list_t *gUpdateEnd;
  62
  63 typedef struct {
  64         void (*handleInput)(void);
  65         void (*renderScreen)(void);
  66         short inMenu;
  67 } gui_screen_handler_t;
  68
  69 static gui_screen_handler_t screenHandlers[] = {{ &menuHandleInputMain, &menuRenderMain, 0 },
  70                                                                                                 { &menuHandleInputMenu, &menuRenderMenu, 1 },
  71                                                                                                 { &menuHandleInputInfo, &menuRenderInfo, 1 } };
  72
  73 // default screen handler (menu screen)
  74 static gui_screen_handler_t *screenHandler = &screenHandlers[GUI_SCREEN_MENU];
  75
  76 // screen transition handling
  77 static gui_screen_handler_t *screenHandlerTarget = NULL;
  78 static int transIndex, transMax, transitionX, transitionY;
  79
  80 // Helper perlin noise data
  81 #define PLASMA_H 32
  82 #define PLASMA_W 32
  83 #define PLASMA_ROWS_PER_FRAME 6
  84 #define FADE_SIZE 256
  85
  86 static GSTEXTURE gBackgroundTex;
  87 static int pperm[512];
  88 static float fadetbl[FADE_SIZE + 1];
  89
  90 static VU_VECTOR pgrad3[12] = {{ 1, 1, 0, 1 }, { -1, 1, 0, 1 }, { 1, -1, 0, 1 }, { -1, -1, 0, 1 },
  91                                                                 { 1, 0, 1, 1 }, { -1, 0, 1, 1 }, { 1, 0, -1, 1 }, { -1, 0, -1, 1 },
  92                                                                 { 0, 1, 1, 1 }, { 0, -1, 1, 1 }, { 0, 1, -1, 1 }, { 0, -1, -1, 1 } };
  93
  94 void guiReloadScreenExtents() {
  95         rmGetScreenExtents(&screenWidth, &screenHeight);
  96 }
  97
  98 void guiInit(void) {
  99         guiFrameId = 0;
 100         guiInactiveFrames = 0;
 101
 102         gFrameHook = NULL;
 103         gTerminate = 0;
 104         gInitComplete = 0;
 105         gScheduledOps = 0;
 106         gCompletedOps = 0;
 107
 108         gUpdateList = NULL;
 109         gUpdateEnd = NULL;
 110
 111         gQueueSema.init_count = 1;
 112         gQueueSema.max_count = 1;
 113         gQueueSema.option = 0;
 114
 115         gSemaId = CreateSema(&gQueueSema);
 116         gGUILockSemaId = CreateSema(&gQueueSema);
 117
 118         guiReloadScreenExtents();
 119
 120         // background texture - for perlin
 121         gBackgroundTex.Width = PLASMA_W;
 122         gBackgroundTex.Height = PLASMA_H;
 123         gBackgroundTex.Mem = memalign(128, PLASMA_W * PLASMA_H * 4);
 124         gBackgroundTex.PSM = GS_PSM_CT32;
 125         gBackgroundTex.Filter = GS_FILTER_LINEAR;
 126         gBackgroundTex.Vram = 0;
 127         gBackgroundTex.VramClut = 0;
 128         gBackgroundTex.Clut = NULL;
 129
 130         wideScreenScale = 1.0f;
 131
 132         // Precalculate the values for the perlin noise plasma
 133         int i;
 134         for (i = 0; i < 256; ++i) {
 135                 pperm[i] = rand() % 256;
 136                 pperm[i + 256] = pperm[i];
 137         }
 138
 139         for (i = 0; i <= FADE_SIZE; ++i) {
 140                 float t = (float) (i) / FADE_SIZE;
 141
 142                 fadetbl[i] = t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 143         }
 144 }
 145
 146 void guiEnd() {
 147         if (gBackgroundTex.Mem)
 148                 free(gBackgroundTex.Mem);
 149
 150         DeleteSema(gSemaId);
 151         DeleteSema(gGUILockSemaId);
 152 }
 153
 154 void guiLock(void) {
 155         WaitSema(gGUILockSemaId);
 156 }
 157
 158 void guiUnlock(void) {
 159         SignalSema(gGUILockSemaId);
 160 }
 161
 162 void guiStartFrame(void) {
 163 #ifdef __DEBUG
 164         u32 newtime = cpu_ticks() / CLOCKS_PER_MILISEC;
 165         time_since_last = newtime - curtime;
 166         curtime = newtime;
 167 #endif
 168
 169         guiLock();
 170         rmStartFrame();
 171         guiFrameId++;
 172 }
 173
 174 void guiEndFrame(void) {
 175         guiUnlock();
 176         rmFlush();
 177
 178 #ifdef __DEBUG
 179         u32 newtime = cpu_ticks() / CLOCKS_PER_MILISEC;
 180         time_render = newtime - curtime;
 181 #endif
 182
 183         rmEndFrame();
 184 }
 185
 186 void guiShowAbout() {
 187         char OPLVersion[64];
 188         snprintf(OPLVersion, 64, _l(_STR_OUL_VER), USBLD_VERSION);
 189
 190 #ifdef VMC
 191         strcat(OPLVersion, " VMC");
 192 #endif
 193 #ifdef __RTL
 194         strcat(OPLVersion, " RTL");
 195 #endif
 196 #ifdef __CHILDPROOF
 197         strcat(OPLVersion, " CHILDPROOF");
 198 #endif
 199
 200         diaSetLabel(diaAbout, 1, OPLVersion);
 201
 202         diaExecuteDialog(diaAbout, -1, 1, NULL);
 203 }
 204
 205 void guiShowConfig() {
 206         // configure the enumerations
 207         const char* deviceNames[] = { _l(_STR_USB_GAMES), _l(_STR_NET_GAMES), _l(_STR_HDD_GAMES), NULL };
 208         const char* deviceModes[] = { _l(_STR_OFF), _l(_STR_MANUAL), _l(_STR_AUTO), NULL };
 209
 210         diaSetEnum(diaConfig, CFG_DEFDEVICE, deviceNames);
 211         diaSetEnum(diaConfig, CFG_USBMODE, deviceModes);
 212         diaSetEnum(diaConfig, CFG_HDDMODE, deviceModes);
 213         diaSetEnum(diaConfig, CFG_ETHMODE, deviceModes);
 214         diaSetEnum(diaConfig, CFG_APPMODE, deviceModes);
 215
 216         diaSetInt(diaConfig, CFG_DEBUG, gDisableDebug);
 217         diaSetString(diaConfig, CFG_EXITTO, gExitPath);
 218         diaSetInt(diaConfig, CFG_DANDROP, gEnableDandR);
 219         diaSetInt(diaConfig, CFG_HDDSPINDOWN, gHDDSpindown);
 220         diaSetInt(diaConfig, CFG_CHECKUSBFRAG, gCheckUSBFragmentation);
 221         diaSetInt(diaConfig, CFG_USBDELAY, gUSBDelay);
 222         diaSetString(diaConfig, CFG_USBPREFIX, gUSBPrefix);
 223         diaSetString(diaConfig, CFG_ETHPREFIX, gETHPrefix);
 224         diaSetInt(diaConfig, CFG_LASTPLAYED, gRememberLastPlayed);
 225         diaSetInt(diaConfig, CFG_DEFDEVICE, gDefaultDevice);
 226         diaSetInt(diaConfig, CFG_USBMODE, gUSBStartMode);
 227         diaSetInt(diaConfig, CFG_HDDMODE, gHDDStartMode);
 228         diaSetInt(diaConfig, CFG_ETHMODE, gETHStartMode);
 229         diaSetInt(diaConfig, CFG_APPMODE, gAPPStartMode);
 230
 231         int ret = diaExecuteDialog(diaConfig, -1, 1, NULL);
 232         if (ret) {
 233                 diaGetString(diaConfig, CFG_EXITTO, gExitPath);
 234                 diaGetInt(diaConfig, CFG_DEBUG, &gDisableDebug);
 235                 diaGetInt(diaConfig, CFG_DANDROP, &gEnableDandR);
 236                 diaGetInt(diaConfig, CFG_HDDSPINDOWN, &gHDDSpindown);
 237                 diaGetInt(diaConfig, CFG_CHECKUSBFRAG, &gCheckUSBFragmentation);
 238                 diaGetInt(diaConfig, CFG_USBDELAY, &gUSBDelay);
 239                 diaGetString(diaConfig, CFG_USBPREFIX, gUSBPrefix);
 240                 diaGetString(diaConfig, CFG_ETHPREFIX, gETHPrefix);
 241                 diaGetInt(diaConfig, CFG_LASTPLAYED, &gRememberLastPlayed);
 242                 diaGetInt(diaConfig, CFG_DEFDEVICE, &gDefaultDevice);
 243                 diaGetInt(diaConfig, CFG_USBMODE, &gUSBStartMode);
 244                 diaGetInt(diaConfig, CFG_HDDMODE, &gHDDStartMode);
 245                 diaGetInt(diaConfig, CFG_ETHMODE, &gETHStartMode);
 246                 diaGetInt(diaConfig, CFG_APPMODE, &gAPPStartMode);
 247
 248                 applyConfig(-1, -1);
 249         }
 250 }
 251
 252 static int curTheme = -1;
 253
 254 static int guiUIUpdater(int modified) {
 255         if (modified) {
 256                 int temp;
 257                 diaGetInt(diaUIConfig, UICFG_THEME, &temp);
 258                 if (temp != curTheme) {
 259                         curTheme = temp;
 260                         if (temp == 0) {
 261                                 diaUIConfig[32].type = UI_COLOUR; // Must be correctly set before doing the diaS/GetColor !!
 262                                 diaUIConfig[36].type = UI_COLOUR;
 263                                 diaUIConfig[40].type = UI_COLOUR;
 264                                 diaUIConfig[44].type = UI_COLOUR;
 265                                 diaSetColor(diaUIConfig, UICFG_BGCOL, gDefaultBgColor);
 266                                 diaSetColor(diaUIConfig, UICFG_UICOL, gDefaultUITextColor);
 267                                 diaSetColor(diaUIConfig, UICFG_TXTCOL, gDefaultTextColor);
 268                                 diaSetColor(diaUIConfig, UICFG_SELCOL, gDefaultSelTextColor);
 269                         } else if (temp == thmGetGuiValue()) {
 270                                 diaUIConfig[32].type = UI_COLOUR;
 271                                 diaUIConfig[36].type = UI_COLOUR;
 272                                 diaUIConfig[40].type = UI_COLOUR;
 273                                 diaUIConfig[44].type = UI_COLOUR;
 274                                 diaSetColor(diaUIConfig, UICFG_BGCOL, gTheme->bgColor);
 275                                 diaSetU64Color(diaUIConfig, UICFG_UICOL, gTheme->uiTextColor);
 276                                 diaSetU64Color(diaUIConfig, UICFG_TXTCOL, gTheme->textColor);
 277                                 diaSetU64Color(diaUIConfig, UICFG_SELCOL, gTheme->selTextColor);
 278                         } else {
 279                                 diaUIConfig[32].type = UI_SPACER;
 280                                 diaUIConfig[36].type = UI_SPACER;
 281                                 diaUIConfig[40].type = UI_SPACER;
 282                                 diaUIConfig[44].type = UI_SPACER;
 283                         }
 284
 285                         temp = !temp;
 286                         diaSetEnabled(diaUIConfig, UICFG_BGCOL, temp);
 287                         diaSetEnabled(diaUIConfig, UICFG_UICOL, temp);
 288                         diaSetEnabled(diaUIConfig, UICFG_TXTCOL, temp);
 289                         diaSetEnabled(diaUIConfig, UICFG_SELCOL, temp);
 290                 }
 291         }
 292
 293         return 0;
 294 }
 295
 296 void guiShowUIConfig() {
 297         curTheme = -1;
 298
 299         // configure the enumerations
 300         const char* scrollSpeeds[] = { _l(_STR_SLOW), _l(_STR_MEDIUM),  _l(_STR_FAST), NULL };
 301         const char* vmodeNames[] = { "AUTO", "PAL", "NTSC", NULL };
 302         diaSetEnum(diaUIConfig, UICFG_SCROLL, scrollSpeeds);
 303         diaSetEnum(diaUIConfig, UICFG_THEME, (const char **) thmGetGuiList());
 304         diaSetEnum(diaUIConfig, UICFG_LANG, (const char **) lngGetGuiList());
 305         diaSetEnum(diaUIConfig, UICFG_VMODE, vmodeNames);
 306
 307         diaSetInt(diaUIConfig, UICFG_SCROLL, gScrollSpeed);
 308         diaSetInt(diaUIConfig, UICFG_THEME, thmGetGuiValue());
 309         diaSetInt(diaUIConfig, UICFG_LANG, lngGetGuiValue());
 310         guiUIUpdater(1);
 311         diaSetInt(diaUIConfig, UICFG_AUTOSORT, gAutosort);
 312         diaSetInt(diaUIConfig, UICFG_AUTOREFRESH, gAutoRefresh);
 313         diaSetInt(diaUIConfig, UICFG_INFOPAGE, gUseInfoScreen);
 314         diaSetInt(diaUIConfig, UICFG_COVERART, gEnableArt);
 315         diaSetInt(diaUIConfig, UICFG_WIDESCREEN, gWideScreen);
 316         diaSetInt(diaUIConfig, UICFG_VMODE, gVMode);
 317         diaSetInt(diaUIConfig, UICFG_VSYNC, gVSync);
 318
 319         int ret = diaExecuteDialog(diaUIConfig, -1, 1, guiUIUpdater);
 320         if (ret) {
 321                 int themeID = -1, langID = -1;
 322                 diaGetInt(diaUIConfig, UICFG_SCROLL, &gScrollSpeed);
 323                 diaGetInt(diaUIConfig, UICFG_LANG, &langID);
 324                 diaGetInt(diaUIConfig, UICFG_THEME, &themeID);
 325                 if (themeID == 0) {
 326                         diaGetColor(diaUIConfig, UICFG_BGCOL, gDefaultBgColor);
 327                         diaGetColor(diaUIConfig, UICFG_UICOL, gDefaultUITextColor);
 328                         diaGetColor(diaUIConfig, UICFG_TXTCOL, gDefaultTextColor);
 329                         diaGetColor(diaUIConfig, UICFG_SELCOL, gDefaultSelTextColor);
 330                 }
 331                 diaGetInt(diaUIConfig, UICFG_AUTOSORT, &gAutosort);
 332                 diaGetInt(diaUIConfig, UICFG_AUTOREFRESH, &gAutoRefresh);
 333                 diaGetInt(diaUIConfig, UICFG_INFOPAGE, &gUseInfoScreen);
 334                 diaGetInt(diaUIConfig, UICFG_COVERART, &gEnableArt);
 335                 diaGetInt(diaUIConfig, UICFG_WIDESCREEN, &gWideScreen);
 336                 diaGetInt(diaUIConfig, UICFG_VMODE, &gVMode);
 337                 diaGetInt(diaUIConfig, UICFG_VSYNC, &gVSync);
 338
 339                 applyConfig(themeID, langID);
 340         }
 341 }
 342
 343 void guiShowIPConfig() {
 344         size_t i;
 345         // upload current values
 346         for (i = 0; i < 4; ++i) {
 347                 if (gNetworkStartup != ERROR_ETH_NOT_STARTED) {
 348                         diaSetEnabled(diaIPConfig, 2 + i, 0);
 349                         diaSetEnabled(diaIPConfig, 6 + i, 0);
 350                         diaSetEnabled(diaIPConfig, 10 + i, 0);
 351                 } else {
 352                         diaSetEnabled(diaIPConfig, 2 + i, 1);
 353                         diaSetEnabled(diaIPConfig, 6 + i, 1);
 354                         diaSetEnabled(diaIPConfig, 10 + i, 1);
 355                 }
 356                 diaSetInt(diaIPConfig, 2 + i, ps2_ip[i]);
 357                 diaSetInt(diaIPConfig, 6 + i, ps2_netmask[i]);
 358                 diaSetInt(diaIPConfig, 10 + i, ps2_gateway[i]);
 359                 diaSetInt(diaIPConfig, 14 + i, pc_ip[i]);
 360         }
 361
 362         diaSetInt(diaIPConfig, 18, gPCPort);
 363         diaSetString(diaIPConfig, 19, gPCShareName);
 364         diaSetString(diaIPConfig, 20, gPCUserName);
 365         diaSetString(diaIPConfig, 21, gPCPassword);
 366
 367         if (gNetworkStartup == 0) {
 368                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_OK));
 369                 diaIPConfig[64].type = UI_SPACER;
 370         } else if (gNetworkStartup >= ERROR_ETH_SMB_LOGON) {
 371                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_RECONNECT));
 372                 diaIPConfig[64].type = UI_TERMINATOR;
 373         } else {
 374                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_OK));
 375                 diaIPConfig[64].type = UI_TERMINATOR;
 376         }
 377
 378
 379         int result = diaExecuteDialog(diaIPConfig, -1, 1, NULL);
 380         if (result) {
 381                 // Store values
 382                 for (i = 0; i < 4; ++i) {
 383                         diaGetInt(diaIPConfig, 2 + i, &ps2_ip[i]);
 384                         diaGetInt(diaIPConfig, 6 + i, &ps2_netmask[i]);
 385                         diaGetInt(diaIPConfig, 10 + i, &ps2_gateway[i]);
 386                         diaGetInt(diaIPConfig, 14 + i, &pc_ip[i]);
 387                 }
 388
 389                 diaGetInt(diaIPConfig, 18, &gPCPort);
 390                 diaGetString(diaIPConfig, 19, gPCShareName);
 391                 diaGetString(diaIPConfig, 20, gPCUserName);
 392                 diaGetString(diaIPConfig, 21, gPCPassword);
 393                 gIPConfigChanged = 1;
 394
 395                 if (result == NETCFG_RECONNECT)
 396                         gNetworkStartup = ERROR_ETH_SMB_LOGON;
 397
 398                 applyConfig(-1, -1);
 399         }
 400 }
 401
 402 int guiShowKeyboard(char* value, int maxLength) {
 403         char tmp[maxLength];
 404         strncpy(tmp, value, maxLength);
 405
 406         int result = diaShowKeyb(tmp, maxLength);
 407         if (result) {
 408                 strncpy(value, tmp, maxLength);
 409                 value[maxLength - 1] = '\0';
 410         }
 411
 412         return result;
 413 }
 414
 415 #ifdef VMC
 416 typedef struct { // size = 76
 417         int VMC_status; // 0=available, 1=busy
 418         int VMC_error;
 419         int VMC_progress;
 420         char VMC_msg[64];
 421 }statusVMCparam_t;
 422
 423 #define OPERATION_CREATE        0
 424 #define OPERATION_CREATING      1
 425 #define OPERATION_ABORTING      2
 426 #define OPERATION_ENDING        3
 427 #define OPERATION_END           4
 428
 429 static short vmc_refresh;
 430 static int vmc_operation;
 431 static statusVMCparam_t vmc_status;
 432
 433 int guiVmcNameHandler(char* text, int maxLen) {
 434         int result = diaShowKeyb(text, maxLen);
 435
 436         if (result)
 437         vmc_refresh = 1;
 438
 439         return result;
 440 }
 441
 442 static int guiRefreshVMCConfig(item_list_t *support, char* name) {
 443         int size = support->itemCheckVMC(name, 0);
 444
 445         if (size != -1) {
 446                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_MODIFY));
 447                 diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_EXISTS));
 448
 449                 if (size == 8)
 450                         diaSetInt(diaVMC, VMC_SIZE, 0);
 451                 else if (size == 16)
 452                         diaSetInt(diaVMC, VMC_SIZE, 1);
 453                 else if (size == 32)
 454                         diaSetInt(diaVMC, VMC_SIZE, 2);
 455                 else if (size == 64)
 456                         diaSetInt(diaVMC, VMC_SIZE, 3);
 457                 else {
 458                         diaSetInt(diaVMC, VMC_SIZE, 0);
 459                         diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_ERROR));
 460                 }
 461
 462                 if (gEnableDandR) {
 463                         diaSetEnabled(diaVMC, VMC_SIZE, 1);
 464                         diaVMC[20].type = UI_SPLITTER;
 465                 }
 466                 else {
 467                         diaSetEnabled(diaVMC, VMC_SIZE, 0);
 468                         diaVMC[20].type = UI_TERMINATOR;
 469                 }
 470         }
 471         else {
 472                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_CREATE));
 473                 diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_NEW));
 474
 475                 diaSetInt(diaVMC, VMC_SIZE, 0);
 476                 diaSetEnabled(diaVMC, VMC_SIZE, 1);
 477                 diaVMC[20].type = UI_TERMINATOR;
 478         }
 479
 480         return size;
 481 }
 482
 483 static int guiVMCUpdater(int modified) {
 484         if (vmc_refresh) {
 485                 vmc_refresh = 0;
 486                 return VMC_REFRESH;
 487         }
 488
 489         if ((vmc_operation == OPERATION_CREATING) || (vmc_operation == OPERATION_ABORTING)) {
 490                 int result = fileXioDevctl("genvmc:", 0xC0DE0003, NULL, 0, (void*) &vmc_status, sizeof(vmc_status));
 491                 if (result == 0) {
 492                         diaSetLabel(diaVMC, VMC_STATUS, vmc_status.VMC_msg);
 493                         diaSetInt(diaVMC, VMC_PROGRESS, vmc_status.VMC_progress);
 494
 495                         if (vmc_status.VMC_error != 0)
 496                                 LOG("genvmc updater: %d\n", vmc_status.VMC_error);
 497
 498                         if (vmc_status.VMC_status == 0x00) {
 499                                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_OK));
 500                                 vmc_operation = OPERATION_ENDING;
 501                                 return VMC_BUTTON_CREATE;
 502                         }
 503                 }
 504                 else
 505                         LOG("status result: %d\n", result);
 506         }
 507
 508         return 0;
 509 }
 510
 511 static int guiShowVMCConfig(int id, item_list_t *support, char *VMCName, int slot, int validate) {
 512         int result = validate ? VMC_BUTTON_CREATE : 0;
 513         char vmc[32];
 514
 515         if (strlen(VMCName))
 516                 strncpy(vmc, VMCName, 32);
 517         else {
 518                 if (validate)
 519                         return 1; // nothing to validate if no user input
 520
 521                 char* startup = support->itemGetStartup(id);
 522                 snprintf(vmc, 32, "%s_%d", startup, slot);
 523         }
 524
 525         vmc_refresh = 0;
 526         vmc_operation = OPERATION_CREATE;
 527         diaSetEnabled(diaVMC, VMC_NAME, 1);
 528         diaSetEnabled(diaVMC, VMC_SIZE, 1);
 529         diaSetInt(diaVMC, VMC_PROGRESS, 0);
 530
 531         const char* VMCSizes[] = {"8 Mb", "16 Mb", "32 Mb", "64 Mb", NULL};
 532         diaSetEnum(diaVMC, VMC_SIZE, VMCSizes);
 533         int size = guiRefreshVMCConfig(support, vmc);
 534         diaSetString(diaVMC, VMC_NAME, vmc);
 535
 536         do {
 537                 if (result == VMC_BUTTON_CREATE) {
 538                         if (vmc_operation == OPERATION_CREATE) { // User start creation of VMC
 539                                 int sizeUI;
 540                                 diaGetInt(diaVMC, VMC_SIZE, &sizeUI);
 541                                 if (sizeUI == 1)
 542                                 sizeUI = 16;
 543                                 else if (sizeUI == 2)
 544                                 sizeUI = 32;
 545                                 else if (sizeUI == 3)
 546                                 sizeUI = 64;
 547                                 else
 548                                 sizeUI = 8;
 549
 550                                 if (sizeUI != size) {
 551                                         support->itemCheckVMC(vmc, sizeUI);
 552
 553                                         diaSetEnabled(diaVMC, VMC_NAME, 0);
 554                                         diaSetEnabled(diaVMC, VMC_SIZE, 0);
 555                                         diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_ABORT));
 556                                         vmc_operation = OPERATION_CREATING;
 557                                 }
 558                                 else
 559                                         break;
 560                         }
 561                         else if (vmc_operation == OPERATION_ENDING) {
 562                                 if (validate)
 563                                         break; // directly close VMC config dialog
 564
 565                                 vmc_operation = OPERATION_END;
 566                         }
 567                         else if (vmc_operation == OPERATION_END) { // User closed creation dialog of VMC
 568                                 break;
 569                         }
 570                         else if (vmc_operation == OPERATION_CREATING) { // User canceled creation of VMC
 571                                 fileXioDevctl("genvmc:", 0xC0DE0002, NULL, 0, NULL, 0);
 572                                 vmc_operation = OPERATION_ABORTING;
 573                         }
 574                 }
 575                 else if (result == VMC_BUTTON_DELETE) {
 576                         if (guiMsgBox(_l(_STR_DELETE_WARNING), 1, diaVMC)) {
 577                                 support->itemCheckVMC(vmc, -1);
 578                                 diaSetString(diaVMC, VMC_NAME, "");
 579                                 break;
 580                         }
 581                 }
 582                 else if (result == VMC_REFRESH) { // User changed the VMC name
 583                         diaGetString(diaVMC, VMC_NAME, vmc);
 584                         size = guiRefreshVMCConfig(support, vmc);
 585                 }
 586
 587                 result = diaExecuteDialog(diaVMC, result, 1, &guiVMCUpdater);
 588
 589                 if ((result == 0) && (vmc_operation == OPERATION_CREATE))
 590                         break;
 591         } while (1);
 592
 593         return result;
 594 }
 595
 596 #endif
 597
 598 int guiAltStartupNameHandler(char* text, int maxLen) {
 599         int i;
 600
 601         int result = diaShowKeyb(text, maxLen);
 602         if (result) {
 603                 for (i = 0; text[i]; i++) {
 604                         if (text[i] > 96 && text[i] < 123)
 605                                 text[i] -= 32;
 606                 }
 607         }
 608
 609         return result;
 610 }
 611
 612 int guiShowCompatConfig(int id, item_list_t *support, config_set_t* configSet) {
 613         int dmaMode = 7; // defaulting to UDMA 4
 614         if (support->haveCompatibilityMode == COMPAT_FULL) {
 615                 configGetInt(configSet, CONFIG_ITEM_DMA, &dmaMode);
 616                 const char* dmaModes[] = { "MDMA 0", "MDMA 1", "MDMA 2", "UDMA 0",      "UDMA 1", "UDMA 2", "UDMA 3", "UDMA 4", "UDMA 5", "UDMA 6",     NULL };
 617                 diaSetEnum(diaCompatConfig, COMPAT_MODE_BASE + COMPAT_MODE_COUNT, dmaModes);
 618                 diaSetInt(diaCompatConfig, COMPAT_MODE_BASE + COMPAT_MODE_COUNT, dmaMode);
 619         } else {
 620                 const char* dmaModes[] = { NULL };
 621                 diaSetEnum(diaCompatConfig, COMPAT_MODE_BASE + COMPAT_MODE_COUNT, dmaModes);
 622                 diaSetInt(diaCompatConfig, COMPAT_MODE_BASE + COMPAT_MODE_COUNT, 0);
 623         }
 624
 625         diaSetLabel(diaCompatConfig, COMPAT_GAME, support->itemGetName(id));
 626
 627         int compatMode = 0;
 628         configGetInt(configSet, CONFIG_ITEM_COMPAT, &compatMode);
 629         int i, result = -1;
 630         for (i = 0; i < COMPAT_MODE_COUNT; ++i)
 631                 diaSetInt(diaCompatConfig, COMPAT_MODE_BASE + i, (compatMode & (1 << i)) > 0 ? 1 : 0);
 632
 633         // Find out the current game ID
 634         char hexid[32];
 635         configGetStrCopy(configSet, CONFIG_ITEM_DNAS, hexid);
 636         diaSetString(diaCompatConfig, COMPAT_GAMEID, hexid);
 637
 638         char altStartup[32];
 639         configGetStrCopy(configSet, CONFIG_ITEM_ALTSTARTUP, altStartup);
 640         diaSetString(diaCompatConfig, COMPAT_ALTSTARTUP, altStartup);
 641
 642 #ifdef VMC
 643         char vmc1[32];
 644         configGetVMC(configSet, vmc1, 0);
 645         diaSetLabel(diaCompatConfig, COMPAT_VMC1_DEFINE, vmc1);
 646
 647         char vmc2[32]; // required as diaSetLabel use pointer to value
 648         configGetVMC(configSet, vmc2, 1);
 649         diaSetLabel(diaCompatConfig, COMPAT_VMC2_DEFINE, vmc2);
 650 #endif
 651
 652         // show dialog
 653         do {
 654 #ifdef VMC
 655                 if (strlen(vmc1))
 656                         diaSetLabel(diaCompatConfig, COMPAT_VMC1_ACTION, _l(_STR_RESET));
 657                 else
 658                         diaSetLabel(diaCompatConfig, COMPAT_VMC1_ACTION, _l(_STR_USE_GENERIC));
 659                 if (strlen(vmc2))
 660                         diaSetLabel(diaCompatConfig, COMPAT_VMC2_ACTION, _l(_STR_RESET));
 661                 else
 662                         diaSetLabel(diaCompatConfig, COMPAT_VMC2_ACTION, _l(_STR_USE_GENERIC));
 663 #endif
 664
 665                 result = diaExecuteDialog(diaCompatConfig, result, 1, NULL);
 666
 667                 if (result == COMPAT_LOADFROMDISC) {
 668                         char hexDiscID[15];
 669                         if (sysGetDiscID(hexDiscID) >= 0)
 670                                 diaSetString(diaCompatConfig, COMPAT_GAMEID, hexDiscID);
 671                         else
 672                                 guiMsgBox(_l(_STR_ERROR_LOADING_ID), 0, NULL);
 673                 }
 674 #ifdef VMC
 675                 else if (result == COMPAT_VMC1_DEFINE) {
 676                         if(guiShowVMCConfig(id, support, vmc1, 0, 0))
 677                                 diaGetString(diaVMC, VMC_NAME, vmc1);
 678                 } else if (result == COMPAT_VMC2_DEFINE) {
 679                         if(guiShowVMCConfig(id, support, vmc2, 1, 0))
 680                                 diaGetString(diaVMC, VMC_NAME, vmc2);
 681                 } else if (result == COMPAT_VMC1_ACTION) {
 682                         if (strlen(vmc1))
 683                                 vmc1[0] = '\0';
 684                         else
 685                                 snprintf(vmc1, 32, "generic_%d", 0);
 686                 } else if (result == COMPAT_VMC2_ACTION) {
 687                         if (strlen(vmc2))
 688                                 vmc2[0] = '\0';
 689                         else
 690                                 snprintf(vmc2, 32, "generic_%d", 1);
 691                 }
 692 #endif
 693         } while (result >= COMPAT_NOEXIT);
 694
 695         if (result == COMPAT_REMOVE) {
 696                 configRemoveKey(configSet, CONFIG_ITEM_DMA);
 697                 configRemoveKey(configSet, CONFIG_ITEM_COMPAT);
 698                 configRemoveKey(configSet, CONFIG_ITEM_DNAS);
 699                 configRemoveKey(configSet, CONFIG_ITEM_ALTSTARTUP);
 700 #ifdef VMC
 701                 configRemoveVMC(configSet, 0);
 702                 configRemoveVMC(configSet, 1);
 703 #endif
 704                 menuSaveConfig();
 705         } else if (result > 0) { // test button pressed or save button
 706                 compatMode = 0;
 707                 for (i = 0; i < COMPAT_MODE_COUNT; ++i) {
 708                         int mdpart;
 709                         diaGetInt(diaCompatConfig, COMPAT_MODE_BASE + i, &mdpart);
 710                         compatMode |= (mdpart ? 1 : 0) << i;
 711                 }
 712
 713                 if (support->haveCompatibilityMode == COMPAT_FULL) {
 714                         diaGetInt(diaCompatConfig, COMPAT_MODE_BASE + COMPAT_MODE_COUNT, &dmaMode);
 715                         if (dmaMode != 7)
 716                                 configSetInt(configSet, CONFIG_ITEM_DMA, dmaMode);
 717                         else
 718                                 configRemoveKey(configSet, CONFIG_ITEM_DMA);
 719                 }
 720
 721                 if (compatMode != 0)
 722                         configSetInt(configSet, CONFIG_ITEM_COMPAT, compatMode);
 723                 else
 724                         configRemoveKey(configSet, CONFIG_ITEM_COMPAT);
 725
 726                 diaGetString(diaCompatConfig, COMPAT_GAMEID, hexid);
 727                 if (hexid[0] != '\0')
 728                         configSetStr(configSet, CONFIG_ITEM_DNAS, hexid);
 729
 730                 diaGetString(diaCompatConfig, COMPAT_ALTSTARTUP, altStartup);
 731                 if (altStartup[0] != '\0')
 732                         configSetStr(configSet, CONFIG_ITEM_ALTSTARTUP, altStartup);
 733                 else
 734                         configRemoveKey(configSet, CONFIG_ITEM_ALTSTARTUP);
 735
 736 #ifdef VMC
 737                 configSetVMC(configSet, vmc1, 0);
 738                 configSetVMC(configSet, vmc2, 1);
 739                 guiShowVMCConfig(id, support, vmc1, 0, 1);
 740                 guiShowVMCConfig(id, support, vmc2, 1, 1);
 741 #endif
 742
 743                 if (result == COMPAT_SAVE)
 744                         menuSaveConfig();
 745         }
 746
 747         return result;
 748 }
 749
 750 int guiGetOpCompleted(int opid) {
 751         return gCompletedOps > opid;
 752 }
 753
 754 int guiDeferUpdate(struct gui_update_t *op) {
 755         WaitSema(gSemaId);
 756
 757         struct gui_update_list_t* up = (struct gui_update_list_t*) malloc(sizeof(struct gui_update_list_t));
 758         up->item = op;
 759         up->next = NULL;
 760
 761         if (!gUpdateList) {
 762                 gUpdateList = up;
 763                 gUpdateEnd = gUpdateList;
 764         } else {
 765                 gUpdateEnd->next = up;
 766                 gUpdateEnd = up;
 767         }
 768
 769         SignalSema(gSemaId);
 770
 771         return gScheduledOps++;
 772 }
 773
 774 static void guiHandleOp(struct gui_update_t* item) {
 775         submenu_list_t* result = NULL;
 776
 777         switch (item->type) {
 778                 case GUI_INIT_DONE:
 779                         gInitComplete = 1;
 780                         break;
 781
 782                 case GUI_OP_ADD_MENU:
 783                         menuAppendItem(item->menu.menu);
 784                         break;
 785
 786                 case GUI_OP_APPEND_MENU:
 787                         result = submenuAppendItem(item->menu.subMenu, item->submenu.icon_id,
 788                                         item->submenu.text, item->submenu.id, item->submenu.text_id);
 789
 790                         if (!item->menu.menu->submenu) { // first subitem in list
 791                                 item->menu.menu->submenu = result;
 792                                 item->menu.menu->current = result;
 793                                 item->menu.menu->pagestart = result;
 794                         } else if (item->submenu.selected) { // remember last game feat.
 795                                 item->menu.menu->current = result;
 796                                 item->menu.menu->pagestart = result;
 797                                 item->menu.menu->remindLast = 1;
 798                         }
 799
 800                         break;
 801
 802                 case GUI_OP_SELECT_MENU:
 803                         menuSetSelectedItem(item->menu.menu);
 804                         screenHandler = &screenHandlers[GUI_SCREEN_MAIN];
 805                         break;
 806
 807                 case GUI_OP_CLEAR_SUBMENU:
 808                         submenuDestroy(item->menu.subMenu);
 809                         item->menu.menu->submenu = NULL;
 810                         item->menu.menu->current = NULL;
 811                         item->menu.menu->pagestart = NULL;
 812                         break;
 813
 814                 case GUI_OP_SORT:
 815                         submenuSort(item->menu.subMenu);
 816                         item->menu.menu->submenu = *item->menu.subMenu;
 817
 818                         if (!item->menu.menu->remindLast)
 819                                 item->menu.menu->current = item->menu.menu->submenu;
 820
 821                         item->menu.menu->pagestart = item->menu.menu->current;
 822                         break;
 823
 824                 case GUI_OP_ADD_HINT:
 825                         // append the hint list in the menu item
 826                         menuAddHint(item->menu.menu, item->hint.text_id, item->hint.icon_id);
 827                         break;
 828
 829                 default:
 830                         LOG("GUI: ??? (%d)\n", item->type);
 831         }
 832 }
 833
 834 static void guiHandleDeferredOps(void) {
 835         // TODO: Fit into the given time interval, skip rest of operations of over limit
 836
 837         while (gUpdateList) {
 838                 WaitSema(gSemaId);
 839
 840                 guiHandleOp(gUpdateList->item);
 841
 842                 struct gui_update_list_t* td = gUpdateList;
 843                 gUpdateList = gUpdateList->next;
 844
 845                 free(td);
 846
 847                 gCompletedOps++;
 848
 849                 SignalSema(gSemaId);
 850         }
 851
 852         gUpdateEnd = NULL;
 853 }
 854
 855 static int bfadeout = 0x0;
 856 static void guiDrawBusy() {
 857         if (gTheme->loadingIcon) {
 858                 GSTEXTURE* texture = thmGetTexture(LOAD0_ICON + guiFrameId % gTheme->loadingIconCount);
 859                 if (texture && texture->Mem) {
 860                         u64 mycolor = GS_SETREG_RGBA(0x080, 0x080, 0x080, bfadeout);
 861                         rmDrawPixmap(texture, gTheme->loadingIcon->posX, gTheme->loadingIcon->posY, gTheme->loadingIcon->aligned, gTheme->loadingIcon->width, gTheme->loadingIcon->height, gTheme->loadingIcon->scaled, mycolor);
 862                 }
 863         }
 864 }
 865
 866 static int wfadeout = 0x0150;
 867 static void guiRenderGreeting() {
 868         int fade = wfadeout > 0xFF ? 0xFF : wfadeout;
 869         u64 mycolor = GS_SETREG_RGBA(0x10, 0x10, 0x10, fade >> 1);
 870         rmDrawRect(0, 0, screenWidth, screenHeight, mycolor);
 871
 872         GSTEXTURE* logo = thmGetTexture(LOGO_PICTURE);
 873         if (logo) {
 874                 mycolor = GS_SETREG_RGBA(0x080, 0x080, 0x080, fade >> 1);
 875                 rmDrawPixmap(logo, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, logo->Width, logo->Height, SCALING_RATIO, mycolor);
 876         }
 877
 878         return;
 879 }
 880
 881 static float mix(float a, float b, float t) {
 882         return (1.0 - t) * a + t * b;
 883 }
 884
 885 static float fade(float t) {
 886         return fadetbl[(int) (t * FADE_SIZE)];
 887 }
 888
 889 // The same as mix, but with 8 (2*4) values mixed at once
 890 static void VU0MixVec(VU_VECTOR *a, VU_VECTOR *b, float mix, VU_VECTOR* res) {
 891         asm (
 892                 "lqc2   vf1, 0(%0)\n" // load the first vector
 893                 "lqc2   vf2, 0(%1)\n" // load the second vector
 894                 "lw     $2, 0(%2)\n" // load value from ptr to reg
 895                 "qmtc2  $2, vf3\n" // load the mix value from reg to VU
 896                 "vaddw.x vf5, vf00, vf00\n" // vf5.x = 1
 897                 "vsub.x vf4x, vf5x, vf3x\n" // subtract 1 - vf3,x, store the result in vf4.x
 898                 "vmulax.xyzw ACC, vf1, vf3x\n" // multiply vf1 by vf3.x, store the result in ACC
 899                 "vmaddx.xyzw vf1, vf2, vf4x\n" // multiply vf2 by vf4.x add ACC, store the result in vf1
 900                 "sqc2   vf1, 0(%3)\n" // transfer the result in acc to the ee
 901                 : : "r" (a), "r" (b), "r" (&mix), "r" (res)
 902         );
 903 }
 904
 905 static float guiCalcPerlin(float x, float y, float z) {
 906         // Taken from: http://people.opera.com/patrickl/experiments/canvas/plasma/perlin-noise-classical.js
 907         // By Sean McCullough
 908
 909         // Find unit grid cell containing point
 910         int X = floor(x);
 911         int Y = floor(y);
 912         int Z = floor(z);
 913
 914         // Get relative xyz coordinates of point within that cell
 915         x = x - X;
 916         y = y - Y;
 917         z = z - Z;
 918
 919         // Wrap the integer cells at 255 (smaller integer period can be introduced here)
 920         X = X & 255;
 921         Y = Y & 255;
 922         Z = Z & 255;
 923
 924         // Calculate a set of eight hashed gradient indices
 925         int gi000 = pperm[X + pperm[Y + pperm[Z]]] % 12;
 926         int gi001 = pperm[X + pperm[Y + pperm[Z + 1]]] % 12;
 927         int gi010 = pperm[X + pperm[Y + 1 + pperm[Z]]] % 12;
 928         int gi011 = pperm[X + pperm[Y + 1 + pperm[Z + 1]]] % 12;
 929         int gi100 = pperm[X + 1 + pperm[Y + pperm[Z]]] % 12;
 930         int gi101 = pperm[X + 1 + pperm[Y + pperm[Z + 1]]] % 12;
 931         int gi110 = pperm[X + 1 + pperm[Y + 1 + pperm[Z]]] % 12;
 932         int gi111 = pperm[X + 1 + pperm[Y + 1 + pperm[Z + 1]]] % 12;
 933
 934         // The gradients of each corner are now:
 935         // g000 = grad3[gi000];
 936         // g001 = grad3[gi001];
 937         // g010 = grad3[gi010];
 938         // g011 = grad3[gi011];
 939         // g100 = grad3[gi100];
 940         // g101 = grad3[gi101];
 941         // g110 = grad3[gi110];
 942         // g111 = grad3[gi111];
 943         // Calculate noise contributions from each of the eight corners
 944         VU_VECTOR vec;
 945         vec.x = x;
 946         vec.y = y;
 947         vec.z = z;
 948         vec.w = 1;
 949
 950         VU_VECTOR a, b;
 951
 952         // float n000
 953         a.x = Vu0DotProduct(&pgrad3[gi000], &vec);
 954
 955         vec.y -= 1;
 956
 957         // float n010
 958         a.z = Vu0DotProduct(&pgrad3[gi010], &vec);
 959
 960         vec.x -= 1;
 961
 962         //float n110
 963         b.z = Vu0DotProduct(&pgrad3[gi110], &vec);
 964
 965         vec.y += 1;
 966
 967         // float n100
 968         b.x = Vu0DotProduct(&pgrad3[gi100], &vec);
 969
 970         vec.z -= 1;
 971
 972         // float n101
 973         b.y = Vu0DotProduct(&pgrad3[gi101], &vec);
 974
 975         vec.y -= 1;
 976
 977         // float n111
 978         b.w = Vu0DotProduct(&pgrad3[gi111], &vec);
 979
 980         vec.x += 1;
 981
 982         // float n011
 983         a.w = Vu0DotProduct(&pgrad3[gi011], &vec);
 984
 985         vec.y += 1;
 986
 987         // float n001
 988         a.y = Vu0DotProduct(&pgrad3[gi001], &vec);
 989
 990         // Compute the fade curve value for each of x, y, z
 991         float u = fade(x);
 992         float v = fade(y);
 993         float w = fade(z);
 994
 995         // TODO: Low priority... This could be done on VU0 (xyzw for the first 4 mixes)
 996         // The result in sw
 997         // Interpolate along x the contributions from each of the corners
 998         VU_VECTOR rv;
 999         VU0MixVec(&b, &a, u, &rv);
1000
1001         // TODO: The VU0MixVec could as well mix the results (as follows) - might improve performance...
1002         // Interpolate the four results along y
1003         float nxy0 = mix(rv.x, rv.z, v);
1004         float nxy1 = mix(rv.y, rv.w, v);
1005         // Interpolate the two last results along z
1006         float nxyz = mix(nxy0, nxy1, w);
1007
1008         return nxyz;
1009 }
1010
1011 static float dir = 0.02;
1012 static float perz = -100;
1013 static int pery = 0;
1014 static unsigned char curbgColor[3] = { 0, 0, 0 };
1015
1016 static int cdirection(unsigned char a, unsigned char b) {
1017         if (a == b)
1018                 return 0;
1019         else if (a > b)
1020                 return -1;
1021         else
1022                 return 1;
1023 }
1024
1025 void guiDrawBGPlasma() {
1026         int x, y;
1027
1028         // transition the colors
1029         curbgColor[0] += cdirection(curbgColor[0], gTheme->bgColor[0]);
1030         curbgColor[1] += cdirection(curbgColor[1], gTheme->bgColor[1]);
1031         curbgColor[2] += cdirection(curbgColor[2], gTheme->bgColor[2]);
1032
1033         // it's PLASMA_ROWS_PER_FRAME rows a frame to stop being a resource hog
1034         if (pery >= PLASMA_H) {
1035                 pery = 0;
1036                 perz += dir;
1037
1038                 if (perz > 100.0f || perz < -100.0f)
1039                         dir = -dir;
1040         }
1041
1042         u32 *buf = gBackgroundTex.Mem + PLASMA_W * pery;
1043         int ymax = pery + PLASMA_ROWS_PER_FRAME;
1044
1045         if (ymax > PLASMA_H)
1046                 ymax = PLASMA_H;
1047
1048         for (y = pery; y < ymax; y++) {
1049                 for (x = 0; x < PLASMA_W; x++) {
1050                         u32 fper = guiCalcPerlin((float) (2 * x) / PLASMA_W, (float) (2 * y) / PLASMA_H, perz) * 0x080 + 0x080;
1051
1052                         *buf = GS_SETREG_RGBA(
1053                                         (u32)(fper * curbgColor[0]) >> 8,
1054                                         (u32)(fper * curbgColor[1]) >> 8,
1055                                         (u32)(fper * curbgColor[2]) >> 8,
1056                                         0x080);
1057
1058                         ++buf;
1059                 }
1060
1061         }
1062
1063         pery = ymax;
1064         rmDrawPixmap(&gBackgroundTex, 0, 0, ALIGN_NONE, screenWidth, screenHeight, SCALING_NONE, gDefaultCol);
1065 }
1066
1067 int guiDrawIconAndText(int iconId, int textId, int font, int x, int y, u64 color) {
1068         GSTEXTURE* iconTex = thmGetTexture(iconId);
1069         if (iconTex && iconTex->Mem) {
1070                 rmDrawPixmap(iconTex, x, y, ALIGN_NONE, iconTex->Width, iconTex->Height, SCALING_RATIO, gDefaultCol);
1071                 x += iconTex->Width + 2;
1072         }
1073
1074         x = fntRenderString(font, x, y, ALIGN_NONE, 0, 0, _l(textId), color);
1075
1076         return x;
1077 }
1078
1079 static void guiDrawOverlays() {
1080         // are there any pending operations?
1081         int pending = ioHasPendingRequests();
1082
1083         if (!pending) {
1084                 if (bfadeout > 0x0)
1085                         bfadeout -= 0x08;
1086                 else
1087                         bfadeout = 0x0;
1088         } else {
1089                 if (bfadeout < 0x080)
1090                         bfadeout += 0x20;
1091         }
1092
1093         if (bfadeout > 0)
1094                 guiDrawBusy();
1095
1096 #ifdef __DEBUG
1097         // fps meter
1098         char fps[20];
1099
1100         if (time_since_last != 0)
1101                 snprintf(fps, 20, "%3d ms %3.1f FPS", time_render, 1000.0f / (float) time_since_last);
1102         else
1103                 snprintf(fps, 20, "%3d ms ----- FPS", time_render);
1104
1105         fntRenderString(FNT_DEFAULT, screenWidth - 90, 30, ALIGN_CENTER, 0, 0, fps, GS_SETREG_RGBA(0x060, 0x060, 0x060, 0x060));
1106 #endif
1107 }
1108
1109 static void guiReadPads() {
1110         if (readPads())
1111                 guiInactiveFrames = 0;
1112         else
1113                 guiInactiveFrames++;
1114 }
1115
1116 // renders the screen and handles inputs. Also handles screen transitions between numerous
1117 // screen handlers. For now we only have left-to right screen transition
1118 static void guiShow() {
1119         // is there a transmission effect going on or are
1120         // we in a normal rendering state?
1121         if (screenHandlerTarget) {
1122                 // advance the effect
1123
1124                 // render the old screen, transposed
1125                 rmSetTransposition(transIndex * transitionX, transIndex * transitionY);
1126                 screenHandler->renderScreen();
1127
1128                 // render new screen transposed again
1129                 rmSetTransposition((transIndex - transMax) * transitionX, (transIndex - transMax) * transitionY);
1130                 screenHandlerTarget->renderScreen();
1131
1132                 // reset transposition to zero
1133                 rmSetTransposition(0, 0);
1134
1135                 // move the transition indicator forward
1136                 transIndex += (min(transIndex, transMax - transIndex) >> 1) + 1;
1137
1138                 if (transIndex > transMax) {
1139                         transitionX = 0;
1140                         transitionY = 0;
1141                         screenHandler = screenHandlerTarget;
1142                         screenHandlerTarget = NULL;
1143                 }
1144         } else
1145                 // render with the set screen handler
1146                 screenHandler->renderScreen();
1147 }
1148
1149 void guiIntroLoop(void) {
1150         int endIntro = 0;
1151         while (!endIntro) {
1152                 guiStartFrame();
1153
1154                 guiReadPads();
1155
1156                 if (wfadeout < 0x0FF)
1157                         guiShow();
1158
1159                 if (gInitComplete)
1160                         wfadeout--;
1161
1162                 if (wfadeout > 0)
1163                         guiRenderGreeting();
1164                 else
1165                         endIntro = 1;
1166
1167                 guiHandleDeferredOps();
1168
1169                 guiEndFrame();
1170
1171                 if (!screenHandlerTarget && screenHandler)
1172                         screenHandler->handleInput();
1173         }
1174 }
1175
1176 void guiMainLoop(void) {
1177         while (!gTerminate) {
1178                 guiStartFrame();
1179
1180                 // Read the pad states to prepare for input processing in the screen handler
1181                 guiReadPads();
1182
1183                 // handle inputs and render screen
1184                 guiShow();
1185
1186                 // Render overlaying gui thingies :)
1187                 guiDrawOverlays();
1188
1189                 // handle deferred operations
1190                 guiHandleDeferredOps();
1191
1192                 guiEndFrame();
1193
1194                 // if not transiting, handle input
1195                 // done here so we can use renderman if needed
1196                 if (!screenHandlerTarget && screenHandler)
1197                         screenHandler->handleInput();
1198
1199                 if (gFrameHook)
1200                         gFrameHook();
1201         }
1202 }
1203
1204 void guiSetFrameHook(gui_callback_t cback) {
1205         gFrameHook = cback;
1206 }
1207
1208 void guiSwitchScreen(int target, int transition) {
1209         if (transition == TRANSITION_LEFT) {
1210                 transitionX = 1;
1211                 transMax = screenWidth;
1212         } else if (transition == TRANSITION_RIGHT) {
1213                 transitionX = -1;
1214                 transMax = screenWidth;
1215         } else if (transition == TRANSITION_UP) {
1216                 transitionY = 1;
1217                 transMax = screenHeight;
1218         } else if (transition == TRANSITION_DOWN) {
1219                 transitionY = -1;
1220                 transMax = screenHeight;
1221         }
1222         transIndex = 0;
1223
1224         screenHandlerTarget = &screenHandlers[target];
1225 }
1226
1227 struct gui_update_t *guiOpCreate(gui_op_type_t type) {
1228         struct gui_update_t *op = (struct gui_update_t *) malloc(sizeof(struct gui_update_t));
1229         memset(op, 0, sizeof(struct gui_update_t));
1230         op->type = type;
1231         return op;
1232 }
1233
1234 void guiUpdateScrollSpeed(void) {
1235         // sanitize the settings
1236         if ((gScrollSpeed < 0) || (gScrollSpeed > 2))
1237                 gScrollSpeed = 1;
1238
1239         // update the pad delays for KEY_UP and KEY_DOWN
1240         // default delay is 7
1241         // fast - 100 ms
1242         // medium - 300 ms
1243         // slow - 500 ms
1244         setButtonDelay(KEY_UP, 500 - gScrollSpeed * 200); // 0,1,2 -> 500, 300, 100
1245         setButtonDelay(KEY_DOWN, 500 - gScrollSpeed * 200);
1246 }
1247
1248 void guiUpdateScreenScale(void) {
1249         if (gWideScreen)
1250                 wideScreenScale = 0.75f;
1251         else
1252                 wideScreenScale = 1.0f;
1253
1254         // apply the scaling to renderman and font rendering
1255         rmSetAspectRatio(wideScreenScale, 1.0f);
1256         fntSetAspectRatio(wideScreenScale, 1.0f);
1257 }
1258
1259 int guiMsgBox(const char* text, int addAccept, struct UIItem *ui) {
1260         int terminate = 0;
1261         while (!terminate) {
1262                 guiStartFrame();
1263
1264                 readPads();
1265
1266                 if (getKeyOn(KEY_CIRCLE))
1267                         terminate = 1;
1268                 else if (getKeyOn(KEY_CROSS))
1269                         terminate = 2;
1270
1271                 if (ui)
1272                         diaRenderUI(ui, screenHandler->inMenu, NULL, 0);
1273                 else
1274                         guiShow();
1275
1276                 rmDrawRect(0, 0, screenWidth, screenHeight, gColDarker);
1277
1278                 rmDrawLine(50, 75, screenWidth - 50, 75, gColWhite);
1279                 rmDrawLine(50, 410, screenWidth - 50, 410, gColWhite);
1280
1281                 fntRenderString(FNT_DEFAULT, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, 0, 0, text, gTheme->textColor);
1282                 guiDrawIconAndText(CIRCLE_ICON, _STR_O_BACK, FNT_DEFAULT, 500, 417, gTheme->selTextColor);
1283                 if (addAccept)
1284                         guiDrawIconAndText(CROSS_ICON, _STR_X_ACCEPT, FNT_DEFAULT, 70, 417, gTheme->selTextColor);
1285
1286                 guiEndFrame();
1287         }
1288
1289         return terminate - 1;
1290 }
1291
1292 void guiHandleDeferedIO(int *ptr, const unsigned char* message, int type, void *data) {
1293         ioPutRequest(type, data);
1294
1295         while (*ptr)
1296                 guiRenderTextScreen(message);
1297 }
1298
1299 void guiRenderTextScreen(const unsigned char* message) {
1300         guiStartFrame();
1301
1302         guiShow();
1303
1304         rmDrawRect(0, 0, screenWidth, screenHeight, gColDarker);
1305
1306         fntRenderString(FNT_DEFAULT, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, 0, 0, message, gTheme->textColor);
1307
1308         guiDrawOverlays();
1309
1310         guiEndFrame();
1311 }