src/sdl2/main.c

   1 #ifdef __EMSCRIPTEN__
   2 #  include <emscripten.h>
   3 #endif
   4
   5 #include <SDL2/SDL.h>
   6 #include <stdio.h>
   7 #include <stdarg.h>
   8 #include <stdlib.h> // srand exit
   9 #include <string.h> // strcasecmp
  10 #include <assert.h>
  11 #include "system.h"
  12 #include "input.h"
  13
  14 #include "my.h" // fexists
  15 #include "player.h" // pl1 pl2
  16 #include "menu.h" // G_keyf
  17 #include "error.h" // logo
  18
  19 #include "files.h" // F_startup F_addwad F_initwads F_allocres
  20 #include "config.h" // CFG_args CFG_load CFG_save
  21 #include "memory.h" // M_startup
  22 #include "game.h" // G_init G_act
  23 #include "sound.h" // S_init S_done
  24 #include "music.h" // S_initmusic S_updatemusic S_donemusic
  25 #include "render.h" // R_init R_draw R_done
  26
  27 #define TITLE_STR "Doom 2D (SDL2)"
  28
  29 static Uint32 ticks;
  30 static int quit = 0;
  31 static SDL_Window *window;
  32 static SDL_GLContext context;
  33 static SDL_Surface *surf;
  34
  35 /* --- error.h --- */
  36
  37 void logo (const char *s, ...) {
  38   va_list ap;
  39   va_start(ap, s);
  40   vprintf(s, ap);
  41   va_end(ap);
  42   fflush(stdout);
  43 }
  44
  45 void logo_gas (int cur, int all) {
  46   // stub
  47 }
  48
  49 void ERR_failinit (char *s, ...) {
  50   va_list ap;
  51   va_start(ap, s);
  52   vprintf(s, ap);
  53   va_end(ap);
  54   puts("");
  55   exit(1);
  56 }
  57
  58 void ERR_fatal (char *s, ...) {
  59   va_list ap;
  60   R_done();
  61   S_done();
  62   S_donemusic();
  63   M_shutdown();
  64   SDL_Quit();
  65   puts("\nКРИТИЧЕСКАЯ ОШИБКА:");
  66   va_start(ap, s);
  67   vprintf(s, ap);
  68   va_end(ap);
  69   puts("");
  70   exit(1);
  71 }
  72
  73 void ERR_quit (void) {
  74   quit = 1;
  75 }
  76
  77 /* --- system.h --- */
  78
  79 static int Y_resize_window (int w, int h, int fullscreen) {
  80   assert(w > 0);
  81   assert(h > 0);
  82   assert(window != NULL);
  83   if (surf != NULL) {
  84     if (surf->w != w || surf->h != h) {
  85       SDL_Surface *s = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);
  86       if (s != NULL) {
  87         SDL_SetPaletteColors(s->format->palette, surf->format->palette->colors, 0, surf->format->palette->ncolors);
  88         SDL_FreeSurface(surf);
  89         surf = s;
  90       }
  91     }
  92   }
  93   SDL_SetWindowSize(window, w, h);
  94   Y_set_fullscreen(fullscreen);
  95   return 1;
  96 }
  97
  98 int Y_set_videomode_opengl (int w, int h, int fullscreen) {
  99   assert(w > 0);
 100   assert(h > 0);
 101   Uint32 flags;
 102   SDL_Window *win;
 103   SDL_GLContext ctx;
 104   if (window != NULL && context != NULL) {
 105     Y_resize_window(w, h, fullscreen);
 106     win = window;
 107   } else {
 108     flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL;
 109     if (fullscreen) {
 110       flags = flags | SDL_WINDOW_FULLSCREEN;
 111     }
 112     // TODO set context version and type
 113 #ifdef __EMSCRIPTEN__
 114     SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
 115     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
 116     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
 117 #else
 118     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
 119     SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
 120 #endif
 121     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 122     win = SDL_CreateWindow(TITLE_STR, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
 123     if (win != NULL) {
 124       ctx = SDL_GL_CreateContext(win);
 125       if (ctx != NULL) {
 126         Y_unset_videomode();
 127         window = win;
 128         context = ctx;
 129         SDL_GL_MakeCurrent(window, context);
 130       } else {
 131         SDL_DestroyWindow(win);
 132         win = NULL;
 133       }
 134     }
 135   }
 136   if (win == NULL) {
 137     logo("Y_set_videomode_opengl: error: %s\n", SDL_GetError());
 138   }
 139   return win != NULL;
 140 }
 141
 142 int Y_set_videomode_software (int w, int h, int fullscreen) {
 143   assert(w > 0);
 144   assert(h > 0);
 145   Uint32 flags;
 146   SDL_Surface *s;
 147   SDL_Window *win;
 148   if (window != NULL && surf != NULL) {
 149     Y_resize_window(w, h, fullscreen);
 150     win = window;
 151   } else {
 152     flags = SDL_WINDOW_RESIZABLE;
 153     if (fullscreen) {
 154       flags = flags | SDL_WINDOW_FULLSCREEN;
 155     }
 156     win = SDL_CreateWindow(TITLE_STR, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags);
 157     if (win != NULL) {
 158       s = SDL_CreateRGBSurface(0, w, h, 8, 0, 0, 0, 0);
 159       if (s != NULL) {
 160         Y_unset_videomode();
 161         window = win;
 162         surf = s;
 163       } else {
 164         SDL_DestroyWindow(win);
 165         win = NULL;
 166       }
 167     }
 168   }
 169   if (win == NULL) {
 170     logo("Y_set_videomode_software: error: %s\n", SDL_GetError());
 171   }
 172   return win != NULL;
 173 }
 174
 175 void Y_get_videomode (int *w, int *h) {
 176   if (window != NULL) {
 177     SDL_GetWindowSize(window, w, h);
 178   } else {
 179     *w = 0;
 180     *h = 0;
 181   }
 182 }
 183
 184 int Y_videomode_setted (void) {
 185   return window != NULL;
 186 }
 187
 188 void Y_unset_videomode (void) {
 189   if (window != NULL) {
 190     if (context != NULL) {
 191       SDL_GL_MakeCurrent(window, NULL);
 192       SDL_GL_DeleteContext(context);
 193       context = NULL;
 194     }
 195     if (surf != NULL) {
 196       SDL_FreeSurface(surf);
 197       surf = NULL;
 198     }
 199     SDL_DestroyWindow(window);
 200     window = NULL;
 201   }
 202 }
 203
 204 void Y_set_fullscreen (int yes) {
 205   if (window != NULL) {
 206     SDL_SetWindowFullscreen(window, yes ? SDL_WINDOW_FULLSCREEN : 0);
 207   }
 208 }
 209
 210 int Y_get_fullscreen (void) {
 211   return (window != NULL) && (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN);
 212 }
 213
 214 void Y_swap_buffers (void) {
 215   assert(window != NULL);
 216   assert(context != NULL);
 217   SDL_GL_SwapWindow(window);
 218 }
 219
 220 void Y_get_buffer (byte **buf, int *w, int *h, int *pitch) {
 221   assert(window != NULL);
 222   assert(surf != NULL);
 223   *buf = surf->pixels;
 224   *w = surf->w;
 225   *h = surf->h;
 226   *pitch = surf->pitch;
 227 }
 228
 229 void Y_set_vga_palette (byte *vgapal) {
 230   assert(window != NULL);
 231   assert(surf != NULL);
 232   int i;
 233   byte *p = vgapal;
 234   SDL_Color colors[256];
 235   for (i = 0; i < 256; i++) {
 236     colors[i] = (SDL_Color) {
 237       .r = p[0] * 255 / 63,
 238       .g = p[1] * 255 / 63,
 239       .b = p[2] * 255 / 63
 240     };
 241     p += 3;
 242   }
 243   SDL_SetPaletteColors(surf->format->palette, colors, 0, 256);
 244 }
 245
 246 void Y_repaint_rect (int x, int y, int w, int h) {
 247   assert(window != NULL);
 248   assert(surf != NULL);
 249   SDL_Surface *s = SDL_GetWindowSurface(window);
 250   SDL_Rect r = (SDL_Rect) {
 251     .x = x,
 252     .y = y,
 253     .w = w,
 254     .h = h
 255   };
 256   SDL_BlitSurface(surf, &r, s, &r);
 257   SDL_UpdateWindowSurfaceRects(window, &r, 1);
 258 }
 259
 260 void Y_repaint (void) {
 261   Y_repaint_rect(0, 0, surf->w, surf->h);
 262 }
 263
 264 void Y_enable_text_input (void) {
 265   SDL_StartTextInput();
 266 }
 267
 268 void Y_disable_text_input (void) {
 269   SDL_StopTextInput();
 270 }
 271
 272 /* --- main --- */
 273
 274 static int sdl_to_key (int code) {
 275   switch (code) {
 276     case SDL_SCANCODE_0: return KEY_0;
 277     case SDL_SCANCODE_1: return KEY_1;
 278     case SDL_SCANCODE_2: return KEY_2;
 279     case SDL_SCANCODE_3: return KEY_3;
 280     case SDL_SCANCODE_4: return KEY_4;
 281     case SDL_SCANCODE_5: return KEY_5;
 282     case SDL_SCANCODE_6: return KEY_6;
 283     case SDL_SCANCODE_7: return KEY_7;
 284     case SDL_SCANCODE_8: return KEY_8;
 285     case SDL_SCANCODE_9: return KEY_9;
 286     case SDL_SCANCODE_A: return KEY_A;
 287     case SDL_SCANCODE_B: return KEY_B;
 288     case SDL_SCANCODE_C: return KEY_C;
 289     case SDL_SCANCODE_D: return KEY_D;
 290     case SDL_SCANCODE_E: return KEY_E;
 291     case SDL_SCANCODE_F: return KEY_F;
 292     case SDL_SCANCODE_G: return KEY_G;
 293     case SDL_SCANCODE_H: return KEY_H;
 294     case SDL_SCANCODE_I: return KEY_I;
 295     case SDL_SCANCODE_J: return KEY_J;
 296     case SDL_SCANCODE_K: return KEY_K;
 297     case SDL_SCANCODE_L: return KEY_L;
 298     case SDL_SCANCODE_M: return KEY_M;
 299     case SDL_SCANCODE_N: return KEY_N;
 300     case SDL_SCANCODE_O: return KEY_O;
 301     case SDL_SCANCODE_P: return KEY_P;
 302     case SDL_SCANCODE_Q: return KEY_Q;
 303     case SDL_SCANCODE_R: return KEY_R;
 304     case SDL_SCANCODE_S: return KEY_S;
 305     case SDL_SCANCODE_T: return KEY_T;
 306     case SDL_SCANCODE_U: return KEY_U;
 307     case SDL_SCANCODE_V: return KEY_V;
 308     case SDL_SCANCODE_W: return KEY_W;
 309     case SDL_SCANCODE_X: return KEY_X;
 310     case SDL_SCANCODE_Y: return KEY_Y;
 311     case SDL_SCANCODE_Z: return KEY_Z;
 312     case SDL_SCANCODE_RETURN: return KEY_RETURN;
 313     case SDL_SCANCODE_ESCAPE: return KEY_ESCAPE;
 314     case SDL_SCANCODE_BACKSPACE: return KEY_BACKSPACE;
 315     case SDL_SCANCODE_TAB: return KEY_TAB;
 316     case SDL_SCANCODE_SPACE: return KEY_SPACE;
 317     case SDL_SCANCODE_MINUS: return KEY_MINUS;
 318     case SDL_SCANCODE_EQUALS: return KEY_EQUALS;
 319     case SDL_SCANCODE_LEFTBRACKET: return KEY_LEFTBRACKET;
 320     case SDL_SCANCODE_RIGHTBRACKET: return KEY_RIGHTBRACKET;
 321     case SDL_SCANCODE_BACKSLASH: return KEY_BACKSLASH;
 322     case SDL_SCANCODE_SEMICOLON: return KEY_SEMICOLON;
 323     case SDL_SCANCODE_APOSTROPHE: return KEY_APOSTROPHE;
 324     case SDL_SCANCODE_GRAVE: return KEY_GRAVE;
 325     case SDL_SCANCODE_COMMA: return KEY_COMMA;
 326     case SDL_SCANCODE_PERIOD: return KEY_PERIOD;
 327     case SDL_SCANCODE_SLASH: return KEY_SLASH;
 328     case SDL_SCANCODE_CAPSLOCK: return KEY_CAPSLOCK;
 329     case SDL_SCANCODE_F1: return KEY_F1;
 330     case SDL_SCANCODE_F2: return KEY_F2;
 331     case SDL_SCANCODE_F3: return KEY_F3;
 332     case SDL_SCANCODE_F4: return KEY_F4;
 333     case SDL_SCANCODE_F5: return KEY_F5;
 334     case SDL_SCANCODE_F6: return KEY_F6;
 335     case SDL_SCANCODE_F7: return KEY_F7;
 336     case SDL_SCANCODE_F8: return KEY_F8;
 337     case SDL_SCANCODE_F9: return KEY_F9;
 338     case SDL_SCANCODE_F10: return KEY_F10;
 339     case SDL_SCANCODE_F11: return KEY_F11;
 340     case SDL_SCANCODE_F12: return KEY_F12;
 341     case SDL_SCANCODE_PRINTSCREEN: return KEY_PRINTSCREEN;
 342     case SDL_SCANCODE_SCROLLLOCK: return KEY_SCROLLLOCK;
 343     case SDL_SCANCODE_PAUSE: return KEY_PAUSE;
 344     case SDL_SCANCODE_INSERT: return KEY_INSERT;
 345     case SDL_SCANCODE_HOME: return KEY_HOME;
 346     case SDL_SCANCODE_PAGEUP: return KEY_PAGEUP;
 347     case SDL_SCANCODE_DELETE: return KEY_DELETE;
 348     case SDL_SCANCODE_END: return KEY_END;
 349     case SDL_SCANCODE_PAGEDOWN: return KEY_PAGEDOWN;
 350     case SDL_SCANCODE_RIGHT: return KEY_RIGHT;
 351     case SDL_SCANCODE_LEFT: return KEY_LEFT;
 352     case SDL_SCANCODE_DOWN: return KEY_DOWN;
 353     case SDL_SCANCODE_UP: return KEY_UP;
 354     case SDL_SCANCODE_NUMLOCKCLEAR: return KEY_NUMLOCK;
 355     case SDL_SCANCODE_KP_DIVIDE: return KEY_KP_DIVIDE;
 356     case SDL_SCANCODE_KP_MULTIPLY: return KEY_KP_MULTIPLY;
 357     case SDL_SCANCODE_KP_MINUS: return KEY_KP_MINUS;
 358     case SDL_SCANCODE_KP_PLUS: return KEY_KP_PLUS;
 359     case SDL_SCANCODE_KP_ENTER: return KEY_KP_ENTER;
 360     case SDL_SCANCODE_KP_0: return KEY_KP_0;
 361     case SDL_SCANCODE_KP_1: return KEY_KP_1;
 362     case SDL_SCANCODE_KP_2: return KEY_KP_2;
 363     case SDL_SCANCODE_KP_3: return KEY_KP_3;
 364     case SDL_SCANCODE_KP_4: return KEY_KP_4;
 365     case SDL_SCANCODE_KP_5: return KEY_KP_5;
 366     case SDL_SCANCODE_KP_6: return KEY_KP_6;
 367     case SDL_SCANCODE_KP_7: return KEY_KP_7;
 368     case SDL_SCANCODE_KP_8: return KEY_KP_8;
 369     case SDL_SCANCODE_KP_9: return KEY_KP_9;
 370     case SDL_SCANCODE_KP_PERIOD: return KEY_KP_PERIOD;
 371     case SDL_SCANCODE_SYSREQ: return KEY_SYSREQ;
 372     case SDL_SCANCODE_LCTRL: return KEY_LCTRL;
 373     case SDL_SCANCODE_LSHIFT: return KEY_LSHIFT;
 374     case SDL_SCANCODE_LALT: return KEY_LALT;
 375     case SDL_SCANCODE_LGUI: return KEY_LSUPER;
 376     case SDL_SCANCODE_RCTRL: return KEY_RCTRL;
 377     case SDL_SCANCODE_RSHIFT: return KEY_RSHIFT;
 378     case SDL_SCANCODE_RALT: return KEY_RALT;
 379     case SDL_SCANCODE_RGUI: return KEY_RSUPER;
 380     default: return KEY_UNKNOWN;
 381   }
 382 }
 383
 384 static void window_event_handler (SDL_WindowEvent *ev) {
 385   switch (ev->event) {
 386     case SDL_WINDOWEVENT_RESIZED:
 387       R_set_videomode(ev->data1, ev->data2, Y_get_fullscreen());
 388       break;
 389     case SDL_WINDOWEVENT_CLOSE:
 390       ERR_quit();
 391       break;
 392   }
 393 }
 394
 395 static int utf8_to_wchar (char *x) {
 396   int i = 0;
 397   byte *s = (byte*)x;
 398   if (s[0] < 0x80) {
 399     return s[0];
 400   } else if (s[0] < 0xE0) {
 401     if (s[0] - 192 >= 0 && s[1] >= 0x80 && s[1] < 0xE0) {
 402       i = (s[0] - 192) * 64 + s[1] - 128;
 403     }
 404   } else if (s[0] < 0xF0) {
 405     if (s[1] >= 0x80 && s[1] < 0xE0 && s[2] >= 0x80 && s[2] < 0xE0) {
 406       i = ((s[0] - 224) * 64 + s[1] - 128) * 64 + s[2] - 128;
 407     }
 408   }
 409   return i;
 410 }
 411
 412 static int wchar_to_cp866 (int uch) {
 413   if (uch <= 0x7f) {
 414     return uch;
 415   } else if (uch >= 0x410 && uch <= 0x43f) {
 416     return uch - 0x410 + 0x80;
 417   } else if (uch >= 0x440 && uch <= 0x44f) {
 418     return uch - 0x440 + 0xe0;
 419   } else {
 420     switch (uch) {
 421       // TODO graphics from 0xb0..0xdf
 422       case 0x401: return 0xf0;
 423       case 0x451: return 0xf1;
 424       case 0x404: return 0xf2;
 425       case 0x454: return 0xf3;
 426       case 0x407: return 0xf4;
 427       case 0x457: return 0xf5;
 428       case 0x40e: return 0xf6;
 429       case 0x45e: return 0xf7;
 430       case 0xb0: return 0xf8;
 431       case 0x2219: return 0xf9;
 432       case 0xb7: return 0xfa;
 433       case 0x221a: return 0xfb;
 434       case 0x2116: return 0xfc;
 435       case 0xa4: return 0xfd;
 436       case 0x25a0: return 0xfe;
 437       case 0xa0: return 0xff;
 438       default: return 0; // unknown
 439     }
 440   }
 441 }
 442
 443 static void poll_events (void) {
 444   int key, down, uch, ch;
 445   SDL_Event ev;
 446   while (SDL_PollEvent(&ev)) {
 447     switch (ev.type) {
 448       case SDL_QUIT:
 449         ERR_quit();
 450         break;
 451       case SDL_WINDOWEVENT:
 452         if (ev.window.windowID == SDL_GetWindowID(window)) {
 453           window_event_handler(&ev.window);
 454         }
 455         break;
 456       case SDL_KEYDOWN:
 457       case SDL_KEYUP:
 458         down = ev.type == SDL_KEYDOWN;
 459         key = sdl_to_key(ev.key.keysym.scancode);
 460         I_press(key, down);
 461         GM_key(key, down);
 462         break;
 463       case SDL_TEXTINPUT:
 464         uch = utf8_to_wchar(ev.text.text);
 465         ch = wchar_to_cp866(uch);
 466         GM_input(ch);
 467         break;
 468     }
 469   }
 470 }
 471
 472 static void step (void) {
 473   poll_events();
 474   S_updatemusic();
 475   Uint32 t = SDL_GetTicks();
 476   if (t - ticks > DELAY) {
 477     ticks = t;
 478     G_act();
 479   }
 480   R_draw();
 481 }
 482
 483 int main (int argc, char **argv) {
 484   char *pw;
 485   logo("system: initialize SDL2\n");
 486   if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS) == -1) {
 487     logo("system: failed to init SDL2: %s\n", SDL_GetError());
 488     return 1;
 489   }
 490   // Player 1 defaults
 491   pl1.ku = KEY_KP_8;
 492   pl1.kd = KEY_KP_5;
 493   pl1.kl = KEY_KP_4;
 494   pl1.kr = KEY_KP_6;
 495   pl1.kf = KEY_PAGEDOWN;
 496   pl1.kj = KEY_DELETE;
 497   pl1.kwl = KEY_HOME;
 498   pl1.kwr = KEY_END;
 499   pl1.kp = KEY_KP_8;
 500   // Player 2 defaults
 501   pl2.ku = KEY_E;
 502   pl2.kd = KEY_D;
 503   pl2.kl = KEY_S;
 504   pl2.kr = KEY_F;
 505   pl2.kf = KEY_A;
 506   pl2.kj = KEY_Q;
 507   pl2.kwl = KEY_1;
 508   pl2.kwr = KEY_2;
 509   pl2.kp = KEY_E;
 510   srand(SDL_GetTicks());
 511   F_startup();
 512 #ifndef WIN32
 513   pw = "/usr/share/doom2d-rembo/doom2d.wad";
 514 #else
 515   pw = "doom2d.wad";
 516 #endif
 517   if (fexists(pw)) {
 518     F_addwad(pw);
 519   } else {
 520     F_addwad("doom2d.wad");
 521   }
 522   CFG_args(argc, argv);
 523   CFG_load();
 524   F_initwads();
 525   M_startup();
 526   F_allocres();
 527   S_init();
 528   S_initmusic();
 529   R_init();
 530   G_init();
 531   ticks = SDL_GetTicks();
 532 #ifdef __EMSCRIPTEN__
 533   emscripten_set_main_loop(step, 0, 1);
 534 #else
 535   while (!quit) {
 536     step();
 537   }
 538 #endif
 539   CFG_save();
 540   R_done();
 541   S_donemusic();
 542   S_done();
 543   M_shutdown();
 544   SDL_Quit();
 545   return 0;
 546 }