yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/libkwineffects/kwinglutils_funcs.cpp

137 lines
4.9 KiB
C++
Raw Normal View History

License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
/********************************************************************
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
License cleanup - add headers where missing, be explicit about GPL being v2+ (right now it says just GPL, which according to GPL itself means any GPL). Decoration clients will come later. CCMAIL: kwin@kde.org svn path=/trunk/KDE/kdebase/workspace/; revision=742302
2007-11-27 19:40:25 +00:00
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
#include "kwinglutils.h"
#include <dlfcn.h>
// Resolves given function, using getProcAddress
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
#ifdef KWIN_HAVE_EGL
#define GL_RESOLVE( function ) \
if (platformInterface == GlxPlatformInterface) \
function = (function ## _func)getProcAddress( #function ); \
else if (platformInterface == EglPlatformInterface) \
function = (function ## _func)eglGetProcAddress( #function );
Rework the resolving of OpenGL function pointers The macro GL_RESOLVE_WITH_EXT was fundamentally broken as it tried to resolve a symbol first by it's name and then by the extension name if the returned pointer is null. From GLX spec: "A non-NULL return value for glXGetProcAddress does not guarantee that an extension function is actually supported at runtime. The client must also query glGetString(GL EXTENSIONS) or glXQueryExtensionsString to determine if an extension is supported by a particular context." This macro is now reworked to be used only in case the symbol name does not match our function name. E.g. glUniform1f vs glUniform1fARB. The resolving itself also had quite some issues as: * in same cases function pointers are not nulled * in same cases only the arb or only the ext is checked * in same cases the wrong extension is checked This is now reworked to always check first the ARB extension if available then the EXT extension and if both are not available the pointers are set to NULL.
2012-10-03 07:32:25 +00:00
// Same as above but tries to use function "symbolName"
// Useful when functionality is defined in an extension with a different name
#define GL_RESOLVE_WITH_EXT( function, symbolName ) \
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
if (platformInterface == GlxPlatformInterface) { \
Rework the resolving of OpenGL function pointers The macro GL_RESOLVE_WITH_EXT was fundamentally broken as it tried to resolve a symbol first by it's name and then by the extension name if the returned pointer is null. From GLX spec: "A non-NULL return value for glXGetProcAddress does not guarantee that an extension function is actually supported at runtime. The client must also query glGetString(GL EXTENSIONS) or glXQueryExtensionsString to determine if an extension is supported by a particular context." This macro is now reworked to be used only in case the symbol name does not match our function name. E.g. glUniform1f vs glUniform1fARB. The resolving itself also had quite some issues as: * in same cases function pointers are not nulled * in same cases only the arb or only the ext is checked * in same cases the wrong extension is checked This is now reworked to always check first the ARB extension if available then the EXT extension and if both are not available the pointers are set to NULL.
2012-10-03 07:32:25 +00:00
function = (function ## _func)getProcAddress( #symbolName ); \
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
} else if (platformInterface == EglPlatformInterface) { \
Rework the resolving of OpenGL function pointers The macro GL_RESOLVE_WITH_EXT was fundamentally broken as it tried to resolve a symbol first by it's name and then by the extension name if the returned pointer is null. From GLX spec: "A non-NULL return value for glXGetProcAddress does not guarantee that an extension function is actually supported at runtime. The client must also query glGetString(GL EXTENSIONS) or glXQueryExtensionsString to determine if an extension is supported by a particular context." This macro is now reworked to be used only in case the symbol name does not match our function name. E.g. glUniform1f vs glUniform1fARB. The resolving itself also had quite some issues as: * in same cases function pointers are not nulled * in same cases only the arb or only the ext is checked * in same cases the wrong extension is checked This is now reworked to always check first the ARB extension if available then the EXT extension and if both are not available the pointers are set to NULL.
2012-10-03 07:32:25 +00:00
function = (function ## _func)eglGetProcAddress( #symbolName ); \
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
}
#else
// same without the switch to egl
#define GL_RESOLVE( function ) function = (function ## _func)getProcAddress( #function );
Rework the resolving of OpenGL function pointers The macro GL_RESOLVE_WITH_EXT was fundamentally broken as it tried to resolve a symbol first by it's name and then by the extension name if the returned pointer is null. From GLX spec: "A non-NULL return value for glXGetProcAddress does not guarantee that an extension function is actually supported at runtime. The client must also query glGetString(GL EXTENSIONS) or glXQueryExtensionsString to determine if an extension is supported by a particular context." This macro is now reworked to be used only in case the symbol name does not match our function name. E.g. glUniform1f vs glUniform1fARB. The resolving itself also had quite some issues as: * in same cases function pointers are not nulled * in same cases only the arb or only the ext is checked * in same cases the wrong extension is checked This is now reworked to always check first the ARB extension if available then the EXT extension and if both are not available the pointers are set to NULL.
2012-10-03 07:32:25 +00:00
#define GL_RESOLVE_WITH_EXT( function, symbolName ) \
function = (function ## _func)getProcAddress( #symbolName );
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
#endif
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
namespace KWin
{
kwin: Resolve functions for GL_ARB_robustness Only the subset of functions available in core contexts is resolved, except for glGetnTexImageARB() and glGetnUniformivARB(), which are not used by kwin. Instead of setting the function pointers to NULL when the extension isn't supported, kwin provides its own implementations that call the non-robust versions of the functions. This is so callers don't have to check if the extension is supported before calling the functions.
2013-05-19 14:14:47 +00:00
static GLenum GetGraphicsResetStatus();
static void ReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
GLenum type, GLsizei bufSize, GLvoid *data);
static void GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
// GL_MESA_swap_control
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
glXSwapIntervalMESA_func glXSwapIntervalMESA;
kwin: Resolve functions for GL_ARB_vertex_array_object
2013-03-13 16:01:14 +00:00
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
// GL_ARB_robustness / GL_EXT_robustness
kwin: Resolve functions for GL_ARB_robustness Only the subset of functions available in core contexts is resolved, except for glGetnTexImageARB() and glGetnUniformivARB(), which are not used by kwin. Instead of setting the function pointers to NULL when the extension isn't supported, kwin provides its own implementations that call the non-robust versions of the functions. This is so callers don't have to check if the extension is supported before calling the functions.
2013-05-19 14:14:47 +00:00
glGetGraphicsResetStatus_func glGetGraphicsResetStatus;
glReadnPixels_func glReadnPixels;
glGetnUniformfv_func glGetnUniformfv;
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
typedef void (*glXFuncPtr)();
kwin: Resolve functions for GL_EXT_gpu_shader4
2012-07-22 13:23:26 +00:00
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
#ifndef KWIN_HAVE_OPENGLES
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
static glXFuncPtr getProcAddress(const char* name)
{
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
glXFuncPtr ret = glXGetProcAddress((const GLubyte*) name);
Replace NULL with nullptr in libkwineffects Completing the task of replacing all NULL to nullptr in all the files in libkwineffects folder. (also substituting some "0" used as nullptr with nullptr) REVIEW: 114823
2014-01-08 10:43:02 +00:00
if (ret == nullptr)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
ret = (glXFuncPtr) dlsym(RTLD_DEFAULT, name);
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
return ret;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
branches/work/kwin_composite becomes new trunk kwin. svn path=/trunk/KDE/kdebase/workspace/; revision=659202
2007-04-29 17:35:43 +00:00
void glxResolveFunctions()
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
if (hasGLExtension(QByteArrayLiteral("GLX_MESA_swap_control")))
Fix buffer swap prototypes BUG: 309647 REVIEW: 107302
2012-11-13 21:19:01 +00:00
glXSwapIntervalMESA = (glXSwapIntervalMESA_func) getProcAddress("glXSwapIntervalMESA");
else
Replace NULL with nullptr in libkwineffects Completing the task of replacing all NULL to nullptr in all the files in libkwineffects folder. (also substituting some "0" used as nullptr with nullptr) REVIEW: 114823
2014-01-08 10:43:02 +00:00
glXSwapIntervalMESA = nullptr;
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
}
kwin/es: Resolve functions for GL_EXT_robustness
2013-05-19 14:17:41 +00:00
#endif
Use libepoxy to resolve GL functions Remove the manually written GL dispatch code, and use libepoxy to resolve functions. The only exceptions are GLX_MESA_swap_control, which is not in the XML API registry, and GL_ARB_robustness/GL_EXT_robustness. For the latter we want to resolve the functions to the same names on both GLES and desktop GL, and plug in our own implementations when the extension is not supported.
2014-02-11 18:57:06 +00:00
#ifdef KWIN_HAVE_EGL
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
void eglResolveFunctions()
{
}
#endif
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
void glResolveFunctions(OpenGLPlatformInterface platformInterface)
KWin uses kdelibs coding style.
2011-01-30 14:34:42 +00:00
{
Provide OpenGL over Egl The Egl backend is decoupled from the OpenGL ES build option which makes it possible to use it as a replacement for glx. To make this possible a new build flag is added when egl is available at compile time and any egl specific code is now ifdefed with this flag instead of the gles flag. In addition at runtime a windowing system enum value is passed to the various detect methods to have egl/glx specific detection for e.g. function pointer resolving. By default egl is used if compiled with OpenGL ES, otherwise glx is used. But in the non-gles case the windowing system can be selected through the new environment variable KWIN_OPENGL_INTERFACE. Setting this variable to "egl" the EglOnXBackend is used. REVIEW: 106632
2012-09-29 11:19:35 +00:00
#ifndef KWIN_HAVE_OPENGLES
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
if (hasGLExtension(QByteArrayLiteral("GL_ARB_robustness"))) {
kwin: Resolve functions for GL_ARB_robustness Only the subset of functions available in core contexts is resolved, except for glGetnTexImageARB() and glGetnUniformivARB(), which are not used by kwin. Instead of setting the function pointers to NULL when the extension isn't supported, kwin provides its own implementations that call the non-robust versions of the functions. This is so callers don't have to check if the extension is supported before calling the functions.
2013-05-19 14:14:47 +00:00
// See http://www.opengl.org/registry/specs/ARB/robustness.txt
GL_RESOLVE_WITH_EXT(glGetGraphicsResetStatus, glGetGraphicsResetStatusARB);
GL_RESOLVE_WITH_EXT(glReadnPixels, glReadnPixelsARB);
GL_RESOLVE_WITH_EXT(glGetnUniformfv, glGetnUniformfvARB);
} else {
glGetGraphicsResetStatus = KWin::GetGraphicsResetStatus;
glReadnPixels = KWin::ReadnPixels;
glGetnUniformfv = KWin::GetnUniformfv;
}
kwin/es: Resolve functions for GL_OES_mapbuffer
2012-09-26 21:27:18 +00:00
#else
Make the GL extension list a QList<QByteArray> It doesn't make sense to convert the extension names to QStrings. This also replaces the QString parameter in hasGLExtension() with a QByteArray and adjusts all callers.
2014-02-11 18:35:54 +00:00
if (hasGLExtension(QByteArrayLiteral("GL_EXT_robustness"))) {
kwin/es: Resolve functions for GL_EXT_robustness
2013-05-19 14:17:41 +00:00
// See http://www.khronos.org/registry/gles/extensions/EXT/EXT_robustness.txt
glGetGraphicsResetStatus = (glGetGraphicsResetStatus_func) eglGetProcAddress("glGetGraphicsResetStatusEXT");
glReadnPixels = (glReadnPixels_func) eglGetProcAddress("glReadnPixelsEXT");
glGetnUniformfv = (glGetnUniformfv_func) eglGetProcAddress("glGetnUniformfvEXT");
} else {
glGetGraphicsResetStatus = KWin::GetGraphicsResetStatus;
glReadnPixels = KWin::ReadnPixels;
glGetnUniformfv = KWin::GetnUniformfv;
}
kwin/es: Resolve functions for GL_OES_mapbuffer
2012-09-26 21:27:18 +00:00
#endif // KWIN_HAVE_OPENGLES
Resolve EGL and GLES function pointers
2010-12-05 11:35:40 +00:00
}
kwin: Resolve functions for GL_ARB_robustness Only the subset of functions available in core contexts is resolved, except for glGetnTexImageARB() and glGetnUniformivARB(), which are not used by kwin. Instead of setting the function pointers to NULL when the extension isn't supported, kwin provides its own implementations that call the non-robust versions of the functions. This is so callers don't have to check if the extension is supported before calling the functions.
2013-05-19 14:14:47 +00:00
static GLenum GetGraphicsResetStatus()
{
return GL_NO_ERROR;
}
static void ReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
GLenum type, GLsizei bufSize, GLvoid *data)
{
Q_UNUSED(bufSize)
glReadPixels(x, y, width, height, format, type, data);
}
static void GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
{
Q_UNUSED(bufSize)
glGetUniformfv(program, location, params);
}
Resolve EGL and GLES function pointers
2010-12-05 11:35:40 +00:00
} // namespace
Reference in a new issue Copy permalink