share/st_common.c

   1 /*
   2  * Copyright (C) 2013 Neverball authors
   3  *
   4  * NEVERBALL is  free software; you can redistribute  it and/or modify
   5  * it under the  terms of the GNU General  Public License as published
   6  * by the Free  Software Foundation; either version 2  of the License,
   7  * or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT  ANY  WARRANTY;  without   even  the  implied  warranty  of
  11  * MERCHANTABILITY or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU
  12  * General Public License for more details.
  13  */
  14
  15 #include <SDL.h>
  16
  17
  18 #include "config.h"
  19 #include "audio.h"
  20 #include "video.h"
  21 #include "geom.h"
  22 #include "lang.h"
  23 #include "gui.h"
  24
  25 #include "st_common.h"
  26
  27 #define AUD_MENU "snd/menu.ogg"
  28
  29 /*---------------------------------------------------------------------------*/
  30
  31 /*
  32  * Conf screen GUI helpers.
  33  */
  34
  35 void conf_slider(int id, const char *text,
  36                  int token, int value,
  37                  int *ids, int num)
  38 {
  39     int jd, kd, i;
  40
  41     if ((jd = gui_harray(id)) && (kd = gui_harray(jd)))
  42     {
  43         /* A series of empty buttons forms a "slider". */
  44
  45         for (i = num - 1; i >= 0; i--)
  46         {
  47             ids[i] = gui_state(kd, NULL, GUI_SML, token, i);
  48
  49             gui_set_hilite(ids[i], (i == value));
  50         }
  51
  52         gui_label(jd, text, GUI_SML, 0, 0);
  53     }
  54 }
  55
  56 int conf_state(int id, const char *label, const char *text, int token)
  57 {
  58     int jd, kd, rd = 0;
  59
  60     if ((jd = gui_harray(id)) && (kd = gui_harray(jd)))
  61     {
  62         rd = gui_state(kd, text, GUI_SML, token, 0);
  63         gui_label(jd, label, GUI_SML, 0, 0);
  64     }
  65
  66     return rd;
  67 }
  68
  69 void conf_toggle(int id, const char *label, int token, int value,
  70                  const char *text1, int value1,
  71                  const char *text0, int value0)
  72 {
  73     int jd, kd;
  74
  75     if ((jd = gui_harray(id)) && (kd = gui_harray(jd)))
  76     {
  77         int btn0, btn1;
  78
  79         btn0 = gui_state(kd, text0, GUI_SML, token, value0);
  80         btn1 = gui_state(kd, text1, GUI_SML, token, value1);
  81
  82         gui_set_hilite(btn0, (value == value0));
  83         gui_set_hilite(btn1, (value == value1));
  84
  85         gui_label(jd, label, GUI_SML, 0, 0);
  86     }
  87 }
  88
  89 void conf_header(int id, const char *text, int token)
  90 {
  91     int jd;
  92
  93     if ((jd = gui_harray(id)))
  94     {
  95         gui_label(jd, text, GUI_SML, 0, 0);
  96         gui_space(jd);
  97         gui_start(jd, _("Back"), GUI_SML, token, 0);
  98     }
  99
 100     gui_space(id);
 101 }
 102
 103 void conf_select(int id, const char *text, int token, int value,
 104                  const struct conf_option *opts, int num)
 105 {
 106     int jd, kd, ld;
 107     int i;
 108
 109     if ((jd = gui_harray(id)) && (kd = gui_harray(jd)))
 110     {
 111         for (i = 0; i < num; i++)
 112         {
 113             ld = gui_state(kd, _(opts[i].text), GUI_SML,
 114                            token, opts[i].value);
 115
 116             gui_set_hilite(ld, (opts[i].value == value));
 117         }
 118
 119         gui_label(jd, text, GUI_SML, 0, 0);
 120     }
 121 }
 122
 123 /*---------------------------------------------------------------------------*/
 124
 125 /*
 126  * Code shared by most screens (not just conf screens).
 127  *
 128  * FIXME This probably makes ball/st_shared.c obsolete.
 129  */
 130
 131 static int (*common_action)(int tok, int val);
 132
 133 void common_init(int (*action_fn)(int, int))
 134 {
 135     common_action = action_fn;
 136 }
 137
 138 void common_leave(struct state *st, struct state *next, int id)
 139 {
 140     gui_delete(id);
 141 }
 142
 143 void common_paint(int id, float st)
 144 {
 145     gui_paint(id);
 146 }
 147
 148 void common_timer(int id, float dt)
 149 {
 150     gui_timer(id, dt);
 151 }
 152
 153 void common_point(int id, int x, int y, int dx, int dy)
 154 {
 155     gui_pulse(gui_point(id, x, y), 1.2f);
 156 }
 157
 158 void common_stick(int id, int a, float v, int bump)
 159 {
 160     gui_pulse(gui_stick(id, a, v, bump), 1.2f);
 161 }
 162
 163 int common_click(int b, int d)
 164 {
 165     if (gui_click(b, d))
 166     {
 167         int active = gui_active();
 168         return common_action(gui_token(active), gui_value(active));
 169     }
 170     return 1;
 171 }
 172
 173 int common_keybd(int c, int d)
 174 {
 175     return (d && c == KEY_EXIT) ? common_action(GUI_BACK, 0) : 1;
 176 }
 177
 178 int common_buttn(int b, int d)
 179 {
 180     if (d)
 181     {
 182         int active = gui_active();
 183
 184         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_A, b))
 185             return common_action(gui_token(active), gui_value(active));
 186         if (config_tst_d(CONFIG_JOYSTICK_BUTTON_B, b))
 187             return common_action(GUI_BACK, 0);
 188     }
 189     return 1;
 190 }
 191
 192 /*---------------------------------------------------------------------------*/
 193
 194 /*
 195  * Code shared by conf screens.
 196  */
 197
 198 void conf_common_init(int (*action_fn)(int, int))
 199 {
 200     back_init("back/gui.png");
 201     audio_music_fade_to(0.5f, "bgm/inter.ogg");
 202
 203     common_init(action_fn);
 204 }
 205
 206 void conf_common_leave(struct state *st, struct state *next, int id)
 207 {
 208     back_free();
 209
 210     gui_delete(id);
 211 }
 212
 213 void conf_common_paint(int id, float t)
 214 {
 215     video_push_persp((float) config_get_d(CONFIG_VIEW_FOV), 0.1f, FAR_DIST);
 216     {
 217         back_draw_easy();
 218     }
 219     video_pop_matrix();
 220
 221     gui_paint(id);
 222 }
 223
 224 /*---------------------------------------------------------------------------*/
 225
 226 enum
 227 {
 228     VIDEO_FULLSCREEN = GUI_LAST,
 229     VIDEO_DISPLAY,
 230     VIDEO_RESOLUTION,
 231     VIDEO_REFLECTION,
 232     VIDEO_BACKGROUND,
 233     VIDEO_SHADOW,
 234     VIDEO_VSYNC,
 235     VIDEO_HMD,
 236     VIDEO_MULTISAMPLE
 237 };
 238
 239 static struct state *video_back;
 240
 241 static int video_action(int tok, int val)
 242 {
 243     int f = config_get_d(CONFIG_FULLSCREEN);
 244     int w = config_get_d(CONFIG_WIDTH);
 245     int h = config_get_d(CONFIG_HEIGHT);
 246     int r = 1;
 247
 248     audio_play(AUD_MENU, 1.0f);
 249
 250     switch (tok)
 251     {
 252     case GUI_BACK:
 253         goto_state(video_back);
 254         video_back = NULL;
 255         break;
 256
 257     case VIDEO_FULLSCREEN:
 258         goto_state(&st_null);
 259         r = video_mode(val, w, h);
 260         goto_state(&st_video);
 261         break;
 262
 263     case VIDEO_DISPLAY:
 264         goto_state(&st_display);
 265         break;
 266
 267     case VIDEO_REFLECTION:
 268         goto_state(&st_null);
 269         config_set_d(CONFIG_REFLECTION, val);
 270         r = video_mode(f, w, h);
 271         goto_state(&st_video);
 272         break;
 273
 274     case VIDEO_BACKGROUND:
 275         goto_state(&st_null);
 276         config_set_d(CONFIG_BACKGROUND, val);
 277         goto_state(&st_video);
 278         break;
 279
 280     case VIDEO_SHADOW:
 281         goto_state(&st_null);
 282         config_set_d(CONFIG_SHADOW, val);
 283         goto_state(&st_video);
 284         break;
 285
 286     case VIDEO_RESOLUTION:
 287         goto_state(&st_resol);
 288         break;
 289
 290     case VIDEO_VSYNC:
 291         goto_state(&st_null);
 292         config_set_d(CONFIG_VSYNC, val);
 293         r = video_mode(f, w, h);
 294         goto_state(&st_video);
 295         break;
 296
 297     case VIDEO_HMD:
 298         goto_state(&st_null);
 299         config_set_d(CONFIG_HMD, val);
 300         r = video_mode(f, w, h);
 301         goto_state(&st_video);
 302         break;
 303
 304     case VIDEO_MULTISAMPLE:
 305         goto_state(&st_null);
 306         config_set_d(CONFIG_MULTISAMPLE, val);
 307         r = video_mode(f, w, h);
 308         goto_state(&st_video);
 309         break;
 310     }
 311
 312     return r;
 313 }
 314
 315 static int video_gui(void)
 316 {
 317     static const struct conf_option multisample_opts[] = {
 318         { N_("Off"), 0 },
 319         { N_("2x"), 2 },
 320         { N_("4x"), 4 },
 321         { N_("8x"), 8 },
 322     };
 323
 324     int id, jd;
 325
 326     if ((id = gui_vstack(0)))
 327     {
 328         char resolution[sizeof ("12345678 x 12345678")];
 329         const char *display;
 330         int dpy = config_get_d(CONFIG_DISPLAY);
 331
 332         sprintf(resolution, "%d x %d",
 333                 config_get_d(CONFIG_WIDTH),
 334                 config_get_d(CONFIG_HEIGHT));
 335
 336         if (!(display = SDL_GetDisplayName(dpy)))
 337             display = _("Unknown Display");
 338
 339         conf_header(id, _("Graphics"), GUI_BACK);
 340
 341         if ((jd = conf_state(id, _("Display"), "Longest Name", VIDEO_DISPLAY)))
 342         {
 343             gui_set_trunc(jd, TRUNC_TAIL);
 344             gui_set_label(jd, display);
 345         }
 346
 347         conf_toggle(id, _("Fullscreen"),   VIDEO_FULLSCREEN,
 348                     config_get_d(CONFIG_FULLSCREEN), _("On"), 1, _("Off"), 0);
 349
 350         if ((jd = conf_state (id, _("Resolution"), resolution,
 351                               VIDEO_RESOLUTION)))
 352         {
 353             /*
 354              * Because we always use the desktop display mode, disable
 355              * display mode switching in fullscreen.
 356              */
 357
 358             if (config_get_d(CONFIG_FULLSCREEN))
 359             {
 360                 gui_set_state(jd, GUI_NONE, 0);
 361                 gui_set_color(jd, gui_gry, gui_gry);
 362             }
 363         }
 364 #if ENABLE_HMD
 365         conf_toggle(id, _("HMD"),          VIDEO_HMD,
 366                     config_get_d(CONFIG_HMD),        _("On"), 1, _("Off"), 0);
 367 #endif
 368
 369         gui_space(id);
 370
 371         conf_toggle(id, _("V-Sync"),       VIDEO_VSYNC,
 372                     config_get_d(CONFIG_VSYNC),      _("On"), 1, _("Off"), 0);
 373         conf_select(id, _("Antialiasing"), VIDEO_MULTISAMPLE,
 374                     config_get_d(CONFIG_MULTISAMPLE),
 375                     multisample_opts, ARRAYSIZE(multisample_opts));
 376
 377         gui_space(id);
 378
 379         conf_toggle(id, _("Reflection"),   VIDEO_REFLECTION,
 380                     config_get_d(CONFIG_REFLECTION), _("On"), 1, _("Off"), 0);
 381         conf_toggle(id, _("Background"),   VIDEO_BACKGROUND,
 382                     config_get_d(CONFIG_BACKGROUND), _("On"), 1, _("Off"), 0);
 383         conf_toggle(id, _("Shadow"),       VIDEO_SHADOW,
 384                     config_get_d(CONFIG_SHADOW),     _("On"), 1, _("Off"), 0);
 385
 386         gui_layout(id, 0, 0);
 387     }
 388
 389     return id;
 390 }
 391
 392 static int video_enter(struct state *st, struct state *prev)
 393 {
 394     if (!video_back)
 395         video_back = prev;
 396
 397     conf_common_init(video_action);
 398     return video_gui();
 399 }
 400
 401 /*---------------------------------------------------------------------------*/
 402
 403 enum
 404 {
 405     DISPLAY_SELECT = GUI_LAST
 406 };
 407
 408 static struct state *display_back;
 409
 410 static int display_action(int tok, int val)
 411 {
 412     int r = 1;
 413
 414     audio_play(AUD_MENU, 1.0f);
 415
 416     switch (tok)
 417     {
 418     case GUI_BACK:
 419         goto_state(display_back);
 420         display_back = NULL;
 421         break;
 422
 423     case DISPLAY_SELECT:
 424         if (val != config_get_d(CONFIG_DISPLAY))
 425         {
 426             goto_state(&st_null);
 427             config_set_d(CONFIG_DISPLAY, val);
 428             r = video_mode(config_get_d(CONFIG_FULLSCREEN),
 429                            config_get_d(CONFIG_WIDTH),
 430                            config_get_d(CONFIG_HEIGHT));
 431             goto_state(&st_display);
 432         }
 433         break;
 434     }
 435
 436     return r;
 437 }
 438
 439 static int display_gui(void)
 440 {
 441     int id, jd;
 442
 443     int i, n = SDL_GetNumVideoDisplays();
 444
 445     if ((id = gui_vstack(0)))
 446     {
 447         conf_header(id, _("Display"), GUI_BACK);
 448
 449         for (i = 0; i < n; i++)
 450         {
 451             const char *name = SDL_GetDisplayName(i);
 452
 453             jd = gui_state(id, name, GUI_SML, DISPLAY_SELECT, i);
 454             gui_set_hilite(jd, (i == config_get_d(CONFIG_DISPLAY)));
 455         }
 456
 457         gui_layout(id, 0, 0);
 458     }
 459
 460     return id;
 461 }
 462
 463 static int display_enter(struct state *st, struct state *prev)
 464 {
 465     if (!display_back)
 466         display_back = prev;
 467
 468     conf_common_init(display_action);
 469     return display_gui();
 470 }
 471
 472 /*---------------------------------------------------------------------------*/
 473
 474 struct mode
 475 {
 476     int w;
 477     int h;
 478 };
 479
 480 static const struct mode modes[] = {
 481     { 2560, 1440 },
 482     { 1920, 1200 },
 483     { 1920, 1080 },
 484     { 1680, 1050 },
 485     { 1600, 1200 },
 486     { 1600, 900 },
 487     { 1440, 900 },
 488     { 1366, 768 },
 489     { 1280, 1024 },
 490     { 1280, 800 },
 491     { 1280, 720 },
 492     { 1024, 768 },
 493     { 800, 600 },
 494     { 640, 480 },
 495     { 480, 320 },
 496     { 320, 240 }
 497 };
 498
 499 enum
 500 {
 501     RESOL_MODE = GUI_LAST
 502 };
 503
 504 static struct state *resol_back;
 505
 506 static int resol_action(int tok, int val)
 507 {
 508     int r = 1;
 509
 510     audio_play(AUD_MENU, 1.0f);
 511
 512     switch (tok)
 513     {
 514     case GUI_BACK:
 515         goto_state(resol_back);
 516         resol_back = NULL;
 517         break;
 518
 519     case RESOL_MODE:
 520         goto_state(&st_null);
 521         r = video_mode(config_get_d(CONFIG_FULLSCREEN),
 522                        modes[val].w,
 523                        modes[val].h);
 524         goto_state(&st_resol);
 525         break;
 526     }
 527
 528     return r;
 529 }
 530
 531 static int resol_gui(void)
 532 {
 533     int id, jd, kd;
 534
 535     if ((id = gui_vstack(0)))
 536     {
 537         const int W = config_get_d(CONFIG_WIDTH);
 538         const int H = config_get_d(CONFIG_HEIGHT);
 539
 540         int i, j, n = ARRAYSIZE(modes);
 541
 542         char buff[sizeof ("1234567890 x 1234567890")] = "";
 543
 544         conf_header(id, _("Resolution"), GUI_BACK);
 545
 546         for (i = 0; i < n; i += 4)
 547         {
 548             if ((jd = gui_harray(id)))
 549             {
 550                 for (j = 3; j >= 0; j--)
 551                 {
 552                     int m = i + j;
 553
 554                     if (m < n)
 555                     {
 556                         sprintf(buff, "%d x %d", modes[m].w, modes[m].h);
 557                         kd = gui_state(jd, buff, GUI_SML, RESOL_MODE, m);
 558                         gui_set_hilite(kd, (modes[m].w == W &&
 559                                             modes[m].h == H));
 560                     }
 561                     else
 562                     {
 563                         gui_space(jd);
 564                     }
 565                 }
 566             }
 567         }
 568
 569         gui_layout(id, 0, 0);
 570     }
 571
 572     return id;
 573 }
 574
 575 static int resol_enter(struct state *st, struct state *prev)
 576 {
 577     if (!resol_back)
 578         resol_back = prev;
 579
 580     conf_common_init(resol_action);
 581     return resol_gui();
 582 }
 583
 584 /*---------------------------------------------------------------------------*/
 585
 586 #define LANG_STEP 10
 587
 588 static Array langs;
 589 static int   first;
 590
 591 enum
 592 {
 593     LANG_DEFAULT = GUI_LAST,
 594     LANG_SELECT
 595 };
 596
 597 static struct state *lang_back;
 598
 599 static int lang_action(int tok, int val)
 600 {
 601     int r = 1;
 602
 603     struct lang_desc *desc;
 604
 605     audio_play(AUD_MENU, 1.0f);
 606
 607     switch (tok)
 608     {
 609     case GUI_BACK:
 610         goto_state(lang_back);
 611         lang_back = NULL;
 612         break;
 613
 614     case GUI_PREV:
 615         first -= LANG_STEP;
 616         goto_state(&st_lang);
 617         break;
 618
 619     case GUI_NEXT:
 620         first += LANG_STEP;
 621         goto_state(&st_lang);
 622         break;
 623
 624     case LANG_DEFAULT:
 625         /* HACK: Reload resources to load the localized font. */
 626         goto_state(&st_null);
 627         config_set_s(CONFIG_LANGUAGE, "");
 628         lang_init();
 629         goto_state(&st_lang);
 630         break;
 631
 632     case LANG_SELECT:
 633         desc = LANG_GET(langs, val);
 634         goto_state(&st_null);
 635         config_set_s(CONFIG_LANGUAGE, desc->code);
 636         lang_init();
 637         goto_state(&st_lang);
 638         break;
 639     }
 640
 641     return r;
 642 }
 643
 644 static int lang_gui(void)
 645 {
 646     const int step = (first == 0 ? LANG_STEP - 1 : LANG_STEP);
 647
 648     int id, jd;
 649     int i;
 650
 651     if ((id = gui_vstack(0)))
 652     {
 653         if ((jd = gui_hstack(id)))
 654         {
 655             gui_label(jd, _("Language"), GUI_SML, 0, 0);
 656             gui_space(jd);
 657             gui_space(jd);
 658             gui_navig(jd, array_len(langs), first, LANG_STEP);
 659         }
 660
 661         gui_space(id);
 662
 663         if (step < LANG_STEP)
 664         {
 665             int default_id;
 666             default_id = gui_state(id, _("Default"), GUI_SML, LANG_DEFAULT, 0);
 667             gui_set_hilite(default_id, !*config_get_s(CONFIG_LANGUAGE));
 668         }
 669
 670         for (i = first; i < first + step; i++)
 671         {
 672             if (i < array_len(langs))
 673             {
 674                 struct lang_desc *desc = LANG_GET(langs, i);
 675
 676                 int lang_id;
 677
 678                 lang_id = gui_state(id, " ", GUI_SML, LANG_SELECT, i);
 679
 680                 gui_set_hilite(lang_id, (strcmp(config_get_s(CONFIG_LANGUAGE),
 681                                                 desc->code) == 0));
 682
 683                 /* Set font and rebuild texture. */
 684
 685                 gui_set_font(lang_id, desc->font);
 686                 gui_set_label(lang_id, lang_name(desc));
 687             }
 688             else
 689             {
 690                 gui_label(id, " ", GUI_SML, 0, 0);
 691             }
 692         }
 693
 694         gui_layout(id, 0, 0);
 695     }
 696
 697     return id;
 698 }
 699
 700 static int lang_enter(struct state *st, struct state *prev)
 701 {
 702     if (!langs)
 703     {
 704         langs = lang_dir_scan();
 705         first = 0;
 706     }
 707
 708     if (!lang_back)
 709         lang_back = prev;
 710
 711     conf_common_init(lang_action);
 712     return lang_gui();
 713 }
 714
 715 void lang_leave(struct state *st, struct state *next, int id)
 716 {
 717     if (!(next == &st_lang || next == &st_null))
 718     {
 719         lang_dir_free(langs);
 720         langs = NULL;
 721     }
 722
 723     conf_common_leave(st, next, id);
 724 }
 725
 726 /*---------------------------------------------------------------------------*/
 727
 728 struct state st_video = {
 729     video_enter,
 730     conf_common_leave,
 731     conf_common_paint,
 732     common_timer,
 733     common_point,
 734     common_stick,
 735     NULL,
 736     common_click,
 737     common_keybd,
 738     common_buttn
 739 };
 740
 741 struct state st_display = {
 742     display_enter,
 743     conf_common_leave,
 744     conf_common_paint,
 745     common_timer,
 746     common_point,
 747     common_stick,
 748     NULL,
 749     common_click,
 750     common_keybd,
 751     common_buttn
 752 };
 753
 754 struct state st_resol = {
 755     resol_enter,
 756     conf_common_leave,
 757     conf_common_paint,
 758     common_timer,
 759     common_point,
 760     common_stick,
 761     NULL,
 762     common_click,
 763     common_keybd,
 764     common_buttn
 765 };
 766
 767 struct state st_lang = {
 768     lang_enter,
 769     lang_leave,
 770     conf_common_paint,
 771     common_timer,
 772     common_point,
 773     common_stick,
 774     NULL,
 775     common_click,
 776     common_keybd,
 777     common_buttn
 778 };
 779
 780 /*---------------------------------------------------------------------------*/