Annotation of brogue-ce/src/platform/sdl2-platform.c, Revision 1.1
1.1 ! rubenllo 1: #ifdef SDL_PATHS
! 2: #include <unistd.h>
! 3: #endif
! 4:
! 5: #include <limits.h>
! 6: #include <SDL_image.h>
! 7: #include "platform.h"
! 8: #include "tiles.h"
! 9:
! 10: #define PAUSE_BETWEEN_EVENT_POLLING 36L//17
! 11: #define MAX_REMAPS 128
! 12:
! 13: struct keypair {
! 14: char from;
! 15: char to;
! 16: };
! 17:
! 18: static struct keypair remapping[MAX_REMAPS];
! 19: static size_t nremaps = 0;
! 20: static boolean showGraphics = false;
! 21:
! 22: static rogueEvent lastEvent;
! 23:
! 24:
! 25: static void sdlfatal(char *file, int line) {
! 26: fprintf(stderr, "Fatal SDL error (%s:%d): %s\n", file, line, SDL_GetError());
! 27: exit(1);
! 28: }
! 29:
! 30:
! 31: static void imgfatal(char *file, int line) {
! 32: fprintf(stderr, "Fatal SDL_image error (%s:%d): %s\n", file, line, IMG_GetError());
! 33: exit(1);
! 34: }
! 35:
! 36:
! 37: /*
! 38: If the key is to be processed, returns true and updates event. False
! 39: otherwise. This function only listens for keypresses which do not produce
! 40: corresponding TextInputEvents.
! 41: */
! 42: static boolean eventFromKey(rogueEvent *event, SDL_Keycode key) {
! 43: event->param1 = -1;
! 44:
! 45: switch (key) {
! 46: case SDLK_ESCAPE:
! 47: event->param1 = ESCAPE_KEY;
! 48: return true;
! 49: case SDLK_UP:
! 50: event->param1 = UP_ARROW;
! 51: return true;
! 52: case SDLK_DOWN:
! 53: event->param1 = DOWN_ARROW;
! 54: return true;
! 55: case SDLK_RIGHT:
! 56: event->param1 = RIGHT_ARROW;
! 57: return true;
! 58: case SDLK_LEFT:
! 59: event->param1 = LEFT_ARROW;
! 60: return true;
! 61: case SDLK_RETURN:
! 62: case SDLK_KP_ENTER:
! 63: event->param1 = RETURN_KEY;
! 64: return true;
! 65: case SDLK_BACKSPACE:
! 66: event->param1 = DELETE_KEY;
! 67: return true;
! 68: case SDLK_TAB:
! 69: event->param1 = TAB_KEY;
! 70: return true;
! 71: case SDLK_PRINTSCREEN:
! 72: event->param1 = PRINTSCREEN_KEY;
! 73: return true;
! 74: }
! 75:
! 76: /*
! 77: Only process keypad events when we're holding a modifier, as there is no
! 78: TextInputEvent then.
! 79: */
! 80: if (event->shiftKey || event->controlKey) {
! 81: switch (key) {
! 82: case SDLK_KP_0:
! 83: event->param1 = NUMPAD_0;
! 84: return true;
! 85: case SDLK_KP_1:
! 86: event->param1 = NUMPAD_1;
! 87: return true;
! 88: case SDLK_KP_2:
! 89: event->param1 = NUMPAD_2;
! 90: return true;
! 91: case SDLK_KP_3:
! 92: event->param1 = NUMPAD_3;
! 93: return true;
! 94: case SDLK_KP_4:
! 95: event->param1 = NUMPAD_4;
! 96: return true;
! 97: case SDLK_KP_5:
! 98: event->param1 = NUMPAD_5;
! 99: return true;
! 100: case SDLK_KP_6:
! 101: event->param1 = NUMPAD_6;
! 102: return true;
! 103: case SDLK_KP_7:
! 104: event->param1 = NUMPAD_7;
! 105: return true;
! 106: case SDLK_KP_8:
! 107: event->param1 = NUMPAD_8;
! 108: return true;
! 109: case SDLK_KP_9:
! 110: event->param1 = NUMPAD_9;
! 111: return true;
! 112: }
! 113: }
! 114:
! 115: // Ctrl+letter doesn't give a TextInputEvent
! 116: if (event->controlKey && key >= SDLK_a && key <= SDLK_z) {
! 117: event->param1 = 'a' + (key - SDLK_a);
! 118: if (event->shiftKey) event->param1 -= 'a' - 'A';
! 119: return true;
! 120: }
! 121:
! 122: return false;
! 123: }
! 124:
! 125:
! 126: static boolean _modifierHeld(int mod) {
! 127: SDL_Keymod km = SDL_GetModState();
! 128: return mod == 0 && (km & (KMOD_LSHIFT | KMOD_RSHIFT))
! 129: || mod == 1 && (km & (KMOD_LCTRL | KMOD_RCTRL));
! 130: }
! 131:
! 132:
! 133: static char applyRemaps(char c) {
! 134: for (size_t i=0; i < nremaps; i++) {
! 135: if (remapping[i].from == c) return remapping[i].to;
! 136: }
! 137: return c;
! 138: }
! 139:
! 140:
! 141: /*
! 142: If an event is available, returns true and updates returnEvent. Otherwise
! 143: it returns false and an error event. This function also processes
! 144: platform-specific inputs/behaviours.
! 145: */
! 146: static boolean pollBrogueEvent(rogueEvent *returnEvent, boolean textInput) {
! 147: static int mx = 0, my = 0;
! 148:
! 149: returnEvent->eventType = EVENT_ERROR;
! 150: returnEvent->shiftKey = _modifierHeld(0);
! 151: returnEvent->controlKey = _modifierHeld(1);
! 152:
! 153: SDL_Event event;
! 154: boolean ret = false;
! 155:
! 156:
! 157: // ~ for (int i=0; i < 100 && SDL_PollEvent(&event); i++) {
! 158: while (SDL_PollEvent(&event)) {
! 159: if (event.type == SDL_QUIT) {
! 160: // the player clicked the X button!
! 161: SDL_Quit();
! 162: quitImmediately();
! 163: } else if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_RESIZED) {
! 164: resizeWindow(event.window.data1, event.window.data2);
! 165: } else if (event.type == SDL_KEYDOWN) {
! 166: SDL_Keycode key = event.key.keysym.sym;
! 167:
! 168: if (key == SDLK_PAGEUP) {
! 169: resizeWindow(max(windowWidth * 11/10, windowWidth + 1), max(windowHeight * 11/10, windowHeight + 1));
! 170: continue;
! 171: } else if (key == SDLK_PAGEDOWN) {
! 172: fullScreen = false;
! 173: resizeWindow(max(windowWidth * 10/11, 1), max(windowHeight * 10/11, 1));
! 174: continue;
! 175: } else if (key == SDLK_F11 || key == SDLK_F12
! 176: || key == SDLK_RETURN && (SDL_GetModState() & KMOD_ALT)) {
! 177: fullScreen = !fullScreen;
! 178: resizeWindow(-1, -1); // Reset to starting resolution
! 179: continue;
! 180: }
! 181:
! 182: if (eventFromKey(returnEvent, key)) {
! 183: returnEvent->eventType = KEYSTROKE;
! 184: return true;
! 185: }
! 186: } else if (event.type == SDL_TEXTINPUT && (unsigned char)(event.text.text[0]) < 0x80) {
! 187: /*
! 188: It's difficult/impossible to check what characters are on the
! 189: shifts of keys. So to detect '&', '>' etc. reliably we need to
! 190: listen for text input events as well as keydowns. This results
! 191: in hybrid keyboard code, where Brogue KEYSTROKEs can come from
! 192: different SDL events.
! 193: */
! 194: char c = event.text.text[0];
! 195:
! 196: if (!textInput) {
! 197: c = applyRemaps(c);
! 198: if (c == '=' || c == '+') {
! 199: resizeWindow(max(windowWidth * 11/10, windowWidth + 1), max(windowHeight * 11/10, windowHeight + 1));
! 200: } else if (c == '-') {
! 201: fullScreen = false;
! 202: resizeWindow(max(windowWidth * 10/11, 1), max(windowHeight * 10/11, 1));
! 203: }
! 204: }
! 205:
! 206: returnEvent->eventType = KEYSTROKE;
! 207: returnEvent->param1 = c;
! 208: // ~ printf("textinput %s\n", event.text.text);
! 209: return true;
! 210: } else if (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) {
! 211: if (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT) {
! 212: if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
! 213: returnEvent->eventType = MOUSE_DOWN;
! 214: } else if (event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT) {
! 215: returnEvent->eventType = MOUSE_UP;
! 216: } else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_RIGHT) {
! 217: returnEvent->eventType = RIGHT_MOUSE_DOWN;
! 218: } else if (event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_RIGHT) {
! 219: returnEvent->eventType = RIGHT_MOUSE_UP;
! 220: }
! 221: returnEvent->param1 = event.button.x * COLS / windowWidth;
! 222: returnEvent->param2 = event.button.y * ROWS / windowHeight;
! 223: return true;
! 224: }
! 225: } else if (event.type == SDL_MOUSEMOTION) {
! 226: // We don't want to return on a mouse motion event, because only the last
! 227: // in the queue is important. That's why we just set ret=true
! 228: int xcell = event.motion.x * COLS / windowWidth,
! 229: ycell = event.motion.y * ROWS / windowHeight;
! 230: if (xcell != mx || ycell != my) {
! 231: returnEvent->eventType = MOUSE_ENTERED_CELL;
! 232: returnEvent->param1 = xcell;
! 233: returnEvent->param2 = ycell;
! 234: mx = xcell;
! 235: my = ycell;
! 236: ret = true;
! 237: }
! 238: }
! 239: }
! 240:
! 241: return ret;
! 242: }
! 243:
! 244:
! 245: static void _gameLoop() {
! 246: #ifdef SDL_PATHS
! 247: char *path = SDL_GetBasePath();
! 248: if (path) {
! 249: path[strlen(path) - 1] = '\0'; // remove trailing separator
! 250: strcpy(dataDirectory, path);
! 251: } else {
! 252: fprintf(stderr, "Failed to find the path to the application\n");
! 253: exit(1);
! 254: }
! 255: free(path);
! 256:
! 257: path = SDL_GetPrefPath("Brogue", "Brogue CE");
! 258: if (!path || chdir(path) != 0) {
! 259: fprintf(stderr, "Failed to find or change to the save directory\n");
! 260: exit(1);
! 261: }
! 262: free(path);
! 263: #endif
! 264:
! 265: if (SDL_Init(SDL_INIT_VIDEO) < 0) sdlfatal(__FILE__, __LINE__);
! 266:
! 267: if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) imgfatal(__FILE__, __LINE__);
! 268:
! 269: initTiles();
! 270:
! 271: lastEvent.eventType = EVENT_ERROR;
! 272:
! 273: resizeWindow(windowWidth, windowHeight);
! 274:
! 275: rogueMain();
! 276:
! 277: SDL_Quit();
! 278: }
! 279:
! 280:
! 281: static boolean _pauseForMilliseconds(short ms) {
! 282: updateScreen();
! 283: SDL_Delay(ms);
! 284:
! 285: if (lastEvent.eventType != EVENT_ERROR
! 286: && lastEvent.eventType != MOUSE_ENTERED_CELL) {
! 287: return true; // SDL already gave us an interrupting event to process
! 288: }
! 289:
! 290: return pollBrogueEvent(&lastEvent, false) // ask SDL for a new event if one is available
! 291: && lastEvent.eventType != EVENT_ERROR // and check if it is interrupting
! 292: && lastEvent.eventType != MOUSE_ENTERED_CELL;
! 293: }
! 294:
! 295:
! 296: static void _nextKeyOrMouseEvent(rogueEvent *returnEvent, boolean textInput, boolean colorsDance) {
! 297: long tstart, dt;
! 298:
! 299: updateScreen();
! 300:
! 301: if (lastEvent.eventType != EVENT_ERROR) {
! 302: *returnEvent = lastEvent;
! 303: lastEvent.eventType = EVENT_ERROR;
! 304: return;
! 305: }
! 306:
! 307: while (true) {
! 308: tstart = SDL_GetTicks();
! 309:
! 310: if (colorsDance) {
! 311: shuffleTerrainColors(3, true);
! 312: commitDraws();
! 313: }
! 314:
! 315: updateScreen();
! 316:
! 317: if (pollBrogueEvent(returnEvent, textInput)) break;
! 318:
! 319: dt = PAUSE_BETWEEN_EVENT_POLLING - (SDL_GetTicks() - tstart);
! 320: if (dt > 0) {
! 321: SDL_Delay(dt);
! 322: }
! 323: }
! 324: }
! 325:
! 326:
! 327: /*
! 328: Returns the index of the sprite representing the given glyph. Sprites <256 are
! 329: from the text font sheet, 256+ are from the tiles sheet.
! 330: */
! 331: static int fontIndex(enum displayGlyph glyph) {
! 332: // These are the only non-ASCII glyphs which always come from the font sheet
! 333: if (glyph == G_UP_ARROW) return 0x90;
! 334: if (glyph == G_DOWN_ARROW) return 0x91;
! 335:
! 336: if (glyph < 128) {
! 337: // ASCII characters map directly
! 338: return glyph;
! 339: } else if (showGraphics && glyph >= 128) {
! 340: // Tile glyphs have sprite indices starting at 256
! 341: // -2 to disregard the up and down arrow glyphs
! 342: return glyph + 128 - 2;
! 343: } else {
! 344: unsigned int code = glyphToUnicode(glyph);
! 345: switch (code) {
! 346: case U_MIDDLE_DOT: return 0x80;
! 347: case U_FOUR_DOTS: return 0x81;
! 348: case U_DIAMOND: return 0x82;
! 349: case U_FLIPPED_V: return 0x83;
! 350: case U_ARIES: return 0x84;
! 351: case U_ESZETT: return 0xdf;
! 352: case U_ANKH: return 0x85;
! 353: case U_MUSIC_NOTE: return 0x86;
! 354: case U_CIRCLE: return 0x87;
! 355: case U_LIGHTNING_BOLT: return 0x99;
! 356: case U_FILLED_CIRCLE: return 0x89;
! 357: case U_NEUTER: return 0x8a;
! 358: case U_U_ACUTE: return 0xda;
! 359: case U_CURRENCY: return 0xa4;
! 360: case U_UP_ARROW: return 0x90;
! 361: case U_DOWN_ARROW: return 0x91;
! 362: case U_LEFT_ARROW: return 0x92;
! 363: case U_RIGHT_ARROW: return 0x93;
! 364: case U_OMEGA: return 0x96;
! 365: case U_CIRCLE_BARS: return 0x8c;
! 366: case U_FILLED_CIRCLE_BARS: return 0x8d;
! 367:
! 368: default:
! 369: brogueAssert(code < 256);
! 370: return code;
! 371: }
! 372: }
! 373: }
! 374:
! 375:
! 376: static void _plotChar(
! 377: enum displayGlyph inputChar,
! 378: short x, short y,
! 379: short foreRed, short foreGreen, short foreBlue,
! 380: short backRed, short backGreen, short backBlue
! 381: ) {
! 382: updateTile(y, x, fontIndex(inputChar),
! 383: foreRed, foreGreen, foreBlue,
! 384: backRed, backGreen, backBlue);
! 385: }
! 386:
! 387:
! 388: static void _remap(const char *from, const char *to) {
! 389: if (nremaps < MAX_REMAPS) {
! 390: remapping[nremaps].from = from[0];
! 391: remapping[nremaps].to = to[0];
! 392: nremaps++;
! 393: }
! 394: }
! 395:
! 396:
! 397: /*
! 398: * Take screenshot in current working directory (ScreenshotN.png)
! 399: */
! 400: static boolean _takeScreenshot() {
! 401: SDL_Surface *screenshot = captureScreen();
! 402: if (!screenshot) return false;
! 403:
! 404: // choose filename
! 405: char screenshotFilepath[BROGUE_FILENAME_MAX];
! 406: getAvailableFilePath(screenshotFilepath, "Screenshot", SCREENSHOT_SUFFIX);
! 407: strcat(screenshotFilepath, SCREENSHOT_SUFFIX);
! 408:
! 409: // save to PNG
! 410: IMG_SavePNG(screenshot, screenshotFilepath);
! 411: SDL_FreeSurface(screenshot);
! 412:
! 413: return true;
! 414: }
! 415:
! 416:
! 417: static boolean _setGraphicsEnabled(boolean state) {
! 418: showGraphics = state;
! 419: refreshScreen();
! 420: updateScreen();
! 421: return state;
! 422: }
! 423:
! 424:
! 425: struct brogueConsole sdlConsole = {
! 426: _gameLoop,
! 427: _pauseForMilliseconds,
! 428: _nextKeyOrMouseEvent,
! 429: _plotChar,
! 430: _remap,
! 431: _modifierHeld,
! 432: NULL,
! 433: _takeScreenshot,
! 434: _setGraphicsEnabled
! 435: };
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdl2-platform.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / platform