void SDLX_sdl_gl_attrib_t::download(SDLX_sdl_gl_attrib_t& self) {
int temporary[4];
// (1) Get the colour buffer depth.
SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &(temporary[0]));
SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &(temporary[1]));
SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &(temporary[2]));
SDL_GL_GetAttribute(SDL_GL_ALPHA_SIZE, &(temporary[3]));
self.colourBufferDepth = Ego::ColourDepth(temporary[0] + temporary[1] + temporary[2] + temporary[3],
temporary[0], temporary[1], temporary[2], temporary[3]);
SDL_GL_GetAttribute(SDL_GL_BUFFER_SIZE, &(self.buffer_size));
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &(self.doublebuffer));
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &(self.depthBufferDepth));
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &(self.stencilBufferDepth));
// (2) Get the accumulation buffer depth.
SDL_GL_GetAttribute(SDL_GL_ACCUM_RED_SIZE, &(temporary[0]));
SDL_GL_GetAttribute(SDL_GL_ACCUM_GREEN_SIZE, &(temporary[1]));
SDL_GL_GetAttribute(SDL_GL_ACCUM_BLUE_SIZE, &(temporary[1]));
SDL_GL_GetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, &(temporary[2]));
self.accumulationBufferDepth = Ego::ColourDepth(temporary[0] + temporary[1] + temporary[2] + temporary[3],
temporary[0], temporary[1], temporary[2], temporary[3]);
SDL_GL_GetAttribute(SDL_GL_STEREO, &(self.stereo));
self.swap_control = SDL_GL_GetSwapInterval();
self.multisampling.download();
#if !defined(ID_LINUX)
SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &(self.accelerated_visual));
#endif
}
static CoglBool
_cogl_winsys_context_init (CoglContext *context, CoglError **error)
{
CoglRenderer *renderer = context->display->renderer;
context->winsys = g_new0 (CoglContextSdl2, 1);
if (G_UNLIKELY (renderer->sdl_event_type_set == FALSE))
g_error ("cogl_sdl_renderer_set_event_type() or cogl_sdl_context_new() "
"must be called during initialization");
if (!_cogl_context_update_features (context, error))
return FALSE;
if (SDL_GL_GetSwapInterval () != -1)
COGL_FLAGS_SET (context->winsys_features,
COGL_WINSYS_FEATURE_SWAP_REGION_THROTTLE,
TRUE);
_cogl_renderer_add_native_filter (renderer,
(CoglNativeFilterFunc) sdl_event_filter_cb,
context);
return TRUE;
}
static bool
_cg_winsys_device_init(cg_device_t *dev, cg_error_t **error)
{
cg_renderer_t *renderer = dev->display->renderer;
dev->winsys = c_new0(cg_device_sdl2_t, 1);
if (!_cg_device_update_features(dev, error))
return false;
CG_FLAGS_SET(dev->features, CG_FEATURE_ID_ONSCREEN_MULTIPLE, true);
if (SDL_GL_GetSwapInterval() != -1)
CG_FLAGS_SET(dev->winsys_features,
CG_WINSYS_FEATURE_SWAP_THROTTLE,
true);
/* We'll manually handle queueing dirty events in response to
* SDL_WINDOWEVENT_EXPOSED events */
CG_FLAGS_SET(dev->private_features, CG_PRIVATE_FEATURE_DIRTY_EVENTS,
true);
_cg_renderer_add_native_filter(
renderer, (cg_native_filter_func_t)sdl_event_filter_cb, dev);
return true;
}
static int lua_SDL_GL_GetSwapInterval(lutok::state& state){
int retval = SDL_GL_GetSwapInterval();
if (retval>=0){
state.push_boolean(retval == 1);
return 1;
}else{
return 0;
}
}
void UIInterface::refresh()
{
int oswap = SDL_GL_GetSwapInterval();
SDL_GL_SetSwapInterval(0);
if (this->m_NidiumCtx) {
this->makeMainGLCurrent();
this->m_NidiumCtx->frame();
}
SDL_GL_SwapWindow(this->m_Win);
SDL_GL_SetSwapInterval(oswap);
}
bool Sdl2Application::setSwapInterval(const Int interval) {
if(SDL_GL_SetSwapInterval(interval) == -1) {
Error() << "Platform::Sdl2Application::setSwapInterval(): cannot set swap interval:" << SDL_GetError();
_flags &= ~Flag::VSyncEnabled;
return false;
}
if(SDL_GL_GetSwapInterval() != interval) {
Error() << "Platform::Sdl2Application::setSwapInterval(): swap interval setting ignored by the driver";
_flags &= ~Flag::VSyncEnabled;
return false;
}
_flags |= Flag::VSyncEnabled;
return true;
}
int
GLVideoSystem::get_vsync() const
{
return SDL_GL_GetSwapInterval();
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
Uint32 windowFlags;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
windowFlags = SDL_GetWindowFlags(window);
if (!(windowFlags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, windowFlags | SDL_WINDOW_OPENGL) < 0) {
/* Uh oh, better try to put it back... */
SDL_RecreateWindow(window, windowFlags);
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->SetRenderTarget = GLES_SetRenderTarget;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderReadPixels = GLES_RenderReadPixels;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
renderer->window = window;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object")) {
data->GL_OES_framebuffer_object_supported = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
value = 0;
data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
data->window_framebuffer = (GLuint)value;
}
data->framebuffers = NULL;
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
}
/*
* Get the state of swap interval of the current context.
*
* @return [Integer]
* return 0 when vsync is not used,
* return 1 when vsync is used,
* and return -1 when vsync is not supported by the system (OS).
*
*/
static VALUE GL_s_swap_interval(VALUE self)
{
return INT2NUM(SDL_GL_GetSwapInterval());
}
int32_t WindowSDL::getSwapInterval() const {
return SDL_GL_GetSwapInterval();
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
int doublebuffer;
if (!(window->flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window->flags | SDL_WINDOW_OPENGL) < 0) {
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->ActivateRenderer = GLES_ActivateRenderer;
renderer->DisplayModeChanged = GLES_DisplayModeChanged;
renderer->CreateTexture = GLES_CreateTexture;
renderer->QueryTexturePixels = GLES_QueryTexturePixels;
renderer->SetTexturePalette = GLES_SetTexturePalette;
renderer->GetTexturePalette = GLES_GetTexturePalette;
renderer->SetTextureColorMod = GLES_SetTextureColorMod;
renderer->SetTextureAlphaMod = GLES_SetTextureAlphaMod;
renderer->SetTextureBlendMode = GLES_SetTextureBlendMode;
renderer->SetTextureScaleMode = GLES_SetTextureScaleMode;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->DirtyTexture = GLES_DirtyTexture;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderDrawRects = GLES_RenderDrawRects;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GL_ES_RenderDriver.info;
renderer->window = window;
renderer->driverdata = data;
renderer->info.flags =
(SDL_RENDERER_PRESENTDISCARD | SDL_RENDERER_ACCELERATED);
#if defined(__QNXNTO__)
#if _NTO_VERSION<=641
/* QNX's OpenGL ES implementation is broken regarding */
/* packed textures support, affected versions 6.3.2, 6.4.0, 6.4.1 */
renderer->info.num_texture_formats = 2;
renderer->info.texture_formats[0] = SDL_PIXELFORMAT_ABGR8888;
renderer->info.texture_formats[1] = SDL_PIXELFORMAT_BGR24;
#endif /* _NTO_VERSION */
#endif /* __QNXNTO__ */
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
if (SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &doublebuffer) == 0) {
if (!doublebuffer) {
renderer->info.flags |= SDL_RENDERER_SINGLEBUFFER;
}
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Set up parameters for rendering */
data->blendMode = -1;
data->glDisable(GL_DEPTH_TEST);
data->glDisable(GL_CULL_FACE);
data->updateSize = SDL_TRUE;
return renderer;
}
SDL_Renderer *
GL_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GL_RenderData *data;
const char *hint;
GLint value;
Uint32 window_flags;
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL)) {
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
return NULL;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GL_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GL_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GL_WindowEvent;
renderer->CreateTexture = GL_CreateTexture;
renderer->UpdateTexture = GL_UpdateTexture;
renderer->LockTexture = GL_LockTexture;
renderer->UnlockTexture = GL_UnlockTexture;
renderer->UpdateViewport = GL_UpdateViewport;
renderer->RenderClear = GL_RenderClear;
renderer->RenderDrawPoints = GL_RenderDrawPoints;
renderer->RenderDrawLines = GL_RenderDrawLines;
renderer->RenderFillRects = GL_RenderFillRects;
renderer->RenderCopy = GL_RenderCopy;
renderer->RenderReadPixels = GL_RenderReadPixels;
renderer->RenderPresent = GL_RenderPresent;
renderer->DestroyTexture = GL_DestroyTexture;
renderer->DestroyRenderer = GL_DestroyRenderer;
renderer->info = GL_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GL_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
if (GL_LoadFunctions(data) < 0) {
GL_DestroyRenderer(renderer);
return NULL;
}
#ifdef __MACOSX__
/* Enable multi-threaded rendering */
/* Disabled until Ryan finishes his VBO/PBO code...
CGLEnable(CGLGetCurrentContext(), kCGLCEMPEngine);
*/
#endif
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
data->GL_ARB_texture_rectangle_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_APPLE_texture_range")) {
data->glTextureRangeAPPLE =
(void (*)(GLenum, GLsizei, const GLvoid *))
SDL_GL_GetProcAddress("glTextureRangeAPPLE");
}
/* Check for multitexture support */
if (SDL_GL_ExtensionSupported("GL_ARB_multitexture")) {
data->glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC) SDL_GL_GetProcAddress("glActiveTextureARB");
if (data->glActiveTextureARB) {
data->GL_ARB_multitexture_supported = SDL_TRUE;
data->glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &data->num_texture_units);
}
}
/* Check for shader support */
hint = SDL_GetHint(SDL_HINT_RENDER_OPENGL_SHADERS);
if (!hint || *hint != '0') {
data->shaders = GL_CreateShaderContext();
}
SDL_LogInfo(SDL_LOG_CATEGORY_RENDER, "OpenGL shaders: %s",
data->shaders ? "ENABLED" : "DISABLED");
/* We support YV12 textures using 3 textures and a shader */
if (data->shaders && data->num_texture_units >= 3) {
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_YV12;
renderer->info.texture_formats[renderer->info.num_texture_formats++] = SDL_PIXELFORMAT_IYUV;
}
/* Set up parameters for rendering */
GL_ResetState(renderer);
return renderer;
}
Moose::Window::CScreen::CScreen()
{
const SDL_VideoInfo *sdlVideoInfo = 0;
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
{
g_Error << "Couldn't initialize screen (SDL_Init())!\n";
}
else
{
sdlVideoInfo = SDL_GetVideoInfo();
if ( !sdlVideoInfo )
{
g_Error << "Couldn't initialize screen "
<< "( SDL_GetVideoInfo())!\n";
}
else
{
// Define which screen depth should be used, currently allowed are
// 32, 24 and 16. Any other ScreenDepth will revert to desktop depth.
switch ( m_iScreenDepth ) {
case 32:
case 24:
case 16:
break;
default:
m_iScreenDepth = sdlVideoInfo->vfmt->BitsPerPixel;
break;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, m_iRedSize);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, m_iGreenSize);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, m_iBlueSize);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, m_iDepthBufferSize);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, m_iMultiSampleBuffers );
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, m_iMultiSampleSamples );
SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, m_bDoubleBuffer);
#ifdef MOOSE_USE_OPENGL3
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, m_iGLMajorVersion);
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, m_iGLMinorVersion);
m_pMainWindow = SDL_CreateWindow( m_ScreenName.c_str(),
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
m_iWidth,
m_iHeight,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if ( m_pMainWindow == NULL)
{
g_Error << "Couldn't initialize screen "
<< "( SDL_CreateWindow: "
<< SDL_GetError() << ")!\n";
}
m_pGLContext = SDL_GL_CreateContext(m_pMainWindow);
g_Log << "Ladies and gents, we have OpenGL 3.2!\n";
#else
if ( SDL_SetVideoMode( m_iWidth,
m_iHeight,
m_iScreenDepth,
m_iVideoModeFlags) == NULL )
{
g_Error << "Couldn't initialize screen "
<< "( SDL_SetVideoMode: "
<< SDL_GetError() << ")!\n";
}
g_Log << "Ladies and gents, we have OpenGL 2.x\n";
#endif
} // ..!sdlVideoInfo
} // ..SDL_Init
GLenum status = glewInit();
if ( status != GLEW_OK )
{
g_Error << "Error initializing GLEW: " << glewGetErrorString(status)<< "\n";
}
#ifdef MOOSE_USE_OPENGL3
SDL_GL_SetSwapInterval(m_bVerticalSync);
// check actual state
switch(SDL_GL_GetSwapInterval())
{
case 1:
m_bVerticalSync = 1;
default:
m_bVerticalSync = 0;
}
#endif
// When images are loaded as textures they are flipped and mirrored over Y-axis.
// By manipulating the texture matrix accordingly we can get rid of the annoyance.
//
// Unfortunately, this bugger messes up the GL_TEXTURE_RECTANGLE_ARB extension.
// (It took Couple of hours of debugging until the culprit was ACCIDENTALY found)
// So, a better ( only ) solution is to flip image directly using SDL_Surface.
//
//glMatrixMode(GL_TEXTURE);
//glRotatef(180.0f,0.0f,0.0f,1.0f);
//glScalef(-1.0f,1.0f,1.0f);
//glMatrixMode(GL_MODELVIEW);
// Register ffmpeg-provided codecs for video textures
//av_register_all();
}
/*
* Enables or disabes the vsync.
*/
void GL3_SetVsync(void)
{
SDL_GL_SetSwapInterval(r_vsync->value ? 1 : 0);
vsyncActive = SDL_GL_GetSwapInterval() != 0;
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
Uint32 window_flags;
int profile_mask = 0, major = 0, minor = 0;
SDL_bool changed_window = SDL_FALSE;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &profile_mask);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &minor);
window_flags = SDL_GetWindowFlags(window);
if (!(window_flags & SDL_WINDOW_OPENGL) ||
profile_mask != SDL_GL_CONTEXT_PROFILE_ES || major != RENDERER_CONTEXT_MAJOR || minor != RENDERER_CONTEXT_MINOR) {
changed_window = SDL_TRUE;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, RENDERER_CONTEXT_MAJOR);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, RENDERER_CONTEXT_MINOR);
if (SDL_RecreateWindow(window, window_flags | SDL_WINDOW_OPENGL) < 0) {
goto error;
}
}
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
goto error;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
goto error;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->GetOutputSize = GLES_GetOutputSize;
renderer->SupportsBlendMode = GLES_SupportsBlendMode;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->SetRenderTarget = GLES_SetRenderTarget;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->UpdateClipRect = GLES_UpdateClipRect;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderCopyEx = GLES_RenderCopyEx;
renderer->RenderReadPixels = GLES_RenderReadPixels;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->GL_BindTexture = GLES_BindTexture;
renderer->GL_UnbindTexture = GLES_UnbindTexture;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
renderer->window = window;
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (GLES_LoadFunctions(data) < 0) {
GLES_DestroyRenderer(renderer);
goto error;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
value = 0;
data->glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Android does not report GL_OES_framebuffer_object but the functionality seems to be there anyway */
if (SDL_GL_ExtensionSupported("GL_OES_framebuffer_object") || data->glGenFramebuffersOES) {
data->GL_OES_framebuffer_object_supported = SDL_TRUE;
renderer->info.flags |= SDL_RENDERER_TARGETTEXTURE;
value = 0;
data->glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &value);
data->window_framebuffer = (GLuint)value;
}
data->framebuffers = NULL;
if (SDL_GL_ExtensionSupported("GL_OES_blend_func_separate")) {
data->GL_OES_blend_func_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_equation_separate")) {
data->GL_OES_blend_equation_separate_supported = SDL_TRUE;
}
if (SDL_GL_ExtensionSupported("GL_OES_blend_subtract")) {
data->GL_OES_blend_subtract_supported = SDL_TRUE;
}
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
error:
if (changed_window) {
/* Uh oh, better try to put it back... */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, profile_mask);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, minor);
SDL_RecreateWindow(window, window_flags);
}
return NULL;
}
bool Window::setWindow(int width, int height, WindowSettings *settings)
{
if (!graphics.get())
graphics.set(Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS));
if (graphics.get() && graphics->isCanvasActive())
throw love::Exception("love.window.setMode cannot be called while a Canvas is active in love.graphics.");
WindowSettings f;
if (settings)
f = *settings;
f.minwidth = std::max(f.minwidth, 1);
f.minheight = std::max(f.minheight, 1);
f.display = std::min(std::max(f.display, 0), getDisplayCount() - 1);
// Use the desktop resolution if a width or height of 0 is specified.
if (width == 0 || height == 0)
{
SDL_DisplayMode mode = {};
SDL_GetDesktopDisplayMode(f.display, &mode);
width = mode.w;
height = mode.h;
}
Uint32 sdlflags = SDL_WINDOW_OPENGL;
// On Android we always must have fullscreen type FULLSCREEN_TYPE_DESKTOP
#ifdef LOVE_ANDROID
f.fstype = FULLSCREEN_DESKTOP;
#endif
if (f.fullscreen)
{
if (f.fstype == FULLSCREEN_DESKTOP)
sdlflags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
else
{
sdlflags |= SDL_WINDOW_FULLSCREEN;
SDL_DisplayMode mode = {0, width, height, 0, nullptr};
// Fullscreen window creation will bug out if no mode can be used.
if (SDL_GetClosestDisplayMode(f.display, &mode, &mode) == nullptr)
{
// GetClosestDisplayMode will fail if we request a size larger
// than the largest available display mode, so we'll try to use
// the largest (first) mode in that case.
if (SDL_GetDisplayMode(f.display, 0, &mode) < 0)
return false;
}
width = mode.w;
height = mode.h;
}
}
if (f.resizable)
sdlflags |= SDL_WINDOW_RESIZABLE;
if (f.borderless)
sdlflags |= SDL_WINDOW_BORDERLESS;
if (f.highdpi)
sdlflags |= SDL_WINDOW_ALLOW_HIGHDPI;
int x = f.x;
int y = f.y;
if (f.useposition && !f.fullscreen)
{
// The position needs to be in the global coordinate space.
SDL_Rect displaybounds = {};
SDL_GetDisplayBounds(f.display, &displaybounds);
x += displaybounds.x;
y += displaybounds.y;
}
else
{
if (f.centered)
x = y = SDL_WINDOWPOS_CENTERED_DISPLAY(f.display);
else
x = y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(f.display);
}
close();
if (!createWindowAndContext(x, y, width, height, sdlflags, f.msaa, f.stencil, f.depth))
return false;
// Make sure the window keeps any previously set icon.
setIcon(icon.get());
// Make sure the mouse keeps its previous grab setting.
setMouseGrab(mouseGrabbed);
// Enforce minimum window dimensions.
SDL_SetWindowMinimumSize(window, f.minwidth, f.minheight);
if ((f.useposition || f.centered) && !f.fullscreen)
SDL_SetWindowPosition(window, x, y);
SDL_RaiseWindow(window);
SDL_GL_SetSwapInterval(f.vsync);
// Check if adaptive vsync was requested but not supported, and fall back
// to regular vsync if so.
if (f.vsync == -1 && SDL_GL_GetSwapInterval() != -1)
SDL_GL_SetSwapInterval(1);
updateSettings(f, false);
if (graphics.get())
{
double scaledw, scaledh;
fromPixels((double) pixelWidth, (double) pixelHeight, scaledw, scaledh);
graphics->setMode((int) scaledw, (int) scaledh, pixelWidth, pixelHeight, f.stencil);
}
#ifdef LOVE_ANDROID
love::android::setImmersive(f.fullscreen);
#endif
return 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;
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;
}
graphics_context::graphics_context(window & target_window)
{
// Set GL context attributes
auto LE_SDL_GL_SetAttribute = [](SDL_GLattr attrib, int val)->void
{
int set_attrib_res = SDL_GL_SetAttribute(attrib, val);
if(set_attrib_res != 0)
{
log_error(log_scope::ENGINE, "Unable to set attribute {:#x} to value {}: {}",
(int)attrib, val, SDL_GetError());
SDL_ClearError();
throw fatal_construction_exception{};
}
};
int const LE_GL_version_major = 3;
int const LE_GL_version_minor = 2;
LE_SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, LE_GL_version_major);
LE_SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, LE_GL_version_minor);
#ifdef LE_MODERN_OPENGL_ONLY
LE_SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#else
LE_SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
#endif
LE_SDL_GL_SetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1);
LE_SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
// Create GL context
p_raw_context = SDL_GL_CreateContext(target_window.get_raw());
if(p_raw_context == nullptr)
{
log_error(log_scope::ENGINE, "Error creating OpenGL context: {}", SDL_GetError());
SDL_ClearError();
throw fatal_construction_exception{};
}
// 1 = v-sync, 0 = no v-sync, -1 = dynamic
SDL_GL_SetSwapInterval(0);
// Check GL context attributes
log_status(log_scope::ENGINE, log_line_seperator);
log_status(log_scope::ENGINE, "OpenGL Context Successfully Created");
log_status(log_scope::ENGINE, "Attributes");
log_status(log_scope::ENGINE, log_line_seperator_sub_1);
int context_attrib_val;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &context_attrib_val);
log_status(log_scope::ENGINE, "Major Version: {}", context_attrib_val);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &context_attrib_val);
log_status(log_scope::ENGINE, "Minor Version: {}", context_attrib_val);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &context_attrib_val);
log_status(log_scope::ENGINE, "Context Profile: {}",
(context_attrib_val == SDL_GL_CONTEXT_PROFILE_CORE) ? "Core" :
(context_attrib_val == SDL_GL_CONTEXT_PROFILE_COMPATIBILITY) ? "Compatibility" :
"unknown");
SDL_GL_GetAttribute(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, &context_attrib_val);
log_status(log_scope::ENGINE, "Framebuffer sRGB: {}",
(context_attrib_val == 1) ? "Enabled" : "Disabled");
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &context_attrib_val);
log_status(log_scope::ENGINE, "Framebuffer Depth: {}", context_attrib_val);
context_attrib_val = SDL_GL_GetSwapInterval();
log_status(log_scope::ENGINE, "Swap Interval: {}",
(context_attrib_val == 0) ? "Immediate" :
(context_attrib_val == 1) ? "Synchronized" :
(context_attrib_val == -1) ? "Dynamic" :
"Unknown");
log_status(log_scope::ENGINE, log_line_seperator);
}
int main(int argc, char *argv[])
{
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
Printf("Failed to initialize SDL: %s\n", SDL_GetError());
return -1;
}
VideoMode mode = {};
mode.width = 800;
mode.height = 600;
mode.gl_major = 1;
mode.gl_minor = 5;
mode.double_buffer = 1;
mode.depth_bits = 24;
mode.stencil_bits = 8;
mode.multisamples = 4;
mode.swap_interval = 1;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, mode.gl_major);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, mode.gl_minor);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, mode.double_buffer);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, mode.depth_bits);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, mode.stencil_bits);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, mode.multisamples>0?1:0);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, mode.multisamples);
mode.window = SDL_CreateWindow(
"World Simulator",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
mode.width, mode.height,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
if (!mode.window)
{
Printf("Failed to create a window: %s\n", SDL_GetError());
return -1;
}
SDL_GLContext context = SDL_GL_CreateContext(mode.window);
// Note: This must be set on a valid context
SDL_GL_SetSwapInterval(mode.swap_interval);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, &mode.gl_major);
SDL_GL_GetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, &mode.gl_minor);
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &mode.double_buffer);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &mode.depth_bits);
SDL_GL_GetAttribute(SDL_GL_STENCIL_SIZE, &mode.stencil_bits);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &mode.multisamples);
mode.swap_interval = SDL_GL_GetSwapInterval();
sim_init_msgs(false);
ImGui_ImplSdl_Init(mode.window);
STATE = sim_init((u32)get_tick());
HISTORY_LENGTH = 0;
bool running = true;
u64 initial_tick = get_tick();
u64 last_frame_t = initial_tick;
r32 elapsed_time = 0.0f;
r32 delta_time = 1.0f / 60.0f;
while (running)
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
ImGui_ImplSdl_ProcessEvent(&event);
switch (event.type)
{
case SDL_WINDOWEVENT:
{
switch (event.window.event)
{
case SDL_WINDOWEVENT_SIZE_CHANGED:
{
Printf("Window %d size changed to %dx%d\n",
event.window.windowID,
event.window.data1,
event.window.data2);
mode.width = event.window.data1;
mode.height = event.window.data2;
} break;
}
} break;
case SDL_QUIT:
{
running = false;
} break;
}
}
gui_tick(mode, elapsed_time, delta_time);
SDL_GL_SwapWindow(mode.window);
delta_time = time_since(last_frame_t);
if (mode.fps_lock > 0)
{
r32 target_time = 1.0f / (r32)mode.fps_lock;
r32 sleep_time = target_time - delta_time;
if (sleep_time >= 0.01f)
SDL_Delay((u32)(sleep_time * 1000.0f));
delta_time = time_since(last_frame_t);
}
last_frame_t = get_tick();
elapsed_time = time_since(initial_tick);
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
Printf("An error occurred: %s\n", gl_error_message(error));
running = false;
}
}
ImGui_ImplSdl_Shutdown();
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(mode.window);
SDL_Quit();
return 0;
}
Int Sdl2Application::swapInterval() const {
return SDL_GL_GetSwapInterval();
}
/*-------------------------------------
Determine if VSync is enabled or disabled within the current window.
-------------------------------------*/
bool Context::get_vsync() const {
return SDL_GL_GetSwapInterval() != 0;
}
SDL_Renderer *
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
{
SDL_Renderer *renderer;
GLES_RenderData *data;
GLint value;
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
if (!renderer) {
SDL_OutOfMemory();
return NULL;
}
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
if (!data) {
GLES_DestroyRenderer(renderer);
SDL_OutOfMemory();
return NULL;
}
renderer->WindowEvent = GLES_WindowEvent;
renderer->CreateTexture = GLES_CreateTexture;
renderer->UpdateTexture = GLES_UpdateTexture;
renderer->LockTexture = GLES_LockTexture;
renderer->UnlockTexture = GLES_UnlockTexture;
renderer->UpdateViewport = GLES_UpdateViewport;
renderer->RenderClear = GLES_RenderClear;
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
renderer->RenderDrawLines = GLES_RenderDrawLines;
renderer->RenderFillRects = GLES_RenderFillRects;
renderer->RenderCopy = GLES_RenderCopy;
renderer->RenderPresent = GLES_RenderPresent;
renderer->DestroyTexture = GLES_DestroyTexture;
renderer->DestroyRenderer = GLES_DestroyRenderer;
renderer->info = GLES_RenderDriver.info;
renderer->info.flags = SDL_RENDERER_ACCELERATED;
renderer->driverdata = data;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
data->context = SDL_GL_CreateContext(window);
if (!data->context) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
GLES_DestroyRenderer(renderer);
return NULL;
}
if (flags & SDL_RENDERER_PRESENTVSYNC) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
if (SDL_GL_GetSwapInterval() > 0) {
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
}
#if SDL_VIDEO_DRIVER_PANDORA
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
#else
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
data->GL_OES_draw_texture_supported = SDL_TRUE;
data->useDrawTexture = SDL_TRUE;
} else {
data->GL_OES_draw_texture_supported = SDL_FALSE;
data->useDrawTexture = SDL_FALSE;
}
#endif
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_width = value;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
renderer->info.max_texture_height = value;
/* Set up parameters for rendering */
GLES_ResetState(renderer);
return renderer;
}
void Window::updateSettings(const WindowSettings &newsettings, bool updateGraphicsViewport)
{
Uint32 wflags = SDL_GetWindowFlags(window);
// Set the new display mode as the current display mode.
SDL_GetWindowSize(window, &windowWidth, &windowHeight);
SDL_GL_GetDrawableSize(window, &pixelWidth, &pixelHeight);
if ((wflags & SDL_WINDOW_FULLSCREEN_DESKTOP) == SDL_WINDOW_FULLSCREEN_DESKTOP)
{
settings.fullscreen = true;
settings.fstype = FULLSCREEN_DESKTOP;
}
else if ((wflags & SDL_WINDOW_FULLSCREEN) == SDL_WINDOW_FULLSCREEN)
{
settings.fullscreen = true;
settings.fstype = FULLSCREEN_EXCLUSIVE;
}
else
{
settings.fullscreen = false;
settings.fstype = newsettings.fstype;
}
#ifdef LOVE_ANDROID
settings.fullscreen = love::android::getImmersive();
#endif
// SDL_GetWindowMinimumSize gives back 0,0 sometimes...
settings.minwidth = newsettings.minwidth;
settings.minheight = newsettings.minheight;
settings.resizable = (wflags & SDL_WINDOW_RESIZABLE) != 0;
settings.borderless = (wflags & SDL_WINDOW_BORDERLESS) != 0;
settings.centered = newsettings.centered;
getPosition(settings.x, settings.y, settings.display);
settings.highdpi = (wflags & SDL_WINDOW_ALLOW_HIGHDPI) != 0;
// Only minimize on focus loss if the window is in exclusive-fullscreen mode
if (settings.fullscreen && settings.fstype == FULLSCREEN_EXCLUSIVE)
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "1");
else
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
// Verify MSAA setting.
int buffers = 0;
int samples = 0;
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &buffers);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &samples);
settings.msaa = (buffers > 0 ? samples : 0);
settings.vsync = SDL_GL_GetSwapInterval();
settings.stencil = newsettings.stencil;
settings.depth = newsettings.depth;
SDL_DisplayMode dmode = {};
SDL_GetCurrentDisplayMode(settings.display, &dmode);
// May be 0 if the refresh rate can't be determined.
settings.refreshrate = (double) dmode.refresh_rate;
// Update the viewport size now instead of waiting for event polling.
if (updateGraphicsViewport && graphics.get())
{
double scaledw, scaledh;
fromPixels((double) pixelWidth, (double) pixelHeight, scaledw, scaledh);
graphics->setViewportSize((int) scaledw, (int) scaledh, pixelWidth, pixelHeight);
}
}
int
RunGLTest(int argc, char *argv[],
int logo, int logocursor, int slowly, int bpp, float gamma,
int noframe, int fsaa, int sync, int accel)
{
int i;
int rgb_size[3];
int w = 640;
int h = 480;
int done = 0;
int frames;
Uint32 start_time, this_time;
float color[8][3] = { {1.0, 1.0, 0.0},
{1.0, 0.0, 0.0},
{0.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, 1.0, 1.0},
{1.0, 1.0, 1.0},
{1.0, 0.0, 1.0},
{0.0, 0.0, 1.0}
};
float cube[8][3] = { {0.5, 0.5, -0.5},
{0.5, -0.5, -0.5},
{-0.5, -0.5, -0.5},
{-0.5, 0.5, -0.5},
{-0.5, 0.5, 0.5},
{0.5, 0.5, 0.5},
{0.5, -0.5, 0.5},
{-0.5, -0.5, 0.5}
};
Uint32 video_flags;
int value;
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
/* See if we should detect the display depth */
if (bpp == 0) {
if (SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8) {
bpp = 8;
} else {
bpp = 16; /* More doesn't seem to work */
}
}
/* Set the flags we want to use for setting the video mode */
video_flags = SDL_OPENGL;
for (i = 1; argv[i]; ++i) {
if (strcmp(argv[i], "-fullscreen") == 0) {
video_flags |= SDL_FULLSCREEN;
}
}
if (noframe) {
video_flags |= SDL_NOFRAME;
}
/* Initialize the display */
switch (bpp) {
case 8:
rgb_size[0] = 3;
rgb_size[1] = 3;
rgb_size[2] = 2;
break;
case 15:
case 16:
rgb_size[0] = 5;
rgb_size[1] = 5;
rgb_size[2] = 5;
break;
default:
rgb_size[0] = 8;
rgb_size[1] = 8;
rgb_size[2] = 8;
break;
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, rgb_size[0]);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, rgb_size[1]);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, rgb_size[2]);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (fsaa) {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, fsaa);
}
if (accel >= 0) {
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, accel);
}
if (SDL_SetVideoMode(w, h, bpp, video_flags) == NULL) {
fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError());
SDL_Quit();
exit(1);
}
if (sync) {
SDL_GL_SetSwapInterval(1);
} else {
SDL_GL_SetSwapInterval(0);
}
printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel);
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");
SDL_GL_GetAttribute(SDL_GL_RED_SIZE, &value);
printf("SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0], value);
SDL_GL_GetAttribute(SDL_GL_GREEN_SIZE, &value);
printf("SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1], value);
SDL_GL_GetAttribute(SDL_GL_BLUE_SIZE, &value);
printf("SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2], value);
SDL_GL_GetAttribute(SDL_GL_DEPTH_SIZE, &value);
printf("SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value);
SDL_GL_GetAttribute(SDL_GL_DOUBLEBUFFER, &value);
printf("SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value);
if (fsaa) {
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &value);
printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value);
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &value);
printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa,
value);
}
if (accel >= 0) {
SDL_GL_GetAttribute(SDL_GL_ACCELERATED_VISUAL, &value);
printf("SDL_GL_ACCELERATED_VISUAL: requested %d, got %d\n", accel,
value);
}
if (sync) {
printf("Buffer swap interval: requested 1, got %d\n",
SDL_GL_GetSwapInterval());
}
/* Set the window manager title bar */
SDL_WM_SetCaption("SDL GL test", "testgl");
/* Set the gamma for the window */
if (gamma != 0.0) {
SDL_SetGamma(gamma, gamma, gamma);
}
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-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);
/* Loop until done. */
start_time = SDL_GetTicks();
frames = 0;
while (!done) {
GLenum gl_error;
char *sdl_error;
SDL_Event event;
/* Do our drawing, too. */
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin(GL_QUADS);
#ifdef SHADED_CUBE
glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);
glColor3fv(color[3]);
glVertex3fv(cube[3]);
glColor3fv(color[3]);
glVertex3fv(cube[3]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);
glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[6]);
glVertex3fv(cube[6]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);
glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
glColor3fv(color[6]);
glVertex3fv(cube[6]);
glColor3fv(color[5]);
glVertex3fv(cube[5]);
glColor3fv(color[0]);
glVertex3fv(cube[0]);
glColor3fv(color[3]);
glVertex3fv(cube[3]);
glColor3fv(color[4]);
glVertex3fv(cube[4]);
glColor3fv(color[6]);
glVertex3fv(cube[6]);
glColor3fv(color[1]);
glVertex3fv(cube[1]);
glColor3fv(color[2]);
glVertex3fv(cube[2]);
glColor3fv(color[7]);
glVertex3fv(cube[7]);
#else /* flat cube */
glColor3f(1.0, 0.0, 0.0);
glVertex3fv(cube[0]);
glVertex3fv(cube[1]);
glVertex3fv(cube[2]);
glVertex3fv(cube[3]);
glColor3f(0.0, 1.0, 0.0);
glVertex3fv(cube[3]);
glVertex3fv(cube[4]);
glVertex3fv(cube[7]);
glVertex3fv(cube[2]);
glColor3f(0.0, 0.0, 1.0);
glVertex3fv(cube[0]);
glVertex3fv(cube[5]);
glVertex3fv(cube[6]);
glVertex3fv(cube[1]);
glColor3f(0.0, 1.0, 1.0);
glVertex3fv(cube[5]);
glVertex3fv(cube[4]);
glVertex3fv(cube[7]);
glVertex3fv(cube[6]);
glColor3f(1.0, 1.0, 0.0);
glVertex3fv(cube[5]);
glVertex3fv(cube[0]);
glVertex3fv(cube[3]);
glVertex3fv(cube[4]);
glColor3f(1.0, 0.0, 1.0);
glVertex3fv(cube[6]);
glVertex3fv(cube[1]);
glVertex3fv(cube[2]);
glVertex3fv(cube[7]);
#endif /* SHADED_CUBE */
glEnd();
glMatrixMode(GL_MODELVIEW);
glRotatef(5.0, 1.0, 1.0, 1.0);
/* Draw 2D logo onto the 3D display */
if (logo) {
DrawLogoTexture();
}
if (logocursor) {
DrawLogoCursor();
}
SDL_GL_SwapBuffers();
/* Check for error conditions. */
gl_error = glGetError();
if (gl_error != GL_NO_ERROR) {
fprintf(stderr, "testgl: OpenGL error: %d\n", gl_error);
}
sdl_error = (char *)SDL_GetError();
if (sdl_error[0] != '\0') {
fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error);
SDL_ClearError();
}
/* Allow the user to see what's happening */
if (slowly) {
SDL_Delay(20);
}
/* Check if there's a pending event. */
while (SDL_PollEvent(&event)) {
done |= HandleEvent(&event);
}
++frames;
}
/* Print out the frames per second */
this_time = SDL_GetTicks();
if (this_time != start_time) {
printf("%2.2f FPS\n",
((float) frames / (this_time - start_time)) * 1000.0);
}
if (global_image) {
SDL_FreeSurface(global_image);
global_image = NULL;
}
if (global_texture) {
glDeleteTextures(1, &global_texture);
global_texture = 0;
}
if (cursor_texture) {
glDeleteTextures(1, &cursor_texture);
cursor_texture = 0;
}
/* Destroy our GL context, etc. */
SDL_Quit();
return (0);
}
SDLContext::SDLContext(const rainbow::Config& config)
: window_(nullptr), vsync_(false), fullscreen_(0), context_(nullptr)
{
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0)
{
LOGF("SDL: Unable to initialise video: %s", SDL_GetError());
return;
}
#ifdef RAINBOW_OS_MACOS
// Prevent the full screen window from being minimized when losing focus.
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0");
#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_DEPTH_SIZE, 0);
if (config.msaa() > 0)
{
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, config.msaa());
}
const uint32_t flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN |
(config.high_dpi() ? SDL_WINDOW_ALLOW_HIGHDPI : 0);
const Vec2i& size = ::window_size(config);
window_ = SDL_CreateWindow(RAINBOW_BUILD,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
size.x,
size.y,
flags);
if (!window_)
{
R_ABORT("SDL: Failed to create window: %s", SDL_GetError());
return;
}
context_ = SDL_GL_CreateContext(window_);
if (!context_)
{
R_ABORT("SDL: Failed to create GL context: %s", SDL_GetError());
return;
}
#ifdef RAINBOW_JS
vsync_ = true;
#else
SDL_GL_SetSwapInterval(1);
vsync_ = SDL_GL_GetSwapInterval() == 1;
#endif
#ifndef NDEBUG
const Vec2i& resolution = drawable_size();
LOGI("SDL: Resolution: %ix%i", resolution.x, resolution.y);
int msaa = 0;
SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &msaa);
if (msaa > 0)
LOGI("SDL: Anti-aliasing: %ix MSAA", msaa);
else
LOGI("SDL: Anti-aliasing: Disabled");
LOGI("SDL: Vertical sync: %s", (vsync_ ? "Enabled" : "Disabled"));
#endif
}
