mirror of
https://github.com/glfw/glfw.git
synced 2026-09-23 00:59:48 +00:00
Renamed context module files.
This commit is contained in:
Camilla Berglund
@@ -0,0 +1,591 @@
|
||||
//========================================================================
|
||||
// GLFW - An OpenGL library
|
||||
// Platform: EGL
|
||||
// API version: 3.0
|
||||
// WWW: http://www.glfw.org/
|
||||
//------------------------------------------------------------------------
|
||||
// Copyright (c) 2002-2006 Marcus Geelnard
|
||||
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
|
||||
//
|
||||
// This software is provided 'as-is', without any express or implied
|
||||
// warranty. In no event will the authors be held liable for any damages
|
||||
// arising from the use of this software.
|
||||
//
|
||||
// Permission is granted to anyone to use this software for any purpose,
|
||||
// including commercial applications, and to alter it and redistribute it
|
||||
// freely, subject to the following restrictions:
|
||||
//
|
||||
// 1. The origin of this software must not be misrepresented; you must not
|
||||
// claim that you wrote the original software. If you use this software
|
||||
// in a product, an acknowledgment in the product documentation would
|
||||
// be appreciated but is not required.
|
||||
//
|
||||
// 2. Altered source versions must be plainly marked as such, and must not
|
||||
// be misrepresented as being the original software.
|
||||
//
|
||||
// 3. This notice may not be removed or altered from any source
|
||||
// distribution.
|
||||
//
|
||||
//========================================================================
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Thread local storage attribute macro
|
||||
//========================================================================
|
||||
#if defined(_MSC_VER)
|
||||
#define _GLFW_TLS __declspec(thread)
|
||||
#elif defined(__GNUC__)
|
||||
#define _GLFW_TLS __thread
|
||||
#else
|
||||
#define _GLFW_TLS
|
||||
#endif
|
||||
|
||||
|
||||
//========================================================================
|
||||
// The per-thread current context/window pointer
|
||||
//========================================================================
|
||||
static _GLFW_TLS _GLFWwindow* _glfwCurrentWindow = NULL;
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Returns the specified attribute of the specified EGLConfig
|
||||
//========================================================================
|
||||
|
||||
static int getConfigAttrib(EGLConfig config, int attrib)
|
||||
{
|
||||
int value;
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config, attrib, &value);
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Return a list of available and usable framebuffer configs
|
||||
//========================================================================
|
||||
|
||||
static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window,
|
||||
const _GLFWwndconfig* wndconfig,
|
||||
unsigned int* found)
|
||||
{
|
||||
EGLConfig* configs;
|
||||
_GLFWfbconfig* result;
|
||||
int i, count = 0;
|
||||
|
||||
*found = 0;
|
||||
|
||||
eglGetConfigs(_glfwLibrary.EGL.display, NULL, 0, &count);
|
||||
|
||||
configs = (EGLConfig*) malloc(sizeof(EGLConfig) * count);
|
||||
if (!configs)
|
||||
{
|
||||
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
eglGetConfigs(_glfwLibrary.EGL.display, configs, count, &count);
|
||||
if (!count)
|
||||
{
|
||||
free(configs);
|
||||
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: No EGLConfigs returned");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
result = (_GLFWfbconfig*) malloc(sizeof(_GLFWfbconfig) * count);
|
||||
if (!result)
|
||||
{
|
||||
free(configs);
|
||||
|
||||
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
_GLFWfbconfig* f = result + *found;
|
||||
|
||||
if (!getConfigAttrib(configs[i], EGL_NATIVE_VISUAL_ID))
|
||||
{
|
||||
// Only consider EGLConfigs with associated visuals
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!(getConfigAttrib(configs[i], EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
|
||||
{
|
||||
// Only consider RGB(A) EGLConfigs
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!(getConfigAttrib(configs[i], EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
|
||||
{
|
||||
// Only consider window EGLConfigs
|
||||
continue;
|
||||
}
|
||||
|
||||
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
|
||||
{
|
||||
if (wndconfig->glMajor == 1)
|
||||
{
|
||||
if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else if (wndconfig->clientAPI == GLFW_OPENGL_API)
|
||||
{
|
||||
if (!(getConfigAttrib(configs[i], EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
|
||||
continue;
|
||||
}
|
||||
|
||||
f->redBits = getConfigAttrib(configs[i], EGL_RED_SIZE);
|
||||
f->greenBits = getConfigAttrib(configs[i], EGL_GREEN_SIZE);
|
||||
f->blueBits = getConfigAttrib(configs[i], EGL_BLUE_SIZE);
|
||||
|
||||
f->alphaBits = getConfigAttrib(configs[i], EGL_ALPHA_SIZE);
|
||||
f->depthBits = getConfigAttrib(configs[i], EGL_DEPTH_SIZE);
|
||||
f->stencilBits = getConfigAttrib(configs[i], EGL_STENCIL_SIZE);
|
||||
|
||||
f->samples = getConfigAttrib(configs[i], EGL_SAMPLES);
|
||||
|
||||
f->platformID = (GLFWintptr) getConfigAttrib(configs[i], EGL_CONFIG_ID);
|
||||
|
||||
(*found)++;
|
||||
}
|
||||
|
||||
free(configs);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Create the actual OpenGL(|ES) context
|
||||
//========================================================================
|
||||
|
||||
#define setEGLattrib(attribs, index, attribName, attribValue) \
|
||||
{ \
|
||||
attribs[index++] = attribName; \
|
||||
attribs[index++] = attribValue; \
|
||||
}
|
||||
|
||||
static int createContext(_GLFWwindow* window,
|
||||
const _GLFWwndconfig* wndconfig,
|
||||
EGLint fbconfigID)
|
||||
{
|
||||
int attribs[40];
|
||||
EGLint count, index;
|
||||
EGLConfig config;
|
||||
EGLContext share = NULL;
|
||||
|
||||
if (wndconfig->share)
|
||||
share = wndconfig->share->EGL.context;
|
||||
|
||||
// Retrieve the previously selected EGLConfig
|
||||
{
|
||||
index = 0;
|
||||
|
||||
setEGLattrib(attribs, index, EGL_CONFIG_ID, fbconfigID);
|
||||
setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
|
||||
|
||||
eglChooseConfig(_glfwLibrary.EGL.display, attribs, &config, 1, &count);
|
||||
if (!count)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: Failed to retrieve the selected EGLConfig");
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
// Retrieve the corresponding visual
|
||||
// NOTE: This is the only non-portable code in this file.
|
||||
// Maybe it would not hurt too much to add #ifdefs for different platforms?
|
||||
#if defined(_GLFW_X11)
|
||||
{
|
||||
int mask;
|
||||
EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
|
||||
XVisualInfo info;
|
||||
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
|
||||
EGL_NATIVE_VISUAL_ID, &visualID);
|
||||
|
||||
info.screen = _glfwLibrary.X11.screen;
|
||||
mask = VisualScreenMask;
|
||||
|
||||
if (visualID)
|
||||
{
|
||||
// The X window visual must match the EGL config
|
||||
info.visualid = visualID;
|
||||
mask |= VisualIDMask;
|
||||
}
|
||||
else
|
||||
{
|
||||
// some EGL drivers don't implement the EGL_NATIVE_VISUAL_ID
|
||||
// attribute, so attempt to find the closest match.
|
||||
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
|
||||
EGL_RED_SIZE, &redBits);
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
|
||||
EGL_GREEN_SIZE, &greenBits);
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
|
||||
EGL_BLUE_SIZE, &blueBits);
|
||||
eglGetConfigAttrib(_glfwLibrary.EGL.display, config,
|
||||
EGL_ALPHA_SIZE, &alphaBits);
|
||||
|
||||
info.depth = redBits + greenBits + blueBits + alphaBits;
|
||||
mask |= VisualDepthMask;
|
||||
}
|
||||
|
||||
window->EGL.visual = XGetVisualInfo(_glfwLibrary.X11.display,
|
||||
mask, &info, &count);
|
||||
|
||||
if (window->EGL.visual == NULL)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: Failed to retrieve visual for EGLConfig");
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
|
||||
{
|
||||
if (!eglBindAPI(EGL_OPENGL_ES_API))
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: OpenGL ES is not supported");
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!eglBindAPI(EGL_OPENGL_API))
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: OpenGL is not supported");
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
index = 0;
|
||||
|
||||
if (_glfwLibrary.EGL.KHR_create_context)
|
||||
{
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
|
||||
|
||||
if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness)
|
||||
{
|
||||
int flags = 0;
|
||||
|
||||
if (wndconfig->glForward)
|
||||
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
|
||||
|
||||
if (wndconfig->glDebug)
|
||||
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
|
||||
|
||||
if (wndconfig->glRobustness)
|
||||
flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
|
||||
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_FLAGS_KHR, flags);
|
||||
}
|
||||
|
||||
if (wndconfig->glProfile)
|
||||
{
|
||||
int flags = 0;
|
||||
|
||||
if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
|
||||
flags = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
|
||||
else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
|
||||
flags = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
|
||||
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, flags);
|
||||
}
|
||||
|
||||
if (wndconfig->glRobustness)
|
||||
{
|
||||
int strategy;
|
||||
|
||||
if (wndconfig->glRobustness == GLFW_OPENGL_NO_RESET_NOTIFICATION)
|
||||
strategy = EGL_NO_RESET_NOTIFICATION_KHR;
|
||||
else if (wndconfig->glRobustness == GLFW_OPENGL_LOSE_CONTEXT_ON_RESET)
|
||||
strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
|
||||
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
|
||||
setEGLattrib(attribs, index, EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
|
||||
}
|
||||
|
||||
setEGLattrib(attribs, index, EGL_NONE, EGL_NONE);
|
||||
|
||||
window->EGL.context = eglCreateContext(_glfwLibrary.EGL.display,
|
||||
config, share, attribs);
|
||||
|
||||
if (window->EGL.context == EGL_NO_CONTEXT)
|
||||
{
|
||||
// TODO: Handle all the various error codes here
|
||||
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: Failed to create context");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
window->EGL.config = config;
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
#undef setEGLattrib
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
////// GLFW internal API //////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//========================================================================
|
||||
// Initialize EGL
|
||||
//========================================================================
|
||||
|
||||
int _glfwInitOpenGL(void)
|
||||
{
|
||||
#ifdef _GLFW_DLOPEN_LIBEGL
|
||||
int i;
|
||||
char* libEGL_names[ ] =
|
||||
{
|
||||
"libEGL.so",
|
||||
"libEGL.so.1",
|
||||
"/usr/lib/libEGL.so",
|
||||
"/usr/lib/libEGL.so.1",
|
||||
NULL
|
||||
};
|
||||
|
||||
for (i = 0; libEGL_names[i] != NULL; i++)
|
||||
{
|
||||
_glfwLibrary.EGL.libEGL = dlopen(libEGL_names[i], RTLD_LAZY | RTLD_GLOBAL);
|
||||
if (_glfwLibrary.EGL.libEGL)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!_glfwLibrary.EGL.libEGL)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR, "EGL: Failed to find libEGL");
|
||||
return GL_FALSE;
|
||||
}
|
||||
#endif
|
||||
|
||||
_glfwLibrary.EGL.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
|
||||
if (_glfwLibrary.EGL.display == EGL_NO_DISPLAY)
|
||||
{
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: Failed to get EGL display");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
if (!eglInitialize(_glfwLibrary.EGL.display,
|
||||
&_glfwLibrary.EGL.majorVersion,
|
||||
&_glfwLibrary.EGL.minorVersion))
|
||||
{
|
||||
_glfwSetError(GLFW_API_UNAVAILABLE,
|
||||
"EGL: Failed to initialize EGL");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
if (_glfwPlatformExtensionSupported("EGL_KHR_create_context"))
|
||||
_glfwLibrary.EGL.KHR_create_context = GL_TRUE;
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Terminate EGL
|
||||
//========================================================================
|
||||
|
||||
void _glfwTerminateOpenGL(void)
|
||||
{
|
||||
#ifdef _GLFW_DLOPEN_LIBEGL
|
||||
if (_glfwLibrary.EGL.libEGL != NULL)
|
||||
{
|
||||
dlclose(_glfwLibrary.EGL.libEGL);
|
||||
_glfwLibrary.EGL.libEGL = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
eglTerminate(_glfwLibrary.EGL.display);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Prepare for creation of the OpenGL context
|
||||
//========================================================================
|
||||
|
||||
int _glfwCreateContext(_GLFWwindow* window,
|
||||
const _GLFWwndconfig* wndconfig,
|
||||
const _GLFWfbconfig* fbconfig)
|
||||
{
|
||||
_GLFWfbconfig closest;
|
||||
|
||||
// Choose the best available fbconfig
|
||||
{
|
||||
unsigned int fbcount;
|
||||
_GLFWfbconfig* fbconfigs;
|
||||
const _GLFWfbconfig* result;
|
||||
|
||||
fbconfigs = getFBConfigs(window, wndconfig, &fbcount);
|
||||
if (!fbconfigs)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: No usable EGLFBConfigs found");
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
result = _glfwChooseFBConfig(fbconfig, fbconfigs, fbcount);
|
||||
if (!result)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: No EGLFBConfig matched the criteria");
|
||||
|
||||
free(fbconfigs);
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
closest = *result;
|
||||
free(fbconfigs);
|
||||
}
|
||||
|
||||
return createContext(window, wndconfig, closest.platformID);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Destroy the OpenGL context
|
||||
//========================================================================
|
||||
|
||||
void _glfwDestroyContext(_GLFWwindow* window)
|
||||
{
|
||||
if (window->EGL.visual)
|
||||
{
|
||||
XFree(window->EGL.visual);
|
||||
window->EGL.visual = NULL;
|
||||
}
|
||||
|
||||
if (window->EGL.surface)
|
||||
{
|
||||
eglDestroySurface(_glfwLibrary.EGL.display, window->EGL.surface);
|
||||
window->EGL.surface = EGL_NO_SURFACE;
|
||||
}
|
||||
|
||||
if (window->EGL.context)
|
||||
{
|
||||
eglDestroyContext(_glfwLibrary.EGL.display, window->EGL.context);
|
||||
window->EGL.context = EGL_NO_CONTEXT;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Make the OpenGL context associated with the specified window current
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformMakeContextCurrent(_GLFWwindow* window)
|
||||
{
|
||||
if (window)
|
||||
{
|
||||
if (window->EGL.surface == EGL_NO_SURFACE)
|
||||
{
|
||||
window->EGL.surface = eglCreateWindowSurface(_glfwLibrary.EGL.display,
|
||||
window->EGL.config,
|
||||
_GLFW_EGL_NATIVE_WINDOW,
|
||||
NULL);
|
||||
if (window->EGL.surface == EGL_NO_SURFACE)
|
||||
{
|
||||
_glfwSetError(GLFW_PLATFORM_ERROR,
|
||||
"EGL: Failed to create window surface");
|
||||
}
|
||||
}
|
||||
|
||||
eglMakeCurrent(_glfwLibrary.EGL.display,
|
||||
window->EGL.surface,
|
||||
window->EGL.surface,
|
||||
window->EGL.context);
|
||||
}
|
||||
else
|
||||
{
|
||||
eglMakeCurrent(_glfwLibrary.EGL.display,
|
||||
EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
||||
}
|
||||
|
||||
_glfwCurrentWindow = window;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Return the window object whose context is current
|
||||
//========================================================================
|
||||
|
||||
_GLFWwindow* _glfwPlatformGetCurrentContext(void)
|
||||
{
|
||||
return _glfwCurrentWindow;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Swap OpenGL buffers
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformSwapBuffers(_GLFWwindow* window)
|
||||
{
|
||||
eglSwapBuffers(_glfwLibrary.EGL.display, window->EGL.surface);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Set double buffering swap interval
|
||||
//========================================================================
|
||||
|
||||
void _glfwPlatformSwapInterval(int interval)
|
||||
{
|
||||
eglSwapInterval(_glfwLibrary.EGL.display, interval);
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Check if an OpenGL extension is available at runtime
|
||||
//========================================================================
|
||||
|
||||
int _glfwPlatformExtensionSupported(const char* extension)
|
||||
{
|
||||
const char* extensions;
|
||||
|
||||
extensions = eglQueryString(_glfwLibrary.EGL.display, EGL_EXTENSIONS);
|
||||
if (extensions != NULL)
|
||||
{
|
||||
if (_glfwStringInExtensionString(extension, (unsigned char*) extensions))
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
|
||||
//========================================================================
|
||||
// Get the function pointer to an OpenGL function
|
||||
//========================================================================
|
||||
|
||||
GLFWglproc _glfwPlatformGetProcAddress(const char* procname)
|
||||
{
|
||||
return _glfw_eglGetProcAddress(procname);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user