src/Main/fg_os_sdl.cxx

   1 #include <stdlib.h>
   2
   3 #include <simgear/compiler.h>
   4 #include <simgear/structure/exception.hxx>
   5 #include <simgear/debug/logstream.hxx>
   6
   7 #include <SDL/SDL.h>
   8 #include <plib/pu.h>
   9
  10 #include "fg_os.hxx"
  11
  12 //
  13 // fg_os callback registration APIs
  14 //
  15
  16 static fgIdleHandler IdleHandler = 0;
  17 static fgDrawHandler DrawHandler = 0;
  18 static fgKeyHandler KeyHandler = 0;
  19 static fgMouseClickHandler MouseClickHandler = 0;
  20 static fgMouseMotionHandler MouseMotionHandler = 0;
  21
  22 static int CurrentModifiers = 0;
  23 static int CurrentMouseX = 0;
  24 static int CurrentMouseY = 0;
  25 static int CurrentMouseCursor = MOUSE_CURSOR_POINTER;
  26 static bool NeedRedraw = false;
  27
  28 void fgRegisterIdleHandler(fgIdleHandler func)
  29 {
  30     IdleHandler = func;
  31 }
  32
  33 void fgRegisterDrawHandler(fgDrawHandler func)
  34 {
  35     DrawHandler = func;
  36     NeedRedraw = true;
  37 }
  38
  39 void fgRegisterWindowResizeHandler(fgWindowResizeHandler func)
  40 {
  41     // Noop.  SDL does not support window resize.
  42 }
  43
  44 void fgRegisterKeyHandler(fgKeyHandler func)
  45 {
  46     KeyHandler = func;
  47 }
  48
  49 void fgRegisterMouseClickHandler(fgMouseClickHandler func)
  50 {
  51     MouseClickHandler = func;
  52 }
  53
  54 void fgRegisterMouseMotionHandler(fgMouseMotionHandler func)
  55 {
  56     MouseMotionHandler = func;
  57 }
  58
  59 //
  60 // fg_os implementation
  61 //
  62 static void initCursors();
  63
  64 void fgOSOpenWindow(int w, int h, int bpp,
  65                     bool alpha, bool stencil, bool fullscreen)
  66 {
  67     int cbits = (bpp <= 16) ?  5 :  8;
  68     int zbits = (bpp <= 16) ? 16 : 24;
  69
  70     if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) == -1)
  71         throw sg_throwable(string("Failed to initialize SDL: ")
  72                            + SDL_GetError());
  73
  74     SDL_WM_SetCaption("FlightGear", "FlightGear");
  75
  76     SDL_GL_SetAttribute(SDL_GL_RED_SIZE, cbits);
  77     SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, cbits);
  78     SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, cbits);
  79     if(alpha)
  80         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
  81     if(bpp > 16 && stencil)
  82         SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
  83     SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, zbits);
  84     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
  85
  86     int vidmask = SDL_OPENGL;
  87     if(fullscreen) {
  88         vidmask |= SDL_FULLSCREEN;
  89     }
  90     if (SDL_SetVideoMode(w, h, 16, vidmask) == 0)
  91         throw sg_throwable(string("Failed to set SDL video mode: ")
  92                                    + SDL_GetError());
  93
  94     // This enables keycode translation (e.g. capital letters when
  95     // shift is pressed, as well as i18n input methods).  Eventually,
  96     // we may want to port the input maps to specify <mod-shift>
  97     // explicitly, and will turn this off.
  98     SDL_EnableUNICODE(1);
  99     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
 100
 101     initCursors();
 102     fgSetMouseCursor(MOUSE_CURSOR_POINTER);
 103
 104     // FIXME: we may not get what we asked for (especially in full
 105     // screen modes), so these need to be propagated back to the
 106     // property tree for the rest of the code to inspect...
 107     //
 108     // SDL_Surface* screen = SDL_GetVideoSurface();
 109     // int realw = screen->w;
 110     // int realh = screen->h;
 111 }
 112
 113 static void handleKey(int key, int raw, int keyup)
 114 {
 115     int modmask = 0;
 116     switch(key) {
 117     case SDLK_RSHIFT: modmask = KEYMOD_SHIFT; break;
 118     case SDLK_LSHIFT: modmask = KEYMOD_SHIFT; break;
 119     case SDLK_RCTRL:  modmask = KEYMOD_CTRL;  break;
 120     case SDLK_LCTRL:  modmask = KEYMOD_CTRL;  break;
 121     case SDLK_RALT:   modmask = KEYMOD_ALT;   break;
 122     case SDLK_LALT:   modmask = KEYMOD_ALT;   break;
 123
 124     case SDLK_LEFT:     key = PU_KEY_LEFT;      break;
 125     case SDLK_UP:       key = PU_KEY_UP;        break;
 126     case SDLK_RIGHT:    key = PU_KEY_RIGHT;     break;
 127     case SDLK_DOWN:     key = PU_KEY_DOWN;      break;
 128     case SDLK_PAGEUP:   key = PU_KEY_PAGE_UP;   break;
 129     case SDLK_PAGEDOWN: key = PU_KEY_PAGE_DOWN; break;
 130     case SDLK_HOME:     key = PU_KEY_HOME;      break;
 131     case SDLK_END:      key = PU_KEY_END;       break;
 132     case SDLK_INSERT:   key = PU_KEY_INSERT;    break;
 133     case SDLK_F1:       key = PU_KEY_F1;        break;
 134     case SDLK_F2:       key = PU_KEY_F2;        break;
 135     case SDLK_F3:       key = PU_KEY_F3;        break;
 136     case SDLK_F4:       key = PU_KEY_F4;        break;
 137     case SDLK_F5:       key = PU_KEY_F5;        break;
 138     case SDLK_F6:       key = PU_KEY_F6;        break;
 139     case SDLK_F7:       key = PU_KEY_F7;        break;
 140     case SDLK_F8:       key = PU_KEY_F8;        break;
 141     case SDLK_F9:       key = PU_KEY_F9;        break;
 142     case SDLK_F10:      key = PU_KEY_F10;       break;
 143     case SDLK_F11:      key = PU_KEY_F11;       break;
 144     case SDLK_F12:      key = PU_KEY_F12;       break;
 145     }
 146
 147     // Keypad codes.  This is a situation where we *don't* want the
 148     // Unicode cooking for our input.  Oddly, neither PUI nor Glut
 149     // define these anywhere, so I lifted the numbers out of
 150     // FlightGear's keyboard.xml.  Some unused code are therefore
 151     // missing.
 152     switch(raw) {
 153     case SDLK_KP0:      key = 364; break;
 154     case SDLK_KP1:      key = 363; break;
 155     case SDLK_KP2:      key = 359; break;
 156     case SDLK_KP3:      key = 361; break;
 157     case SDLK_KP4:      key = 356; break;
 158     case SDLK_KP5:      key = 309; break;
 159     case SDLK_KP6:      key = 358; break;
 160     case SDLK_KP7:      key = 362; break;
 161     case SDLK_KP8:      key = 357; break;
 162     case SDLK_KP9:      key = 360; break;
 163     case SDLK_KP_ENTER: key = 269; break;
 164     }
 165
 166     int keymod = 0;
 167     if(keyup) {
 168         CurrentModifiers &= ~modmask;
 169         keymod = CurrentModifiers | KEYMOD_RELEASED;
 170     } else {
 171         CurrentModifiers |= modmask;
 172         keymod = CurrentModifiers & ~KEYMOD_RELEASED;
 173     }
 174     if(modmask == 0 && KeyHandler)
 175         (*KeyHandler)(key, keymod, CurrentMouseX, CurrentMouseY);
 176 }
 177
 178 // FIXME: need to export this and get the rest of FlightGear to use
 179 // it, the SDL hook is required to do things like reset the video
 180 // mode and key repeat.  Integrate with existing fgExit() in util.cxx.
 181 void fgOSExit(int code)
 182 {
 183     SDL_Quit();
 184     exit(code);
 185 }
 186
 187 void fgOSMainLoop()
 188 {
 189     while(1) {
 190         SDL_Event e;
 191         int key;
 192         while(SDL_PollEvent(&e)) {
 193             switch(e.type) {
 194             case SDL_QUIT:
 195                 fgOSExit(0);
 196                 break;
 197             case SDL_KEYDOWN:
 198             case SDL_KEYUP:
 199                 key = e.key.keysym.unicode;
 200                 if(key == 0) key = e.key.keysym.sym;
 201                 handleKey(key, e.key.keysym.sym, e.key.state == SDL_RELEASED);
 202                 break;
 203             case SDL_MOUSEBUTTONDOWN:
 204             case SDL_MOUSEBUTTONUP:
 205                 // Note offset: SDL uses buttons 1,2,3 not 0,1,2
 206                 CurrentMouseX = e.button.x;
 207                 CurrentMouseY = e.button.y;
 208                 if(MouseClickHandler)
 209                     (*MouseClickHandler)(e.button.button - 1,
 210                                          e.button.state == SDL_RELEASED,
 211                                          e.button.x, e.button.y);
 212                 break;
 213             case SDL_MOUSEMOTION:
 214                 CurrentMouseX = e.motion.x;
 215                 CurrentMouseY = e.motion.y;
 216                 if(MouseMotionHandler)
 217                     (*MouseMotionHandler)(e.motion.x, e.motion.y);
 218                 break;
 219             }
 220         }
 221         if(IdleHandler) (*IdleHandler)();
 222         if(NeedRedraw && DrawHandler) {
 223             (*DrawHandler)();
 224             SDL_GL_SwapBuffers();
 225             NeedRedraw = false;
 226         }
 227     }
 228 }
 229
 230 int fgGetKeyModifiers()
 231 {
 232     return CurrentModifiers;
 233 }
 234
 235 void fgWarpMouse(int x, int y)
 236 {
 237     SDL_WarpMouse(x, y);
 238 }
 239
 240 void fgRequestRedraw()
 241 {
 242     NeedRedraw = true;
 243 }
 244
 245 void fgOSInit(int* argc, char** argv)
 246 {
 247     // Nothing to do here.  SDL has no command line options.
 248 }
 249
 250 void fgOSFullScreen()
 251 {
 252     // Noop.  SDL must set fullscreen at window open time and cannot
 253     // change modes.
 254 }
 255
 256 static struct cursor_rec {
 257     int name;
 258     SDL_Cursor* sdlCursor;
 259     int w;
 260     int h;
 261     int hotx;
 262     int hoty;
 263     char *img[32]; // '.' == white, '#' == black, ' ' == transparent
 264 } cursors[] = {
 265     { MOUSE_CURSOR_POINTER, 0, // must be first!
 266       10, 16, 1, 1,
 267       { "..        ",
 268         ".#.       ",
 269         ".##.      ",
 270         ".###.     ",
 271         ".####.    ",
 272         ".#####.   ",
 273         ".######.  ",
 274         ".#######. ",
 275         ".########.",
 276         ".#####....",
 277         ".##.##.   ",
 278         ".#. .##.  ",
 279         "..  .##.  ",
 280         "     .##. ",
 281         "     .##. ",
 282         "      ..  " } },
 283     { MOUSE_CURSOR_CROSSHAIR, 0,
 284       17, 17, 8, 8,
 285       { "       ...       ",
 286         "       .#.       ",
 287         "       .#.       ",
 288         "       .#.       ",
 289         "       .#.       ",
 290         "       .#.       ",
 291         "       .#.       ",
 292         "........#........",
 293         ".#######.#######.",
 294         "........#........",
 295         "       .#.       ",
 296         "       .#.       ",
 297         "       .#.       ",
 298         "       .#.       ",
 299         "       .#.       ",
 300         "       .#.       ",
 301         "       ...       " } },
 302     { MOUSE_CURSOR_WAIT, 0,
 303       16, 16, 7, 7,
 304       { "  .########.    ",
 305         "  .########.    ",
 306         "  .########.    ",
 307         " .##########.   ",
 308         ".##....#...##.  ",
 309         "##.....#....##..",
 310         "#......#.....###",
 311         "#.....###....###",
 312         "#.....###....###",
 313         "#....#.......###",
 314         "##..#.......##..",
 315         ".##........##.  ",
 316         " .##########.   ",
 317         "  .########.    ",
 318         "  .########.    ",
 319         "  .########.    " } },
 320     { MOUSE_CURSOR_LEFTRIGHT, 0,
 321       17, 9, 8, 4,
 322       { "    ..     ..    ",
 323         "   .#.     .#.   ",
 324         "  .##.......##.  ",
 325         " .#############. ",
 326         ".####.......####.",
 327         " .#############. ",
 328         "  .##.......##.  ",
 329         "   .#.     .#.   ",
 330         "    ..     ..    " } },
 331     { MOUSE_CURSOR_NONE, 0, // must come last!
 332       1, 1, 0, 0, { " " } },
 333 };
 334
 335 #define NCURSORS (sizeof(cursors)/sizeof(struct cursor_rec))
 336
 337 void fgSetMouseCursor(int cursor)
 338 {
 339     if(cursor == MOUSE_CURSOR_NONE) {
 340         SDL_ShowCursor(SDL_DISABLE);
 341         return;
 342     }
 343     SDL_ShowCursor(SDL_ENABLE);
 344     for(int i=0; i<NCURSORS; i++) {
 345         if(cursor == cursors[i].name) {
 346             CurrentMouseCursor = cursor;
 347             SDL_SetCursor(cursors[i].sdlCursor);
 348             return;
 349         }
 350     }
 351     // Default to pointer
 352     CurrentMouseCursor = MOUSE_CURSOR_POINTER;
 353     SDL_SetCursor(cursors[0].sdlCursor);
 354 }
 355
 356 int fgGetMouseCursor()
 357 {
 358     return CurrentMouseCursor;
 359 }
 360
 361 static void initCursors()
 362 {
 363     unsigned char mask[128], img[128];
 364     int i=0;
 365     for(int i=0; i<NCURSORS; i++) {
 366         if(cursors[i].name == MOUSE_CURSOR_NONE) break;
 367         for(int j=0; j<128; j++) mask[j] = img[j] = 0;
 368         for(int y=0; y<cursors[i].h; y++) {
 369             for(int x=0; x<cursors[i].w; x++) {
 370                 int byte = (4 * y) + (x >> 3);
 371                 int bit = 1 << (7 - (x & 7));
 372                 int pix = cursors[i].img[y][x];
 373                 if(pix != ' ') { mask[byte] |= bit; }
 374                 if(pix == '#') { img[byte] |= bit; }
 375             }
 376         }
 377         cursors[i].sdlCursor = SDL_CreateCursor(img, mask, 32, 32,
 378                                                 cursors[i].hotx,
 379                                                 cursors[i].hoty);
 380     }
 381 }