result TizenGraphicsManager::Construct() {
// Initialize our OpenGL ES context.
loadEgl();
// Notify the OpenGL code about our context.
// We default to RGB565 and RGBA5551 which is closest to the actual output
// mode we setup.
notifyContextCreate(Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0), Graphics::PixelFormat(2, 5, 5, 5, 1, 11, 6, 1, 0));
// Tell our size.
int x, y, width, height;
_appForm->GetBounds(x, y, width, height);
AppLog("screen size: %dx%d", width, height);
setActualScreenSize(width, height);
return E_SUCCESS;
}
bool OpenGLSdlGraphicsManager::setupMode(uint width, uint height) {
// In case we request a fullscreen mode we will use the mode the user
// has chosen last time or the biggest mode available.
if (_wantsFullScreen) {
if (_desiredFullscreenWidth && _desiredFullscreenHeight) {
// In case only a distinct set of modes is available we check
// whether the requested mode is actually available.
if (!_fullscreenVideoModes.empty()) {
VideoModeArray::const_iterator i = Common::find(_fullscreenVideoModes.begin(),
_fullscreenVideoModes.end(),
VideoMode(_desiredFullscreenWidth, _desiredFullscreenHeight));
// It's not available fall back to default.
if (i == _fullscreenVideoModes.end()) {
_desiredFullscreenWidth = 0;
_desiredFullscreenHeight = 0;
}
}
}
// In case no desired mode has been set we default to the biggest mode
// available or the requested mode in case we don't know any
// any fullscreen modes.
if (!_desiredFullscreenWidth || !_desiredFullscreenHeight) {
if (!_fullscreenVideoModes.empty()) {
VideoModeArray::const_iterator i = _fullscreenVideoModes.end();
--i;
_desiredFullscreenWidth = i->width;
_desiredFullscreenHeight = i->height;
} else {
_desiredFullscreenWidth = width;
_desiredFullscreenHeight = height;
}
}
// Remember our choice.
ConfMan.setInt("last_fullscreen_mode_width", _desiredFullscreenWidth, Common::ConfigManager::kApplicationDomain);
ConfMan.setInt("last_fullscreen_mode_height", _desiredFullscreenHeight, Common::ConfigManager::kApplicationDomain);
// Use our choice.
width = _desiredFullscreenWidth;
height = _desiredFullscreenHeight;
}
// This is pretty confusing since RGBA8888 talks about the memory
// layout here. This is a different logical layout depending on
// whether we run on little endian or big endian. However, we can
// only safely assume that RGBA8888 in memory layout is supported.
// Thus, we chose this one.
const Graphics::PixelFormat rgba8888 =
#ifdef SCUMM_LITTLE_ENDIAN
Graphics::PixelFormat(4, 8, 8, 8, 8, 0, 8, 16, 24);
#else
Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0);
#endif
#if SDL_VERSION_ATLEAST(2, 0, 0)
if (_glContext) {
notifyContextDestroy();
SDL_GL_DeleteContext(_glContext);
_glContext = nullptr;
}
_window->destroyWindow();
uint32 flags = SDL_WINDOW_OPENGL;
if (_wantsFullScreen) {
flags |= SDL_WINDOW_FULLSCREEN;
} else {
flags |= SDL_WINDOW_RESIZABLE;
}
// Request a OpenGL (ES) context we can use.
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, _glContextProfileMask);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, _glContextMajor);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, _glContextMinor);
if (!_window->createWindow(width, height, flags)) {
// We treat fullscreen requests as a "hint" for now. This means in
// case it is not available we simply ignore it.
if (_wantsFullScreen) {
_window->createWindow(width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
}
if (!_window->getSDLWindow()) {
return false;
}
}
_glContext = SDL_GL_CreateContext(_window->getSDLWindow());
if (!_glContext) {
return false;
}
notifyContextCreate(rgba8888, rgba8888);
int actualWidth, actualHeight;
getWindowDimensions(&actualWidth, &actualHeight);
setActualScreenSize(actualWidth, actualHeight);
_eventSource->resetKeyboardEmulation(actualWidth - 1, actualHeight - 1);
return true;
#else
// WORKAROUND: Working around infamous SDL bugs when switching
// resolutions too fast. This might cause the event system to supply
// incorrect mouse position events otherwise.
// Reference: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=665779
const uint32 curTime = SDL_GetTicks();
if (_hwScreen && (curTime < _lastVideoModeLoad || curTime - _lastVideoModeLoad < 100)) {
for (int i = 10; i > 0; --i) {
SDL_PumpEvents();
SDL_Delay(10);
}
}
uint32 flags = SDL_OPENGL;
if (_wantsFullScreen) {
flags |= SDL_FULLSCREEN;
} else {
flags |= SDL_RESIZABLE;
}
if (_hwScreen) {
// When a video mode has been setup already we notify the manager that
// the context is about to be destroyed.
// We do this because on Windows SDL_SetVideoMode can destroy and
// recreate the OpenGL context.
notifyContextDestroy();
}
_hwScreen = SDL_SetVideoMode(width, height, 32, flags);
if (!_hwScreen) {
// We treat fullscreen requests as a "hint" for now. This means in
// case it is not available we simply ignore it.
if (_wantsFullScreen) {
_hwScreen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL | SDL_RESIZABLE);
}
}
// Part of the WORKAROUND mentioned above.
_lastVideoModeLoad = SDL_GetTicks();
if (_hwScreen) {
notifyContextCreate(rgba8888, rgba8888);
setActualScreenSize(_hwScreen->w, _hwScreen->h);
_eventSource->resetKeyboardEmulation(_hwScreen->w - 1, _hwScreen->h - 1);
}
// Ignore resize events (from SDL) for a few frames, if this isn't
// caused by a notification from SDL. This avoids bad resizes to a
// (former) resolution for which we haven't processed an event yet.
if (!_gotResize)
_ignoreResizeEvents = 10;
return _hwScreen != nullptr;
#endif
}
