src/libsdl/sdl.c

   1 /* SDL handling
   2  *
   3  * (C) 2018 by Andreas Eversberg <jolly@eversberg.eu>
   4  * All Rights Reserved
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdint.h>
  22 #include <errno.h>
  23 #include "print.h"
  24 #include "sdl.h"
  25 #include "opengl.h"
  26
  27 #include <SDL2/SDL.h>
  28 #define GL3_PROTOTYPES 1
  29 #include <GL/glew.h>
  30
  31 static int sdl_initialized = 0;
  32 static int audio_initialized = 0;
  33 static const char *device_string = NULL;
  34 static SDL_AudioDeviceID audio_devid = 0;
  35 static SDL_Window *gl_window = NULL;
  36 static SDL_GLContext gl_context = NULL;
  37 static void (*keyboard_sdl)(int down, enum keycode keycode) = NULL;
  38 static void (*audio_sdl)(float *data, int len) = NULL;
  39 static void (*resize_window_sdl)(int width, int height) = NULL;
  40
  41 static void audio_cb(void __attribute__((unused)) *userdata, Uint8 *stream, int len)
  42 {
  43         float audio_data[len / sizeof(float)];
  44
  45         SDL_memset(stream, 0, len);
  46         audio_sdl(audio_data, len / sizeof(float) / 2);
  47         SDL_MixAudioFormat(stream, (Uint8 *)audio_data, AUDIO_F32, len, SDL_MIX_MAXVOLUME / 2.0);
  48 }
  49
  50 int init_sdl(const char *progname, int width, int height, int sound_samplerate, int sound_chunk, void (*keyboard)(int down, enum keycode keycode), void (*audio)(float *data, int len), void (*resize_window)(int width, int height), int multisampling, int vbl_sync, int rift)
  51 {
  52         int rc;
  53
  54         keyboard_sdl = keyboard;
  55         audio_sdl = audio;
  56         resize_window_sdl = resize_window;
  57
  58         /* init SDL library */
  59         rc = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
  60         if (rc < 0) {
  61                 print_error("Failed to init SDL\n");
  62                 goto error;
  63         }
  64         sdl_initialized = 1;
  65
  66         if (multisampling > 1) {
  67                 SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
  68                 SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
  69                 SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
  70                 SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
  71                 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
  72                 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
  73                 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, multisampling);
  74         }
  75
  76         /* open window */
  77         gl_window = SDL_CreateWindow(progname, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
  78         if (!gl_window) {
  79                 print_error("Failed to open SDL window: %s (try without multisampling)\n", SDL_GetError());
  80                 rc = EIO;
  81                 goto error;
  82         }
  83
  84         /* create GL context */
  85         gl_context = SDL_GL_CreateContext(gl_window);
  86         if (!gl_context) {
  87                 print_error("Failed to create SDL's OpenGL context: %s\n", SDL_GetError());
  88                 rc = EIO;
  89                 goto error;
  90         }
  91
  92         rc = SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
  93         if (rc < 0) {
  94                 print_error("Failed to set SDL's OpenGL context profile\n");
  95                 goto error;
  96         }
  97
  98         rc = SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
  99         if (rc < 0) {
 100                 print_error("Failed to set SDL's OpenGL major version\n");
 101                 goto error;
 102         }
 103         rc = SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
 104         if (rc < 0) {
 105                 print_error("Failed to set SDL's OpenGL minor version\n");
 106                 goto error;
 107         }
 108
 109         rc = SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 110         if (rc < 0) {
 111                 print_error("Failed to set SDL's OpenGL doublebuffer\n");
 112                 goto error;
 113         }
 114
 115         rc = SDL_GL_SetSwapInterval((vbl_sync) ? 1 : 0);
 116         if (rc < 0) {
 117                 print_error("Failed to set SDL's OpenGL swap interval to VBLANK\n");
 118                 // continue anyway
 119         }
 120
 121 // seems like a hack to me. do we need this?
 122 #ifndef __APPLE__
 123 #if !defined(_WIN32)
 124         glewExperimental = GL_TRUE;
 125         if (glewInit() != GLEW_OK) {
 126                 print_error("Failed to init GLEW\n");
 127                 goto error;
 128         }
 129 #endif
 130 #endif
 131
 132         /* just in case */
 133         glDisable(GL_DEPTH_TEST);
 134         glDisable(GL_CULL_FACE);
 135         if (multisampling > 1)
 136                 glEnable(GL_MULTISAMPLE);
 137
 138         if (rift) {
 139                 int i, count;
 140                 count = SDL_GetNumAudioDevices(0);
 141                 const char *string;
 142                 for(i = 0; i < count; i++) {
 143                         string = SDL_GetAudioDeviceName(i, 0);
 144                         if (strstr(string, "Rift"))
 145                                 device_string = string;
 146                 }
 147                 if (!device_string)
 148                         print_error("Oculus Rift headset not found, falling back to default audio device.\n");
 149         }
 150
 151         /* open audio */
 152         SDL_AudioSpec want, have;
 153         SDL_memset(&want, 0, sizeof(want)); /* or SDL_zero(want) */
 154         want.freq = sound_samplerate;
 155         want.format = AUDIO_F32; /* we always use float in this project */
 156         want.channels = 2;
 157         want.samples = sound_chunk; /* must be a power of two */
 158         want.callback = audio_cb;
 159         audio_devid = SDL_OpenAudioDevice(device_string, 0, &want, &have, SDL_AUDIO_ALLOW_ANY_CHANGE);
 160         if (audio_devid <= 0) {
 161                 print_error("Failed to open audio! (No speaker connected?)\n");
 162                 rc = -EIO;
 163                 goto error;
 164         } else if (have.format != want.format) {
 165                 print_error("Failed to open audio with desired audio format (want %d, got %d)\n", want.format, have.format);
 166                 rc = -EIO;
 167                 goto error;
 168         } else if (have.freq != want.freq) {
 169                 print_error("Failed to open audio with desired sample rate (want %d, got %d)\n", want.freq, have.freq);
 170                 rc = -EIO;
 171                 goto error;
 172         } else if (have.channels != want.channels) {
 173                 print_error("Failed to open audio with desired number of channels (want %d, got %d)\n", want.channels, have.channels);
 174                 rc = -EIO;
 175                 goto error;
 176         } else {
 177                 SDL_PauseAudioDevice(audio_devid, 0);
 178                 audio_initialized = 1;
 179         }
 180
 181         return 0;
 182
 183 error:
 184         exit_sdl();
 185         return rc;
 186 }
 187
 188 static enum keycode sdl2keycode(SDL_Keycode sym)
 189 {
 190         switch (sym) {
 191         case SDLK_LCTRL: return KEYCODE_LCTRL;
 192         case SDLK_RCTRL: return KEYCODE_RCTRL;
 193         case SDLK_LSHIFT: return KEYCODE_LSHIFT;
 194         case SDLK_RSHIFT: return KEYCODE_RSHIFT;
 195         case SDLK_PAUSE: return KEYCODE_PAUSE;
 196         case SDLK_LEFT: return KEYCODE_LEFT;
 197         case SDLK_RIGHT: return KEYCODE_RIGHT;
 198         case SDLK_UP: return KEYCODE_UP;
 199         case SDLK_DOWN: return KEYCODE_DOWN;
 200         case SDLK_END: return KEYCODE_END;
 201         case SDLK_a: return KEYCODE_a;
 202         case SDLK_b: return KEYCODE_b;
 203         case SDLK_c: return KEYCODE_c;
 204         case SDLK_d: return KEYCODE_d;
 205         case SDLK_e: return KEYCODE_e;
 206         case SDLK_f: return KEYCODE_f;
 207         case SDLK_g: return KEYCODE_g;
 208         case SDLK_h: return KEYCODE_h;
 209         case SDLK_i: return KEYCODE_i;
 210         case SDLK_j: return KEYCODE_j;
 211         case SDLK_k: return KEYCODE_k;
 212         case SDLK_l: return KEYCODE_l;
 213         case SDLK_m: return KEYCODE_m;
 214         case SDLK_n: return KEYCODE_n;
 215         case SDLK_o: return KEYCODE_o;
 216         case SDLK_p: return KEYCODE_p;
 217         case SDLK_q: return KEYCODE_q;
 218         case SDLK_r: return KEYCODE_r;
 219         case SDLK_s: return KEYCODE_s;
 220         case SDLK_t: return KEYCODE_t;
 221         case SDLK_u: return KEYCODE_u;
 222         case SDLK_v: return KEYCODE_v;
 223         case SDLK_w: return KEYCODE_w;
 224         case SDLK_x: return KEYCODE_x;
 225         case SDLK_y: return KEYCODE_y;
 226         case SDLK_z: return KEYCODE_z;
 227         case SDLK_0: return KEYCODE_0;
 228         case SDLK_1: return KEYCODE_1;
 229         case SDLK_2: return KEYCODE_2;
 230         case SDLK_3: return KEYCODE_3;
 231         case SDLK_4: return KEYCODE_4;
 232         case SDLK_5: return KEYCODE_5;
 233         case SDLK_6: return KEYCODE_6;
 234         case SDLK_7: return KEYCODE_7;
 235         case SDLK_8: return KEYCODE_8;
 236         case SDLK_9: return KEYCODE_9;
 237         case SDLK_KP_0: return KEYCODE_KP_0;
 238         case SDLK_KP_1: return KEYCODE_KP_1;
 239         case SDLK_KP_2: return KEYCODE_KP_2;
 240         case SDLK_KP_3: return KEYCODE_KP_3;
 241         case SDLK_KP_4: return KEYCODE_KP_4;
 242         case SDLK_KP_5: return KEYCODE_KP_5;
 243         case SDLK_KP_6: return KEYCODE_KP_6;
 244         case SDLK_KP_7: return KEYCODE_KP_7;
 245         case SDLK_KP_8: return KEYCODE_KP_8;
 246         case SDLK_KP_9: return KEYCODE_KP_9;
 247         case SDLK_KP_DIVIDE: return KEYCODE_KP_DIVIDE;
 248         case SDLK_KP_MULTIPLY: return KEYCODE_KP_MULTIPLY;
 249         case SDLK_KP_MINUS: return KEYCODE_KP_MINUS;
 250         case SDLK_KP_PLUS: return KEYCODE_KP_PLUS;
 251         case SDLK_KP_PERIOD: return KEYCODE_KP_PERIOD;
 252         case SDLK_F1: return KEYCODE_F1;
 253         case SDLK_F2: return KEYCODE_F2;
 254         case SDLK_F3: return KEYCODE_F3;
 255         case SDLK_F4: return KEYCODE_F4;
 256         case SDLK_F5: return KEYCODE_F5;
 257         case SDLK_F6: return KEYCODE_F6;
 258         case SDLK_F7: return KEYCODE_F7;
 259         case SDLK_F8: return KEYCODE_F8;
 260         case SDLK_F9: return KEYCODE_F9;
 261         case SDLK_F10: return KEYCODE_F10;
 262         case SDLK_SPACE: return KEYCODE_SPACE;
 263         case SDLK_BACKSPACE: return KEYCODE_BACKSPACE;
 264         case SDLK_TAB: return KEYCODE_TAB;
 265         case SDLK_KP_ENTER: return KEYCODE_KP_ENTER;
 266         case SDLK_RETURN: return KEYCODE_RETURN;
 267         case SDLK_ESCAPE: return KEYCODE_ESCAPE;
 268         case SDLK_DELETE: return KEYCODE_DELETE;
 269         case SDLK_INSERT: return KEYCODE_INSERT;
 270         default: return KEYCODE_UNDEFINED;
 271         }
 272 }
 273
 274 static int key_ctrl = 0, key_f = 0, fullscreen = 0;
 275
 276 int event_sdl(void)
 277 {
 278         int quit = 0;
 279         SDL_Event event;
 280
 281         while (SDL_PollEvent(&event)) {
 282                 if (event.type == SDL_QUIT)
 283                         quit = 1;
 284                 if (event.type == SDL_WINDOWEVENT) {
 285                         if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
 286                                 resize_window_sdl(event.window.data1, event.window.data2);
 287                 }
 288                 if (event.type == SDL_KEYDOWN) {
 289                         switch (event.key.keysym.sym) {
 290                         case SDLK_f:
 291                                 if (key_ctrl && !key_f) {
 292                                         if (fullscreen) {
 293                                                 fullscreen = 0;
 294                                                 SDL_SetWindowFullscreen(gl_window, 0);
 295                                                 SDL_ShowCursor(SDL_ENABLE);
 296                                         } else {
 297                                                 SDL_SetWindowFullscreen(gl_window, SDL_WINDOW_FULLSCREEN_DESKTOP);
 298                                                 SDL_ShowCursor(SDL_DISABLE);
 299                                                 fullscreen = 1;
 300                                         }
 301                                 }
 302                                 key_f = 1;
 303                                 break;
 304                         case SDLK_LCTRL:
 305                         case SDLK_RCTRL:
 306                                 key_ctrl = 1;
 307                                 break;
 308                         }
 309                         keyboard_sdl(1, sdl2keycode(event.key.keysym.sym));
 310                 }
 311                 if (event.type == SDL_KEYUP) {
 312                         switch (event.key.keysym.sym) {
 313                         case SDLK_LCTRL:
 314                         case SDLK_RCTRL:
 315                                 key_ctrl = 0;
 316                                 break;
 317                         case SDLK_f:
 318                                 key_f = 0;
 319                                 break;
 320                         }
 321                         keyboard_sdl(0, sdl2keycode(event.key.keysym.sym));
 322                 }
 323         }
 324
 325         return quit;
 326 }
 327
 328 void swap_sdl(void)
 329 {
 330         SDL_GL_SwapWindow(gl_window);
 331 }
 332
 333 void exit_sdl(void)
 334 {
 335         /* close window */
 336         if (gl_window) {
 337                 SDL_DestroyWindow(gl_window);
 338                 gl_window = NULL;
 339         }
 340
 341         /* clear OpenGL context */
 342         if (gl_context) {
 343                 SDL_GL_DeleteContext(gl_context);
 344                 gl_context = NULL;
 345         }
 346
 347         /* exit SDL library */
 348         if (audio_initialized) {
 349                 SDL_PauseAudioDevice(audio_devid, 1);
 350                 audio_initialized = 0;
 351         }
 352         if (audio_devid > 0) {
 353                 SDL_CloseAudioDevice(audio_devid);
 354                 audio_devid = 0;
 355         }
 356         if (sdl_initialized) {
 357                 SDL_Quit();
 358                 sdl_initialized = 0;
 359         }
 360 }
 361
 362 uint32_t ticks_sdl(void)
 363 {
 364         return SDL_GetTicks();
 365 }