void Window_InitializeVideo(void) { int iFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN; SDL_Surface *sIcon; // [28/7/2013] Moved check here and corrected, seems more secure ~hogsy if (SDL_VideoInit(NULL) < 0) Sys_Error("Failed to initialize video!\n%s\n", SDL_GetError()); SDL_DisableScreenSaver(); // Get display information. if (SDL_GetCurrentDisplayMode(0, &sDisplayMode) != 0) Sys_Error("Failed to get current display information!\n%s\n", SDL_GetError()); if (!Video.fullscreen) iFlags &= ~SDL_WINDOW_FULLSCREEN; #if 0 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); #endif SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8); #if 0 SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 8); #endif SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); sMainWindow = SDL_CreateWindow( Game->Name, // [9/7/2013] Window name is based on the name given by Game ~hogsy SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Video.iWidth, Video.iHeight, iFlags); if (!sMainWindow) Sys_Error("Failed to create window!\n%s\n", SDL_GetError()); // Attempt to grab the window icon from the game directory. sIcon = SDL_LoadBMP(va("%s/icon.bmp", com_gamedir)); if (sIcon) { // [25/3/2014] Set the transparency key... ~hogsy SDL_SetColorKey(sIcon, true, SDL_MapRGB(sIcon->format, 0, 0, 0)); SDL_SetWindowIcon(sMainWindow, sIcon); SDL_FreeSurface(sIcon); } else // Give us a warning, but continue. Con_Warning("Failed to load window icon! (%s)\n", SDL_GetError()); sMainContext = SDL_GL_CreateContext(sMainWindow); if (!sMainContext) Sys_Error("Failed to create context!\n%s\n", SDL_GetError()); SDL_GL_SetSwapInterval(0); #ifdef _WIN32 if (SDL_GetWindowWMInfo(sMainWindow, &sSystemInfo)) g_mainwindow.instance = sSystemInfo.info.win.window; else Con_Warning("Failed to get WM information! (%s)\n", SDL_GetError()); #endif }
int SDL_InitSubSystem(Uint32 flags) { #if !SDL_VIDEO_DISABLED /* Initialize the video/event subsystem */ if ( (flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO) ) { if ( SDL_VideoInit(SDL_getenv("SDL_VIDEODRIVER"), (flags&SDL_INIT_EVENTTHREAD)) < 0 ) { return(-1); } SDL_initialized |= SDL_INIT_VIDEO; } #else if ( flags & SDL_INIT_VIDEO ) { SDL_SetError("SDL not built with video support"); return(-1); } #endif #if !SDL_AUDIO_DISABLED /* Initialize the audio subsystem */ if ( (flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO) ) { if ( SDL_AudioInit(SDL_getenv("SDL_AUDIODRIVER")) < 0 ) { return(-1); } SDL_initialized |= SDL_INIT_AUDIO; } #else if ( flags & SDL_INIT_AUDIO ) { SDL_SetError("SDL not built with audio support"); return(-1); } #endif #if !SDL_TIMERS_DISABLED /* Initialize the timer subsystem */ if ( ! ticks_started ) { SDL_StartTicks(); ticks_started = 1; } if ( (flags & SDL_INIT_TIMER) && !(SDL_initialized & SDL_INIT_TIMER) ) { if ( SDL_TimerInit() < 0 ) { return(-1); } SDL_initialized |= SDL_INIT_TIMER; } #else if ( flags & SDL_INIT_TIMER ) { SDL_SetError("SDL not built with timer support"); return(-1); } #endif #if !SDL_JOYSTICK_DISABLED /* Initialize the joystick subsystem */ if ( (flags & SDL_INIT_JOYSTICK) && !(SDL_initialized & SDL_INIT_JOYSTICK) ) { if ( SDL_JoystickInit() < 0 ) { return(-1); } SDL_initialized |= SDL_INIT_JOYSTICK; } #else if ( flags & SDL_INIT_JOYSTICK ) { SDL_SetError("SDL not built with joystick support"); return(-1); } #endif #if !SDL_CDROM_DISABLED /* Initialize the CD-ROM subsystem */ if ( (flags & SDL_INIT_CDROM) && !(SDL_initialized & SDL_INIT_CDROM) ) { if ( SDL_CDROMInit() < 0 ) { return(-1); } SDL_initialized |= SDL_INIT_CDROM; } #else if ( flags & SDL_INIT_CDROM ) { SDL_SetError("SDL not built with cdrom support"); return(-1); } #endif return(0); }
int SDL_InitSubSystem(Uint32 flags) { if (!SDL_MainIsReady) { SDL_SetError("Application didn't initialize properly, did you include SDL_main.h in the file containing your main() function?"); return -1; } /* Clear the error message */ SDL_ClearError(); #if SDL_VIDEO_DRIVER_WINDOWS if ((flags & (SDL_INIT_HAPTIC|SDL_INIT_JOYSTICK))) { if (SDL_HelperWindowCreate() < 0) { return -1; } } #endif #if !SDL_TIMERS_DISABLED SDL_TicksInit(); #endif if ((flags & SDL_INIT_GAMECONTROLLER)) { /* game controller implies joystick */ flags |= SDL_INIT_JOYSTICK; } if ((flags & (SDL_INIT_VIDEO|SDL_INIT_JOYSTICK))) { /* video or joystick implies events */ flags |= SDL_INIT_EVENTS; } /* Initialize the event subsystem */ if ((flags & SDL_INIT_EVENTS)) { #if !SDL_EVENTS_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_EVENTS)) { if (SDL_StartEventLoop() < 0) { return (-1); } SDL_QuitInit(); } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_EVENTS); #else return SDL_SetError("SDL not built with events support"); #endif } /* Initialize the timer subsystem */ if ((flags & SDL_INIT_TIMER)){ #if !SDL_TIMERS_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_TIMER)) { if (SDL_TimerInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_TIMER); #else return SDL_SetError("SDL not built with timer support"); #endif } /* Initialize the video subsystem */ if ((flags & SDL_INIT_VIDEO)){ #if !SDL_VIDEO_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_VIDEO)) { if (SDL_VideoInit(NULL) < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_VIDEO); #else return SDL_SetError("SDL not built with video support"); #endif } /* Initialize the audio subsystem */ if ((flags & SDL_INIT_AUDIO)){ #if !SDL_AUDIO_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_AUDIO)) { if (SDL_AudioInit(NULL) < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_AUDIO); #else return SDL_SetError("SDL not built with audio support"); #endif } /* Initialize the joystick subsystem */ if ((flags & SDL_INIT_JOYSTICK)){ #if !SDL_JOYSTICK_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_JOYSTICK)) { if (SDL_JoystickInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_JOYSTICK); #else return SDL_SetError("SDL not built with joystick support"); #endif } if ((flags & SDL_INIT_GAMECONTROLLER)){ #if !SDL_JOYSTICK_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_GAMECONTROLLER)) { if (SDL_GameControllerInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_GAMECONTROLLER); #else return SDL_SetError("SDL not built with joystick support"); #endif } /* Initialize the haptic subsystem */ if ((flags & SDL_INIT_HAPTIC)){ #if !SDL_HAPTIC_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_HAPTIC)) { if (SDL_HapticInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_HAPTIC); #else return SDL_SetError("SDL not built with haptic (force feedback) support"); #endif } return (0); }
int audio_Init(void (*samplecallback)(void*, unsigned int), unsigned int buffersize, const char* backend, int s16, char** error) { #ifndef USE_SDL_GRAPHICS if (!sdlvideoinit) { if (SDL_VideoInit(NULL) < 0) { char errormsg[512]; snprintf(errormsg,sizeof(errormsg), "Failed to initialize SDL video: %s", SDL_GetError()); errormsg[sizeof(errormsg)-1] = 0; *error = strdup(errormsg); return 0; } sdlvideoinit = 1; } #endif if (soundenabled) { // quit old sound first SDL_PauseAudio(1); SDL_AudioQuit(); soundenabled = 0; } #ifdef ANDROID if (!s16) { *error = strdup("No 32bit float audio available on Android"); return 0; } #endif if (!samplecallback) { *error = strdup("Need sample callback"); return 0; } char errbuf[512]; char preferredbackend[20] = ""; #ifdef WINDOWS if (backend && strcasecmp(backend, "waveout") == 0) { strcpy(preferredbackend, "waveout"); } if (backend && (strcasecmp(backend, "directsound") == 0 || strcasecmp(backend, "dsound") == 0)) { strcpy(preferredbackend, "directsound"); } #else #ifdef LINUX if (backend && strcasecmp(backend, "alsa") == 0) { strcpy(preferredbackend, "alsa"); } if (backend && (strcasecmp(backend, "oss") == 0 || strcasecmp(backend, "dsp") == 0)) { strcpy(preferredbackend, "dsp"); } #endif #endif const char* b = preferredbackend; if (strlen(b) <= 0) { b = NULL; } if (SDL_AudioInit(b) < 0) { snprintf(errbuf,sizeof(errbuf),"Failed to initialize SDL audio: %s", SDL_GetError()); errbuf[sizeof(errbuf)-1] = 0; *error = strdup(errbuf); return 0; } SDL_AudioSpec fmt,actualfmt; int custombuffersize = DEFAULTSOUNDBUFFERSIZE; if (buffersize > 0) { if (buffersize < MINSOUNDBUFFERSIZE) { buffersize = MINSOUNDBUFFERSIZE; } if (buffersize > MAXSOUNDBUFFERSIZE) { buffersize = MAXSOUNDBUFFERSIZE; } custombuffersize = buffersize; } memset(&fmt,0,sizeof(fmt)); fmt.freq = 48000; if (!s16) { fmt.format = AUDIO_F32SYS; }else{ fmt.format = AUDIO_S16; } fmt.channels = 2; fmt.samples = custombuffersize; fmt.callback = audiocallback; fmt.userdata = NULL; samplecallbackptr = samplecallback; if (SDL_OpenAudio(&fmt, &actualfmt) < 0) { snprintf(errbuf,sizeof(errbuf),"Failed to open SDL audio: %s", SDL_GetError()); errbuf[sizeof(errbuf)-1] = 0; *error = strdup(errbuf); // FIXME: this is a workaround for http:// bugzilla.libsdl.org/show_bug.cgi?id=1343 (will cause a memory leak!) // SDL_AudioQuit(); return 0; } if (actualfmt.channels != 2 || actualfmt.freq != 48000 || (s16 && actualfmt.format != AUDIO_S16) || (!s16 && actualfmt.format != AUDIO_F32SYS)) { *error = strdup("SDL audio delivered wrong/unusable format"); // FIXME: this is a workaround for http:// bugzilla.libsdl.org/show_bug.cgi?id=1343 (will cause a memory leak!) // SDL_AudioQuit(); return 0; } soundenabled = 1; SDL_PauseAudio(0); return 1; }
int SDL_InitSubSystem(Uint32 flags) { #if !SDL_TIMERS_DISABLED if (!ticks_started) { SDL_StartTicks(); ticks_started = 1; } #endif /* Initialize the timer subsystem */ if ((flags & SDL_INIT_TIMER) ){ #if !SDL_TIMERS_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_TIMER)) { if (SDL_TimerInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_TIMER); #else SDL_SetError("SDL not built with timer support"); return (-1); #endif } /* Initialize the video/event subsystem */ if ((flags & SDL_INIT_VIDEO) ){ #if !SDL_VIDEO_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_VIDEO)) { if (SDL_VideoInit(NULL) < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_VIDEO); #else SDL_SetError("SDL not built with video support"); return (-1); #endif } /* Initialize the audio subsystem */ if ((flags & SDL_INIT_AUDIO) ){ #if !SDL_AUDIO_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_AUDIO)) { if (SDL_AudioInit(NULL) < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_AUDIO); #else SDL_SetError("SDL not built with audio support"); return (-1); #endif } if ((flags & SDL_INIT_GAMECONTROLLER)) { // Game controller implies Joystick. flags |= SDL_INIT_JOYSTICK; } /* Initialize the joystick subsystem */ if ((flags & SDL_INIT_JOYSTICK) ){ #if !SDL_JOYSTICK_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_JOYSTICK)) { if (SDL_JoystickInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_JOYSTICK); #else SDL_SetError("SDL not built with joystick support"); return (-1); #endif } if ((flags & SDL_INIT_GAMECONTROLLER) ){ #if !SDL_JOYSTICK_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_GAMECONTROLLER)) { if (SDL_GameControllerInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_GAMECONTROLLER); #else SDL_SetError("SDL not built with joystick support"); return (-1); #endif } /* Initialize the haptic subsystem */ if ((flags & SDL_INIT_HAPTIC) ){ #if !SDL_HAPTIC_DISABLED if (SDL_PrivateShouldInitSubsystem(SDL_INIT_HAPTIC)) { if (SDL_HapticInit() < 0) { return (-1); } } SDL_PrivateSubsystemRefCountIncr(SDL_INIT_HAPTIC); #else SDL_SetError("SDL not built with haptic (force feedback) support"); return (-1); #endif } return (0); }
bool ZL_CreateWindow(const char* windowtitle, int width, int height, int displayflags) { #if (defined(_MSC_VER) && !defined(WINAPI_FAMILY)) //if compiler errors, enum ZL_WindowFlags does not map to enum SDL_WindowFlags enum { __asrt = 1/(int)(ZL_WINDOW_FULLSCREEN==SDL_WINDOW_FULLSCREEN&&ZL_WINDOW_MINIMIZED==SDL_WINDOW_MINIMIZED&&ZL_WINDOW_RESIZABLE==SDL_WINDOW_RESIZABLE) }; #endif Uint32 windowflags = SDL_WINDOW_OPENGL; // | SDL_WINDOW_SHOWN; if (displayflags & ZL_DISPLAY_FULLSCREEN) windowflags |= SDL_WINDOW_FULLSCREEN; if (displayflags & ZL_DISPLAY_RESIZABLE) windowflags |= SDL_WINDOW_RESIZABLE; if (SDL_VideoInit(NULL) < 0) { ZL_SDL_ShowError("Could not initialize video display"); return false; } //limit window size to desktop resolution of primary display (if data can be acquired via SDL) SDL_DisplayMode DesktopMode = { 0, 0, 0, 0, 0 }; SDL_GetDesktopDisplayMode(0, &DesktopMode); if (DesktopMode.w) { if (DesktopMode.w > 500 && width > DesktopMode.w) width = DesktopMode.w; if (DesktopMode.h > 400 && height > DesktopMode.h) height = DesktopMode.h; } SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, (displayflags & ZL_DISPLAY_DEPTHBUFFER ? 16 : 0)); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); // should enable 4x AA if possible SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); //SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2); ZL_SDL_Window = SDL_CreateWindow(windowtitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, windowflags); if (!ZL_SDL_Window) { SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0); ZL_SDL_Window = SDL_CreateWindow(windowtitle, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, windowflags); if (!ZL_SDL_Window) { ZL_SDL_ShowError("Could not create OpenGL window"); return false; } } if (!SDL_GL_CreateContext(ZL_SDL_Window)) { ZL_SDL_ShowError("Could not initialize OpenGL context"); return false; } glClear(GL_COLOR_BUFFER_BIT); SDL_GL_SwapWindow(ZL_SDL_Window); if (ZL_Requested_FPS < 0) ZL_MainApplication->SetFpsLimit(DesktopMode.refresh_rate > 0 ? (unsigned short)DesktopMode.refresh_rate : 60); else ZL_UpdateTPFLimit(); //const GLubyte* pstrGlVendor = glGetString(GL_VENDOR); //if (pstrGlVendor[0] == 'A' && pstrGlVendor[1] == 'T' && pstrGlVendor[2] == 'I') ZL_MainApplicationFlags |= ZL_APPLICATION_VSYNCHACK; //printf("Vendor: %s\n", glGetString(GL_VENDOR)); //printf("Renderer: %s\n", glGetString(GL_RENDERER)); //printf("Version: %s\n", glGetString(GL_VERSION)); //printf("GLSL: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); //printf("Extensions : %s\n", glGetString(GL_EXTENSIONS)); //printf("\n"); InitExtensionEntries(); /* #ifndef __MACOSX__ printf("glDeleteBuffers = %d\n", (glDeleteBuffers ? 1 : 0)); printf("glCreateShader = %d\n", (glCreateShader ? 1 : 0)); printf("glCompileShader = %d\n", (glCompileShader ? 1 : 0)); printf("glCreateProgram = %d\n", (glCreateProgram ? 1 : 0)); printf("glLinkProgram = %d\n", (glLinkProgram ? 1 : 0)); printf("glUseProgram = %d\n", (glUseProgram ? 1 : 0)); printf("glBindAttribLocation = %d\n", (glBindAttribLocation ? 1 : 0)); printf("glVertexAttribPointer = %d\n", (glVertexAttribPointer ? 1 : 0)); printf("glVertexAttrib4fv = %d\n", (glVertexAttrib4fv ? 1 : 0)); printf("glUniform1f = %d\n", (glUniform1f ? 1 : 0)); printf("glIsProgram = %d\n", (glIsProgram ? 1 : 0)); #if !defined(ZL_DOUBLE_PRECISCION) printf("glUniformMatrix4fv = %d\n", (glUniformMatrix4fv ? 1 : 0)); #else #endif #ifndef GL_ATI_blend_equation_separate printf("glBlendEquation = %d\n", (glBlendEquation ? 1 : 0)); #endif #endif printf("glGenFramebuffers = %d\n", (glGenFramebuffers ? 1 : 0)); printf("glDeleteFramebuffers = %d\n", (glDeleteFramebuffers ? 1 : 0)); printf("glBindFramebuffer = %d\n", (glBindFramebuffer ? 1 : 0)); printf("glFramebufferTexture2D = %d\n", (glFramebufferTexture2D? 1 : 0)); printf("\n"); */ pZL_WindowFlags = (unsigned int*)&ZL_SDL_Window->flags; return true; }
SDL_bool CommonInit(CommonState * state) { int i, j, m, n; SDL_DisplayMode fullscreen_mode; if (state->flags & SDL_INIT_VIDEO) { if (state->verbose & VERBOSE_VIDEO) { n = SDL_GetNumVideoDrivers(); if (n == 0) { fprintf(stderr, "No built-in video drivers\n"); } else { fprintf(stderr, "Built-in video drivers:"); for (i = 0; i < n; ++i) { if (i > 0) { fprintf(stderr, ","); } fprintf(stderr, " %s", SDL_GetVideoDriver(i)); } fprintf(stderr, "\n"); } } if (SDL_VideoInit(state->videodriver, 0) < 0) { fprintf(stderr, "Couldn't initialize video driver: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_VIDEO) { fprintf(stderr, "Video driver: %s\n", SDL_GetCurrentVideoDriver()); } /* Upload GL settings */ SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size); SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size); SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size); SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples); if (state->gl_accelerated >= 0) { SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, state->gl_accelerated); } SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version); if (state->verbose & VERBOSE_MODES) { SDL_DisplayMode mode; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; n = SDL_GetNumVideoDisplays(); fprintf(stderr, "Number of displays: %d\n", n); for (i = 0; i < n; ++i) { fprintf(stderr, "Display %d:\n", i); SDL_SelectVideoDisplay(i); SDL_GetDesktopDisplayMode(&mode); SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); fprintf(stderr, " Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n", mode.w, mode.h, mode.refresh_rate, bpp, PixelFormatToString(mode.format)); if (Rmask || Gmask || Bmask) { fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask); fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask); fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask); if (Amask) fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask); } /* Print available fullscreen video modes */ m = SDL_GetNumDisplayModes(); if (m == 0) { fprintf(stderr, "No available fullscreen video modes\n"); } else { fprintf(stderr, " Fullscreen video modes:\n"); for (j = 0; j < m; ++j) { SDL_GetDisplayMode(j, &mode); SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask, &Amask); fprintf(stderr, " Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n", j, mode.w, mode.h, mode.refresh_rate, bpp, PixelFormatToString(mode.format)); if (Rmask || Gmask || Bmask) { fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask); fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask); fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask); if (Amask) fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask); } } } } } SDL_SelectVideoDisplay(state->display); if (state->verbose & VERBOSE_RENDER) { SDL_RendererInfo info; n = SDL_GetNumRenderDrivers(); if (n == 0) { fprintf(stderr, "No built-in render drivers\n"); } else { fprintf(stderr, "Built-in render drivers:\n"); for (i = 0; i < n; ++i) { SDL_GetRenderDriverInfo(i, &info); PrintRenderer(&info); } } } SDL_zero(fullscreen_mode); switch (state->depth) { case 8: fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8; break; case 15: fullscreen_mode.format = SDL_PIXELFORMAT_RGB555; break; case 16: fullscreen_mode.format = SDL_PIXELFORMAT_RGB565; break; case 24: fullscreen_mode.format = SDL_PIXELFORMAT_RGB24; break; default: fullscreen_mode.format = SDL_PIXELFORMAT_RGB888; break; } fullscreen_mode.refresh_rate = state->refresh_rate; state->windows = (SDL_Window **) SDL_malloc(state->num_windows * sizeof(*state->windows)); if (!state->windows) { fprintf(stderr, "Out of memory!\n"); return SDL_FALSE; } for (i = 0; i < state->num_windows; ++i) { char title[1024]; if (state->num_windows > 1) { SDL_snprintf(title, SDL_arraysize(title), "%s %d", state->window_title, i + 1); } else { SDL_strlcpy(title, state->window_title, SDL_arraysize(title)); } state->windows[i] = SDL_CreateWindow(title, state->window_x, state->window_y, state->window_w, state->window_h, state->window_flags); if (!state->windows[i]) { fprintf(stderr, "Couldn't create window: %s\n", SDL_GetError()); return SDL_FALSE; } if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) { fprintf(stderr, "Can't set up fullscreen display mode: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->window_icon) { SDL_Surface *icon = LoadIcon(state->window_icon); if (icon) { SDL_SetWindowIcon(state->windows[i], icon); SDL_FreeSurface(icon); } } SDL_ShowWindow(state->windows[i]); if (!state->skip_renderer && (state->renderdriver || !(state->window_flags & SDL_WINDOW_OPENGL))) { m = -1; if (state->renderdriver) { SDL_RendererInfo info; n = SDL_GetNumRenderDrivers(); for (j = 0; j < n; ++j) { SDL_GetRenderDriverInfo(j, &info); if (SDL_strcasecmp(info.name, state->renderdriver) == 0) { m = j; break; } } if (m == n) { fprintf(stderr, "Couldn't find render driver named %s", state->renderdriver); return SDL_FALSE; } } if (SDL_CreateRenderer (state->windows[i], m, state->render_flags) < 0) { fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_RENDER) { SDL_RendererInfo info; fprintf(stderr, "Current renderer:\n"); SDL_GetRendererInfo(&info); PrintRenderer(&info); } } } SDL_SelectRenderer(state->windows[0]); } if (state->flags & SDL_INIT_AUDIO) { if (state->verbose & VERBOSE_AUDIO) { n = SDL_GetNumAudioDrivers(); if (n == 0) { fprintf(stderr, "No built-in audio drivers\n"); } else { fprintf(stderr, "Built-in audio drivers:"); for (i = 0; i < n; ++i) { if (i > 0) { fprintf(stderr, ","); } fprintf(stderr, " %s", SDL_GetAudioDriver(i)); } fprintf(stderr, "\n"); } } if (SDL_AudioInit(state->audiodriver) < 0) { fprintf(stderr, "Couldn't initialize audio driver: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->verbose & VERBOSE_VIDEO) { fprintf(stderr, "Audio driver: %s\n", SDL_GetCurrentAudioDriver()); } if (SDL_OpenAudio(&state->audiospec, NULL) < 0) { fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError()); return SDL_FALSE; } } return SDL_TRUE; }
int SDL_InitSubSystem(Uint32 flags) { #if !SDL_VIDEO_DISABLED /* Initialize the video/event subsystem */ if ((flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO)) { if (SDL_VideoInit(NULL, (flags & SDL_INIT_EVENTTHREAD)) < 0) { return (-1); } SDL_initialized |= SDL_INIT_VIDEO; } #else if (flags & SDL_INIT_VIDEO) { SDL_SetError("SDL not built with video support"); return (-1); } #endif #if !SDL_AUDIO_DISABLED /* Initialize the audio subsystem */ if ((flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO)) { if (SDL_AudioInit(NULL) < 0) { return (-1); } SDL_initialized |= SDL_INIT_AUDIO; } #else if (flags & SDL_INIT_AUDIO) { SDL_SetError("SDL not built with audio support"); return (-1); } #endif #if !SDL_TIMERS_DISABLED /* Initialize the timer subsystem */ if (!ticks_started) { SDL_StartTicks(); ticks_started = 1; } if ((flags & SDL_INIT_TIMER) && !(SDL_initialized & SDL_INIT_TIMER)) { if (SDL_TimerInit() < 0) { return (-1); } SDL_initialized |= SDL_INIT_TIMER; } #else if (flags & SDL_INIT_TIMER) { SDL_SetError("SDL not built with timer support"); return (-1); } #endif #if !SDL_JOYSTICK_DISABLED /* Initialize the joystick subsystem */ if ((flags & SDL_INIT_JOYSTICK) && !(SDL_initialized & SDL_INIT_JOYSTICK)) { if (SDL_JoystickInit() < 0) { return (-1); } SDL_initialized |= SDL_INIT_JOYSTICK; } #else if (flags & SDL_INIT_JOYSTICK) { SDL_SetError("SDL not built with joystick support"); return (-1); } #endif #if !SDL_HAPTIC_DISABLED /* Initialize the haptic subsystem */ if ((flags & SDL_INIT_HAPTIC) && !(SDL_initialized & SDL_INIT_HAPTIC)) { if (SDL_HapticInit() < 0) { return (-1); } SDL_initialized |= SDL_INIT_HAPTIC; } #else if (flags & SDL_INIT_HAPTIC) { SDL_SetError("SDL not built with haptic (force feedback) support"); return (-1); } #endif return (0); }
int main(int argc, char *argv[]) { int i, done; const char *driver; SDL_Window *window; SDL_Renderer *renderer; SDL_Texture *sprite; int window_w, window_h; int sprite_w, sprite_h; SDL_Event event; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); if (SDL_VideoInit(NULL) < 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL video: %s\n", SDL_GetError()); exit(1); } driver = SDL_GetCurrentVideoDriver(); /* Find a native window driver and create a native window */ for (i = 0; factories[i]; ++i) { if (SDL_strcmp(driver, factories[i]->tag) == 0) { factory = factories[i]; break; } } if (!factory) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't find native window code for %s driver\n", driver); quit(2); } SDL_Log("Creating native window for %s driver\n", driver); native_window = factory->CreateNativeWindow(WINDOW_W, WINDOW_H); if (!native_window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create native window\n"); quit(3); } window = SDL_CreateWindowFrom(native_window); if (!window) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create SDL window: %s\n", SDL_GetError()); quit(4); } SDL_SetWindowTitle(window, "SDL Native Window Test"); /* Create the renderer */ renderer = SDL_CreateRenderer(window, -1, 0); if (!renderer) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError()); quit(5); } /* Clear the window, load the sprite and go! */ SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); sprite = LoadSprite(renderer, "icon.bmp"); if (!sprite) { quit(6); } /* Allocate memory for the sprite info */ SDL_GetWindowSize(window, &window_w, &window_h); SDL_QueryTexture(sprite, NULL, NULL, &sprite_w, &sprite_h); positions = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect)); velocities = (SDL_Rect *) SDL_malloc(NUM_SPRITES * sizeof(SDL_Rect)); if (!positions || !velocities) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!\n"); quit(2); } srand(time(NULL)); for (i = 0; i < NUM_SPRITES; ++i) { positions[i].x = rand() % (window_w - sprite_w); positions[i].y = rand() % (window_h - sprite_h); positions[i].w = sprite_w; positions[i].h = sprite_h; velocities[i].x = 0; velocities[i].y = 0; while (!velocities[i].x && !velocities[i].y) { velocities[i].x = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED; velocities[i].y = (rand() % (MAX_SPEED * 2 + 1)) - MAX_SPEED; } } /* Main render loop */ done = 0; while (!done) { /* Check for events */ while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_EXPOSED: SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); break; } break; case SDL_QUIT: done = 1; break; default: break; } } MoveSprites(renderer, sprite); } quit(0); return 0; /* to prevent compiler warning */ }
bool initGL() { #ifdef DEBUG_DRIVERS /************ DEBUG DRIVERS ********************************/ // Identify video drivers (this is for debug) OUTSTREAM << "\nSDL found the following video drivers:\n"; int numdrivers = SDL_GetNumVideoDrivers(); const char* drivername; for (int i = 0; i < numdrivers; ++i) { drivername = SDL_GetVideoDriver(i); if (SDL_VideoInit(drivername) == 0) { SDL_VideoQuit(); OUTSTREAM << "\t\t Driver " << drivername << " works.\n"; } else { OUTSTREAM << "\t<!>\tDriver " << drivername << " DOES NOT WORK!\n"; } } // Identify render drivers (this is for debug) OUTSTREAM << "SDL found the following render drivers: "; numdrivers = SDL_GetNumRenderDrivers(); for (int i = 0; i < numdrivers; ++i) { SDL_RendererInfo info; SDL_GetRenderDriverInfo(i, &info); OUTSTREAM << info.name << ((i < numdrivers - 1)? ", " : "\n"); } #endif /************************** DEBUG DRIVERS ********************************/ // Initialize SDL overall. if (SDL_Init(SDL_INIT_VIDEO) < 0) { OUTSTREAM << "<!> SDL did not initialize! SDL Error: " << SDL_GetError() << std::endl; return false; } // SDL_GL_CONTEXT_CORE gives us only the newer version, deprecated functions are disabled SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); // Specify OpenGL version SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, GLVERSION_MAJOR); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, GLVERSION_MINOR); // Turn on double buffering with a 24bit Z buffer. // You may need to change this to 16 or 32 for your system SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); // Create the SDL window pWindow = SDL_CreateWindow("OpenGL Window", // name of window SDL_WINDOWPOS_CENTERED, // x position of window SDL_WINDOWPOS_CENTERED, // y position of window RESOLUTION_X, RESOLUTION_Y, // x and y width of window SCREENOPTIONS); // options (fullscreen, etc) // If the window couldn't be created for whatever reason if (pWindow == NULL) { OUTSTREAM << "<!> SDL window was not created! SDL Error: " << SDL_GetError() << std::endl; return false; } else { OUTSTREAM << "SDL window created.\n"; } //Create context context = SDL_GL_CreateContext(pWindow); //context is the place where openGL can draw if(context == NULL) { OUTSTREAM << "<!> OpenGL context was not created! SDL Error: " << SDL_GetError() << std::endl; return false; } else { OUTSTREAM << "GL context created.\n"; } checkGlError(__LINE__); //Initialize GLEW (openGL Extensions Wrangler) glewExperimental = GL_TRUE; // Sometimes things wont work without this line GLenum glewError = glewInit(); // GL enumerator error is thrown here when using openGL versions 3.2+ It's fine. // see https://www.opengl.org/wiki/OpenGL_Loading_Library if(glewError != GLEW_OK) { OUTSTREAM << "<!> Could not initialize GLEW! " << glewGetErrorString(glewError) << std::endl; return false; } else { OUTSTREAM << "GLEW initialized.\n"; } checkGlError(__LINE__); #ifdef USE_VSYNC /************ USE VSYNC ********************************/ if (SDL_GL_SetSwapInterval(1) < 0) { OUTSTREAM << "<!> Warning: Unable to set VSync! SDL Error: " << SDL_GetError() << std::endl; // Do not return. This is not an essential functionality. } else { OUTSTREAM << "VSync enabled.\n"; } #endif /********************** USE VSYNC ********************************/ // set openGL clear color glClearColor(CLEARCOLOR); #ifdef USE_DEPTHBUFFER // enable the occlusion of objects hidden behind other objects (using the depth buffer) glEnable(GL_DEPTH_TEST); // set the test for that occlusion to: "draw if distance of new fragment is less than or equal to old fragment" glDepthFunc(GL_LEQUAL); #endif #ifdef USE_BACKFACE_CULLING // enable the culling of back faces (back faces will not be drawn) glEnable(GL_CULL_FACE); #endif #ifdef USE_TRANSPARENCY // enable transparency glEnable (GL_BLEND); // set transparency function (this is standard transparency) glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #endif checkGlError(__LINE__); checkSDLError(__LINE__); return true; }