static D3DTEXTUREFILTERTYPE GetScaleQuality(void) { const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY); if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) { return D3DTEXF_POINT; } else if (*hint == '1' || SDL_strcasecmp(hint, "linear") == 0) { return D3DTEXF_LINEAR; } else { return D3DTEXF_ANISOTROPIC; } }
/* * Add or update an entry into the Mappings Database */ int SDL_GameControllerAddMapping(const char *mappingString) { char *pchGUID; char *pchName; char *pchMapping; SDL_JoystickGUID jGUID; ControllerMapping_t *pControllerMapping; SDL_bool is_xinput_mapping = SDL_FALSE; pchGUID = SDL_PrivateGetControllerGUIDFromMappingString(mappingString); if (!pchGUID) { return SDL_SetError("Couldn't parse GUID from %s", mappingString); } if (!SDL_strcasecmp(pchGUID, "xinput")) { is_xinput_mapping = SDL_TRUE; } jGUID = SDL_JoystickGetGUIDFromString(pchGUID); SDL_free(pchGUID); pchName = SDL_PrivateGetControllerNameFromMappingString(mappingString); if (!pchName) { return SDL_SetError("Couldn't parse name from %s", mappingString); } pchMapping = SDL_PrivateGetControllerMappingFromMappingString(mappingString); if (!pchMapping) { SDL_free(pchName); return SDL_SetError("Couldn't parse %s", mappingString); } pControllerMapping = SDL_PrivateGetControllerMappingForGUID(&jGUID); if (pControllerMapping) { /* Update existing mapping */ SDL_free(pControllerMapping->name); pControllerMapping->name = pchName; SDL_free(pControllerMapping->mapping); pControllerMapping->mapping = pchMapping; /* refresh open controllers */ SDL_PrivateGameControllerRefreshMapping(pControllerMapping); return 0; } else { pControllerMapping = SDL_malloc(sizeof(*pControllerMapping)); if (!pControllerMapping) { SDL_free(pchName); SDL_free(pchMapping); return SDL_OutOfMemory(); } if (is_xinput_mapping) { s_pXInputMapping = pControllerMapping; } pControllerMapping->guid = jGUID; pControllerMapping->name = pchName; pControllerMapping->mapping = pchMapping; pControllerMapping->next = s_pSupportedControllers; s_pSupportedControllers = pControllerMapping; return 1; } }
/* * Add or update an entry into the Mappings Database with a priority */ static int SDL_PrivateGameControllerAddMapping(const char *mappingString, SDL_ControllerMappingPriority priority) { char *pchGUID; SDL_JoystickGUID jGUID; SDL_bool is_xinput_mapping = SDL_FALSE; SDL_bool is_emscripten_mapping = SDL_FALSE; SDL_bool existing = SDL_FALSE; ControllerMapping_t *pControllerMapping; if (!mappingString) { return SDL_InvalidParamError("mappingString"); } pchGUID = SDL_PrivateGetControllerGUIDFromMappingString(mappingString); if (!pchGUID) { return SDL_SetError("Couldn't parse GUID from %s", mappingString); } if (!SDL_strcasecmp(pchGUID, "xinput")) { is_xinput_mapping = SDL_TRUE; } if (!SDL_strcasecmp(pchGUID, "emscripten")) { is_emscripten_mapping = SDL_TRUE; } jGUID = SDL_JoystickGetGUIDFromString(pchGUID); SDL_free(pchGUID); pControllerMapping = SDL_PrivateAddMappingForGUID(jGUID, mappingString, &existing, priority); if (!pControllerMapping) { return -1; } if (existing) { return 0; } else { if (is_xinput_mapping) { s_pXInputMapping = pControllerMapping; } if (is_emscripten_mapping) { s_pEmscriptenMapping = pControllerMapping; } return 1; } }
bool CFileProvider::extension(const std::string &filename, const std::string &extension) { const char *fname = filename.c_str(), *ext = extension.c_str(); if (strlen(fname) < strlen(ext) || SDL_strcasecmp(fname + strlen(fname) - strlen(ext), ext)) return false; else return true; }
static GLenum GetScaleQuality(void) { const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY); if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) { return GL_NEAREST; } else { return GL_LINEAR; } }
static void SDLCALL SDL_TouchMouseEventsChanged(void *userdata, const char *name, const char *oldValue, const char *hint) { SDL_Mouse *mouse = (SDL_Mouse *)userdata; if (hint && (*hint == '0' || SDL_strcasecmp(hint, "false") == 0)) { mouse->touch_mouse_events = SDL_FALSE; } else { mouse->touch_mouse_events = SDL_TRUE; } }
static int GetScaleQuality(void) { const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY); if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) { return 0; } else { return 1; } }
/* * convert a string to its enum equivalent */ SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const char *pchString) { int entry; if (!pchString || !pchString[0]) return SDL_CONTROLLER_AXIS_INVALID; for (entry = 0; map_StringForControllerAxis[entry]; ++entry) { if (!SDL_strcasecmp(pchString, map_StringForControllerAxis[entry])) return entry; } return SDL_CONTROLLER_AXIS_INVALID; }
/* * convert a string to its enum equivalent */ SDL_GameControllerButton SDL_GameControllerGetButtonFromString(const char *pchString) { int entry; if (!pchString || !pchString[0]) return SDL_CONTROLLER_BUTTON_INVALID; for (entry = 0; map_StringForControllerButton[entry]; ++entry) { if (SDL_strcasecmp(pchString, map_StringForControllerButton[entry]) == 0) return entry; } return SDL_CONTROLLER_BUTTON_INVALID; }
SDL_bool SDL_GetHintBoolean(const char *name, SDL_bool default_value) { const char *hint = SDL_GetHint(name); if (!hint) { return default_value; } if (*hint == '0' || SDL_strcasecmp(hint, "false") == 0) { return SDL_FALSE; } return SDL_TRUE; }
/* String compare s1 and s2 ignoring leading hyphens */ static int StrCaseCmpIgnoreHyphen(char* s1, char* s2) { /* treat NULL pointer as empty strings */ if(!s1) s1 = ""; if(!s2) s2 = ""; while(*s1 == '-') s1++; while(*s2 == '-') s2++; return SDL_strcasecmp(s1, s2); }
SDL_Scancode SDL_GetScancodeFromName(const char *name) { unsigned int i; if (!name || !*name) { return SDL_SCANCODE_UNKNOWN; } for (i = 0; i < SDL_arraysize(SDL_scancode_names); ++i) { if (!SDL_scancode_names[i]) { continue; } if (SDL_strcasecmp(name, SDL_scancode_names[i]) == 0) { return static_cast<SDL_Scancode>(i); } } return SDL_SCANCODE_UNKNOWN; }
static void SDLCALL SDL_MouseTouchEventsChanged(void *userdata, const char *name, const char *oldValue, const char *hint) { SDL_Mouse *mouse = (SDL_Mouse *)userdata; if (hint == NULL || *hint == '\0') { /* Default */ #if defined(__ANDROID__) || (defined(__IPHONEOS__) && !defined(__TVOS__)) mouse->mouse_touch_events = SDL_TRUE; #else mouse->mouse_touch_events = SDL_FALSE; #endif } else if (*hint == '1' || SDL_strcasecmp(hint, "true") == 0) { mouse->mouse_touch_events = SDL_TRUE; } else { mouse->mouse_touch_events = SDL_FALSE; } if (mouse->mouse_touch_events) { SDL_AddTouch(SDL_MOUSE_TOUCHID, SDL_TOUCH_DEVICE_DIRECT, "mouse_input"); } }
int CommonArg(CommonState * state, int index) { char **argv = state->argv; if (SDL_strcasecmp(argv[index], "--video") == 0) { ++index; if (!argv[index]) { return -1; } state->videodriver = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--renderer") == 0) { ++index; if (!argv[index]) { return -1; } state->renderdriver = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--info") == 0) { ++index; if (!argv[index]) { return -1; } if (SDL_strcasecmp(argv[index], "all") == 0) { state->verbose |= (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER | VERBOSE_EVENT); return 2; } if (SDL_strcasecmp(argv[index], "video") == 0) { state->verbose |= VERBOSE_VIDEO; return 2; } if (SDL_strcasecmp(argv[index], "modes") == 0) { state->verbose |= VERBOSE_MODES; return 2; } if (SDL_strcasecmp(argv[index], "render") == 0) { state->verbose |= VERBOSE_RENDER; return 2; } if (SDL_strcasecmp(argv[index], "event") == 0) { state->verbose |= VERBOSE_EVENT; return 2; } return -1; } if (SDL_strcasecmp(argv[index], "--display") == 0) { ++index; if (!argv[index]) { return -1; } state->display = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) { state->window_flags |= SDL_WINDOW_FULLSCREEN; state->num_windows = 1; return 1; } if (SDL_strcasecmp(argv[index], "--windows") == 0) { ++index; if (!argv[index] || !SDL_isdigit(*argv[index])) { return -1; } if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) { state->num_windows = SDL_atoi(argv[index]); } return 2; } if (SDL_strcasecmp(argv[index], "--title") == 0) { ++index; if (!argv[index]) { return -1; } state->window_title = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--center") == 0) { state->window_x = SDL_WINDOWPOS_CENTERED; state->window_y = SDL_WINDOWPOS_CENTERED; return 1; } if (SDL_strcasecmp(argv[index], "--position") == 0) { char *x, *y; ++index; if (!argv[index]) { return -1; } x = argv[index]; y = argv[index]; while (*y && *y != ',') { ++y; } if (!*y) { return -1; } *y++ = '\0'; state->window_x = SDL_atoi(x); state->window_y = SDL_atoi(y); return 2; } if (SDL_strcasecmp(argv[index], "--geometry") == 0) { char *w, *h; ++index; if (!argv[index]) { return -1; } w = argv[index]; h = argv[index]; while (*h && *h != 'x') { ++h; } if (!*h) { return -1; } *h++ = '\0'; state->window_w = SDL_atoi(w); state->window_h = SDL_atoi(h); return 2; } if (SDL_strcasecmp(argv[index], "--depth") == 0) { ++index; if (!argv[index]) { return -1; } state->depth = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--refresh") == 0) { ++index; if (!argv[index]) { return -1; } state->refresh_rate = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--vsync") == 0) { state->render_flags |= SDL_RENDERER_PRESENTVSYNC; return 1; } if (SDL_strcasecmp(argv[index], "--noframe") == 0) { state->window_flags |= SDL_WINDOW_BORDERLESS; return 1; } if (SDL_strcasecmp(argv[index], "--resize") == 0) { state->window_flags |= SDL_WINDOW_RESIZABLE; return 1; } if (SDL_strcasecmp(argv[index], "--minimize") == 0) { state->window_flags |= SDL_WINDOW_MINIMIZED; return 1; } if (SDL_strcasecmp(argv[index], "--maximize") == 0) { state->window_flags |= SDL_WINDOW_MAXIMIZED; return 1; } if (SDL_strcasecmp(argv[index], "--grab") == 0) { state->window_flags |= SDL_WINDOW_INPUT_GRABBED; return 1; } if (SDL_strcasecmp(argv[index], "--rate") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.freq = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--format") == 0) { ++index; if (!argv[index]) { return -1; } if (SDL_strcasecmp(argv[index], "U8") == 0) { state->audiospec.format = AUDIO_U8; return 2; } if (SDL_strcasecmp(argv[index], "S8") == 0) { state->audiospec.format = AUDIO_S8; return 2; } if (SDL_strcasecmp(argv[index], "U16") == 0) { state->audiospec.format = AUDIO_U16; return 2; } if (SDL_strcasecmp(argv[index], "U16LE") == 0) { state->audiospec.format = AUDIO_U16LSB; return 2; } if (SDL_strcasecmp(argv[index], "U16BE") == 0) { state->audiospec.format = AUDIO_U16MSB; return 2; } if (SDL_strcasecmp(argv[index], "S16") == 0) { state->audiospec.format = AUDIO_S16; return 2; } if (SDL_strcasecmp(argv[index], "S16LE") == 0) { state->audiospec.format = AUDIO_S16LSB; return 2; } if (SDL_strcasecmp(argv[index], "S16BE") == 0) { state->audiospec.format = AUDIO_S16MSB; return 2; } return -1; } if (SDL_strcasecmp(argv[index], "--channels") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.channels = (Uint8) SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--samples") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.samples = (Uint16) SDL_atoi(argv[index]); return 2; } if ((SDL_strcasecmp(argv[index], "-h") == 0) || (SDL_strcasecmp(argv[index], "--help") == 0)) { /* Print the usage message */ return -1; } return 0; }
/* parser an argument, updates the state object and returns the number of arguments processed; returns -1 on failure */ static int ParseArg(char** argv, int index, SDLVisualTest_HarnessState* state) { if(!argv || !argv[index] || !state) return 0; if(StrCaseCmpIgnoreHyphen("sutapp", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for sutapp."); return -1; } SDL_strlcpy(state->sutapp, argv[index], MAX_PATH_LEN); SDLTest_Log("SUT Application: %s", state->sutapp); return 2; } else if(StrCaseCmpIgnoreHyphen("output-dir", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for output-dir."); return -1; } SDL_strlcpy(state->output_dir, argv[index], MAX_PATH_LEN); SDLTest_Log("Screenshot Output Directory: %s", state->output_dir); return 2; } else if(StrCaseCmpIgnoreHyphen("verify-dir", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for verify-dir."); return -1; } SDL_strlcpy(state->verify_dir, argv[index], MAX_PATH_LEN); SDLTest_Log("Screenshot Verification Directory: %s", state->verify_dir); return 2; } else if(StrCaseCmpIgnoreHyphen("sutargs", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for sutargs."); return -1; } SDL_strlcpy(state->sutargs, argv[index], MAX_SUT_ARGS_LEN); SDLTest_Log("SUT Arguments: %s", state->sutargs); return 2; } else if(StrCaseCmpIgnoreHyphen("timeout", argv[index]) == 0) { int hr, min, sec; index++; if(!argv[index] || SDL_sscanf(argv[index], "%d:%d:%d", &hr, &min, &sec) != 3) { SDLTest_LogError("Arguments parsing error: Invalid argument for timeout."); return -1; } state->timeout = (((hr * 60) + min) * 60 + sec) * 1000; SDLTest_Log("Maximum Timeout for each SUT run: %d milliseconds", state->timeout); return 2; } else if(StrCaseCmpIgnoreHyphen("parameter-config", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for parameter-config."); return -1; } SDLTest_Log("SUT Parameters file: %s", argv[index]); SDLVisualTest_FreeSUTConfig(&state->sut_config); if(!SDLVisualTest_ParseSUTConfig(argv[index], &state->sut_config)) { SDLTest_LogError("Failed to parse SUT parameters file"); return -1; } return 2; } else if(StrCaseCmpIgnoreHyphen("variator", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for variator."); return -1; } SDLTest_Log("Variator: %s", argv[index]); if(SDL_strcasecmp("exhaustive", argv[index]) == 0) state->variator_type = SDL_VARIATOR_EXHAUSTIVE; else if(SDL_strcasecmp("random", argv[index]) == 0) state->variator_type = SDL_VARIATOR_RANDOM; else { SDLTest_LogError("Arguments parsing error: Invalid variator name."); return -1; } return 2; } else if(StrCaseCmpIgnoreHyphen("num-variations", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: Invalid argument for num-variations."); return -1; } state->num_variations = SDL_atoi(argv[index]); SDLTest_Log("Number of variations to run: %d", state->num_variations); if(state->num_variations <= 0) { SDLTest_LogError("Arguments parsing error: num-variations must be positive."); return -1; } return 2; } else if(StrCaseCmpIgnoreHyphen("no-launch", argv[index]) == 0) { state->no_launch = SDL_TRUE; SDLTest_Log("SUT will not be launched."); return 1; } else if(StrCaseCmpIgnoreHyphen("action-config", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: invalid argument for action-config"); return -1; } SDLTest_Log("Action Config file: %s", argv[index]); SDLVisualTest_EmptyActionQueue(&state->action_queue); if(!SDLVisualTest_ParseActionConfig(argv[index], &state->action_queue)) { SDLTest_LogError("SDLVisualTest_ParseActionConfig() failed"); return -1; } return 2; } else if(StrCaseCmpIgnoreHyphen("config", argv[index]) == 0) { index++; if(!argv[index]) { SDLTest_LogError("Arguments parsing error: invalid argument for config"); return -1; } /* do nothing, this option has already been handled */ return 2; } return 0; }
int SDLTest_CommonArg(SDLTest_CommonState * state, int index) { char **argv = state->argv; if (SDL_strcasecmp(argv[index], "--video") == 0) { ++index; if (!argv[index]) { return -1; } state->videodriver = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--renderer") == 0) { ++index; if (!argv[index]) { return -1; } state->renderdriver = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--gldebug") == 0) { state->gl_debug = 1; return 1; } if (SDL_strcasecmp(argv[index], "--info") == 0) { ++index; if (!argv[index]) { return -1; } if (SDL_strcasecmp(argv[index], "all") == 0) { state->verbose |= (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER | VERBOSE_EVENT); return 2; } if (SDL_strcasecmp(argv[index], "video") == 0) { state->verbose |= VERBOSE_VIDEO; return 2; } if (SDL_strcasecmp(argv[index], "modes") == 0) { state->verbose |= VERBOSE_MODES; return 2; } if (SDL_strcasecmp(argv[index], "render") == 0) { state->verbose |= VERBOSE_RENDER; return 2; } if (SDL_strcasecmp(argv[index], "event") == 0) { state->verbose |= VERBOSE_EVENT; return 2; } return -1; } if (SDL_strcasecmp(argv[index], "--log") == 0) { ++index; if (!argv[index]) { return -1; } if (SDL_strcasecmp(argv[index], "all") == 0) { SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "error") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "system") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "audio") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "video") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "render") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_RENDER, SDL_LOG_PRIORITY_VERBOSE); return 2; } if (SDL_strcasecmp(argv[index], "input") == 0) { SDL_LogSetPriority(SDL_LOG_CATEGORY_INPUT, SDL_LOG_PRIORITY_VERBOSE); return 2; } return -1; } if (SDL_strcasecmp(argv[index], "--display") == 0) { ++index; if (!argv[index]) { return -1; } state->display = SDL_atoi(argv[index]); if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) { state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display); state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display); } if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) { state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display); state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display); } return 2; } if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) { state->window_flags |= SDL_WINDOW_FULLSCREEN; state->num_windows = 1; return 1; } if (SDL_strcasecmp(argv[index], "--fullscreen-desktop") == 0) { state->window_flags |= SDL_WINDOW_FULLSCREEN_DESKTOP; state->num_windows = 1; return 1; } if (SDL_strcasecmp(argv[index], "--windows") == 0) { ++index; if (!argv[index] || !SDL_isdigit(*argv[index])) { return -1; } if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) { state->num_windows = SDL_atoi(argv[index]); } return 2; } if (SDL_strcasecmp(argv[index], "--title") == 0) { ++index; if (!argv[index]) { return -1; } state->window_title = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--icon") == 0) { ++index; if (!argv[index]) { return -1; } state->window_icon = argv[index]; return 2; } if (SDL_strcasecmp(argv[index], "--center") == 0) { state->window_x = SDL_WINDOWPOS_CENTERED; state->window_y = SDL_WINDOWPOS_CENTERED; return 1; } if (SDL_strcasecmp(argv[index], "--position") == 0) { char *x, *y; ++index; if (!argv[index]) { return -1; } x = argv[index]; y = argv[index]; while (*y && *y != ',') { ++y; } if (!*y) { return -1; } *y++ = '\0'; state->window_x = SDL_atoi(x); state->window_y = SDL_atoi(y); return 2; } if (SDL_strcasecmp(argv[index], "--geometry") == 0) { char *w, *h; ++index; if (!argv[index]) { return -1; } w = argv[index]; h = argv[index]; while (*h && *h != 'x') { ++h; } if (!*h) { return -1; } *h++ = '\0'; state->window_w = SDL_atoi(w); state->window_h = SDL_atoi(h); return 2; } if (SDL_strcasecmp(argv[index], "--min-geometry") == 0) { char *w, *h; ++index; if (!argv[index]) { return -1; } w = argv[index]; h = argv[index]; while (*h && *h != 'x') { ++h; } if (!*h) { return -1; } *h++ = '\0'; state->window_minW = SDL_atoi(w); state->window_minH = SDL_atoi(h); return 2; } if (SDL_strcasecmp(argv[index], "--max-geometry") == 0) { char *w, *h; ++index; if (!argv[index]) { return -1; } w = argv[index]; h = argv[index]; while (*h && *h != 'x') { ++h; } if (!*h) { return -1; } *h++ = '\0'; state->window_maxW = SDL_atoi(w); state->window_maxH = SDL_atoi(h); return 2; } if (SDL_strcasecmp(argv[index], "--logical") == 0) { char *w, *h; ++index; if (!argv[index]) { return -1; } w = argv[index]; h = argv[index]; while (*h && *h != 'x') { ++h; } if (!*h) { return -1; } *h++ = '\0'; state->logical_w = SDL_atoi(w); state->logical_h = SDL_atoi(h); return 2; } if (SDL_strcasecmp(argv[index], "--scale") == 0) { ++index; if (!argv[index]) { return -1; } state->scale = (float)SDL_atof(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--depth") == 0) { ++index; if (!argv[index]) { return -1; } state->depth = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--refresh") == 0) { ++index; if (!argv[index]) { return -1; } state->refresh_rate = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--vsync") == 0) { state->render_flags |= SDL_RENDERER_PRESENTVSYNC; return 1; } if (SDL_strcasecmp(argv[index], "--noframe") == 0) { state->window_flags |= SDL_WINDOW_BORDERLESS; return 1; } if (SDL_strcasecmp(argv[index], "--resize") == 0) { state->window_flags |= SDL_WINDOW_RESIZABLE; return 1; } if (SDL_strcasecmp(argv[index], "--minimize") == 0) { state->window_flags |= SDL_WINDOW_MINIMIZED; return 1; } if (SDL_strcasecmp(argv[index], "--maximize") == 0) { state->window_flags |= SDL_WINDOW_MAXIMIZED; return 1; } if (SDL_strcasecmp(argv[index], "--grab") == 0) { state->window_flags |= SDL_WINDOW_INPUT_GRABBED; return 1; } if (SDL_strcasecmp(argv[index], "--rate") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.freq = SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--format") == 0) { ++index; if (!argv[index]) { return -1; } if (SDL_strcasecmp(argv[index], "U8") == 0) { state->audiospec.format = AUDIO_U8; return 2; } if (SDL_strcasecmp(argv[index], "S8") == 0) { state->audiospec.format = AUDIO_S8; return 2; } if (SDL_strcasecmp(argv[index], "U16") == 0) { state->audiospec.format = AUDIO_U16; return 2; } if (SDL_strcasecmp(argv[index], "U16LE") == 0) { state->audiospec.format = AUDIO_U16LSB; return 2; } if (SDL_strcasecmp(argv[index], "U16BE") == 0) { state->audiospec.format = AUDIO_U16MSB; return 2; } if (SDL_strcasecmp(argv[index], "S16") == 0) { state->audiospec.format = AUDIO_S16; return 2; } if (SDL_strcasecmp(argv[index], "S16LE") == 0) { state->audiospec.format = AUDIO_S16LSB; return 2; } if (SDL_strcasecmp(argv[index], "S16BE") == 0) { state->audiospec.format = AUDIO_S16MSB; return 2; } return -1; } if (SDL_strcasecmp(argv[index], "--channels") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.channels = (Uint8) SDL_atoi(argv[index]); return 2; } if (SDL_strcasecmp(argv[index], "--samples") == 0) { ++index; if (!argv[index]) { return -1; } state->audiospec.samples = (Uint16) SDL_atoi(argv[index]); return 2; } if ((SDL_strcasecmp(argv[index], "-h") == 0) || (SDL_strcasecmp(argv[index], "--help") == 0)) { /* Print the usage message */ return -1; } if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) { /* Debug flag sent by Xcode */ return 2; } return 0; }
SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state) { int i, j, m, n, w, h; 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) { 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); if (state->gl_major_version) { 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->gl_debug) { SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG); } if (state->verbose & VERBOSE_MODES) { SDL_Rect bounds; 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: %s\n", i, SDL_GetDisplayName(i)); SDL_zero(bounds); SDL_GetDisplayBounds(i, &bounds); fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y); SDL_GetDesktopDisplayMode(i, &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, SDL_GetPixelFormatName(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(i); 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(i, 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, SDL_GetPixelFormatName(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); } } } } } 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); SDLTest_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)); state->renderers = (SDL_Renderer **) SDL_malloc(state->num_windows * sizeof(*state->renderers)); if (!state->windows || !state->renderers) { 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 (state->window_minW || state->window_minH) { SDL_SetWindowMinimumSize(state->windows[i], state->window_minW, state->window_minH); } if (state->window_maxW || state->window_maxH) { SDL_SetWindowMaximumSize(state->windows[i], state->window_maxW, state->window_maxH); } SDL_GetWindowSize(state->windows[i], &w, &h); if (!(state->window_flags & SDL_WINDOW_RESIZABLE) && (w != state->window_w || h != state->window_h)) { printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h); state->window_w = w; state->window_h = h; } 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 = SDLTest_LoadIcon(state->window_icon); if (icon) { SDL_SetWindowIcon(state->windows[i], icon); SDL_FreeSurface(icon); } } SDL_ShowWindow(state->windows[i]); state->renderers[i] = NULL; 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; } } state->renderers[i] = SDL_CreateRenderer(state->windows[i], m, state->render_flags); if (!state->renderers[i]) { fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError()); return SDL_FALSE; } if (state->logical_w && state->logical_h) { SDL_RenderSetLogicalSize(state->renderers[i], state->logical_w, state->logical_h); } else if (state->scale) { SDL_RenderSetScale(state->renderers[i], state->scale, state->scale); } if (state->verbose & VERBOSE_RENDER) { SDL_RendererInfo info; fprintf(stderr, "Current renderer:\n"); SDL_GetRendererInfo(state->renderers[i], &info); SDLTest_PrintRenderer(&info); } } } } 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; }
SDL_Renderer * SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags) { SDL_Renderer *renderer = NULL; int n = SDL_GetNumRenderDrivers(); const char *hint; if (!window) { SDL_SetError("Invalid window"); return NULL; } if (SDL_GetRenderer(window)) { SDL_SetError("Renderer already associated with window"); return NULL; } hint = SDL_GetHint(SDL_HINT_RENDER_VSYNC); if (hint) { if (*hint == '0') { flags &= ~SDL_RENDERER_PRESENTVSYNC; } else { flags |= SDL_RENDERER_PRESENTVSYNC; } } if (index < 0) { hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER); if (hint) { for (index = 0; index < n; ++index) { const SDL_RenderDriver *driver = render_drivers[index]; if (SDL_strcasecmp(hint, driver->info.name) == 0) { /* Create a new renderer instance */ renderer = driver->CreateRenderer(window, flags); break; } } } if (!renderer) { for (index = 0; index < n; ++index) { const SDL_RenderDriver *driver = render_drivers[index]; if ((driver->info.flags & flags) == flags) { /* Create a new renderer instance */ renderer = driver->CreateRenderer(window, flags); if (renderer) { /* Yay, we got one! */ break; } } } } if (index == n) { SDL_SetError("Couldn't find matching render driver"); return NULL; } } else { if (index >= SDL_GetNumRenderDrivers()) { SDL_SetError("index must be -1 or in the range of 0 - %d", SDL_GetNumRenderDrivers() - 1); return NULL; } /* Create a new renderer instance */ renderer = render_drivers[index]->CreateRenderer(window, flags); } if (renderer) { renderer->magic = &renderer_magic; renderer->window = window; if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED) { renderer->minimized = SDL_TRUE; } else { renderer->minimized = SDL_FALSE; } SDL_SetWindowData(window, SDL_WINDOWRENDERDATA, renderer); SDL_RenderSetViewport(renderer, NULL); SDL_AddEventWatch(SDL_RendererEventWatch, renderer); SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "Created renderer: %s", renderer->info.name); } return renderer; }
int main(int argc, char *argv[]) { int fsaa, accel; int value; int i, done; SDL_DisplayMode mode; SDL_Event event; Uint32 then, now, frames; int status; /* Initialize parameters */ fsaa = 0; accel = 0; /* Initialize test framework */ state = CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = CommonArg(state, i); if (consumed == 0) { if (SDL_strcasecmp(argv[i], "--fsaa") == 0) { ++fsaa; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--accel") == 0) { ++accel; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--zdepth") == 0) { i++; if (!argv[i]) { consumed = -1; } else { depth = SDL_atoi(argv[i]); consumed = 1; } } else { consumed = -1; } } if (consumed < 0) { fprintf(stderr, "Usage: %s %s [--fsaa] [--accel] [--zdepth %%d]\n", argv[0], CommonUsage(state)); quit(1); } i += consumed; } /* Set OpenGL parameters */ state->window_flags |= SDL_WINDOW_OPENGL; state->gl_red_size = 5; state->gl_green_size = 5; state->gl_blue_size = 5; state->gl_depth_size = depth; if (fsaa) { state->gl_multisamplebuffers=1; state->gl_multisamplesamples=fsaa; } if (accel) { state->gl_accelerated=1; } if (!CommonInit(state)) { quit(2); } context = SDL_calloc(state->num_windows, sizeof(context)); if (context == NULL) { fprintf(stderr, "Out of memory!\n"); quit(2); } /* Create OpenGL ES contexts */ for (i = 0; i < state->num_windows; i++) { context[i] = SDL_GL_CreateContext(state->windows[i]); if (!context[i]) { fprintf(stderr, "SDL_GL_CreateContext(): %s\n", SDL_GetError()); quit(2); } } if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { SDL_GL_SetSwapInterval(1); } else { SDL_GL_SetSwapInterval(0); } SDL_GetCurrentDisplayMode(&mode); printf("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format)); printf("\n"); printf("Vendor : %s\n", glGetString(GL_VENDOR)); printf("Renderer : %s\n", glGetString(GL_RENDERER)); printf("Version : %s\n", glGetString(GL_VERSION)); printf("Extensions : %s\n", glGetString(GL_EXTENSIONS)); printf("\n"); status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); if (!status) { printf("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); } else { fprintf(stderr, "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); if (!status) { printf("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); } else { fprintf(stderr, "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); if (!status) { printf("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); } else { fprintf(stderr, "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); if (!status) { printf("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", depth, value); } else { fprintf(stderr, "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError()); } if (fsaa) { status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); if (!status) { printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); } else { fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); if (!status) { printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value); } else { fprintf(stderr, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError()); } } if (accel) { status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); if (!status) { printf("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value); } else { fprintf(stderr, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError()); } } /* Set rendering settings for each context */ for (i = 0; i < state->num_windows; ++i) { status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); /* Continue for next window */ continue; } glViewport(0, 0, state->window_w, state->window_h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrthof(-2.0, 2.0, -2.0, 2.0, -20.0, 20.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glShadeModel(GL_SMOOTH); } /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_RESIZED: for (i = 0; i < state->num_windows; ++i) { if (event.window.windowID == state->windows[i]) { status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); break; } /* Change view port to the new window dimensions */ glViewport(0, 0, event.window.data1, event.window.data2); /* Update window content */ Render(); SDL_GL_SwapWindow(state->windows[i]); break; } } break; } } CommonEvent(state, &event, &done); } for (i = 0; i < state->num_windows; ++i) { status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { printf("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); /* Continue for next window */ continue; } Render(); SDL_GL_SwapWindow(state->windows[i]); } } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { printf("%2.2f frames per second\n", ((double) frames * 1000) / (now - then)); } quit(0); return 0; }
SDL_Renderer * SW_CreateRenderer(SDL_Window * window, Uint32 flags) { SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); SDL_DisplayMode *displayMode = &display->current_mode; SDL_Renderer *renderer; SW_RenderData *data; int i, n; int bpp; Uint32 Rmask, Gmask, Bmask, Amask; Uint32 renderer_flags; const char *desired_driver; if (!SDL_PixelFormatEnumToMasks (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) { SDL_SetError("Unknown display format"); return NULL; } renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer)); if (!renderer) { SDL_OutOfMemory(); return NULL; } data = (SW_RenderData *) SDL_calloc(1, sizeof(*data)); if (!data) { SW_DestroyRenderer(renderer); SDL_OutOfMemory(); return NULL; } renderer->ActivateRenderer = SW_ActivateRenderer; renderer->DisplayModeChanged = SW_DisplayModeChanged; renderer->RenderPoint = SW_RenderPoint; renderer->RenderLine = SW_RenderLine; renderer->RenderFill = SW_RenderFill; renderer->RenderCopy = SW_RenderCopy; renderer->RenderPresent = SW_RenderPresent; renderer->DestroyRenderer = SW_DestroyRenderer; renderer->info.name = SW_RenderDriver.info.name; renderer->info.flags = 0; renderer->window = window->id; renderer->driverdata = data; Setup_SoftwareRenderer(renderer); if (flags & SDL_RENDERER_PRESENTFLIP2) { renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2; n = 2; } else if (flags & SDL_RENDERER_PRESENTFLIP3) { renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3; n = 3; } else { renderer->info.flags |= SDL_RENDERER_PRESENTCOPY; n = 1; } data->format = displayMode->format; /* Find a render driver that we can use to display data */ renderer_flags = (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD); if (flags & SDL_RENDERER_PRESENTVSYNC) { renderer_flags |= SDL_RENDERER_PRESENTVSYNC; } desired_driver = SDL_getenv("SDL_VIDEO_RENDERER_SWDRIVER"); for (i = 0; i < display->num_render_drivers; ++i) { SDL_RenderDriver *driver = &display->render_drivers[i]; if (driver->info.name == SW_RenderDriver.info.name) { continue; } if (desired_driver && SDL_strcasecmp(desired_driver, driver->info.name) != 0) { continue; } data->renderer = driver->CreateRenderer(window, renderer_flags); if (data->renderer) { break; } } if (i == display->num_render_drivers) { SW_DestroyRenderer(renderer); SDL_SetError("Couldn't find display render driver"); return NULL; } if (data->renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) { renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC; } /* Create the textures we'll use for display */ for (i = 0; i < n; ++i) { data->texture[i] = CreateTexture(data->renderer, data->format, window->w, window->h); if (!data->texture[i]) { SW_DestroyRenderer(renderer); return NULL; } } data->current_texture = 0; /* Create a surface we'll use for rendering */ data->surface.flags = SDL_PREALLOC; data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); if (!data->surface.format) { SW_DestroyRenderer(renderer); return NULL; } SDL_SetSurfacePalette(&data->surface, display->palette); /* Set up a palette watch on the display palette */ if (display->palette) { SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data); } return renderer; }
int SDL_EGL_LoadLibrary(_THIS, const char *egl_path, NativeDisplayType native_display) { void *dll_handle = NULL, *egl_dll_handle = NULL; /* The naming is counter intuitive, but hey, I just work here -- Gabriel */ char *path = NULL; #if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_WINRT const char *d3dcompiler; #endif if (_this->egl_data) { return SDL_SetError("OpenGL ES context already created"); } _this->egl_data = (struct SDL_EGL_VideoData *) SDL_calloc(1, sizeof(SDL_EGL_VideoData)); if (!_this->egl_data) { return SDL_OutOfMemory(); } #if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_WINRT d3dcompiler = SDL_GetHint(SDL_HINT_VIDEO_WIN_D3DCOMPILER); if (!d3dcompiler) { if (WIN_IsWindowsVistaOrGreater()) { //WPB Changed to from d3dcompiler_46.dll to d3dcompiler_47.dll d3dcompiler = "d3dcompiler_47.dll"; } else { d3dcompiler = "d3dcompiler_43.dll"; } } if (SDL_strcasecmp(d3dcompiler, "none") != 0) { SDL_LoadObject(d3dcompiler); } #endif /* A funny thing, loading EGL.so first does not work on the Raspberry, so we load libGL* first */ path = SDL_getenv("SDL_VIDEO_GL_DRIVER"); if (path != NULL) { egl_dll_handle = SDL_LoadObject(path); } if (egl_dll_handle == NULL) { if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES) { if (_this->gl_config.major_version > 1) { path = DEFAULT_OGL_ES2; egl_dll_handle = SDL_LoadObject(path); } else { path = DEFAULT_OGL_ES; egl_dll_handle = SDL_LoadObject(path); if (egl_dll_handle == NULL) { path = DEFAULT_OGL_ES_PVR; egl_dll_handle = SDL_LoadObject(path); } } } #ifdef DEFAULT_OGL else { path = DEFAULT_OGL; egl_dll_handle = SDL_LoadObject(path); } #endif } _this->egl_data->egl_dll_handle = egl_dll_handle; if (egl_dll_handle == NULL) { return SDL_SetError("Could not initialize OpenGL / GLES library"); } /* Loading libGL* in the previous step took care of loading libEGL.so, but we future proof by double checking */ if (egl_path != NULL) { dll_handle = SDL_LoadObject(egl_path); } /* Try loading a EGL symbol, if it does not work try the default library paths */ if (dll_handle == NULL || SDL_LoadFunction(dll_handle, "eglChooseConfig") == NULL) { if (dll_handle != NULL) { SDL_UnloadObject(dll_handle); } path = SDL_getenv("SDL_VIDEO_EGL_DRIVER"); if (path == NULL) { path = DEFAULT_EGL; } dll_handle = SDL_LoadObject(path); if (dll_handle == NULL || SDL_LoadFunction(dll_handle, "eglChooseConfig") == NULL) { if (dll_handle != NULL) { SDL_UnloadObject(dll_handle); } return SDL_SetError("Could not load EGL library"); } SDL_ClearError(); } _this->egl_data->dll_handle = dll_handle; /* Load new function pointers */ LOAD_FUNC(eglGetDisplay); LOAD_FUNC(eglInitialize); LOAD_FUNC(eglTerminate); LOAD_FUNC(eglGetProcAddress); LOAD_FUNC(eglChooseConfig); LOAD_FUNC(eglGetConfigAttrib); LOAD_FUNC(eglCreateContext); LOAD_FUNC(eglDestroyContext); LOAD_FUNC(eglCreateWindowSurface); LOAD_FUNC(eglDestroySurface); LOAD_FUNC(eglMakeCurrent); LOAD_FUNC(eglSwapBuffers); LOAD_FUNC(eglSwapInterval); LOAD_FUNC(eglWaitNative); LOAD_FUNC(eglWaitGL); LOAD_FUNC(eglBindAPI); LOAD_FUNC(eglQueryString); #if !defined(__WINRT__) _this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display); if (!_this->egl_data->egl_display) { return SDL_SetError("Could not get EGL display"); } if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) { return SDL_SetError("Could not initialize EGL"); } #endif _this->gl_config.driver_loaded = 1; if (path) { SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1); } else { *_this->gl_config.driver_path = '\0'; } return 0; }
signed ODE_Init() { Quit = SDL_FALSE; dInitODE2(dInitFlagManualThreadCleanup); dSetMessageHandler(Error); dSetDebugHandler(Error); dSetErrorHandler(Error); World = dWorldCreate(); Space = dHashSpaceCreate(0); Group = dJointGroupCreate(0); Step = 1.0/50.0; lua_getglobal(State, "World"); int table = lua_gettop(State); if (!lua_isnil(State, table)) { lua_pushnil(State); while (lua_next(State, table)) { const char *key = lua_tostring(State, -2); #define tointeger lua_tointeger(State, -1) #define toboolean lua_toboolean(State, -1) #define tonumber lua_tonumber(State, -1) if (!SDL_strcasecmp(key, "FPS")) { Step = 1.0/tonumber; } else if (!SDL_strcasecmp(key, "ERP")) { dWorldSetERP(World, tonumber); } else if (!SDL_strcasecmp(key, "CFM")) { dWorldSetCFM(World, tonumber); } else if (!SDL_strcasecmp(key, "LINEAR_DAMPING")) { dWorldSetLinearDamping(World, tonumber); } else if (!SDL_strcasecmp(key, "LINEAR_DAMPING_THRESHOLD")) { dWorldSetLinearDampingThreshold(World, tonumber); } else if (!SDL_strcasecmp(key, "ANGULAR_DAMPING")) { dWorldSetAngularDamping(World, tonumber); } else if (!SDL_strcasecmp(key, "ANGULAR_DAMPING_THRESHOLD")) { dWorldSetAngularDampingThreshold(World, tonumber); } else if (!SDL_strcasecmp(key, "MAX_ANGULAR_SPEED")) { dWorldSetMaxAngularSpeed(World, tonumber); } else if (!SDL_strcasecmp(key, "CONTACT_MAX_CORRECTING_VELOCITY")) { dWorldSetContactMaxCorrectingVel(World, tonumber); } else if (!SDL_strcasecmp(key, "CONTACT_SURFACE_LAYER")) { dWorldSetContactSurfaceLayer(World, tonumber); } else if (!SDL_strcasecmp(key, "AUTO_DISABLE")) { dWorldSetAutoDisableFlag(World, toboolean); } else if (!SDL_strcasecmp(key, "AUTO_DISABLE_LINEAR_THRESHOLD")) { dWorldSetAutoDisableLinearThreshold(World, tonumber); } else if (!SDL_strcasecmp(key, "AUTO_DISABLE_ANGULAR_THRESHOLD")) { dWorldSetAutoDisableAngularThreshold(World, tonumber); } else if (!SDL_strcasecmp(key, "AUTO_DISABLE_STEPS")) { dWorldSetAutoDisableSteps(World, tointeger); } else if (!SDL_strcasecmp(key, "AUTO_DISABLE_TIME")) { dWorldSetAutoDisableTime(World, tonumber); } else { SDL_Log("World: %s does not match", key); } lua_pop(State, 1); } } lua_pop(State, 1); Cond = SDL_CreateCond(); if (!Cond) { dWorldDestroy(World); dSpaceDestroy(Space); dJointGroupDestroy(Group); SDL_perror("SDL_CreateCond"); return SDL_SetError("cannot create simulation signal"); } Mutex = SDL_CreateMutex(); if (!Mutex) { dWorldDestroy(World); dSpaceDestroy(Space); dJointGroupDestroy(Group); SDL_DestroyCond(Cond); SDL_perror("SDL_CreateMutex"); return SDL_SetError("cannot create simulation mutex"); } Thread = SDL_CreateThread(SimulationThread, "ODE", NULL); if (!Thread) { dWorldDestroy(World); dSpaceDestroy(Space); dJointGroupDestroy(Group); SDL_DestroyCond(Cond); SDL_DestroyMutex(Mutex); SDL_perror("SDL_CreateThread"); return SDL_SetError("cannot create simulation thread"); } TimerID = SDL_AddTimer(Uint32(1000*Step), SimulationTimer, NULL); if (!TimerID) { dWorldDestroy(World); dSpaceDestroy(Space); dJointGroupDestroy(Group); SDL_DestroyCond(Cond); SDL_DestroyMutex(Mutex); SDL_perror("SDL_AddTimer"); return SDL_SetError("cannot create simulation timer"); } return 0; }
int main(int argc, char *argv[]) { int fsaa, accel; int value; int i, done; SDL_DisplayMode mode; SDL_Event event; Uint32 then, now, frames; int status; int dw, dh; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Initialize parameters */ fsaa = 0; accel = -1; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { if (SDL_strcasecmp(argv[i], "--fsaa") == 0 && i+1 < argc) { fsaa = atoi(argv[i+1]); consumed = 2; } else if (SDL_strcasecmp(argv[i], "--accel") == 0 && i+1 < argc) { accel = atoi(argv[i+1]); consumed = 2; } else { consumed = -1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--fsaa n] [--accel n]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } /* Set OpenGL parameters */ state->window_flags |= SDL_WINDOW_OPENGL; state->gl_red_size = 5; state->gl_green_size = 5; state->gl_blue_size = 5; state->gl_depth_size = 16; state->gl_double_buffer = 1; if (fsaa) { state->gl_multisamplebuffers = 1; state->gl_multisamplesamples = fsaa; } if (accel >= 0) { state->gl_accelerated = accel; } if (!SDLTest_CommonInit(state)) { quit(2); } /* Create OpenGL context */ context = SDL_GL_CreateContext(state->windows[0]); if (!context) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GL_CreateContext(): %s\n", SDL_GetError()); quit(2); } /* Important: call this *after* creating the context */ if (LoadContext(&ctx) < 0) { SDL_Log("Could not load GL functions\n"); quit(2); return 0; } if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { /* try late-swap-tearing first. If not supported, try normal vsync. */ if (SDL_GL_SetSwapInterval(-1) == -1) { SDL_GL_SetSwapInterval(1); } } else { SDL_GL_SetSwapInterval(0); /* disable vsync. */ } SDL_GetCurrentDisplayMode(0, &mode); SDL_Log("Screen BPP : %d\n", SDL_BITSPERPIXEL(mode.format)); SDL_Log("Swap Interval : %d\n", SDL_GL_GetSwapInterval()); SDL_GetWindowSize(state->windows[0], &dw, &dh); SDL_Log("Window Size : %d,%d\n", dw, dh); SDL_GL_GetDrawableSize(state->windows[0], &dw, &dh); SDL_Log("Draw Size : %d,%d\n", dw, dh); SDL_Log("\n"); SDL_Log("Vendor : %s\n", ctx.glGetString(GL_VENDOR)); SDL_Log("Renderer : %s\n", ctx.glGetString(GL_RENDERER)); SDL_Log("Version : %s\n", ctx.glGetString(GL_VERSION)); SDL_Log("Extensions : %s\n", ctx.glGetString(GL_EXTENSIONS)); SDL_Log("\n"); status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); if (!status) { SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); if (!status) { SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); if (!status) { SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); if (!status) { SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", 16, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError()); } if (fsaa) { status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError()); } } if (accel >= 0) { status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); if (!status) { SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested %d, got %d\n", accel, value); } else { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError()); } } /* Set rendering settings */ ctx.glMatrixMode(GL_PROJECTION); ctx.glLoadIdentity(); ctx.glOrtho(-2.0, 2.0, -2.0, 2.0, -20.0, 20.0); ctx.glMatrixMode(GL_MODELVIEW); ctx.glLoadIdentity(); ctx.glEnable(GL_DEPTH_TEST); ctx.glDepthFunc(GL_LESS); ctx.glShadeModel(GL_SMOOTH); /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { SDLTest_CommonEvent(state, &event, &done); } for (i = 0; i < state->num_windows; ++i) { int w, h; if (state->windows[i] == NULL) continue; SDL_GL_MakeCurrent(state->windows[i], context); SDL_GL_GetDrawableSize(state->windows[i], &w, &h); ctx.glViewport(0, 0, w, h); Render(); SDL_GL_SwapWindow(state->windows[i]); } } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { SDL_Log("%2.2f frames per second\n", ((double) frames * 1000) / (now - then)); } quit(0); return 0; }
int main(int argc, char *argv[]) { int i, j, done; SDL_Event event; Uint32 then, now, frames; SDL_Rect viewport; SDL_bool use_target = SDL_FALSE; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { consumed = -1; if (SDL_strcasecmp(argv[i], "--target") == 0) { use_target = SDL_TRUE; consumed = 1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--target]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } if (!SDLTest_CommonInit(state)) { quit(2); } if (use_target) { int w, h; for (i = 0; i < state->num_windows; ++i) { SDL_GetWindowSize(state->windows[i], &w, &h); state->targets[i] = SDL_CreateTexture(state->renderers[i], SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, w, h); SDL_SetRenderTarget(state->renderers[i], state->targets[i]); } } for (i = 0; i < state->num_windows; ++i) { SDL_Renderer *renderer = state->renderers[i]; SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); } /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; j = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { SDLTest_CommonEvent(state, &event, &done); } /* Move a viewport box in steps around the screen */ viewport.x = j * 100; viewport.y = viewport.x; viewport.w = 100 + j * 50; viewport.h = 100 + j * 50; j = (j + 1) % 4; SDL_Log("Current Viewport x=%i y=%i w=%i h=%i", viewport.x, viewport.y, viewport.w, viewport.h); for (i = 0; i < state->num_windows; ++i) { if (state->windows[i] == NULL) continue; /* Draw using viewport */ DrawOnViewport(state->renderers[i], viewport); /* Update the screen! */ if (use_target) { SDL_SetRenderTarget(state->renderers[i], NULL); SDL_RenderCopy(state->renderers[i], state->targets[i], NULL, NULL); SDL_RenderPresent(state->renderers[i]); SDL_SetRenderTarget(state->renderers[i], state->targets[i]); } else { SDL_RenderPresent(state->renderers[i]); } } SDL_Delay(1000); } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { double fps = ((double) frames * 1000) / (now - then); SDL_Log("%2.2f frames per second\n", fps); } quit(0); return 0; }
int main(int argc, char *argv[]) { int i; Uint32 then, now, frames; Uint64 seed; const char *icon = "icon.bmp"; /* Initialize parameters */ num_sprites = NUM_SPRITES; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { consumed = -1; if (SDL_strcasecmp(argv[i], "--blend") == 0) { if (argv[i + 1]) { if (SDL_strcasecmp(argv[i + 1], "none") == 0) { blendMode = SDL_BLENDMODE_NONE; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) { blendMode = SDL_BLENDMODE_BLEND; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) { blendMode = SDL_BLENDMODE_ADD; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) { blendMode = SDL_BLENDMODE_MOD; consumed = 2; } } } else if (SDL_strcasecmp(argv[i], "--iterations") == 0) { if (argv[i + 1]) { iterations = SDL_atoi(argv[i + 1]); if (iterations < -1) iterations = -1; consumed = 2; } } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) { cycle_color = SDL_TRUE; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) { cycle_alpha = SDL_TRUE; consumed = 1; } else if (SDL_isdigit(*argv[i])) { num_sprites = SDL_atoi(argv[i]); consumed = 1; } else if (argv[i][0] != '-') { icon = argv[i]; consumed = 1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--blend none|blend|add|mod] [--cyclecolor] [--cyclealpha] [--iterations N] [num_sprites] [icon.bmp]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } if (!SDLTest_CommonInit(state)) { quit(2); } /* Create the windows, initialize the renderers, and load the textures */ sprites = (SDL_Texture **) SDL_malloc(state->num_windows * sizeof(*sprites)); if (!sprites) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Out of memory!\n"); quit(2); } for (i = 0; i < state->num_windows; ++i) { SDL_Renderer *renderer = state->renderers[i]; SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); } if (LoadSprite(icon) < 0) { quit(2); } /* Allocate memory for the sprite info */ 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); } /* Position sprites and set their velocities using the fuzzer */ if (iterations >= 0) { /* Deterministic seed - used for visual tests */ seed = (Uint64)iterations; } else { /* Pseudo-random seed generated from the time */ seed = (Uint64)time(NULL); } SDLTest_FuzzerInit(seed); for (i = 0; i < num_sprites; ++i) { positions[i].x = SDLTest_RandomIntegerInRange(0, state->window_w - sprite_w); positions[i].y = SDLTest_RandomIntegerInRange(0, state->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 = SDLTest_RandomIntegerInRange(-MAX_SPEED, MAX_SPEED); velocities[i].y = SDLTest_RandomIntegerInRange(-MAX_SPEED, MAX_SPEED); } } /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; #ifdef __EMSCRIPTEN__ emscripten_set_main_loop(loop, 0, 1); #else while (!done) { ++frames; loop(); } #endif /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { double fps = ((double) frames * 1000) / (now - then); SDL_Log("%2.2f frames per second\n", fps); } quit(0); return 0; }
int main(int argc, char *argv[]) { int i, done; SDL_Event event; Uint32 then, now, frames; /* Initialize parameters */ num_sprites = NUM_SPRITES; /* Initialize test framework */ state = CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = CommonArg(state, i); if (consumed == 0) { consumed = -1; if (SDL_strcasecmp(argv[i], "--blend") == 0) { if (argv[i + 1]) { if (SDL_strcasecmp(argv[i + 1], "none") == 0) { blendMode = SDL_BLENDMODE_NONE; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "mask") == 0) { blendMode = SDL_BLENDMODE_MASK; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) { blendMode = SDL_BLENDMODE_BLEND; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) { blendMode = SDL_BLENDMODE_ADD; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) { blendMode = SDL_BLENDMODE_MOD; consumed = 2; } } } else if (SDL_strcasecmp(argv[i], "--scale") == 0) { if (argv[i + 1]) { if (SDL_strcasecmp(argv[i + 1], "none") == 0) { scaleMode = SDL_TEXTURESCALEMODE_NONE; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "fast") == 0) { scaleMode = SDL_TEXTURESCALEMODE_FAST; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "slow") == 0) { scaleMode = SDL_TEXTURESCALEMODE_SLOW; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "best") == 0) { scaleMode = SDL_TEXTURESCALEMODE_BEST; consumed = 2; } } } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) { cycle_color = SDL_TRUE; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) { cycle_alpha = SDL_TRUE; consumed = 1; } else if (SDL_isdigit(*argv[i])) { num_sprites = SDL_atoi(argv[i]); consumed = 1; } } if (consumed < 0) { fprintf(stderr, "Usage: %s %s [--blend none|mask|blend|add|mod] [--scale none|fast|slow|best] [--cyclecolor] [--cyclealpha]\n", argv[0], CommonUsage(state)); quit(1); } i += consumed; } if (!CommonInit(state)) { quit(2); } /* Create the windows, initialize the renderers, and load the textures */ sprites = (SDL_TextureID *) SDL_malloc(state->num_windows * sizeof(*sprites)); if (!sprites) { fprintf(stderr, "Out of memory!\n"); quit(2); } for (i = 0; i < state->num_windows; ++i) { SDL_SelectRenderer(state->windows[i]); SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderRect(NULL); } if (LoadSprite("icon.bmp") < 0) { quit(2); } /* Allocate memory for the sprite info */ positions = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect)); velocities = (SDL_Rect *) SDL_malloc(num_sprites * sizeof(SDL_Rect)); if (!positions || !velocities) { fprintf(stderr, "Out of memory!\n"); quit(2); } srand(time(NULL)); if (scaleMode != SDL_TEXTURESCALEMODE_NONE) { sprite_w += sprite_w / 2; sprite_h += sprite_h / 2; } for (i = 0; i < num_sprites; ++i) { positions[i].x = rand() % (state->window_w - sprite_w); positions[i].y = rand() % (state->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 */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event)) { CommonEvent(state, &event, &done); switch (event.type) { case SDL_WINDOWEVENT: switch (event.window.event) { case SDL_WINDOWEVENT_EXPOSED: SDL_SelectRenderer(event.window.windowID); SDL_SetRenderDrawColor(0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderRect(NULL); break; } break; default: break; } } for (i = 0; i < state->num_windows; ++i) { MoveSprites(state->windows[i], sprites[i]); } } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { double fps = ((double) frames * 1000) / (now - then); printf("%2.2f frames per second\n", fps); } quit(0); }
int main(int argc, char *argv[]) { int i; Uint32 then, now, frames; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Initialize parameters */ num_objects = NUM_OBJECTS; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { consumed = -1; if (SDL_strcasecmp(argv[i], "--blend") == 0) { if (argv[i + 1]) { if (SDL_strcasecmp(argv[i + 1], "none") == 0) { blendMode = SDL_BLENDMODE_NONE; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "blend") == 0) { blendMode = SDL_BLENDMODE_BLEND; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "add") == 0) { blendMode = SDL_BLENDMODE_ADD; consumed = 2; } else if (SDL_strcasecmp(argv[i + 1], "mod") == 0) { blendMode = SDL_BLENDMODE_MOD; consumed = 2; } } } else if (SDL_strcasecmp(argv[i], "--cyclecolor") == 0) { cycle_color = SDL_TRUE; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--cyclealpha") == 0) { cycle_alpha = SDL_TRUE; consumed = 1; } else if (SDL_isdigit(*argv[i])) { num_objects = SDL_atoi(argv[i]); consumed = 1; } } if (consumed < 0) { SDL_Log("Usage: %s %s [--blend none|blend|add|mod] [--cyclecolor] [--cyclealpha]\n", argv[0], SDLTest_CommonUsage(state)); return 1; } i += consumed; } if (!SDLTest_CommonInit(state)) { return 2; } /* Create the windows and initialize the renderers */ for (i = 0; i < state->num_windows; ++i) { SDL_Renderer *renderer = state->renderers[i]; SDL_SetRenderDrawBlendMode(renderer, blendMode); SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); } srand((unsigned int)time(NULL)); /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; #ifdef __EMSCRIPTEN__ emscripten_set_main_loop(loop, 0, 1); #else while (!done) { ++frames; loop(); } #endif SDLTest_CommonQuit(state); /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { double fps = ((double) frames * 1000) / (now - then); SDL_Log("%2.2f frames per second\n", fps); } return 0; }
int main(int argc, char *argv[]) { int i; SDL_Event event; Uint32 then, now, frames; FPSmanager fpsm; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } SDL_Log("SDL2_gfx %i.%i.%i: testframerate", SDL2_GFXPRIMITIVES_MAJOR, SDL2_GFXPRIMITIVES_MINOR, SDL2_GFXPRIMITIVES_MICRO); SDL_Log("Platform: %s", SDL_GetPlatform()); for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { consumed = -1; if (SDL_strcasecmp(argv[i], "--x") == 0) { if (argv[i + 1]) { x = SDL_atoi(argv[i + 1]); if (x < 0) x = 0; if (x >= WIDTH) x = WIDTH - 1; consumed = 2; } } else if (SDL_strcasecmp(argv[i], "--y") == 0) { if (argv[i + 1]) { y = SDL_atoi(argv[i + 1]); if (y < 0) y = 0; if (y >= HEIGHT) y = HEIGHT - 1; consumed = 2; } } } if (consumed < 0) { SDL_Log("Usage: %s %s [--x #] [--y #]\n", argv[0], SDLTest_CommonUsage(state)); return 1; } i += consumed; } if (!SDLTest_CommonInit(state)) { return 2; } /* Create the windows and initialize the renderers */ for (i = 0; i < state->num_windows; ++i) { SDL_Renderer *renderer = state->renderers[i]; SDL_RendererInfo info; SDL_GetRendererInfo(state->renderers[i], &info); SDL_Log("Renderer %i: %s %s", i, info.name, (info.flags | SDL_RENDERER_ACCELERATED) ? "(Accelerated)" : ""); SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF); SDL_RenderClear(renderer); } /* Initialize random number generator */ srand((unsigned int)time(NULL)); /* Create common message buffer */ messageText = (char *)SDL_malloc(1024); if (messageText == NULL) { return -1; } /* Initialize framerate manager */ SDL_initFramerate(&fpsm); /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; while (!done) { /* Check for events */ ++frames; while (SDL_PollEvent(&event) && !done) { SDLTest_CommonEvent(state, &event, &done); } /* Do all the drawing work */ Draw(state->renderers[0], &fpsm); } /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { double fps = ((double) frames * 1000) / (now - then); SDL_Log("%2.2f frames per second\n", fps); } /* Free common message buffer */ if (messageText) { free(messageText); } /* Shutdown SDL */ SDLTest_CommonQuit(state); return 0; }
int main(int argc, char *argv[]) { int fsaa, accel; int value; int i; SDL_DisplayMode mode; Uint32 then, now; int status; shader_data *data; /* Initialize parameters */ fsaa = 0; accel = 0; /* Initialize test framework */ state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO); if (!state) { return 1; } for (i = 1; i < argc;) { int consumed; consumed = SDLTest_CommonArg(state, i); if (consumed == 0) { if (SDL_strcasecmp(argv[i], "--fsaa") == 0) { ++fsaa; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--accel") == 0) { ++accel; consumed = 1; } else if (SDL_strcasecmp(argv[i], "--zdepth") == 0) { i++; if (!argv[i]) { consumed = -1; } else { depth = SDL_atoi(argv[i]); consumed = 1; } } else { consumed = -1; } } if (consumed < 0) { SDL_Log ("Usage: %s %s [--fsaa] [--accel] [--zdepth %%d]\n", argv[0], SDLTest_CommonUsage(state)); quit(1); } i += consumed; } /* Set OpenGL parameters */ state->window_flags |= SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_BORDERLESS; state->gl_red_size = 5; state->gl_green_size = 5; state->gl_blue_size = 5; state->gl_depth_size = depth; state->gl_major_version = 2; state->gl_minor_version = 0; state->gl_profile_mask = SDL_GL_CONTEXT_PROFILE_ES; if (fsaa) { state->gl_multisamplebuffers=1; state->gl_multisamplesamples=fsaa; } if (accel) { state->gl_accelerated=1; } if (!SDLTest_CommonInit(state)) { quit(2); return 0; } context = (SDL_GLContext *)SDL_calloc(state->num_windows, sizeof(context)); if (context == NULL) { SDL_Log("Out of memory!\n"); quit(2); } /* Create OpenGL ES contexts */ for (i = 0; i < state->num_windows; i++) { context[i] = SDL_GL_CreateContext(state->windows[i]); if (!context[i]) { SDL_Log("SDL_GL_CreateContext(): %s\n", SDL_GetError()); quit(2); } } /* Important: call this *after* creating the context */ if (LoadContext(&ctx) < 0) { SDL_Log("Could not load GLES2 functions\n"); quit(2); return 0; } /* from here on out, it should be ok to call gles 2.0 routines */ if (state->render_flags & SDL_RENDERER_PRESENTVSYNC) { SDL_GL_SetSwapInterval(1); } else { SDL_GL_SetSwapInterval(0); } SDL_Log("first call address is %llx data is %lx\n",(long long)(&glGetString),GL_VENDOR); const char *test = ctx.glGetString(GL_VENDOR); if (test) { SDL_Log("we got %s\n",test); } else { SDL_Log("we got a null.\n"); quit(2); } SDL_Log("try again call address is %lx\n",(long long)(&glGetString)); SDL_Log("first ctx address is %llx data is %lx ind %llx\n",(long long)(ctx.glGetString),GL_VENDOR,((long long *)(ctx.glGetString))[0] ); {const char *test = glGetString(GL_VENDOR); if (test) { SDL_Log("we got %s\n",test); } else { SDL_Log("we got a null.\n"); quit(2); } } SDL_GetCurrentDisplayMode(0, &mode); SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(mode.format)); SDL_Log("\n"); SDL_Log("Vendor : %s\n", glGetString(GL_VENDOR)); SDL_Log("Renderer : %s\n", glGetString(GL_RENDERER)); SDL_Log("Version : %s\n", glGetString(GL_VERSION)); SDL_Log("Extensions : %s\n", glGetString(GL_EXTENSIONS)); SDL_Log("\n"); status = SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value); if (!status) { SDL_Log("SDL_GL_RED_SIZE: requested %d, got %d\n", 5, value); } else { SDL_Log( "Failed to get SDL_GL_RED_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value); if (!status) { SDL_Log("SDL_GL_GREEN_SIZE: requested %d, got %d\n", 5, value); } else { SDL_Log( "Failed to get SDL_GL_GREEN_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value); if (!status) { SDL_Log("SDL_GL_BLUE_SIZE: requested %d, got %d\n", 5, value); } else { SDL_Log( "Failed to get SDL_GL_BLUE_SIZE: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value); if (!status) { SDL_Log("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", depth, value); } else { SDL_Log( "Failed to get SDL_GL_DEPTH_SIZE: %s\n", SDL_GetError()); } if (fsaa) { status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value); } else { SDL_Log( "Failed to get SDL_GL_MULTISAMPLEBUFFERS: %s\n", SDL_GetError()); } status = SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value); if (!status) { SDL_Log("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value); } else { SDL_Log( "Failed to get SDL_GL_MULTISAMPLESAMPLES: %s\n", SDL_GetError()); } } if (accel) { status = SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value); if (!status) { SDL_Log("SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value); } else { SDL_Log( "Failed to get SDL_GL_ACCELERATED_VISUAL: %s\n", SDL_GetError()); } } datas = (shader_data *)SDL_calloc(state->num_windows, sizeof(shader_data)); /* Set rendering settings for each context */ for (i = 0; i < state->num_windows; ++i) { int w, h; status = SDL_GL_MakeCurrent(state->windows[i], context[i]); if (status) { SDL_Log("SDL_GL_MakeCurrent(): %s\n", SDL_GetError()); /* Continue for next window */ continue; } SDL_GL_GetDrawableSize(state->windows[i], &w, &h); glViewport(0, 0, w, h); data = &datas[i]; data->angle_x = 0; data->angle_y = 0; data->angle_z = 0; /* Shader Initialization */ process_shader(&data->shader_vert, _shader_vert_src, GL_VERTEX_SHADER); process_shader(&data->shader_frag, _shader_frag_src, GL_FRAGMENT_SHADER); /* Create shader_program (ready to attach shaders) */ data->shader_program = GL_CHECK(glCreateProgram()); /* Attach shaders and link shader_program */ GL_CHECK(glAttachShader(data->shader_program, data->shader_vert)); GL_CHECK(glAttachShader(data->shader_program, data->shader_frag)); GL_CHECK(glLinkProgram(data->shader_program)); /* Get attribute locations of non-fixed attributes like color and texture coordinates. */ data->attr_position = GL_CHECK(glGetAttribLocation(data->shader_program, "av4position")); data->attr_color = GL_CHECK(glGetAttribLocation(data->shader_program, "av3color")); /* Get uniform locations */ data->attr_mvp = GL_CHECK(glGetUniformLocation(data->shader_program, "mvp")); GL_CHECK(glUseProgram(data->shader_program)); /* Enable attributes for position, color and texture coordinates etc. */ GL_CHECK(glEnableVertexAttribArray(data->attr_position)); GL_CHECK(glEnableVertexAttribArray(data->attr_color)); /* Populate attributes for position, color and texture coordinates etc. */ GL_CHECK(glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, _vertices)); GL_CHECK(glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, _colors)); GL_CHECK(glEnable(GL_CULL_FACE)); GL_CHECK(glEnable(GL_DEPTH_TEST)); } /* Main render loop */ frames = 0; then = SDL_GetTicks(); done = 0; #ifdef __EMSCRIPTEN__ emscripten_set_main_loop(loop, 0, 1); #else while (!done) { loop(); } #endif /* Print out some timing information */ now = SDL_GetTicks(); if (now > then) { SDL_Log("%2.2f frames per second\n", ((double) frames * 1000) / (now - then)); } #if !defined(__ANDROID__) && !defined(__NACL__) quit(0); #endif return 0; }
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()); } 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\n", mode.w, mode.h, mode.refresh_rate, bpp); 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\n", j, mode.w, mode.h, mode.refresh_rate, bpp); 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); } } } 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; default: fullscreen_mode.format = SDL_PIXELFORMAT_RGB888; break; } fullscreen_mode.w = state->window_w; fullscreen_mode.h = state->window_h; fullscreen_mode.refresh_rate = state->refresh_rate; SDL_SetFullscreenDisplayMode(&fullscreen_mode); state->windows = (SDL_WindowID *) 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 (!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; }