mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-22 04:54:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into multi-monitor

Browse Source 
Conflicts:
	include/GL/glfw3.h
	src/window.c
	tests/glfwinfo.c
This commit is contained in:
Camilla Berglund 2012-12-22 19:40:15 +01:00
commit 692f34b536
19 changed files with 2369 additions and 483 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
include/GL/glfw3.h
View File

@ -459,88 +459,124 @@ extern "C" {
* @{ */ * @{ */
/*! @brief @c GL_TRUE if the window has focus, or @c GL_FALSE otherwise. /*! @brief @c GL_TRUE if the window has focus, or @c GL_FALSE otherwise.
* @see glfwGetWindowParam
*/ */
#define GLFW_FOCUSED 0x00020001 #define GLFW_FOCUSED 0x00020001
/*! @brief @c GL_TRUE if the window is iconified, or @c GL_FALSE otherwise. /*! @brief @c GL_TRUE if the window is iconified, or @c GL_FALSE otherwise.
* @see glfwGetWindowParam
*/ */
#define GLFW_ICONIFIED 0x00020002 #define GLFW_ICONIFIED 0x00020002
/*! @brief @c GL_TRUE if the window has been requested to close, or @c GL_FALSE /*! @brief @c GL_TRUE if the window has been requested to close, or @c GL_FALSE
* otherwise. * otherwise.
* @see glfwGetWindowParam
*/ */
#define GLFW_CLOSE_REQUESTED 0x00020003 #define GLFW_CLOSE_REQUESTED 0x00020003
/*! @brief The client API version revision. /*! @brief The client API version revision.
* @see glfwGetWindowParam
*/ */
#define GLFW_CONTEXT_REVISION 0x00020004 #define GLFW_CONTEXT_REVISION 0x00020004
/*! @brief The bit depth of the red component of the color buffer. /*! @brief The bit depth of the red component of the color buffer.
* @see glfwWindowHint
*/ */
#define GLFW_RED_BITS 0x00021000 #define GLFW_RED_BITS 0x00021000
/*! @brief The bit depth of the green component of the color buffer. /*! @brief The bit depth of the green component of the color buffer.
* @see glfwWindowHint
*/ */
#define GLFW_GREEN_BITS 0x00021001 #define GLFW_GREEN_BITS 0x00021001
/*! @brief The bit depth of the blue component of the color buffer. /*! @brief The bit depth of the blue component of the color buffer.
* @see glfwWindowHint
*/ */
#define GLFW_BLUE_BITS 0x00021002 #define GLFW_BLUE_BITS 0x00021002
/*! @brief The bit depth of the alpha component of the color buffer. /*! @brief The bit depth of the alpha component of the color buffer.
* @see glfwWindowHint
*/ */
#define GLFW_ALPHA_BITS 0x00021003 #define GLFW_ALPHA_BITS 0x00021003
/*! @brief The bit depth of the depth buffer of the default framebuffer. /*! @brief The bit depth of the depth buffer of the default framebuffer.
* @see glfwWindowHint
*/ */
#define GLFW_DEPTH_BITS 0x00021004 #define GLFW_DEPTH_BITS 0x00021004
/*! @brief The bit depth of the stencil buffer of the default framebuffer. /*! @brief The bit depth of the stencil buffer of the default framebuffer.
* @see glfwWindowHint
*/ */
#define GLFW_STENCIL_BITS 0x00021005 #define GLFW_STENCIL_BITS 0x00021005
/*! @brief The monitor refresh rate. /*! @brief The monitor refresh rate.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_REFRESH_RATE 0x00021006 #define GLFW_REFRESH_RATE 0x00021006
/*! @brief The bit depth of the red component of the accumulation buffer. /*! @brief The bit depth of the red component of the accumulation buffer.
* @see glfwWindowHint
*/ */
#define GLFW_ACCUM_RED_BITS 0x00021007 #define GLFW_ACCUM_RED_BITS 0x00021007
/*! @brief The bit depth of the red component of the accumulation buffer. /*! @brief The bit depth of the red component of the accumulation buffer.
* @see glfwWindowHint
*/ */
#define GLFW_ACCUM_GREEN_BITS 0x00021008 #define GLFW_ACCUM_GREEN_BITS 0x00021008
/*! @brief The bit depth of the red component of the accumulation buffer. /*! @brief The bit depth of the red component of the accumulation buffer.
* @see glfwWindowHint
*/ */
#define GLFW_ACCUM_BLUE_BITS 0x00021009 #define GLFW_ACCUM_BLUE_BITS 0x00021009
/*! @brief The bit depth of the red component of the accumulation buffer. /*! @brief The bit depth of the red component of the accumulation buffer.
* @see glfwWindowHint
*/ */
#define GLFW_ACCUM_ALPHA_BITS 0x0002100A #define GLFW_ACCUM_ALPHA_BITS 0x0002100A
/*! @brief The number of auxiliary buffers. /*! @brief The number of auxiliary buffers.
* @see glfwWindowHint
*/ */
#define GLFW_AUX_BUFFERS 0x0002100B #define GLFW_AUX_BUFFERS 0x0002100B
/*! @brief @c GL_TRUE for stereo rendering, or @c GL_FALSE otherwise. /*! @brief @c GL_TRUE for stereo rendering, or @c GL_FALSE otherwise.
* @see glfwWindowHint
*/ */
#define GLFW_STEREO 0x0002100C #define GLFW_STEREO 0x0002100C
/*! @brief The number of samples used for default framebuffer multisampling, or /*! @brief The number of samples used for default framebuffer multisampling, or
* zero to disable multisampling. * zero to disable multisampling.
* @see glfwWindowHint
*/ */
#define GLFW_FSAA_SAMPLES 0x0002100E #define GLFW_FSAA_SAMPLES 0x0002100E
/*! @brief @c GL_TRUE if the framebuffer should be sRGB capable, or @c GL_FALSE /*! @brief @c GL_TRUE if the framebuffer should be sRGB capable, or @c GL_FALSE
* otherwise. * otherwise.
* @see glfwWindowHint
*/ */
#define GLFW_SRGB_CAPABLE 0x0002100F #define GLFW_SRGB_CAPABLE 0x0002100F
/*! @brief The @link clients client API @endlink to create a context for. /*! @brief The @link clients client API @endlink to create a context for.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_CLIENT_API 0x00022000 #define GLFW_CLIENT_API 0x00022000
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_CONTEXT_VERSION_MAJOR 0x00022001 #define GLFW_CONTEXT_VERSION_MAJOR 0x00022001
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_CONTEXT_VERSION_MINOR 0x00022002 #define GLFW_CONTEXT_VERSION_MINOR 0x00022002
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_CONTEXT_ROBUSTNESS 0x00022003 #define GLFW_CONTEXT_ROBUSTNESS 0x00022003
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_OPENGL_FORWARD_COMPAT 0x00022004 #define GLFW_OPENGL_FORWARD_COMPAT 0x00022004
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_OPENGL_DEBUG_CONTEXT 0x00022005 #define GLFW_OPENGL_DEBUG_CONTEXT 0x00022005
/*! @see glfwWindowHint glfwGetWindowParam
*/
#define GLFW_OPENGL_PROFILE 0x00022006 #define GLFW_OPENGL_PROFILE 0x00022006
/*! @brief @c GL_TRUE if the window is resizable, or @c GL_FALSE otherwise. /*! @brief @c GL_TRUE if the window is resizable, or @c GL_FALSE otherwise.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_RESIZABLE 0x00022007 #define GLFW_RESIZABLE 0x00022007
/*! @brief @c GL_TRUE if the window is visible, or @c GL_FALSE otherwise. /*! @brief @c GL_TRUE if the window is visible, or @c GL_FALSE otherwise.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_VISIBLE 0x00022008 #define GLFW_VISIBLE 0x00022008
/*! @brief The x-coordinate, in pixels, of the upper-left corner of the /*! @brief The x-coordinate, in pixels, of the upper-left corner of the
* client area of the window. * client area of the window.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_POSITION_X 0x00022009 #define GLFW_POSITION_X 0x00022009
/*! @brief The y-coordinate, in pixels, of the upper-left corner of the /*! @brief The y-coordinate, in pixels, of the upper-left corner of the
* client area of the window. * client area of the window.
* @see glfwWindowHint glfwGetWindowParam
*/ */
#define GLFW_POSITION_Y 0x0002200A #define GLFW_POSITION_Y 0x0002200A
@ -1082,6 +1118,8 @@ GLFWAPI void glfwSetGammaRamp(const GLFWgammaramp* ramp);
* The @ref GLFW_CONTEXT_VERSION_MAJOR and @ref GLFW_CONTEXT_VERSION_MINOR * The @ref GLFW_CONTEXT_VERSION_MAJOR and @ref GLFW_CONTEXT_VERSION_MINOR
* hints are set to 1 and 0, respectively. * hints are set to 1 and 0, respectively.
* *
* The @ref GLFW_CONTEXT_ROBUSTNESS hint is set to @ref GLFW_NO_ROBUSTNESS.
*
* All other hints are set to 0. * All other hints are set to 0.
* *
* @ingroup window * @ingroup window
@ -1102,8 +1140,10 @@ GLFWAPI void glfwDefaultWindowHints(void);
* specify the desired bit depths of the various components of the default * specify the desired bit depths of the various components of the default
* framebuffer. * framebuffer.
* *
* The @ref GLFW_REFRESH_RATE hint specifies the desired monitor refresh rate * The @ref GLFW_REFRESH_RATE hint specifies the desired monitor refresh rate,
* for fullscreen windows. * in Hz, of the video mode for a fullscreen window, or zero to let the system
* choose a suitable refresh rate. If a windowed mode window is created, this
* hint is ignored.
* *
* The @ref GLFW_ACCUM_RED_BITS, @ref GLFW_ACCUM_GREEN_BITS, @ref * The @ref GLFW_ACCUM_RED_BITS, @ref GLFW_ACCUM_GREEN_BITS, @ref
* GLFW_ACCUM_BLUE_BITS and @ref GLFW_ACCUM_ALPHA_BITS hints specify the * GLFW_ACCUM_BLUE_BITS and @ref GLFW_ACCUM_ALPHA_BITS hints specify the
@ -1137,17 +1177,23 @@ GLFWAPI void glfwDefaultWindowHints(void);
* For OpenGL ES, these hints are hard constraints, as there is no backward * For OpenGL ES, these hints are hard constraints, as there is no backward
* compatibility between OpenGL ES versions. * compatibility between OpenGL ES versions.
* *
* The @ref GLFW_OPENGL_FORWARD_COMPAT hint specifies whether the OpenGL * If an OpenGL context is requested, the @ref GLFW_OPENGL_FORWARD_COMPAT hint
* context should be forward-compatible, i.e. one where all functionality * specifies whether the OpenGL context should be forward-compatible, i.e. one
* deprecated in the requested version of OpenGL is removed. * where all functionality deprecated in the requested version of OpenGL is
* removed. This may only be used if the requested OpenGL version is 3.0 or
* above. If another client API is requested, this hint is ignored.
* *
* The @ref GLFW_OPENGL_DEBUG_CONTEXT hint specifies whether to create a debug * If an OpenGL context is requested, the @ref GLFW_OPENGL_DEBUG_CONTEXT hint
* OpenGL context, which may have additional error and performance issue * specifies whether to create a debug OpenGL context, which may have
* reporting functionality. * additional error and performance issue reporting functionality. If another
* client API is requested, this hint is ignored.
* *
* The @ref GLFW_OPENGL_PROFILE hint specifies which OpenGL profile to create * If an OpenGL context is requested, the @ref GLFW_OPENGL_PROFILE hint
* the context for. Possible values are @ref GLFW_OPENGL_NO_PROFILE, @ref * specifies which OpenGL profile to create the context for. Possible values
* GLFW_OPENGL_CORE_PROFILE and @ref GLFW_OPENGL_COMPAT_PROFILE. * are @ref GLFW_OPENGL_NO_PROFILE, @ref GLFW_OPENGL_CORE_PROFILE and @ref
* GLFW_OPENGL_COMPAT_PROFILE. This may only be used if the requested OpenGL
* version is 3.2 or above. If another client API is requested, this hint
* is ignored.
* *
* The @ref GLFW_CONTEXT_ROBUSTNESS hint specifies the robustness strategy to * The @ref GLFW_CONTEXT_ROBUSTNESS hint specifies the robustness strategy to
* be used by the context. * be used by the context.
@ -1169,9 +1215,12 @@ GLFWAPI void glfwDefaultWindowHints(void);
* find out the actual properties of the created window and context, use the * find out the actual properties of the created window and context, use the
* @ref glfwGetWindowParam function. * @ref glfwGetWindowParam function.
* *
* The following window hints are hard constraints: * The following hints are hard constraints:
* @arg @ref GLFW_STEREO * @arg @ref GLFW_STEREO
* @arg @ref GLFW_CLIENT_API * @arg @ref GLFW_CLIENT_API
*
* The following additional hints are hard constraints if requesting an OpenGL
* context:
* @arg @ref GLFW_OPENGL_FORWARD_COMPAT * @arg @ref GLFW_OPENGL_FORWARD_COMPAT
* @arg @ref GLFW_OPENGL_PROFILE * @arg @ref GLFW_OPENGL_PROFILE
* *

3
src/cocoa_init.m
View File

@ -85,8 +85,7 @@ int _glfwPlatformInit(void)
CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl")); CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
if (_glfwLibrary.NSGL.framework == NULL) if (_glfwLibrary.NSGL.framework == NULL)
{ {
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR, "Failed to locate OpenGL framework");
"glfwInit: Failed to locate OpenGL framework");
return GL_FALSE; return GL_FALSE;
} }

2
src/cocoa_window.m
View File

@ -731,7 +731,7 @@ static GLboolean createContext(_GLFWwindow* window,
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API) if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
{ {
_glfwSetError(GLFW_VERSION_UNAVAILABLE, _glfwSetError(GLFW_VERSION_UNAVAILABLE,
"Cocoa/NSOpenGL: NSOpenGL does not support OpenGL ES"); "NSOpenGL: This API does not support OpenGL ES");
return GL_FALSE; return GL_FALSE;
} }

152
src/context.c
View File

@ -255,7 +255,6 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
//======================================================================== //========================================================================
// Checks whether the client API part of the window config is sane // Checks whether the client API part of the window config is sane
// It blames glfwOpenWindow because that's the only caller
//======================================================================== //========================================================================
GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig) GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
@ -263,39 +262,25 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
if (wndconfig->clientAPI != GLFW_OPENGL_API && if (wndconfig->clientAPI != GLFW_OPENGL_API &&
wndconfig->clientAPI != GLFW_OPENGL_ES_API) wndconfig->clientAPI != GLFW_OPENGL_ES_API)
{ {
_glfwSetError(GLFW_INVALID_ENUM, _glfwSetError(GLFW_INVALID_ENUM, "Invalid client API requested");
"glfwCreateWindow: Invalid client API requested");
return GL_FALSE; return GL_FALSE;
} }
if (wndconfig->clientAPI == GLFW_OPENGL_API) if (wndconfig->clientAPI == GLFW_OPENGL_API)
{ {
if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0) if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
(wndconfig->glMajor == 1 && wndconfig->glMinor > 5) ||
(wndconfig->glMajor == 2 && wndconfig->glMinor > 1) ||
(wndconfig->glMajor == 3 && wndconfig->glMinor > 3))
{ {
// OpenGL 1.0 is the smallest valid version // OpenGL 1.0 is the smallest valid version
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL version requested");
return GL_FALSE;
}
if (wndconfig->glMajor == 1 && wndconfig->glMinor > 5)
{
// OpenGL 1.x series ended with version 1.5 // OpenGL 1.x series ended with version 1.5
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL version requested");
return GL_FALSE;
}
else if (wndconfig->glMajor == 2 && wndconfig->glMinor > 1)
{
// OpenGL 2.x series ended with version 2.1 // OpenGL 2.x series ended with version 2.1
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL version requested");
return GL_FALSE;
}
else if (wndconfig->glMajor == 3 && wndconfig->glMinor > 3)
{
// OpenGL 3.x series ended with version 3.3 // OpenGL 3.x series ended with version 3.3
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL version requested"); "Invalid OpenGL version %i.%i requested",
wndconfig->glMajor, wndconfig->glMinor);
return GL_FALSE; return GL_FALSE;
} }
else else
@ -309,7 +294,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE) wndconfig->glProfile != GLFW_OPENGL_COMPAT_PROFILE)
{ {
_glfwSetError(GLFW_INVALID_ENUM, _glfwSetError(GLFW_INVALID_ENUM,
"glfwCreateWindow: Invalid OpenGL profile requested"); "Invalid OpenGL profile requested");
return GL_FALSE; return GL_FALSE;
} }
@ -320,7 +305,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
// and above // and above
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Context profiles only exist for " "Context profiles only exist for "
"OpenGL version 3.2 and above"); "OpenGL version 3.2 and above");
return GL_FALSE; return GL_FALSE;
} }
@ -330,25 +315,24 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
{ {
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above // Forward-compatible contexts are only defined for OpenGL version 3.0 and above
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Forward compatibility only exist " "Forward compatibility only exist for OpenGL "
"for OpenGL version 3.0 and above"); "version 3.0 and above");
return GL_FALSE; return GL_FALSE;
} }
} }
else if (wndconfig->clientAPI == GLFW_OPENGL_ES_API) else if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
{ {
if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0) if (wndconfig->glMajor < 1 || wndconfig->glMinor < 0 ||
(wndconfig->glMajor == 1 && wndconfig->glMinor > 1) ||
(wndconfig->glMajor == 2 && wndconfig->glMinor > 0))
{ {
// OpenGL ES 1.0 is the smallest valid version // OpenGL ES 1.0 is the smallest valid version
_glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL ES version requested");
return GL_FALSE;
}
if (wndconfig->glMajor == 1 && wndconfig->glMinor > 1)
{
// OpenGL ES 1.x series ended with version 1.1 // OpenGL ES 1.x series ended with version 1.1
// OpenGL ES 2.x series ended with version 2.0
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL ES version requested"); "Invalid OpenGL ES version %i.%i requested",
wndconfig->glMajor, wndconfig->glMinor);
return GL_FALSE; return GL_FALSE;
} }
else else
@ -360,8 +344,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
{ {
// OpenGL ES does not support profiles // OpenGL ES does not support profiles
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Context profiles are not supported " "Context profiles are not supported by OpenGL ES");
"by OpenGL ES");
return GL_FALSE; return GL_FALSE;
} }
@ -369,8 +352,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
{ {
// OpenGL ES does not support forward-compatibility // OpenGL ES does not support forward-compatibility
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Forward compatibility is not " "Forward compatibility is not supported by OpenGL ES");
"supported by OpenGL ES");
return GL_FALSE; return GL_FALSE;
} }
} }
@ -381,8 +363,7 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
wndconfig->glRobustness != GLFW_LOSE_CONTEXT_ON_RESET) wndconfig->glRobustness != GLFW_LOSE_CONTEXT_ON_RESET)
{ {
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwCreateWindow: Invalid OpenGL robustness mode " "Invalid OpenGL robustness mode requested");
"requested");
return GL_FALSE; return GL_FALSE;
} }
} }
@ -393,7 +374,6 @@ GLboolean _glfwIsValidContextConfig(_GLFWwndconfig* wndconfig)
//======================================================================== //========================================================================
// Reads back context properties // Reads back context properties
// It blames glfwCreateWindow because that's the only caller
//======================================================================== //========================================================================
GLboolean _glfwRefreshContextParams(void) GLboolean _glfwRefreshContextParams(void)
@ -418,41 +398,77 @@ GLboolean _glfwRefreshContextParams(void)
if (!window->GetStringi) if (!window->GetStringi)
{ {
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR,
"glfwCreateWindow: Entry point retrieval is broken"); "Entry point retrieval is broken");
return GL_FALSE; return GL_FALSE;
} }
} }
// Read back forward-compatibility flag if (window->clientAPI == GLFW_OPENGL_API)
{ {
window->glForward = GL_FALSE; // Read back context flags (OpenGL 3.0 and above)
if (window->glMajor >= 3)
{
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (window->clientAPI == GLFW_OPENGL_API && window->glMajor >= 3) if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
{ window->glForward = GL_TRUE;
GLint flags;
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT) if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
window->glForward = GL_TRUE; window->glDebug = GL_TRUE;
if (flags & 0) else if (glfwExtensionSupported("GL_ARB_debug_output"))
window->glDebug = GL_TRUE; {
} // HACK: This is a workaround for older drivers (pre KHR_debug)
// not setting the debug bit in the context flags for debug
// contexts
window->glDebug = GL_TRUE;
}
}
// Read back OpenGL context profile (OpenGL 3.2 and above)
if (window->glMajor > 3 ||
(window->glMajor == 3 && window->glMinor >= 2))
{
GLint mask;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->glProfile = GLFW_OPENGL_CORE_PROFILE;
}
// Read back robustness strategy
if (glfwExtensionSupported("GL_ARB_robustness"))
{
// NOTE: We avoid using the context flags for detection, as they are
// only present from 3.0 while the extension applies from 1.1
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
}
} }
else
// Read back OpenGL context profile
{ {
window->glProfile = 0; // Read back robustness strategy
if (glfwExtensionSupported("GL_EXT_robustness"))
{
// NOTE: The values of these constants match those of the OpenGL ARB
// one, so we can reuse them here
if (window->glMajor > 3 || (window->glMajor == 3 && window->glMinor >= 2)) GLint strategy;
{ glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
GLint mask;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->glProfile = GLFW_OPENGL_COMPAT_PROFILE; window->glRobustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT) else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->glProfile = GLFW_OPENGL_CORE_PROFILE; window->glRobustness = GLFW_NO_RESET_NOTIFICATION;
} }
} }
return GL_TRUE; return GL_TRUE;
@ -461,7 +477,6 @@ GLboolean _glfwRefreshContextParams(void)
//======================================================================== //========================================================================
// Checks whether the current context fulfils the specified requirements // Checks whether the current context fulfils the specified requirements
// It blames glfwCreateWindow because that's the only caller
//======================================================================== //========================================================================
GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig) GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
@ -479,8 +494,7 @@ GLboolean _glfwIsValidContext(_GLFWwndconfig* wndconfig)
// For API consistency, we emulate the behavior of the // For API consistency, we emulate the behavior of the
// {GLX|WGL}_ARB_create_context extension and fail here // {GLX|WGL}_ARB_create_context extension and fail here
_glfwSetError(GLFW_VERSION_UNAVAILABLE, _glfwSetError(GLFW_VERSION_UNAVAILABLE, NULL);
"glfwCreateWindow: The requested OpenGL version is not available");
return GL_FALSE; return GL_FALSE;
} }

101
src/egl_context.c
View File

@ -175,7 +175,7 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window,
// Create the actual OpenGL(|ES) context // Create the actual OpenGL(|ES) context
//======================================================================== //========================================================================
#define setEGLattrib(attribs, index, attribName, attribValue) \ #define setEGLattrib(attribName, attribValue) \
{ \ { \
attribs[index++] = attribName; \ attribs[index++] = attribName; \
attribs[index++] = attribValue; \ attribs[index++] = attribValue; \
@ -186,7 +186,7 @@ static int createContext(_GLFWwindow* window,
EGLint fbconfigID) EGLint fbconfigID)
{ {
int attribs[40]; int attribs[40];
EGLint count, index; EGLint count;
EGLConfig config; EGLConfig config;
EGLContext share = NULL; EGLContext share = NULL;
@ -195,10 +195,10 @@ static int createContext(_GLFWwindow* window,
// Retrieve the previously selected EGLConfig // Retrieve the previously selected EGLConfig
{ {
index = 0; int index = 0;
setEGLattrib(attribs, index, EGL_CONFIG_ID, fbconfigID); setEGLattrib(EGL_CONFIG_ID, fbconfigID);
setEGLattrib(attribs, index, EGL_NONE, EGL_NONE); setEGLattrib(EGL_NONE, EGL_NONE);
eglChooseConfig(_glfwLibrary.EGL.display, attribs, &config, 1, &count); eglChooseConfig(_glfwLibrary.EGL.display, attribs, &config, 1, &count);
if (!count) if (!count)
@ -209,10 +209,8 @@ static int createContext(_GLFWwindow* window,
} }
} }
// 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) #if defined(_GLFW_X11)
// Retrieve the visual corresponding to the chosen EGL config
{ {
int mask; int mask;
EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0; EGLint redBits, greenBits, blueBits, alphaBits, visualID = 0;
@ -264,8 +262,7 @@ static int createContext(_GLFWwindow* window,
{ {
if (!eglBindAPI(EGL_OPENGL_ES_API)) if (!eglBindAPI(EGL_OPENGL_ES_API))
{ {
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR, "EGL: OpenGL ES is not supported");
"EGL: OpenGL ES is not supported");
return GL_FALSE; return GL_FALSE;
} }
} }
@ -273,66 +270,65 @@ static int createContext(_GLFWwindow* window,
{ {
if (!eglBindAPI(EGL_OPENGL_API)) if (!eglBindAPI(EGL_OPENGL_API))
{ {
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR, "EGL: OpenGL is not supported");
"EGL: OpenGL is not supported");
return GL_FALSE; return GL_FALSE;
} }
} }
index = 0;
if (_glfwLibrary.EGL.KHR_create_context) if (_glfwLibrary.EGL.KHR_create_context)
{ {
setEGLattrib(attribs, index, EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor); int index = 0, mask = 0, flags = 0, strategy = 0;
setEGLattrib(attribs, index, EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness) if (wndconfig->clientAPI == GLFW_OPENGL_API)
{ {
int flags = 0; if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
mask |= EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
mask |= EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
if (wndconfig->glForward) if (wndconfig->glForward)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR; flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
if (wndconfig->glDebug) if (wndconfig->glDebug)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR; 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) if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
{ {
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_NO_RESET_NOTIFICATION) if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
strategy = EGL_NO_RESET_NOTIFICATION_KHR; strategy = EGL_NO_RESET_NOTIFICATION_KHR;
else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET) else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR; strategy = EGL_LOSE_CONTEXT_ON_RESET_KHR;
setEGLattrib(attribs, index, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy); flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
} }
if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
{
setEGLattrib(EGL_CONTEXT_MAJOR_VERSION_KHR, wndconfig->glMajor);
setEGLattrib(EGL_CONTEXT_MINOR_VERSION_KHR, wndconfig->glMinor);
}
if (mask)
setEGLattrib(EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, mask);
if (flags)
setEGLattrib(EGL_CONTEXT_FLAGS_KHR, flags);
if (strategy)
setEGLattrib(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR, strategy);
setEGLattrib(EGL_NONE, EGL_NONE);
} }
else else
{ {
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API) int index = 0;
setEGLattrib(attribs, index, EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
}
setEGLattrib(attribs, index, EGL_NONE, EGL_NONE); if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
setEGLattrib(EGL_CONTEXT_CLIENT_VERSION, wndconfig->glMajor);
setEGLattrib(EGL_NONE, EGL_NONE);
}
window->EGL.context = eglCreateContext(_glfwLibrary.EGL.display, window->EGL.context = eglCreateContext(_glfwLibrary.EGL.display,
config, share, attribs); config, share, attribs);
@ -341,8 +337,7 @@ static int createContext(_GLFWwindow* window,
{ {
// TODO: Handle all the various error codes here // TODO: Handle all the various error codes here
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR, "EGL: Failed to create context");
"EGL: Failed to create context");
return GL_FALSE; return GL_FALSE;
} }
@ -499,6 +494,22 @@ void _glfwDestroyContext(_GLFWwindow* window)
} }
//========================================================================
// Analyzes the specified context for possible recreation
//========================================================================
int _glfwAnalyzeContext(const _GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
{
#if _GLFW_WIN32
return _GLFW_RECREATION_NOT_NEEDED;
#else
return 0;
#endif
}
//======================================================================== //========================================================================
// Make the OpenGL context associated with the specified window current // Make the OpenGL context associated with the specified window current
//======================================================================== //========================================================================

2
src/egl_platform.h
View File

@ -36,7 +36,7 @@
// This path may need to be changed if you build GLFW using your own setup // This path may need to be changed if you build GLFW using your own setup
// We ship and use our own copy of eglext.h since GLFW uses fairly new // We ship and use our own copy of eglext.h since GLFW uses fairly new
// extensions and not all operating systems come with an up-to-date version // extensions and not all operating systems come with an up-to-date version
#include "../support/GL/eglext.h" #include "../support/EGL/eglext.h"
// Do we have support for dlopen/dlsym? // Do we have support for dlopen/dlsym?
#if defined(_GLFW_HAS_DLOPEN) #if defined(_GLFW_HAS_DLOPEN)

2
src/gamma.c
View File

@ -55,7 +55,7 @@ GLFWAPI void glfwSetGamma(float gamma)
if (gamma <= 0.f) if (gamma <= 0.f)
{ {
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE,
"glfwSetGamma: Gamma value must be greater than zero"); "Gamma value must be greater than zero");
return; return;
} }

170
src/glx_context.c
View File

@ -221,7 +221,7 @@ static int errorHandler(Display *display, XErrorEvent* event)
// Create the actual OpenGL context // Create the actual OpenGL context
//======================================================================== //========================================================================
#define setGLXattrib(attribs, index, attribName, attribValue) \ #define setGLXattrib(attribName, attribValue) \
attribs[index++] = attribName; \ attribs[index++] = attribName; \
attribs[index++] = attribValue; attribs[index++] = attribValue;
@ -230,7 +230,6 @@ static int createContext(_GLFWwindow* window,
GLXFBConfigID fbconfigID) GLXFBConfigID fbconfigID)
{ {
int attribs[40]; int attribs[40];
int dummy, index;
GLXFBConfig* fbconfig; GLXFBConfig* fbconfig;
GLXContext share = NULL; GLXContext share = NULL;
@ -239,17 +238,18 @@ static int createContext(_GLFWwindow* window,
// Retrieve the previously selected GLXFBConfig // Retrieve the previously selected GLXFBConfig
{ {
index = 0; int dummy, index = 0;
setGLXattrib(attribs, index, GLX_FBCONFIG_ID, (int) fbconfigID); setGLXattrib(GLX_FBCONFIG_ID, (int) fbconfigID);
setGLXattrib(attribs, index, None, None); setGLXattrib(None, None);
if (_glfwLibrary.GLX.SGIX_fbconfig) if (_glfwLibrary.GLX.SGIX_fbconfig)
{ {
fbconfig = _glfwLibrary.GLX.ChooseFBConfigSGIX(_glfwLibrary.X11.display, fbconfig =
_glfwLibrary.X11.screen, _glfwLibrary.GLX.ChooseFBConfigSGIX(_glfwLibrary.X11.display,
attribs, _glfwLibrary.X11.screen,
&dummy); attribs,
&dummy);
} }
else else
{ {
@ -270,8 +270,9 @@ static int createContext(_GLFWwindow* window,
// Retrieve the corresponding visual // Retrieve the corresponding visual
if (_glfwLibrary.GLX.SGIX_fbconfig) if (_glfwLibrary.GLX.SGIX_fbconfig)
{ {
window->GLX.visual = _glfwLibrary.GLX.GetVisualFromFBConfigSGIX(_glfwLibrary.X11.display, window->GLX.visual =
*fbconfig); _glfwLibrary.GLX.GetVisualFromFBConfigSGIX(_glfwLibrary.X11.display,
*fbconfig);
} }
else else
{ {
@ -288,95 +289,98 @@ static int createContext(_GLFWwindow* window,
return GL_FALSE; return GL_FALSE;
} }
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
{
if (!_glfwLibrary.GLX.ARB_create_context ||
!_glfwLibrary.GLX.ARB_create_context_profile ||
!_glfwLibrary.GLX.EXT_create_context_es2_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: OpenGL ES requested but "
"GLX_EXT_create_context_es2_profile is unavailable");
return GL_FALSE;
}
}
if (wndconfig->glForward)
{
if (!_glfwLibrary.GLX.ARB_create_context)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: Forward compatibility requested but "
"GLX_ARB_create_context_profile is unavailable");
return GL_FALSE;
}
}
if (wndconfig->glProfile)
{
if (!_glfwLibrary.GLX.ARB_create_context ||
!_glfwLibrary.GLX.ARB_create_context_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: An OpenGL profile requested but "
"GLX_ARB_create_context_profile is unavailable");
return GL_FALSE;
}
}
if (_glfwLibrary.GLX.ARB_create_context) if (_glfwLibrary.GLX.ARB_create_context)
{ {
index = 0; int index = 0, mask = 0, flags = 0, strategy = 0;
if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0) if (wndconfig->clientAPI == GLFW_OPENGL_API)
{ {
// Request an explicitly versioned context
setGLXattrib(attribs, index, GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
setGLXattrib(attribs, index, GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
}
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
{
if (!_glfwLibrary.GLX.ARB_create_context_profile ||
!_glfwLibrary.GLX.EXT_create_context_es2_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: OpenGL ES 2.x requested but "
"GLX_EXT_create_context_es2_profile is unavailable");
return GL_FALSE;
}
setGLXattrib(attribs, index,
GLX_CONTEXT_PROFILE_MASK_ARB,
GLX_CONTEXT_ES2_PROFILE_BIT_EXT);
}
if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness)
{
int flags = 0;
if (wndconfig->glForward) if (wndconfig->glForward)
flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
if (wndconfig->glDebug) if (wndconfig->glDebug)
flags |= GLX_CONTEXT_DEBUG_BIT_ARB; flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
if (wndconfig->glRobustness) if (wndconfig->glProfile)
{
if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
}
}
else
mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT;
if (wndconfig->glRobustness != GLFW_NO_ROBUSTNESS)
{
if (_glfwLibrary.GLX.ARB_create_context_robustness)
{
if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
strategy = GLX_NO_RESET_NOTIFICATION_ARB;
else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
strategy = GLX_LOSE_CONTEXT_ON_RESET_ARB;
flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB; flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
setGLXattrib(attribs, index, GLX_CONTEXT_FLAGS_ARB, flags);
}
if (wndconfig->glProfile)
{
int flags = 0;
if (!_glfwLibrary.GLX.ARB_create_context_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: An OpenGL profile requested but "
"GLX_ARB_create_context_profile is unavailable");
return GL_FALSE;
} }
if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
flags = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
flags = GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
setGLXattrib(attribs, index, GLX_CONTEXT_PROFILE_MASK_ARB, flags);
} }
if (wndconfig->glRobustness) if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
{ {
int strategy; // NOTE: Only request an explicitly versioned context when
// necessary, as explicitly requesting version 1.0 does not always
// return the highest available version
if (!_glfwLibrary.GLX.ARB_create_context_robustness) setGLXattrib(GLX_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
{ setGLXattrib(GLX_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"GLX: An OpenGL robustness strategy was "
"requested but GLX_ARB_create_context_robustness "
"is unavailable");
return GL_FALSE;
}
if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
strategy = GLX_NO_RESET_NOTIFICATION_ARB;
else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
strategy = GLX_LOSE_CONTEXT_ON_RESET_ARB;
setGLXattrib(attribs,
index,
GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
strategy);
} }
setGLXattrib(attribs, index, None, None); if (mask)
setGLXattrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
if (flags)
setGLXattrib(GLX_CONTEXT_FLAGS_ARB, flags);
if (strategy)
setGLXattrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
setGLXattrib(None, None);
// This is the only place we set an Xlib error handler, and we only do // This is the only place we set an Xlib error handler, and we only do
// it because glXCreateContextAttribsARB generates a BadMatch error if // it because glXCreateContextAttribsARB generates a BadMatch error if
@ -422,7 +426,7 @@ static int createContext(_GLFWwindow* window,
// TODO: Handle all the various error codes here // TODO: Handle all the various error codes here
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR,
"GLX: Failed to create OpenGL context"); "GLX: Failed to create context");
return GL_FALSE; return GL_FALSE;
} }

4
src/input.c
View File

@ -323,7 +323,7 @@ GLFWAPI int glfwGetKey(GLFWwindow handle, int key)
if (key < 0 || key > GLFW_KEY_LAST) if (key < 0 || key > GLFW_KEY_LAST)
{ {
_glfwSetError(GLFW_INVALID_ENUM, _glfwSetError(GLFW_INVALID_ENUM,
"glfwGetKey: The specified key is invalid"); "The specified key is invalid");
return GLFW_RELEASE; return GLFW_RELEASE;
} }
@ -355,7 +355,7 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow handle, int button)
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST) if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
{ {
_glfwSetError(GLFW_INVALID_ENUM, _glfwSetError(GLFW_INVALID_ENUM,
"glfwGetMouseButton: The specified mouse button is invalid"); "The specified mouse button is invalid");
return GLFW_RELEASE; return GLFW_RELEASE;
} }

2
src/nsgl_context.m
View File

@ -51,7 +51,7 @@ int _glfwInitOpenGL(void)
if (pthread_key_create(&_glfwCurrentTLS, NULL) != 0) if (pthread_key_create(&_glfwCurrentTLS, NULL) != 0)
{ {
_glfwSetError(GLFW_PLATFORM_ERROR, _glfwSetError(GLFW_PLATFORM_ERROR,
"Cocoa/NSGL: Failed to create context TLS"); "NSOpenGL: Failed to create context TLS");
return GL_FALSE; return GL_FALSE;
} }

195
src/wgl_context.c
View File

@ -329,12 +329,16 @@ static _GLFWfbconfig* getFBConfigs(_GLFWwindow* window, unsigned int* found)
// Creates an OpenGL context on the specified device context // Creates an OpenGL context on the specified device context
//======================================================================== //========================================================================
#define setWGLattrib(attribName, attribValue) \
attribs[index++] = attribName; \
attribs[index++] = attribValue;
static GLboolean createContext(_GLFWwindow* window, static GLboolean createContext(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig, const _GLFWwndconfig* wndconfig,
int pixelFormat) int pixelFormat)
{ {
int attribs[40];
PIXELFORMATDESCRIPTOR pfd; PIXELFORMATDESCRIPTOR pfd;
int i = 0, attribs[40];
HGLRC share = NULL; HGLRC share = NULL;
if (wndconfig->share) if (wndconfig->share)
@ -356,94 +360,56 @@ static GLboolean createContext(_GLFWwindow* window,
if (window->WGL.ARB_create_context) if (window->WGL.ARB_create_context)
{ {
// Use the newer wglCreateContextAttribsARB creation method int index = 0, mask = 0, flags = 0, strategy = 0;
if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0) if (wndconfig->clientAPI == GLFW_OPENGL_API)
{ {
// Request an explicitly versioned context
attribs[i++] = WGL_CONTEXT_MAJOR_VERSION_ARB;
attribs[i++] = wndconfig->glMajor;
attribs[i++] = WGL_CONTEXT_MINOR_VERSION_ARB;
attribs[i++] = wndconfig->glMinor;
}
if (wndconfig->clientAPI == GLFW_OPENGL_ES_API)
{
if (!window->WGL.ARB_create_context_profile ||
!window->WGL.EXT_create_context_es2_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"Win32/WGL: OpenGL ES 2.x requested but "
"WGL_EXT_create_context_es2_profile is unavailable");
return GL_FALSE;
}
attribs[i++] = WGL_CONTEXT_PROFILE_MASK_ARB;
attribs[i++] = WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
}
if (wndconfig->glForward || wndconfig->glDebug || wndconfig->glRobustness)
{
int flags = 0;
if (wndconfig->glForward) if (wndconfig->glForward)
flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
if (wndconfig->glDebug) if (wndconfig->glDebug)
flags |= WGL_CONTEXT_DEBUG_BIT_ARB; flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
if (wndconfig->glRobustness) if (wndconfig->glProfile)
flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
attribs[i++] = WGL_CONTEXT_FLAGS_ARB;
attribs[i++] = flags;
}
if (wndconfig->glProfile)
{
int flags = 0;
if (!window->WGL.ARB_create_context_profile)
{ {
_glfwSetError(GLFW_VERSION_UNAVAILABLE, if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
"WGL: OpenGL profile requested but " mask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
"WGL_ARB_create_context_profile is unavailable"); else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
return GL_FALSE; mask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
} }
if (wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE)
flags = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
else if (wndconfig->glProfile == GLFW_OPENGL_COMPAT_PROFILE)
flags = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
attribs[i++] = WGL_CONTEXT_PROFILE_MASK_ARB;
attribs[i++] = flags;
} }
else
mask |= WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
if (wndconfig->glRobustness) if (wndconfig->glRobustness)
{ {
int strategy = 0; if (window->WGL.ARB_create_context_robustness)
if (!window->WGL.ARB_create_context_robustness)
{ {
_glfwSetError(GLFW_VERSION_UNAVAILABLE, if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
"WGL: An OpenGL robustness strategy was " strategy = WGL_NO_RESET_NOTIFICATION_ARB;
"requested but WGL_ARB_create_context_robustness " else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
"is unavailable"); strategy = WGL_LOSE_CONTEXT_ON_RESET_ARB;
return GL_FALSE;
flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
} }
if (wndconfig->glRobustness == GLFW_NO_RESET_NOTIFICATION)
strategy = WGL_NO_RESET_NOTIFICATION_ARB;
else if (wndconfig->glRobustness == GLFW_LOSE_CONTEXT_ON_RESET)
strategy = WGL_LOSE_CONTEXT_ON_RESET_ARB;
attribs[i++] = WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB;
attribs[i++] = strategy;
} }
attribs[i++] = 0; if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
{
setWGLattrib(WGL_CONTEXT_MAJOR_VERSION_ARB, wndconfig->glMajor);
setWGLattrib(WGL_CONTEXT_MINOR_VERSION_ARB, wndconfig->glMinor);
}
if (flags)
setWGLattrib(WGL_CONTEXT_FLAGS_ARB, flags);
if (mask)
setWGLattrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
if (strategy)
setWGLattrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, strategy);
setWGLattrib(0, 0);
window->WGL.context = window->WGL.CreateContextAttribsARB(window->WGL.DC, window->WGL.context = window->WGL.CreateContextAttribsARB(window->WGL.DC,
share, share,
@ -483,6 +449,8 @@ static GLboolean createContext(_GLFWwindow* window,
return GL_TRUE; return GL_TRUE;
} }
#undef setWGLattrib
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
////// GLFW internal API ////// ////// GLFW internal API //////
@ -554,6 +522,91 @@ void _glfwDestroyContext(_GLFWwindow* window)
} }
//========================================================================
// Analyzes the specified context for possible recreation
//========================================================================
int _glfwAnalyzeContext(const _GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig)
{
GLboolean required = GL_FALSE;
if (wndconfig->clientAPI == GLFW_OPENGL_API)
{
if (wndconfig->glForward)
{
if (!window->WGL.ARB_create_context)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"WGL: A forward compatible OpenGL context "
"requested but WGL_ARB_create_context is "
"unavailable");
return _GLFW_RECREATION_IMPOSSIBLE;
}
required = GL_TRUE;
}
if (wndconfig->glProfile)
{
if (!window->WGL.ARB_create_context_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"WGL: OpenGL profile requested but "
"WGL_ARB_create_context_profile is unavailable");
return _GLFW_RECREATION_IMPOSSIBLE;
}
required = GL_TRUE;
}
}
else
{
if (!window->WGL.ARB_create_context ||
!window->WGL.ARB_create_context_profile ||
!window->WGL.EXT_create_context_es2_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"WGL: OpenGL ES requested but "
"WGL_ARB_create_context_es2_profile is unavailable");
return _GLFW_RECREATION_IMPOSSIBLE;
}
required = GL_TRUE;
}
if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0)
{
if (window->WGL.ARB_create_context)
required = GL_TRUE;
}
if (wndconfig->glDebug)
{
if (window->WGL.ARB_create_context)
required = GL_TRUE;
}
if (fbconfig->samples > 0)
{
// We want FSAA, but can we get it?
// FSAA is not a hard constraint, so otherwise we just don't care
if (window->WGL.ARB_multisample && window->WGL.ARB_pixel_format)
{
// We appear to have both the extension and the means to ask for it
required = GL_TRUE;
}
}
if (required)
return _GLFW_RECREATION_REQUIRED;
return _GLFW_RECREATION_NOT_NEEDED;
}
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
////// GLFW platform API ////// ////// GLFW platform API //////
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////

7
src/win32_platform.h
View File

@ -105,6 +105,10 @@ typedef DWORD (WINAPI * TIMEGETTIME_T) (void);
// between applications using different versions of GLFW // between applications using different versions of GLFW
#define _GLFW_WNDCLASSNAME L"GLFW30" #define _GLFW_WNDCLASSNAME L"GLFW30"
#define _GLFW_RECREATION_NOT_NEEDED 0
#define _GLFW_RECREATION_REQUIRED 1
#define _GLFW_RECREATION_IMPOSSIBLE 2
#if defined(_GLFW_WGL) #if defined(_GLFW_WGL)
#include "wgl_platform.h" #include "wgl_platform.h"
@ -218,6 +222,9 @@ int _glfwCreateContext(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig, const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig); const _GLFWfbconfig* fbconfig);
void _glfwDestroyContext(_GLFWwindow* window); void _glfwDestroyContext(_GLFWwindow* window);
int _glfwAnalyzeContext(const _GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig);
// Fullscreen support // Fullscreen support
void _glfwSetVideoMode(int* width, int* height, void _glfwSetVideoMode(int* width, int* height,

55
src/win32_window.c
View File

@ -866,7 +866,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig, const _GLFWwndconfig* wndconfig,
const _GLFWfbconfig* fbconfig) const _GLFWfbconfig* fbconfig)
{ {
GLboolean recreateContext = GL_FALSE; int status;
window->Win32.desiredRefreshRate = wndconfig->refreshRate; window->Win32.desiredRefreshRate = wndconfig->refreshRate;
@ -900,57 +900,12 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
if (!createWindow(window, wndconfig, fbconfig)) if (!createWindow(window, wndconfig, fbconfig))
return GL_FALSE; return GL_FALSE;
if (wndconfig->glMajor != 1 || wndconfig->glMinor != 0) status = _glfwAnalyzeContext(window, wndconfig, fbconfig);
{
if (window->WGL.ARB_create_context)
recreateContext = GL_TRUE;
}
if (wndconfig->glDebug) if (status == _GLFW_RECREATION_IMPOSSIBLE)
{ return GL_FALSE;
if (window->WGL.ARB_create_context)
recreateContext = GL_TRUE;
}
if (wndconfig->glForward) if (status == _GLFW_RECREATION_REQUIRED)
{
if (!window->WGL.ARB_create_context)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"WGL: A forward compatible OpenGL context requested "
"but WGL_ARB_create_context is unavailable");
return GL_FALSE;
}
recreateContext = GL_TRUE;
}
if (wndconfig->glProfile)
{
if (!window->WGL.ARB_create_context_profile)
{
_glfwSetError(GLFW_VERSION_UNAVAILABLE,
"WGL: OpenGL profile requested but "
"WGL_ARB_create_context_profile is unavailable");
return GL_FALSE;
}
recreateContext = GL_TRUE;
}
if (fbconfig->samples > 0)
{
// We want FSAA, but can we get it?
// FSAA is not a hard constraint, so otherwise we just don't care
if (window->WGL.ARB_multisample && window->WGL.ARB_pixel_format)
{
// We appear to have both the FSAA extension and the means to ask for it
recreateContext = GL_TRUE;
}
}
if (recreateContext)
{ {
// Some window hints require us to re-create the context using WGL // Some window hints require us to re-create the context using WGL
// extensions retrieved through the current context, as we cannot check // extensions retrieved through the current context, as we cannot check

5
src/window.c
View File

@ -253,7 +253,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
wndconfig.glForward = _glfwLibrary.hints.glForward ? GL_TRUE : GL_FALSE; wndconfig.glForward = _glfwLibrary.hints.glForward ? GL_TRUE : GL_FALSE;
wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE; wndconfig.glDebug = _glfwLibrary.hints.glDebug ? GL_TRUE : GL_FALSE;
wndconfig.glProfile = _glfwLibrary.hints.glProfile; wndconfig.glProfile = _glfwLibrary.hints.glProfile;
wndconfig.glRobustness = _glfwLibrary.hints.glRobustness ? GL_TRUE : GL_FALSE; wndconfig.glRobustness = _glfwLibrary.hints.glRobustness;
wndconfig.monitor = (_GLFWmonitor*) monitor; wndconfig.monitor = (_GLFWmonitor*) monitor;
wndconfig.share = (_GLFWwindow*) share; wndconfig.share = (_GLFWwindow*) share;
@ -266,8 +266,7 @@ GLFWAPI GLFWwindow glfwCreateWindow(int width, int height,
if (width <= 0 || height <= 0) if (width <= 0 || height <= 0)
{ {
_glfwSetError(GLFW_INVALID_VALUE, _glfwSetError(GLFW_INVALID_VALUE, "Invalid window size");
"glfwCreateWindow: Invalid window size");
return GL_FALSE; return GL_FALSE;
} }

0
support/GL/eglext.h → support/EGL/eglext.h
View File

1947
support/GL/glext.h
View File

File diff suppressed because it is too large Load Diff

26
support/GL/glxext.h
View File

@ -6,7 +6,7 @@ extern "C" {
#endif #endif
/* /*
** Copyright (c) 2007-2010 The Khronos Group Inc. ** Copyright (c) 2007-2012 The Khronos Group Inc.
** **
** Permission is hereby granted, free of charge, to any person obtaining a ** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the ** copy of this software and/or associated documentation files (the
@ -48,9 +48,9 @@ extern "C" {
/*************************************************************/ /*************************************************************/
/* Header file version number, required by OpenGL ABI for Linux */ /* Header file version number, required by OpenGL ABI for Linux */
/* glxext.h last updated 2010/08/06 */ /* glxext.h last updated 2012/02/29 */
/* Current version at http://www.opengl.org/registry/ */ /* Current version at http://www.opengl.org/registry/ */
#define GLX_GLXEXT_VERSION 32 #define GLX_GLXEXT_VERSION 33
#ifndef GLX_VERSION_1_3 #ifndef GLX_VERSION_1_3
#define GLX_WINDOW_BIT 0x00000001 #define GLX_WINDOW_BIT 0x00000001
@ -440,6 +440,14 @@ extern "C" {
#define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 #define GLX_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
#endif #endif
#ifndef GLX_EXT_swap_control_tear
#define GLX_LATE_SWAPS_TEAR_EXT 0x20F3
#endif
#ifndef GLX_EXT_buffer_age
#define GLX_BACK_BUFFER_AGE_EXT 0x20F4
#endif
/*************************************************************/ /*************************************************************/
@ -964,9 +972,9 @@ typedef void ( * PFNGLXRELEASEVIDEOCAPTUREDEVICENVPROC) (Display *dpy, GLXVideoC
#ifndef GLX_EXT_swap_control #ifndef GLX_EXT_swap_control
#define GLX_EXT_swap_control 1 #define GLX_EXT_swap_control 1
#ifdef GLX_GLXEXT_PROTOTYPES #ifdef GLX_GLXEXT_PROTOTYPES
extern int glXSwapIntervalEXT (Display *dpy, GLXDrawable drawable, int interval); extern void glXSwapIntervalEXT (Display *dpy, GLXDrawable drawable, int interval);
#endif /* GLX_GLXEXT_PROTOTYPES */ #endif /* GLX_GLXEXT_PROTOTYPES */
typedef int ( * PFNGLXSWAPINTERVALEXTPROC) (Display *dpy, GLXDrawable drawable, int interval); typedef void ( * PFNGLXSWAPINTERVALEXTPROC) (Display *dpy, GLXDrawable drawable, int interval);
#endif #endif
#ifndef GLX_NV_copy_image #ifndef GLX_NV_copy_image
@ -985,6 +993,14 @@ typedef void ( * PFNGLXCOPYIMAGESUBDATANVPROC) (Display *dpy, GLXContext srcCtx,
#define GLX_NV_multisample_coverage 1 #define GLX_NV_multisample_coverage 1
#endif #endif
#ifndef GLX_EXT_swap_control_tear
#define GLX_EXT_swap_control_tear 1
#endif
#ifndef GLX_EXT_buffer_age
#define GLX_EXT_buffer_age 1
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }

48
support/GL/wglext.h
View File

@ -6,7 +6,7 @@ extern "C" {
#endif #endif
/* /*
** Copyright (c) 2007-2010 The Khronos Group Inc. ** Copyright (c) 2007-2012 The Khronos Group Inc.
** **
** Permission is hereby granted, free of charge, to any person obtaining a ** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the ** copy of this software and/or associated documentation files (the
@ -48,9 +48,9 @@ extern "C" {
/*************************************************************/ /*************************************************************/
/* Header file version number */ /* Header file version number */
/* wglext.h last updated 2010/08/06 */ /* wglext.h last updated 2012/01/04 */
/* Current version at http://www.opengl.org/registry/ */ /* Current version at http://www.opengl.org/registry/ */
#define WGL_WGLEXT_VERSION 22 #define WGL_WGLEXT_VERSION 24
#ifndef WGL_ARB_buffer_region #ifndef WGL_ARB_buffer_region
#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 #define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001
@ -416,6 +416,18 @@ extern "C" {
#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 #define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004
#endif #endif
#ifndef WGL_NV_DX_interop
#define WGL_ACCESS_READ_ONLY_NV 0x00000000
#define WGL_ACCESS_READ_WRITE_NV 0x00000001
#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002
#endif
#ifndef WGL_NV_DX_interop2
#endif
#ifndef WGL_EXT_swap_control_tear
#endif
/*************************************************************/ /*************************************************************/
@ -893,6 +905,36 @@ typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcNa
#define WGL_NV_multisample_coverage 1 #define WGL_NV_multisample_coverage 1
#endif #endif
#ifndef WGL_NV_DX_interop
#define WGL_NV_DX_interop 1
#ifdef WGL_WGLEXT_PROTOTYPES
extern BOOL WINAPI wglDXSetResourceShareHandleNV (void *dxObject, HANDLE shareHandle);
extern HANDLE WINAPI wglDXOpenDeviceNV (void *dxDevice);
extern BOOL WINAPI wglDXCloseDeviceNV (HANDLE hDevice);
extern HANDLE WINAPI wglDXRegisterObjectNV (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
extern BOOL WINAPI wglDXUnregisterObjectNV (HANDLE hDevice, HANDLE hObject);
extern BOOL WINAPI wglDXObjectAccessNV (HANDLE hObject, GLenum access);
extern BOOL WINAPI wglDXLockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
extern BOOL WINAPI wglDXUnlockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects);
#endif /* WGL_WGLEXT_PROTOTYPES */
typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void *dxObject, HANDLE shareHandle);
typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void *dxDevice);
typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice);
typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access);
typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject);
typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access);
typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects);
typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects);
#endif
#ifndef WGL_NV_DX_interop2
#define WGL_NV_DX_interop2 1
#endif
#ifndef WGL_EXT_swap_control_tear
#define WGL_EXT_swap_control_tear 1
#endif
#ifdef __cplusplus #ifdef __cplusplus
} }

58
tests/glfwinfo.c
View File

@ -77,9 +77,9 @@ static const char* get_client_api_name(int api)
static const char* get_profile_name_gl(GLint mask) static const char* get_profile_name_gl(GLint mask)
{ {
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
return "compatibility"; return PROFILE_NAME_COMPAT;
if (mask & GL_CONTEXT_CORE_PROFILE_BIT) if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
return "core"; return PROFILE_NAME_CORE;
return "unknown"; return "unknown";
} }
@ -87,9 +87,29 @@ static const char* get_profile_name_gl(GLint mask)
static const char* get_profile_name_glfw(int profile) static const char* get_profile_name_glfw(int profile)
{ {
if (profile == GLFW_OPENGL_COMPAT_PROFILE) if (profile == GLFW_OPENGL_COMPAT_PROFILE)
return "compatibility"; return PROFILE_NAME_COMPAT;
if (profile == GLFW_OPENGL_CORE_PROFILE) if (profile == GLFW_OPENGL_CORE_PROFILE)
return "core"; return PROFILE_NAME_CORE;
return "unknown";
}
static const char* get_strategy_name_gl(GLint strategy)
{
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
return STRATEGY_NAME_LOSE;
if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
return STRATEGY_NAME_NONE;
return "unknown";
}
static const char* get_strategy_name_glfw(int strategy)
{
if (strategy == GLFW_LOSE_CONTEXT_ON_RESET)
return STRATEGY_NAME_LOSE;
if (strategy == GLFW_NO_RESET_NOTIFICATION)
return STRATEGY_NAME_NONE;
return "unknown"; return "unknown";
} }
@ -265,9 +285,6 @@ int main(int argc, char** argv)
glfwWindowHint(GLFW_VISIBLE, GL_FALSE); glfwWindowHint(GLFW_VISIBLE, GL_FALSE);
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
window = glfwCreateWindow(200, 200, "Version", NULL, NULL); window = glfwCreateWindow(200, 200, "Version", NULL, NULL);
if (!window) if (!window)
{ {
@ -303,8 +320,10 @@ int main(int argc, char** argv)
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT) if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
printf(" forward-compatible"); printf(" forward-compatible");
if (flags & 0) if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
printf(" debug"); printf(" debug");
if (flags & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB)
printf(" robustness");
putchar('\n'); putchar('\n');
printf("%s context flags parsed by GLFW:", get_client_api_name(api)); printf("%s context flags parsed by GLFW:", get_client_api_name(api));
@ -313,6 +332,8 @@ int main(int argc, char** argv)
printf(" forward-compatible"); printf(" forward-compatible");
if (glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT)) if (glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT))
printf(" debug"); printf(" debug");
if (glfwGetWindowParam(window, GLFW_CONTEXT_ROBUSTNESS) != GLFW_NO_ROBUSTNESS)
printf(" robustness");
putchar('\n'); putchar('\n');
} }
@ -330,6 +351,24 @@ int main(int argc, char** argv)
get_client_api_name(api), get_client_api_name(api),
get_profile_name_glfw(profile)); get_profile_name_glfw(profile));
} }
if (glfwExtensionSupported("GL_ARB_robustness"))
{
int robustness;
GLint strategy;
glGetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB, &strategy);
printf("%s robustness strategy (0x%08x): %s\n",
get_client_api_name(api),
strategy,
get_strategy_name_gl(strategy));
robustness = glfwGetWindowParam(window, GLFW_CONTEXT_ROBUSTNESS);
printf("%s robustness strategy parsed by GLFW: %s\n",
get_client_api_name(api),
get_strategy_name_glfw(robustness));
}
} }
printf("%s context renderer string: \"%s\"\n", printf("%s context renderer string: \"%s\"\n",
@ -339,9 +378,6 @@ int main(int argc, char** argv)
get_client_api_name(api), get_client_api_name(api),
glGetString(GL_VENDOR)); glGetString(GL_VENDOR));
printf("OpenGL context debug flag saved by GLFW: %s\n",
glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT) ? "true" : "false");
if (major > 1) if (major > 1)
{ {
printf("%s context shading language version: \"%s\"\n", printf("%s context shading language version: \"%s\"\n",