int
SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags)
{
int i, actual_bpp = 0;
if (!SDL_GetVideoDevice()) {
return 0;
}
if (!(flags & SDL_FULLSCREEN)) {
SDL_DisplayMode mode;
SDL_GetDesktopDisplayMode(GetVideoDisplay(), &mode);
return SDL_BITSPERPIXEL(mode.format);
}
for (i = 0; i < SDL_GetNumDisplayModes(GetVideoDisplay()); ++i) {
SDL_DisplayMode mode;
SDL_GetDisplayMode(GetVideoDisplay(), i, &mode);
if (!mode.w || !mode.h || (width == mode.w && height == mode.h)) {
if (!mode.format) {
return bpp;
}
if (SDL_BITSPERPIXEL(mode.format) >= (Uint32) bpp) {
actual_bpp = SDL_BITSPERPIXEL(mode.format);
}
}
}
return actual_bpp;
}
VideoMode VideoMode::getDesktopMode()
{
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(0, &dm) != 0)
return {};
return {(u32)dm.w, (u32)dm.h, SDL_BITSPERPIXEL(dm.format)};
}
int SDL_COMPAT_GetBitsPerPixel(void)
{
int bpp;
SDL_DisplayMode mode;
SDL_GetCurrentDisplayMode(0, &mode);
bpp = SDL_BITSPERPIXEL(mode.format);
return (bpp==24)? 32 : bpp;
}
int
sdl_init()
{
/* Initialize defaults and Video subsystem */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
LOGE("sdl-video", "Unable to initialize SDL: %s.", SDL_GetError());
return -1;
}
/* Display program name and version in caption */
char caption[64];
snprintf(caption, 64, "freeserf %s", FREESERF_VERSION);
/* Create window and renderer */
window = SDL_CreateWindow(caption,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
800, 600, SDL_WINDOW_RESIZABLE);
if (window == NULL) {
LOGE("sdl-video", "Unable to create SDL window: %s.", SDL_GetError());
return -1;
}
/* Create renderer for window */
renderer = SDL_CreateRenderer(window, -1, 0);
if (renderer == NULL) {
LOGE("sdl-video", "Unable to create SDL renderer: %s.", SDL_GetError());
return -1;
}
/* Determine optimal pixel format for current window */
SDL_RendererInfo render_info = {0};
SDL_GetRendererInfo(renderer, &render_info);
for (int i = 0; i < render_info.num_texture_formats; i++) {
Uint32 format = render_info.texture_formats[i];
int bpp = SDL_BITSPERPIXEL(format);
if (32 == bpp) {
pixel_format = format;
break;
}
}
SDL_PixelFormatEnumToMasks(pixel_format, &bpp, &Rmask, &Gmask, &Bmask, &Amask);
/* Set scaling mode */
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
/* Exit on signals */
signal(SIGINT, exit);
signal(SIGTERM, exit);
/* Init sprite cache */
surface_ht_init(&transp_sprite_cache, 4096);
surface_ht_init(&overlay_sprite_cache, 512);
surface_ht_init(&masked_sprite_cache, 1024);
return 0;
}
static void osd_sdl_info(void)
{
#if SDL_VERSION_ATLEAST(1,3,0)
int i, cur, num = SDL_GetNumVideoDrivers();
mame_printf_verbose("Available videodrivers: ");
for (i=0;i<num;i++)
{
const char *name = SDL_GetVideoDriver(i);
mame_printf_verbose("%s ", name);
}
mame_printf_verbose("\n");
mame_printf_verbose("Current Videodriver: %s\n", SDL_GetCurrentVideoDriver());
num = SDL_GetNumVideoDisplays();
cur = SDL_GetCurrentVideoDisplay();
for (i=0;i<num;i++)
{
SDL_DisplayMode mode;
int j;
SDL_SelectVideoDisplay(i);
mame_printf_verbose("\tDisplay #%d\n", i);
if (SDL_GetDesktopDisplayMode(&mode));
mame_printf_verbose("\t\tDesktop Mode: %dx%d-%d@%d\n", mode.w, mode.h, SDL_BITSPERPIXEL(mode.format), mode.refresh_rate);
if (SDL_GetCurrentDisplayMode(&mode));
mame_printf_verbose("\t\tCurrent Display Mode: %dx%d-%d@%d\n", mode.w, mode.h, SDL_BITSPERPIXEL(mode.format), mode.refresh_rate);
mame_printf_verbose("\t\tRenderdrivers:\n");
for (j=0; j<SDL_GetNumRenderDrivers(); j++)
{
SDL_RendererInfo info;
SDL_GetRenderDriverInfo(j, &info);
mame_printf_verbose("\t\t\t%10s (%dx%d)\n", info.name, info.max_texture_width, info.max_texture_height);
}
}
SDL_SelectVideoDisplay(cur);
mame_printf_verbose("Available audio drivers: \n");
num = SDL_GetNumAudioDrivers();
for (i=0;i<num;i++)
{
mame_printf_verbose("\t%-20s\n", SDL_GetAudioDriver(i));
}
#endif
}
static HRESULT WINAPI
DRI3Present_GetWindowInfo( struct DRI3Present *This,
HWND hWnd,
int *width, int *height, int *depth )
{
int w,h;
SDL_GetWindowSize(This->sdl_win, &w, &h);
Uint32 format = SDL_GetWindowPixelFormat(This->sdl_win);
*width = w;
*height = h;
*depth = format != SDL_PIXELFORMAT_UNKNOWN ? SDL_BITSPERPIXEL(format) : 24;
return D3D_OK;
}
int bbSDLGraphicsGraphicsModes( int display, int *imodes,int maxcount ) {
SDL_DisplayMode mode;
int count,i;
count = SDL_GetNumDisplayModes(display);
if (count>maxcount) count=maxcount;
for (i=0;i<count;i++) {
SDL_GetDisplayMode(display, i, &mode);
*imodes++=mode.w;
*imodes++=mode.h;
*imodes++=SDL_BITSPERPIXEL(mode.format);
*imodes++=mode.refresh_rate;
}
return count;
}
/*
* Calculate the pad-aligned scanline width of a surface
*/
int
SDL_CalculatePitch(Uint32 format, int width)
{
int pitch;
/* Surface should be 4-byte aligned for speed */
pitch = width * SDL_BYTESPERPIXEL(format);
switch (SDL_BITSPERPIXEL(format)) {
case 1:
pitch = (pitch + 7) / 8;
break;
case 4:
pitch = (pitch + 1) / 2;
break;
default:
break;
}
pitch = (pitch + 3) & ~3; /* 4-byte aligning */
return pitch;
}
/*
* VID_GetSysModes
*/
unsigned int VID_GetSysModes( vidmode_t *modes )
{
int num;
SDL_DisplayMode mode;
int prevwidth = 0, prevheight = 0;
unsigned int ret = 0;
num = SDL_GetNumDisplayModes( 0 );
if( num < 1 )
return 0;
while( num-- ) // reverse to help the sorting a little
{
if( SDL_GetDisplayMode( 0, num, &mode ) )
continue;
if( SDL_BITSPERPIXEL( mode.format ) < 16 )
continue;
if( ( mode.w == prevwidth ) && ( mode.h == prevheight ) )
continue;
if( modes )
{
modes[ret].width = mode.w;
modes[ret].height = mode.h;
}
prevwidth = mode.w;
prevheight = mode.h;
ret++;
}
return ret;
}
const Array<VideoMode>& VideoMode::getFullscreenModes()
{
LOCAL_PERSIST Array<VideoMode> modes{defaultAllocator()};
if (len(modes) == 0)
{
s32 displayModeCount;
SDL_DisplayMode dm;
displayModeCount = SDL_GetNumDisplayModes(0);
if (displayModeCount < 1)
{
std::cerr << "SDL_GetNumDisplayModes failed: " << SDL_GetError()
<< std::endl;
return modes;
}
for (s32 i = 0; i < displayModeCount; i++)
{
if (SDL_GetDisplayMode(0, i, &dm) != 0)
{
std::cerr << "SDL_GetNumDisplayModes failed: " << SDL_GetError()
<< std::endl;
continue;
}
append(
modes,
VideoMode{(u32)dm.w, (u32)dm.h, SDL_BITSPERPIXEL(dm.format)});
}
std::sort(begin(modes), end(modes), std::greater<VideoMode>());
}
return modes;
}
void WINDOW_SDL::ChangeDisplay(
int width, int height,
int bpp, int dbpp,
bool fullscreen,
unsigned int antialiasing,
std::ostream & info_output,
std::ostream & error_output)
{
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, dbpp);
fsaa = 1;
if (antialiasing > 1)
{
fsaa = antialiasing;
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);
info_output << "Enabling antialiasing: " << fsaa << "X" << std::endl;
}
else
{
info_output << "Disabling antialiasing" << std::endl;
}
#if SDL_VERSION_ATLEAST(2,0,0)
SDL_DisplayMode desktop_mode;
int display = GetVideoDisplay();
SDL_GetDesktopDisplayMode(display, &desktop_mode);
if (width == 0)
width = desktop_mode.w;
if (height == 0)
height = desktop_mode.h;
if (bpp == 0)
bpp = SDL_BITSPERPIXEL(desktop_mode.format);
// Try to resize the existing window and surface
if (!fullscreen && ResizeWindow(width, height))
return;
if (glcontext)
{
SDL_GL_DeleteContext(glcontext);
glcontext = NULL;
}
if (window)
{
SDL_DestroyWindow(window);
}
// Create a new window
Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
if (fullscreen)
window_flags |= SDL_WINDOW_FULLSCREEN;
window = SDL_CreateWindow(NULL,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height, window_flags);
if (!window)
{
assert(0);
}
glcontext = SDL_GL_CreateContext(window);
if (!glcontext)
{
assert(0);
}
if (SDL_GL_MakeCurrent(window, glcontext) < 0)
{
assert(0);
}
#else
const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
if (!videoInfo)
{
error_output << "SDL video query failed: " << SDL_GetError() << std::endl;
assert (0);
}
int videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
if (fullscreen)
videoFlags |= (SDL_HWSURFACE | SDL_ANYFORMAT | SDL_FULLSCREEN);
else
videoFlags |= (SDL_SWSURFACE | SDL_ANYFORMAT);
if (surface != NULL)
{
SDL_FreeSurface(surface);
surface = NULL;
}
surface = SDL_SetVideoMode(width, height, bpp, videoFlags);
if (!surface)
{
error_output << "Display change failed: " << width << "x" << height << "x" << bpp << " " << dbpp << "z fullscreen=" << fullscreen << std::endl << "Error: " << SDL_GetError() << std::endl;
assert (0);
}
else
{
info_output << "Display change was successful: " << width << "x" << height << "x" << bpp << " " << dbpp << "z fullscreen=" << fullscreen << std::endl;
}
#endif
w = width;
h = height;
}
int video_mode(int f, int w, int h)
{
//senquack
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE);
int stereo = config_get_d(CONFIG_STEREO) ? 1 : 0;
int stencil = config_get_d(CONFIG_REFLECTION) ? 1 : 0;
int buffers = config_get_d(CONFIG_MULTISAMPLE) ? 1 : 0;
int samples = config_get_d(CONFIG_MULTISAMPLE);
int vsync = config_get_d(CONFIG_VSYNC) ? 1 : 0;
int hmd = config_get_d(CONFIG_HMD) ? 1 : 0;
int highdpi = config_get_d(CONFIG_HIGHDPI) ? 1 : 0;
int dpy = config_get_d(CONFIG_DISPLAY);
int X = SDL_WINDOWPOS_CENTERED_DISPLAY(dpy);
int Y = SDL_WINDOWPOS_CENTERED_DISPLAY(dpy);
hmd_free();
if (window)
{
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
}
//senquack
// SDL_GL_SetAttribute(SDL_GL_STEREO, stereo);
//senquack - disabled drawing shadows and reflections on GCW Zero, don't need a stencil buffer:
#ifdef GCWZERO
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
#endif
//senquack - don't need or want these on GCW Zero:
#ifndef GCWZERO
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, buffers);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, samples);
#endif
/* Require 16-bit double buffer with 16-bit depth buffer. */
//senquack - GCW Zero port change
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_BUFFER_SIZE, 32);
// SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
// SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
// SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
// SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
// SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
//senquack
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
/* Try to set the currently specified mode. */
log_printf("Creating a window (%dx%d, %s)\n",
w, h, (f ? "fullscreen" : "windowed"));
//senquack DEBUG - DO NOT RUN - loads GLES2.0 for some reason
// SDL_VideoInit(NULL);
window = SDL_CreateWindow("", X, Y, w, h,
SDL_WINDOW_OPENGL |
(highdpi ? SDL_WINDOW_ALLOW_HIGHDPI : 0) |
(f ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));
if (window)
{
if ((context = SDL_GL_CreateContext(window)))
{
int buf, smp;
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &buf);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &smp);
/*
* Work around SDL+WGL returning pixel formats below
* minimum specifications instead of failing, thus
* bypassing our fallback path. SDL tries to ensure that
* WGL plays by the rules, but forgets about extended
* context attributes such as multisample. See SDL
* Bugzilla #77.
*/
if (buf < buffers || smp < samples)
{
log_printf("GL context does not meet minimum specifications\n");
SDL_GL_DeleteContext(context);
context = NULL;
}
}
}
if (window && context)
{
set_window_title(TITLE);
set_window_icon(ICON);
/*
* SDL_GetWindowSize can be unreliable when going fullscreen
* on OSX (and possibly elsewhere). We should really be
* waiting for a resize / size change event, but for now we're
* doing this lazy thing instead.
*/
if (f)
{
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(video_display(), &dm) == 0)
{
video.window_w = dm.w;
video.window_h = dm.h;
// //senquack
dm.format = SDL_PIXELFORMAT_RGBA8888;
// dm.format = SDL_PIXELFORMAT_RGB565;
dm.w = 320;
dm.h = 240;
dm.refresh_rate = 60;
dm.driverdata = 0;
SDL_SetWindowDisplayMode(window, &dm);
printf("setting new video dm..\n");
SDL_GetCurrentDisplayMode(0, &dm);
SDL_Log("Screen w: %d h: %d\n", dm.w, dm.h);
SDL_Log("Screen bpp: %d\n", SDL_BITSPERPIXEL(dm.format));
SDL_Log("Screen dm: ");
SDL_Log("\n\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");
fflush(NULL);
}
}
else
{
SDL_GetWindowSize(window, &video.window_w, &video.window_h);
}
if (highdpi)
{
SDL_GL_GetDrawableSize(window, &video.device_w, &video.device_h);
}
else
{
video.device_w = video.window_w;
video.device_h = video.window_h;
}
video.device_scale = (float) video.device_h / (float) video.window_h;
log_printf("Created a window (%u, %dx%d, %s)\n",
SDL_GetWindowID(window),
video.window_w, video.window_h,
(f ? "fullscreen" : "windowed"));
config_set_d(CONFIG_DISPLAY, video_display());
config_set_d(CONFIG_FULLSCREEN, f);
config_set_d(CONFIG_WIDTH, video.window_w);
config_set_d(CONFIG_HEIGHT, video.window_h);
SDL_GL_SetSwapInterval(vsync);
if (!glext_init())
return 0;
glViewport(0, 0, video.device_w, video.device_h);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_LIGHTING);
glEnable(GL_BLEND);
#if !ENABLE_OPENGLES
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,
GL_SEPARATE_SPECULAR_COLOR);
#endif
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthFunc(GL_LEQUAL);
/* If GL supports multisample, and SDL got a multisample buffer... */
if (glext_check("ARB_multisample"))
{
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &buffers);
if (buffers) glEnable(GL_MULTISAMPLE);
}
/* Set up HMD display if requested. */
if (hmd)
hmd_init();
/* Initialize screen snapshotting. */
snapshot_init();
video_show_cursor();
/* Grab input immediately in HMD mode. */
if (hmd_stat())
SDL_SetWindowGrab(window, SDL_TRUE);
return 1;
}
/* If the mode failed, try it without stereo. */
else if (stereo)
{
config_set_d(CONFIG_STEREO, 0);
return video_mode(f, w, h);
}
/* If the mode failed, try decreasing the level of multisampling. */
else if (buffers)
{
config_set_d(CONFIG_MULTISAMPLE, samples / 2);
return video_mode(f, w, h);
}
/* If that mode failed, try it without reflections. */
else if (stencil)
{
config_set_d(CONFIG_REFLECTION, 0);
return video_mode(f, w, h);
}
/* If THAT mode failed, punt. */
return 0;
}
); int nib = SDL_GetDesktopDisplayMode(displayIdx, &desktop_mode); // Push the current resolution information into Lua. lua_newtable(L); lua_pushstring(L, "w"); lua_pushnumber(L, current_mode.w); lua_settable(L, -3); lua_pushstring(L, "h"); lua_pushnumber(L, current_mode.h); lua_settable(L,-3); lua_pushstring(L, "bpp"); lua_pushnumber(L, SDL_BITSPERPIXEL(current_mode.format)); lua_settable(L,-3); lua_pushstring(L, "refresh"); lua_pushnumber(L, current_mode.refresh_rate); lua_settable(L,-3); // @todo Determine whether fullscreen or not. lua_pushstring(L, "format"); lua_pushnumber(L, current_mode.format); //lua_pushboolean(L, 0); lua_settable(L,-3); #ifdef RETURNGLOBALS lua_setglobal(L,"resolutionCurrent"); #endif
SDL_Surface *
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
SDL_DisplayMode desktop_mode;
int display = GetVideoDisplay();
int window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(display);
int window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(display);
int window_w;
int window_h;
Uint32 window_flags;
Uint32 surface_flags;
if (!SDL_GetVideoDevice()) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) {
return NULL;
}
}
SDL_GetDesktopDisplayMode(display, &desktop_mode);
if (width == 0) {
width = desktop_mode.w;
}
if (height == 0) {
height = desktop_mode.h;
}
if (bpp == 0) {
bpp = SDL_BITSPERPIXEL(desktop_mode.format);
}
/* See if we can simply resize the existing window and surface */
if (SDL_ResizeVideoMode(width, height, bpp, flags) == 0) {
return SDL_PublicSurface;
}
/* Destroy existing window */
SDL_PublicSurface = NULL;
if (SDL_ShadowSurface) {
SDL_ShadowSurface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(SDL_ShadowSurface);
SDL_ShadowSurface = NULL;
}
if (SDL_VideoSurface) {
SDL_VideoSurface->flags &= ~SDL_DONTFREE;
SDL_FreeSurface(SDL_VideoSurface);
SDL_VideoSurface = NULL;
}
if (SDL_VideoContext) {
/* SDL_GL_MakeCurrent(0, NULL); *//* Doesn't do anything */
SDL_GL_DeleteContext(SDL_VideoContext);
SDL_VideoContext = NULL;
}
if (SDL_VideoWindow) {
SDL_GetWindowPosition(SDL_VideoWindow, &window_x, &window_y);
SDL_DestroyWindow(SDL_VideoWindow);
}
/* Set up the event filter */
if (!SDL_GetEventFilter(NULL, NULL)) {
SDL_SetEventFilter(SDL_CompatEventFilter, NULL);
}
/* Create a new window */
window_flags = SDL_WINDOW_SHOWN;
if (flags & SDL_FULLSCREEN) {
window_flags |= SDL_WINDOW_FULLSCREEN;
}
if (flags & SDL_OPENGL) {
window_flags |= SDL_WINDOW_OPENGL;
}
if (flags & SDL_RESIZABLE) {
window_flags |= SDL_WINDOW_RESIZABLE;
}
if (flags & SDL_NOFRAME) {
window_flags |= SDL_WINDOW_BORDERLESS;
}
GetEnvironmentWindowPosition(width, height, &window_x, &window_y);
SDL_VideoWindow =
SDL_CreateWindow(wm_title, window_x, window_y, width, height,
window_flags);
if (!SDL_VideoWindow) {
return NULL;
}
SDL_SetWindowIcon(SDL_VideoWindow, SDL_VideoIcon);
SetupScreenSaver(flags);
window_flags = SDL_GetWindowFlags(SDL_VideoWindow);
surface_flags = 0;
if (window_flags & SDL_WINDOW_FULLSCREEN) {
surface_flags |= SDL_FULLSCREEN;
}
if ((window_flags & SDL_WINDOW_OPENGL) && (flags & SDL_OPENGL)) {
surface_flags |= SDL_OPENGL;
}
if (window_flags & SDL_WINDOW_RESIZABLE) {
surface_flags |= SDL_RESIZABLE;
}
if (window_flags & SDL_WINDOW_BORDERLESS) {
surface_flags |= SDL_NOFRAME;
}
SDL_VideoFlags = flags;
/* If we're in OpenGL mode, just create a stub surface and we're done! */
if (flags & SDL_OPENGL) {
SDL_VideoContext = SDL_GL_CreateContext(SDL_VideoWindow);
if (!SDL_VideoContext) {
return NULL;
}
if (SDL_GL_MakeCurrent(SDL_VideoWindow, SDL_VideoContext) < 0) {
return NULL;
}
SDL_VideoSurface =
SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0);
if (!SDL_VideoSurface) {
return NULL;
}
SDL_VideoSurface->flags |= surface_flags;
SDL_PublicSurface = SDL_VideoSurface;
return SDL_PublicSurface;
}
/* Create the screen surface */
SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow);
if (!SDL_WindowSurface) {
return NULL;
}
/* Center the public surface in the window surface */
SDL_GetWindowSize(SDL_VideoWindow, &window_w, &window_h);
SDL_VideoViewport.x = (window_w - width)/2;
SDL_VideoViewport.y = (window_h - height)/2;
SDL_VideoViewport.w = width;
SDL_VideoViewport.h = height;
SDL_VideoSurface = SDL_CreateRGBSurfaceFrom(NULL, 0, 0, 32, 0, 0, 0, 0, 0);
SDL_VideoSurface->flags |= surface_flags;
SDL_VideoSurface->flags |= SDL_DONTFREE;
SDL_FreeFormat(SDL_VideoSurface->format);
SDL_VideoSurface->format = SDL_WindowSurface->format;
SDL_VideoSurface->format->refcount++;
SDL_VideoSurface->w = width;
SDL_VideoSurface->h = height;
SDL_VideoSurface->pitch = SDL_WindowSurface->pitch;
SDL_VideoSurface->pixels = (void *)((Uint8 *)SDL_WindowSurface->pixels +
SDL_VideoViewport.y * SDL_VideoSurface->pitch +
SDL_VideoViewport.x * SDL_VideoSurface->format->BytesPerPixel);
SDL_SetClipRect(SDL_VideoSurface, NULL);
/* Create a shadow surface if necessary */
if ((bpp != SDL_VideoSurface->format->BitsPerPixel)
&& !(flags & SDL_ANYFORMAT)) {
SDL_ShadowSurface =
SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);
if (!SDL_ShadowSurface) {
return NULL;
}
SDL_ShadowSurface->flags |= surface_flags;
SDL_ShadowSurface->flags |= SDL_DONTFREE;
/* 8-bit SDL_ShadowSurface surfaces report that they have exclusive palette */
if (SDL_ShadowSurface->format->palette) {
SDL_ShadowSurface->flags |= SDL_HWPALETTE;
SDL_DitherColors(SDL_ShadowSurface->format->palette->colors,
SDL_ShadowSurface->format->BitsPerPixel);
}
SDL_FillRect(SDL_ShadowSurface, NULL,
SDL_MapRGB(SDL_ShadowSurface->format, 0, 0, 0));
}
SDL_PublicSurface =
(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);
ClearVideoSurface();
/* We're finally done! */
return SDL_PublicSurface;
}
int lite3d_video_open(lite3d_video_settings *settings, int hideConsole)
{
uint32_t windowFlags;
SDL_DisplayMode displayMode;
SDL_assert(settings);
#ifdef PLATFORM_Windows
if (hideConsole)
{
FreeConsole();
}
#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, settings->colorBits > 24 ? 8 : 0);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
#ifndef GLES
/* Specify openGL context */
if (settings->FSAA > 1)
{
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, settings->FSAA);
}
if (settings->glProfile == LITE3D_GL_PROFILE_CORE)
{
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"Setting Core OpenGL Profile");
SDL_GL_SetAttribute(
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_CORE);
set_opengl_version(settings);
}
else if (settings->glProfile == LITE3D_GL_PROFILE_COMPATIBILITY)
{
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"Setting Compatibility OpenGL Profile");
SDL_GL_SetAttribute(
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
set_opengl_version(settings);
}
else
{
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"Using Default OpenGL Profile");
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"Using Default OpenGL Version");
}
#endif
#ifdef WITH_GLES2
SDL_GL_SetAttribute(
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#elif WITH_GLES3
SDL_GL_SetAttribute(
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
#endif
windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN;
if (settings->fullscreen)
{
windowFlags |= SDL_WINDOW_FULLSCREEN;
windowFlags |= SDL_WINDOW_BORDERLESS;
}
if (settings->screenWidth == 0 || settings->screenHeight == 0)
{
if (!lite3d_video_get_display_size(
&settings->screenWidth,
&settings->screenHeight))
{
SDL_LogWarn(
SDL_LOG_CATEGORY_APPLICATION,
"lite3d_video_get_display_size failed");
return LITE3D_FALSE;
}
}
/* setup render window */
gRenderWindow = SDL_CreateWindow(
settings->caption,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
settings->screenWidth,
settings->screenHeight,
windowFlags);
if (!gRenderWindow)
{
SDL_LogCritical(
SDL_LOG_CATEGORY_APPLICATION,
"%s: SDL_CreateWindow failed..",
LITE3D_CURRENT_FUNCTION);
return LITE3D_FALSE;
}
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"%s: render window created %dx%d (%s)",
LITE3D_CURRENT_FUNCTION,
settings->screenWidth,
settings->screenHeight,
settings->fullscreen ? "fullscreen" : "windowed");
/* Create an OpenGL context associated with the window. */
gGLContext = SDL_GL_CreateContext(gRenderWindow);
if (!gGLContext)
{
SDL_LogCritical(
SDL_LOG_CATEGORY_APPLICATION,
"%s: GL Context create failed..",
LITE3D_CURRENT_FUNCTION);
return LITE3D_FALSE;
}
/* set gl context */
SDL_GL_MakeCurrent(gRenderWindow, gGLContext);
SDL_GetWindowDisplayMode(gRenderWindow, &displayMode);
SDL_LogInfo(
SDL_LOG_CATEGORY_APPLICATION,
"%s: selected pixel format: %d bpp, %s",
LITE3D_CURRENT_FUNCTION,
SDL_BITSPERPIXEL(displayMode.format),
SDL_GetPixelFormatName(displayMode.format));
SDL_GL_SetSwapInterval(settings->vsync ? 1 : 0);
if (!init_gl_extensions(settings))
{
SDL_LogWarn(
SDL_LOG_CATEGORY_APPLICATION,
"init_gl_extensions failed");
lite3d_video_close();
return LITE3D_FALSE;
}
if (!settings->hidden)
{
SDL_ShowWindow(gRenderWindow);
}
return LITE3D_TRUE;
}
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;
}
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;
}
/**
* Initializes OpenGL
*/
void SpringApp::InitOpenGL()
{
// reinit vsync
VSync.Init();
// check if FSAA init worked fine
if (globalRendering->FSAA && !MultisampleVerify())
globalRendering->FSAA = 0;
// setup GL smoothing
const int lineSmoothing = configHandler->GetInt("SmoothLines");
if (lineSmoothing > 0) {
GLenum hint = GL_FASTEST;
if (lineSmoothing >= 3) {
hint = GL_NICEST;
} else if (lineSmoothing >= 2) {
hint = GL_DONT_CARE;
}
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, hint);
}
const int pointSmoothing = configHandler->GetInt("SmoothPoints");
if (pointSmoothing > 0) {
GLenum hint = GL_FASTEST;
if (pointSmoothing >= 3) {
hint = GL_NICEST;
} else if (pointSmoothing >= 2) {
hint = GL_DONT_CARE;
}
glEnable(GL_POINT_SMOOTH);
glHint(GL_POINT_SMOOTH_HINT, hint);
}
// setup LOD bias factor
const float lodBias = configHandler->GetFloat("TextureLODBias");
if (math::fabs(lodBias) > 0.01f) {
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, lodBias );
}
//FIXME not needed anymore with SDL2?
if (configHandler->GetBool("FixAltTab")) {
// free GL resources
GLContext::Free();
// initialize any GL resources that were lost
GLContext::Init();
}
// setup viewport
SetupViewportGeometry();
glViewport(globalRendering->viewPosX, globalRendering->viewPosY, globalRendering->viewSizeX, globalRendering->viewSizeY);
gluPerspective(45.0f, globalRendering->aspectRatio, 2.8f, CGlobalRendering::MAX_VIEW_RANGE);
// Initialize some GL states
glShadeModel(GL_SMOOTH);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Clear Window
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SDL_GL_SwapWindow(window);
// Print Final Mode (call after SetupViewportGeometry, which updates viewSizeX/Y)
SDL_DisplayMode dmode;
SDL_GetWindowDisplayMode(window, &dmode);
bool isBorderless = (SDL_GetWindowFlags(window) & SDL_WINDOW_BORDERLESS) != 0;
LOG("[%s] video mode set to %ix%i:%ibit @%iHz %s", __FUNCTION__, globalRendering->viewSizeX, globalRendering->viewSizeY, SDL_BITSPERPIXEL(dmode.format), dmode.refresh_rate, globalRendering->fullScreen ? (isBorderless ? "(borderless)" : "") : "(windowed)");
}
virtual std::vector<std::string> GetSupportedResolutions() const {
std::vector<std::string> mode_vec;
unsigned valid_mode_count = SDL_GetNumDisplayModes(m_display_id);
/* Check if our resolution is restricted */
if ( valid_mode_count < 1 ) {
Logger().errorStream() << "No valid resolutions found!?";
} else {
for (int i = 0; i < valid_mode_count; ++i) {
SDL_DisplayMode mode;
if (SDL_GetDisplayMode(m_display_id, i, &mode) != 0) {
SDL_Log("SDL_GetDisplayMode failed: %s", SDL_GetError());
} else {
mode_vec.push_back(boost::io::str(boost::format("%1% x %2% @ %3%") % mode.w % mode.h % SDL_BITSPERPIXEL(mode.format)));
}
}
}
return mode_vec;
}
SDL_bool
SDL_PixelFormatEnumToMasks(Uint32 format, int *bpp, Uint32 * Rmask,
Uint32 * Gmask, Uint32 * Bmask, Uint32 * Amask)
{
Uint32 masks[4];
/* Initialize the values here */
if (SDL_BYTESPERPIXEL(format) <= 2) {
*bpp = SDL_BITSPERPIXEL(format);
} else {
*bpp = SDL_BYTESPERPIXEL(format) * 8;
}
*Rmask = *Gmask = *Bmask = *Amask = 0;
if (format == SDL_PIXELFORMAT_RGB24) {
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
*Rmask = 0x00FF0000;
*Gmask = 0x0000FF00;
*Bmask = 0x000000FF;
#else
*Rmask = 0x000000FF;
*Gmask = 0x0000FF00;
*Bmask = 0x00FF0000;
#endif
return SDL_TRUE;
}
if (format == SDL_PIXELFORMAT_BGR24) {
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
*Rmask = 0x000000FF;
*Gmask = 0x0000FF00;
*Bmask = 0x00FF0000;
#else
*Rmask = 0x00FF0000;
*Gmask = 0x0000FF00;
*Bmask = 0x000000FF;
#endif
return SDL_TRUE;
}
if (SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED8 &&
SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED16 &&
SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED32) {
/* Not a format that uses masks */
return SDL_TRUE;
}
switch (SDL_PIXELLAYOUT(format)) {
case SDL_PACKEDLAYOUT_332:
masks[0] = 0x00000000;
masks[1] = 0x000000E0;
masks[2] = 0x0000001C;
masks[3] = 0x00000003;
break;
case SDL_PACKEDLAYOUT_4444:
masks[0] = 0x0000F000;
masks[1] = 0x00000F00;
masks[2] = 0x000000F0;
masks[3] = 0x0000000F;
break;
case SDL_PACKEDLAYOUT_1555:
masks[0] = 0x00008000;
masks[1] = 0x00007C00;
masks[2] = 0x000003E0;
masks[3] = 0x0000001F;
break;
case SDL_PACKEDLAYOUT_5551:
masks[0] = 0x0000F800;
masks[1] = 0x000007C0;
masks[2] = 0x0000003E;
masks[3] = 0x00000001;
break;
case SDL_PACKEDLAYOUT_565:
masks[0] = 0x00000000;
masks[1] = 0x0000F800;
masks[2] = 0x000007E0;
masks[3] = 0x0000001F;
break;
case SDL_PACKEDLAYOUT_8888:
masks[0] = 0xFF000000;
masks[1] = 0x00FF0000;
masks[2] = 0x0000FF00;
masks[3] = 0x000000FF;
break;
case SDL_PACKEDLAYOUT_2101010:
masks[0] = 0xC0000000;
masks[1] = 0x3FF00000;
masks[2] = 0x000FFC00;
masks[3] = 0x000003FF;
break;
case SDL_PACKEDLAYOUT_1010102:
masks[0] = 0xFFC00000;
masks[1] = 0x003FF000;
masks[2] = 0x00000FFC;
masks[3] = 0x00000003;
break;
default:
SDL_SetError("Unknown pixel format");
return SDL_FALSE;
}
switch (SDL_PIXELORDER(format)) {
case SDL_PACKEDORDER_XRGB:
*Rmask = masks[1];
*Gmask = masks[2];
*Bmask = masks[3];
break;
case SDL_PACKEDORDER_RGBX:
*Rmask = masks[0];
*Gmask = masks[1];
*Bmask = masks[2];
break;
case SDL_PACKEDORDER_ARGB:
*Amask = masks[0];
*Rmask = masks[1];
*Gmask = masks[2];
*Bmask = masks[3];
break;
case SDL_PACKEDORDER_RGBA:
*Rmask = masks[0];
*Gmask = masks[1];
*Bmask = masks[2];
*Amask = masks[3];
break;
case SDL_PACKEDORDER_XBGR:
*Bmask = masks[1];
*Gmask = masks[2];
*Rmask = masks[3];
break;
case SDL_PACKEDORDER_BGRX:
*Bmask = masks[0];
*Gmask = masks[1];
*Rmask = masks[2];
break;
case SDL_PACKEDORDER_BGRA:
*Bmask = masks[0];
*Gmask = masks[1];
*Rmask = masks[2];
*Amask = masks[3];
break;
case SDL_PACKEDORDER_ABGR:
*Amask = masks[0];
*Bmask = masks[1];
*Gmask = masks[2];
*Rmask = masks[3];
break;
default:
SDL_SetError("Unknown pixel format");
return SDL_FALSE;
}
return SDL_TRUE;
}
// This stage, we handle display mode setting
bool wzMainScreenSetup(int antialiasing, bool fullscreen, bool vsync)
{
// populate with the saved values (if we had any)
int width = pie_GetVideoBufferWidth();
int height = pie_GetVideoBufferHeight();
int bitDepth = pie_GetVideoBufferDepth();
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
{
debug(LOG_ERROR, "Error: Could not initialise SDL (%s).", SDL_GetError());
return false;
}
// Populated our resolution list (does all displays now)
SDL_DisplayMode displaymode;
struct screeninfo screenlist;
for (int i = 0; i < SDL_GetNumVideoDisplays(); ++i) // How many monitors we got
{
int numdisplaymodes = SDL_GetNumDisplayModes(i); // Get the number of display modes on this monitor
for (int j = 0; j < numdisplaymodes; j++)
{
displaymode.format = displaymode.w = displaymode.h = displaymode.refresh_rate = 0;
displaymode.driverdata = 0;
if (SDL_GetDisplayMode(i, j, &displaymode) < 0)
{
debug(LOG_FATAL, "SDL_LOG_CATEGORY_APPLICATION error:%s", SDL_GetError());
SDL_Quit();
exit(EXIT_FAILURE);
}
debug(LOG_WZ, "Monitor[%d]%dx%d %d %s", i, displaymode.w, displaymode.h, displaymode.refresh_rate, getSDL_fmt_string(displaymode.format));
if (displaymode.refresh_rate < 59)
{
continue; // only store 60Hz & higher modes, some display report 59 on linux
}
screenlist.height = displaymode.h;
screenlist.width = displaymode.w;
screenlist.refresh_rate = displaymode.refresh_rate;
screenlist.screen = i; // which monitor this belongs to
displaylist.push_back(screenlist);
}
}
SDL_DisplayMode current = { 0, 0, 0, 0, 0 };
for (int i = 0; i < SDL_GetNumVideoDisplays(); ++i)
{
int display = SDL_GetCurrentDisplayMode(i, ¤t);
if (display != 0)
{
debug(LOG_FATAL, "Can't get the current display mode, because: %s", SDL_GetError());
SDL_Quit();
exit(EXIT_FAILURE);
}
debug(LOG_WZ, "Monitor[%d]%dx%d %d", i, current.w, current.h, current.refresh_rate);
}
if (width == 0 || height == 0)
{
pie_SetVideoBufferWidth(width = screenWidth = current.w);
pie_SetVideoBufferHeight(height = screenHeight = current.h);
}
else
{
screenWidth = width;
screenHeight = height;
}
screenWidth = MAX(screenWidth, 640);
screenHeight = MAX(screenHeight, 480);
//// The flags to pass to SDL_CreateWindow
int video_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
if (war_getFullscreen())
{
video_flags |= SDL_WINDOW_FULLSCREEN;
}
SDL_Rect bounds;
for (int i = 0; i < SDL_GetNumVideoDisplays(); i++)
{
SDL_GetDisplayBounds(i, &bounds);
debug(LOG_WZ, "Monitor %d: pos %d x %d : res %d x %d", i, (int)bounds.x, (int)bounds.y, (int)bounds.w, (int)bounds.h);
}
if (war_GetScreen() > SDL_GetNumVideoDisplays())
{
debug(LOG_FATAL, "Invalid screen defined in configuration");
SDL_Quit();
exit(EXIT_FAILURE);
}
SDL_GetDisplayBounds(war_GetScreen(), &bounds);
bounds.w -= (bounds.w + screenWidth) / 2;
bounds.h -= (bounds.h + screenHeight) / 2;
WZwindow = SDL_CreateWindow(PACKAGE_NAME, bounds.x + bounds.w, bounds.y + bounds.h, screenWidth, screenHeight, video_flags);
if (!WZwindow)
{
debug(LOG_FATAL, "Can't create a window, because: %s", SDL_GetError());
SDL_Quit();
exit(EXIT_FAILURE);
}
WZglcontext = SDL_GL_CreateContext(WZwindow);
if (!WZglcontext)
{
debug(LOG_ERROR, "Failed to create a openGL context! [%s]", SDL_GetError());
return false;
}
// Set the double buffer OpenGL attribute.
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// Enable FSAA anti-aliasing if and at the level requested by the user
if (antialiasing)
{
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, antialiasing);
}
int bpp = SDL_BITSPERPIXEL(SDL_GetWindowPixelFormat(WZwindow));
debug(LOG_WZ, "Bpp = %d format %s" , bpp, getSDL_fmt_string(SDL_GetWindowPixelFormat(WZwindow)));
if (!bpp)
{
debug(LOG_ERROR, "Video mode %dx%d@%dbpp is not supported!", width, height, bitDepth);
return false;
}
switch (bpp)
{
case 32:
case 24: // all is good...
break;
case 16:
info("Using colour depth of %i instead of a 32/24 bit depth (True color).", bpp);
info("You will experience graphics glitches!");
break;
case 8:
debug(LOG_FATAL, "You don't want to play Warzone with a bit depth of %i, do you?", bpp);
SDL_Quit();
exit(1);
break;
default:
debug(LOG_FATAL, "Unsupported bit depth: %i", bpp);
exit(1);
break;
}
// Enable/disable vsync if requested by the user
wzSetSwapInterval(war_GetVsync());
int value = 0;
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &value) == -1 || value == 0)
{
debug(LOG_FATAL, "OpenGL initialization did not give double buffering!");
debug(LOG_FATAL, "Double buffering is required for this game!");
SDL_Quit();
exit(1);
}
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
uint32_t rmask = 0xff000000;
uint32_t gmask = 0x00ff0000;
uint32_t bmask = 0x0000ff00;
uint32_t amask = 0x000000ff;
#else
uint32_t rmask = 0x000000ff;
uint32_t gmask = 0x0000ff00;
uint32_t bmask = 0x00ff0000;
uint32_t amask = 0xff000000;
#endif
SDL_Surface *surface_icon = SDL_CreateRGBSurfaceFrom((void *)wz2100icon.pixel_data, wz2100icon.width, wz2100icon.height, wz2100icon.bytes_per_pixel * 8,
wz2100icon.width * wz2100icon.bytes_per_pixel, rmask, gmask, bmask, amask);
if (surface_icon)
{
SDL_SetWindowIcon(WZwindow, surface_icon);
SDL_FreeSurface(surface_icon);
}
else
{
debug(LOG_ERROR, "Could not set window icon because %s", SDL_GetError());
}
SDL_SetWindowTitle(WZwindow, PACKAGE_NAME);
/* initialise all cursors */
if (war_GetColouredCursor())
{
sdlInitColoredCursors();
}
else
{
sdlInitCursors();
}
// FIXME: aspect ratio
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, width, height, 0, 1, -1);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
return true;
}
SDL_Surface *
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
SDL_DisplayMode desktop_mode;
SDL_DisplayMode mode;
int window_x = SDL_WINDOWPOS_UNDEFINED;
int window_y = SDL_WINDOWPOS_UNDEFINED;
Uint32 window_flags;
Uint32 desktop_format;
Uint32 desired_format;
Uint32 surface_flags;
if (!SDL_GetVideoDevice()) {
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE) < 0) {
return NULL;
}
}
SDL_GetDesktopDisplayMode(&desktop_mode);
if (width == 0) {
width = desktop_mode.w;
}
if (height == 0) {
height = desktop_mode.h;
}
/* See if we can simply resize the existing window and surface */
if (SDL_ResizeVideoMode(width, height, bpp, flags) == 0) {
return SDL_PublicSurface;
}
/* Destroy existing window */
SDL_PublicSurface = NULL;
if (SDL_ShadowSurface) {
SDL_FreeSurface(SDL_ShadowSurface);
SDL_ShadowSurface = NULL;
}
if (SDL_VideoSurface) {
SDL_DelPaletteWatch(SDL_VideoSurface->format->palette,
SDL_VideoPaletteChanged, NULL);
SDL_FreeSurface(SDL_VideoSurface);
SDL_VideoSurface = NULL;
}
if (SDL_VideoContext) {
/* SDL_GL_MakeCurrent(0, NULL); *//* Doesn't do anything */
SDL_GL_DeleteContext(SDL_VideoContext);
SDL_VideoContext = NULL;
}
if (SDL_VideoWindow) {
SDL_GetWindowPosition(SDL_VideoWindow, &window_x, &window_y);
SDL_DestroyWindow(SDL_VideoWindow);
}
/* Set up the event filter */
if (!SDL_GetEventFilter(NULL, NULL)) {
SDL_SetEventFilter(SDL_CompatEventFilter, NULL);
}
/* Create a new window */
window_flags = SDL_WINDOW_SHOWN;
if (flags & SDL_FULLSCREEN) {
window_flags |= SDL_WINDOW_FULLSCREEN;
}
if (flags & SDL_OPENGL) {
window_flags |= SDL_WINDOW_OPENGL;
}
if (flags & SDL_RESIZABLE) {
window_flags |= SDL_WINDOW_RESIZABLE;
}
if (flags & SDL_NOFRAME) {
window_flags |= SDL_WINDOW_BORDERLESS;
}
GetEnvironmentWindowPosition(width, height, &window_x, &window_y);
SDL_SetFullscreenDisplayMode(NULL);
SDL_VideoWindow =
SDL_CreateWindow(wm_title, window_x, window_y, width, height,
window_flags);
if (!SDL_VideoWindow) {
return NULL;
}
SDL_SetWindowIcon(SDL_VideoWindow, SDL_VideoIcon);
window_flags = SDL_GetWindowFlags(SDL_VideoWindow);
surface_flags = 0;
if (window_flags & SDL_WINDOW_FULLSCREEN) {
surface_flags |= SDL_FULLSCREEN;
}
if (window_flags & SDL_WINDOW_OPENGL) {
surface_flags |= SDL_OPENGL;
}
if (window_flags & SDL_WINDOW_RESIZABLE) {
surface_flags |= SDL_RESIZABLE;
}
if (window_flags & SDL_WINDOW_BORDERLESS) {
surface_flags |= SDL_NOFRAME;
}
/* Set up the desired display mode */
desktop_format = desktop_mode.format;
if (desktop_format && ((flags & SDL_ANYFORMAT)
|| (bpp == SDL_BITSPERPIXEL(desktop_format)))) {
desired_format = desktop_format;
} else {
switch (bpp) {
case 0:
if (desktop_format) {
desired_format = desktop_format;
} else {
desired_format = SDL_PIXELFORMAT_RGB888;
}
bpp = SDL_BITSPERPIXEL(desired_format);
break;
case 8:
desired_format = SDL_PIXELFORMAT_INDEX8;
break;
case 15:
desired_format = SDL_PIXELFORMAT_RGB555;
break;
case 16:
desired_format = SDL_PIXELFORMAT_RGB565;
break;
case 24:
desired_format = SDL_PIXELFORMAT_RGB24;
break;
case 32:
desired_format = SDL_PIXELFORMAT_RGB888;
break;
default:
SDL_SetError("Unsupported bpp in SDL_SetVideoMode()");
return NULL;
}
}
mode.format = desired_format;
mode.w = width;
mode.h = height;
mode.refresh_rate = 0;
/* Set the desired display mode */
if (flags & SDL_FULLSCREEN) {
if (SDL_SetFullscreenDisplayMode(&mode) < 0) {
return NULL;
}
}
/* If we're in OpenGL mode, just create a stub surface and we're done! */
if (flags & SDL_OPENGL) {
SDL_VideoContext = SDL_GL_CreateContext(SDL_VideoWindow);
if (!SDL_VideoContext) {
return NULL;
}
if (SDL_GL_MakeCurrent(SDL_VideoWindow, SDL_VideoContext) < 0) {
return NULL;
}
SDL_VideoSurface =
SDL_CreateRGBSurfaceFrom(NULL, width, height, bpp, 0, 0, 0, 0, 0);
if (!SDL_VideoSurface) {
return NULL;
}
SDL_VideoSurface->flags |= surface_flags;
SDL_PublicSurface = SDL_VideoSurface;
return SDL_PublicSurface;
}
/* Create a renderer for the window */
if (SDL_CreateRenderer
(SDL_VideoWindow, -1,
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0) {
return NULL;
}
SDL_GetRendererInfo(&SDL_VideoRendererInfo);
/* Create a texture for the screen surface */
SDL_VideoTexture =
SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_STREAMING, width,
height);
if (!SDL_VideoTexture) {
SDL_VideoTexture =
SDL_CreateTexture(desktop_format,
SDL_TEXTUREACCESS_STREAMING, width, height);
}
if (!SDL_VideoTexture) {
return NULL;
}
/* Create the screen surface */
SDL_VideoSurface = CreateVideoSurface(SDL_VideoTexture);
if (!SDL_VideoSurface) {
return NULL;
}
SDL_VideoSurface->flags |= surface_flags;
/* Set a default screen palette */
if (SDL_VideoSurface->format->palette) {
SDL_VideoSurface->flags |= SDL_HWPALETTE;
SDL_DitherColors(SDL_VideoSurface->format->palette->colors,
SDL_VideoSurface->format->BitsPerPixel);
SDL_AddPaletteWatch(SDL_VideoSurface->format->palette,
SDL_VideoPaletteChanged, SDL_VideoSurface);
SDL_SetPaletteColors(SDL_VideoSurface->format->palette,
SDL_VideoSurface->format->palette->colors, 0,
SDL_VideoSurface->format->palette->ncolors);
}
/* Create a shadow surface if necessary */
if ((bpp != SDL_VideoSurface->format->BitsPerPixel)
&& !(flags & SDL_ANYFORMAT)) {
SDL_ShadowSurface =
SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);
if (!SDL_ShadowSurface) {
return NULL;
}
SDL_ShadowSurface->flags |= surface_flags;
/* 8-bit SDL_ShadowSurface surfaces report that they have exclusive palette */
if (SDL_ShadowSurface->format->palette) {
SDL_ShadowSurface->flags |= SDL_HWPALETTE;
if (SDL_VideoSurface->format->palette) {
SDL_SetSurfacePalette(SDL_ShadowSurface,
SDL_VideoSurface->format->palette);
} else {
SDL_DitherColors(SDL_ShadowSurface->format->palette->colors,
SDL_ShadowSurface->format->BitsPerPixel);
}
SDL_AddPaletteWatch(SDL_ShadowSurface->format->palette,
SDL_VideoPaletteChanged, SDL_ShadowSurface);
}
}
SDL_PublicSurface =
(SDL_ShadowSurface ? SDL_ShadowSurface : SDL_VideoSurface);
SDL_VideoFlags = flags;
ClearVideoSurface();
SetupScreenSaver(flags);
/* We're finally done! */
return SDL_PublicSurface;
}
void Window::ChangeDisplay(
int width, int height,
int bpp, int dbpp,
bool fullscreen,
unsigned int antialiasing,
std::ostream & info_output,
std::ostream & error_output)
{
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, dbpp);
fsaa = 1;
if (antialiasing > 1)
{
fsaa = antialiasing;
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);
info_output << "Enabling antialiasing: " << fsaa << "X" << std::endl;
}
else
{
info_output << "Disabling antialiasing" << std::endl;
}
SDL_DisplayMode desktop_mode;
int display = GetVideoDisplay();
SDL_GetDesktopDisplayMode(display, &desktop_mode);
if (width == 0)
width = desktop_mode.w;
if (height == 0)
height = desktop_mode.h;
if (bpp == 0)
bpp = SDL_BITSPERPIXEL(desktop_mode.format);
// Try to resize the existing window and surface
if (!fullscreen && ResizeWindow(width, height))
return;
if (glcontext)
{
SDL_GL_DeleteContext(glcontext);
glcontext = NULL;
}
if (window)
{
SDL_DestroyWindow(window);
}
// Create a new window
Uint32 window_flags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL;
if (fullscreen)
window_flags |= SDL_WINDOW_FULLSCREEN;
window = SDL_CreateWindow(NULL,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
width, height, window_flags);
if (!window)
{
assert(0);
}
glcontext = SDL_GL_CreateContext(window);
if (!glcontext)
{
assert(0);
}
if (SDL_GL_MakeCurrent(window, glcontext) < 0)
{
assert(0);
}
w = width;
h = height;
}
static HBITMAP
GDI_CreateDIBSection(HDC hdc, int w, int h, int pitch, Uint32 format,
HPALETTE * hpal, void ** pixels)
{
int bmi_size;
LPBITMAPINFO bmi;
bmi_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
bmi = (LPBITMAPINFO) SDL_calloc(1, bmi_size);
if (!bmi) {
SDL_OutOfMemory();
return NULL;
}
bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi->bmiHeader.biWidth = w;
bmi->bmiHeader.biHeight = -h; /* topdown bitmap */
bmi->bmiHeader.biPlanes = 1;
bmi->bmiHeader.biSizeImage = h * pitch;
bmi->bmiHeader.biXPelsPerMeter = 0;
bmi->bmiHeader.biYPelsPerMeter = 0;
bmi->bmiHeader.biClrUsed = 0;
bmi->bmiHeader.biClrImportant = 0;
bmi->bmiHeader.biBitCount = SDL_BYTESPERPIXEL(format) * 8;
if (SDL_ISPIXELFORMAT_INDEXED(format)) {
bmi->bmiHeader.biCompression = BI_RGB;
if (hpal) {
int i, ncolors;
LOGPALETTE *palette;
ncolors = (1 << SDL_BITSPERPIXEL(format));
palette =
(LOGPALETTE *) SDL_malloc(sizeof(*palette) +
ncolors * sizeof(PALETTEENTRY));
if (!palette) {
SDL_free(bmi);
SDL_OutOfMemory();
return NULL;
}
palette->palVersion = 0x300;
palette->palNumEntries = ncolors;
for (i = 0; i < ncolors; ++i) {
palette->palPalEntry[i].peRed = 0xFF;
palette->palPalEntry[i].peGreen = 0xFF;
palette->palPalEntry[i].peBlue = 0xFF;
palette->palPalEntry[i].peFlags = 0;
}
*hpal = CreatePalette(palette);
SDL_free(palette);
}
} else {
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
bmi->bmiHeader.biCompression = BI_BITFIELDS;
SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask);
((Uint32 *) bmi->bmiColors)[0] = Rmask;
((Uint32 *) bmi->bmiColors)[1] = Gmask;
((Uint32 *) bmi->bmiColors)[2] = Bmask;
if (hpal) {
*hpal = NULL;
}
}
return CreateDIBSection(hdc, bmi, DIB_RGB_COLORS, pixels, NULL, 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;
}
void initSDL()
{
SDL_DisplayMode video_info;
int init_flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK;
if(SDL_Init(init_flags) < 0)
{
printf("SDL Failed to Init!!!! (%s)\n", SDL_GetError());
borExit(0);
}
SDL_ShowCursor(SDL_DISABLE);
atexit(SDL_Quit);
#ifdef LOADGL
if(SDL_GL_LoadLibrary(NULL) < 0)
{
printf("Warning: couldn't load OpenGL library (%s)\n", SDL_GetError());
}
#endif
SDL_GetCurrentDisplayMode(0, &video_info);
nativeWidth = video_info.w;
nativeHeight = video_info.h;
printf("debug:nativeWidth, nativeHeight, bpp, Hz %d, %d, %d, %d\n", nativeWidth, nativeHeight, SDL_BITSPERPIXEL(video_info.format), video_info.refresh_rate);
SDL_initFramerate(&framerate_manager);
SDL_setFramerate(&framerate_manager, 200);
}
rserr_t R_ChangeDisplaySettings( int width, int height, qboolean fullscreen )
{
#ifdef XASH_SDL
SDL_DisplayMode displayMode;
SDL_GetCurrentDisplayMode(0, &displayMode);
R_SaveVideoMode( width, height );
// check our desktop attributes
glw_state.desktopBitsPixel = SDL_BITSPERPIXEL(displayMode.format);
glw_state.desktopWidth = displayMode.w;
glw_state.desktopHeight = displayMode.h;
glState.fullScreen = fullscreen;
// check for 4:3 or 5:4
if( width * 3 != height * 4 && width * 4 != height * 5 )
glState.wideScreen = true;
else glState.wideScreen = false;
if(!host.hWnd)
{
if( !VID_CreateWindow( width, height, fullscreen ) )
return rserr_invalid_mode;
}
else if( fullscreen )
{
SDL_DisplayMode want, got;
want.w = width;
want.h = height;
want.driverdata = NULL;
want.format = want.refresh_rate = 0; // don't care
if( !SDL_GetClosestDisplayMode(0, &want, &got) )
return rserr_invalid_mode;
MsgDev(D_NOTE, "Got closest display mode: %ix%i@%i\n", got.w, got.h, got.refresh_rate);
if( ( SDL_GetWindowFlags(host.hWnd) & SDL_WINDOW_FULLSCREEN ) == SDL_WINDOW_FULLSCREEN)
if( SDL_SetWindowFullscreen(host.hWnd, 0) == -1 )
return rserr_invalid_fullscreen;
if( SDL_SetWindowDisplayMode(host.hWnd, &got) )
return rserr_invalid_mode;
if( SDL_SetWindowFullscreen(host.hWnd, SDL_WINDOW_FULLSCREEN) == -1 )
return rserr_invalid_fullscreen;
R_ChangeDisplaySettingsFast( got.w, got.h );
}
else
{
if( SDL_SetWindowFullscreen(host.hWnd, 0) )
return rserr_invalid_fullscreen;
SDL_SetWindowSize(host.hWnd, width, height);
R_ChangeDisplaySettingsFast( width, height );
}
#endif // XASH_SDL
return rserr_ok;
}
bool RenderWindow2D::CreateWindowAndRenderer(unsigned int width, unsigned int height)
{
int iRet = SDL_Init(SDL_INIT_VIDEO);
if (iRet < 0)
{
ATLTRACE(_T("couldn't init SDL\n"));
return false;
}
unsigned int scaledWidth = width * scaleFactor;
unsigned int scaledHeight = height * scaleFactor;
SDL_DisplayMode mode = {0};
if (SDL_GetDisplayMode(0, 0, &mode) < 0)
{
return false;
}
int bitsPerPixel = SDL_BITSPERPIXEL(mode.format) == 24 ? 32 : SDL_BITSPERPIXEL(mode.format);
unscaledSurfaceBuffer.resize(width * height * (bitsPerPixel / 8), 0);
SDL_Window* rawWindow = nullptr;
SDL_Renderer* rawRenderer = nullptr;
SDL_CreateWindowAndRenderer(
scaledWidth,
scaledHeight,
SDL_WINDOW_SHOWN | SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC,
&rawWindow, &rawRenderer);
if (rawWindow == nullptr || rawRenderer == nullptr)
return false;
window.reset(rawWindow, &SDL_DestroyWindow);
renderer.reset(rawRenderer, &SDL_DestroyRenderer);
SDL_RenderSetLogicalSize(renderer.get(), scaledWidth, scaledHeight);
ATLTRACE(_T("SDL window, res=%ux%u, %i bpp, refresh rate: %i Hz\n"),
scaledWidth,
scaledHeight,
bitsPerPixel,
mode.refresh_rate);
// create texture
Uint32 pixelFormat = bitsPerPixel == 16 ? SDL_PIXELFORMAT_RGB565 : SDL_PIXELFORMAT_ARGB8888;
int bpp = 0;
Uint32 rmask = 0, gmask = 0, bmask = 0, amask = 0;
SDL_PixelFormatEnumToMasks(pixelFormat, &bpp, &rmask, &gmask, &bmask, &amask);
SDL_Surface* rawSurface = SDL_CreateRGBSurface(0, scaledWidth, scaledHeight, bpp,
rmask, gmask, bmask, amask);
if (rawSurface == nullptr)
return false;
surface.reset(rawSurface, &SDL_FreeSurface);
SDL_Texture* rawTexture = SDL_CreateTexture(
renderer.get(),
pixelFormat,
SDL_TEXTUREACCESS_STREAMING,
scaledWidth,
scaledHeight);
if (rawTexture != nullptr)
texture.reset(rawTexture, &SDL_DestroyTexture);
return rawTexture != nullptr;
}
