src/Main/fg_os_sdl.cxx

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