qglfunctions.cpp File Reference

#include "qglfunctions.h"
#include "qgl_p.h"

Go to the source code of this file.

Classes
struct	QGLFunctionsPrivateEx

Functions
static void	qglfResolveActiveTexture (GLenum texture)
static void	qglfResolveAttachShader (GLuint program, GLuint shader)
static void	qglfResolveBindAttribLocation (GLuint program, GLuint index, const char *name)
static void	qglfResolveBindBuffer (GLenum target, GLuint buffer)
static void	qglfResolveBindFramebuffer (GLenum target, GLuint framebuffer)
static void	qglfResolveBindRenderbuffer (GLenum target, GLuint renderbuffer)
static void	qglfResolveBlendColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
static void	qglfResolveBlendEquation (GLenum mode)
static void	qglfResolveBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha)
static void	qglfResolveBlendFuncSeparate (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
static void	qglfResolveBufferData (GLenum target, qgl_GLsizeiptr size, const void *data, GLenum usage)
static void	qglfResolveBufferSubData (GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void *data)
static GLenum	qglfResolveCheckFramebufferStatus (GLenum target)
static void	qglfResolveCompileShader (GLuint shader)
static void	qglfResolveCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
static void	qglfResolveCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
static GLuint	qglfResolveCreateProgram ()
static GLuint	qglfResolveCreateShader (GLenum type)
static void	qglfResolveDeleteBuffers (GLsizei n, const GLuint *buffers)
static void	qglfResolveDeleteFramebuffers (GLsizei n, const GLuint *framebuffers)
static void	qglfResolveDeleteProgram (GLuint program)
static void	qglfResolveDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers)
static void	qglfResolveDeleteShader (GLuint shader)
static void	qglfResolveDetachShader (GLuint program, GLuint shader)
static void	qglfResolveDisableVertexAttribArray (GLuint index)
static void	qglfResolveEnableVertexAttribArray (GLuint index)
static void	qglfResolveFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
static void	qglfResolveFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
static void	qglfResolveGenBuffers (GLsizei n, GLuint *buffers)
static void	qglfResolveGenerateMipmap (GLenum target)
static void	qglfResolveGenFramebuffers (GLsizei n, GLuint *framebuffers)
static void	qglfResolveGenRenderbuffers (GLsizei n, GLuint *renderbuffers)
static void	qglfResolveGetActiveAttrib (GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name)
static void	qglfResolveGetActiveUniform (GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name)
static void	qglfResolveGetAttachedShaders (GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders)
static int	qglfResolveGetAttribLocation (GLuint program, const char *name)
static void	qglfResolveGetBufferParameteriv (GLenum target, GLenum pname, GLint *params)
static void	qglfResolveGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params)
static void	qglfResolveGetProgramInfoLog (GLuint program, GLsizei bufsize, GLsizei *length, char *infolog)
static void	qglfResolveGetProgramiv (GLuint program, GLenum pname, GLint *params)
static void	qglfResolveGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params)
static void	qglfResolveGetShaderInfoLog (GLuint shader, GLsizei bufsize, GLsizei *length, char *infolog)
static void	qglfResolveGetShaderiv (GLuint shader, GLenum pname, GLint *params)
static void	qglfResolveGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
static void	qglfResolveGetShaderSource (GLuint shader, GLsizei bufsize, GLsizei *length, char *source)
static void	qglfResolveGetUniformfv (GLuint program, GLint location, GLfloat *params)
static void	qglfResolveGetUniformiv (GLuint program, GLint location, GLint *params)
static int	qglfResolveGetUniformLocation (GLuint program, const char *name)
static void	qglfResolveGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params)
static void	qglfResolveGetVertexAttribiv (GLuint index, GLenum pname, GLint *params)
static void	qglfResolveGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer)
static GLboolean	qglfResolveIsBuffer (GLuint buffer)
static GLboolean	qglfResolveIsFramebuffer (GLuint framebuffer)
static GLboolean	qglfResolveIsProgram (GLuint program)
static GLboolean	qglfResolveIsRenderbuffer (GLuint renderbuffer)
static GLboolean	qglfResolveIsShader (GLuint shader)
static void	qglfResolveLinkProgram (GLuint program)
static void	qglfResolveReleaseShaderCompiler ()
static void	qglfResolveRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
static void	qglfResolveSampleCoverage (GLclampf value, GLboolean invert)
static void	qglfResolveShaderBinary (GLint n, const GLuint *shaders, GLenum binaryformat, const void *binary, GLint length)
static void	qglfResolveShaderSource (GLuint shader, GLsizei count, const char **string, const GLint *length)
static void	qglfResolveStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask)
static void	qglfResolveStencilMaskSeparate (GLenum face, GLuint mask)
static void	qglfResolveStencilOpSeparate (GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
static void	qglfResolveUniform1f (GLint location, GLfloat x)
static void	qglfResolveUniform1fv (GLint location, GLsizei count, const GLfloat *v)
static void	qglfResolveUniform1i (GLint location, GLint x)
static void	qglfResolveUniform1iv (GLint location, GLsizei count, const GLint *v)
static void	qglfResolveUniform2f (GLint location, GLfloat x, GLfloat y)
static void	qglfResolveUniform2fv (GLint location, GLsizei count, const GLfloat *v)
static void	qglfResolveUniform2i (GLint location, GLint x, GLint y)
static void	qglfResolveUniform2iv (GLint location, GLsizei count, const GLint *v)
static void	qglfResolveUniform3f (GLint location, GLfloat x, GLfloat y, GLfloat z)
static void	qglfResolveUniform3fv (GLint location, GLsizei count, const GLfloat *v)
static void	qglfResolveUniform3i (GLint location, GLint x, GLint y, GLint z)
static void	qglfResolveUniform3iv (GLint location, GLsizei count, const GLint *v)
static void	qglfResolveUniform4f (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
static void	qglfResolveUniform4fv (GLint location, GLsizei count, const GLfloat *v)
static void	qglfResolveUniform4i (GLint location, GLint x, GLint y, GLint z, GLint w)
static void	qglfResolveUniform4iv (GLint location, GLsizei count, const GLint *v)
static void	qglfResolveUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
static void	qglfResolveUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
static void	qglfResolveUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
static void	qglfResolveUseProgram (GLuint program)
static void	qglfResolveValidateProgram (GLuint program)
static void	qglfResolveVertexAttrib1f (GLuint indx, GLfloat x)
static void	qglfResolveVertexAttrib1fv (GLuint indx, const GLfloat *values)
static void	qglfResolveVertexAttrib2f (GLuint indx, GLfloat x, GLfloat y)
static void	qglfResolveVertexAttrib2fv (GLuint indx, const GLfloat *values)
static void	qglfResolveVertexAttrib3f (GLuint indx, GLfloat x, GLfloat y, GLfloat z)
static void	qglfResolveVertexAttrib3fv (GLuint indx, const GLfloat *values)
static void	qglfResolveVertexAttrib4f (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
static void	qglfResolveVertexAttrib4fv (GLuint indx, const GLfloat *values)
static void	qglfResolveVertexAttribPointer (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *ptr)
static void	qglfSpecialGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
static GLboolean	qglfSpecialIsProgram (GLuint program)
static GLboolean	qglfSpecialIsShader (GLuint shader)
static void	qglfSpecialReleaseShaderCompiler ()
static QGLFunctionsPrivateEx *	qt_gl_functions (const QGLContext *context=0)
static int	qt_gl_resolve_features ()

Function Documentation

qglfResolveActiveTexture()

static void qglfResolveActiveTexture ( GLenum  texture )

static

Definition at line 1514 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glActiveTexture)(GLenum texture);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->activeTexture = (type_glActiveTexture)
        context->getProcAddress(QLatin1String("glActiveTexture"));
    if (!funcs->activeTexture) {
        funcs->activeTexture = (type_glActiveTexture)
            context->getProcAddress(QLatin1String("glActiveTextureARB"));
    }

    if (funcs->activeTexture)
        funcs->activeTexture(texture);
    else
        funcs->activeTexture = qglfResolveActiveTexture;
}

qglfResolveAttachShader()

static void qglfResolveAttachShader ( GLuint  program, GLuint  shader  )

static

Definition at line 1534 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glAttachShader)(GLuint program, GLuint shader);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->attachShader = (type_glAttachShader)
        context->getProcAddress(QLatin1String("glAttachShader"));
    if (!funcs->attachShader) {
        funcs->attachShader = (type_glAttachShader)
            context->getProcAddress(QLatin1String("glAttachObjectARB"));
    }

    if (funcs->attachShader)
        funcs->attachShader(program, shader);
    else
        funcs->attachShader = qglfResolveAttachShader;
}

qglfResolveBindAttribLocation()

static void qglfResolveBindAttribLocation ( GLuint  program, GLuint  index, const char *  name  )

static

Definition at line 1554 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBindAttribLocation)(GLuint program, GLuint index, const char* name);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bindAttribLocation = (type_glBindAttribLocation)
        context->getProcAddress(QLatin1String("glBindAttribLocation"));
    if (!funcs->bindAttribLocation) {
        funcs->bindAttribLocation = (type_glBindAttribLocation)
            context->getProcAddress(QLatin1String("glBindAttribLocationARB"));
    }

    if (funcs->bindAttribLocation)
        funcs->bindAttribLocation(program, index, name);
    else
        funcs->bindAttribLocation = qglfResolveBindAttribLocation;
}

qglfResolveBindBuffer()

static void qglfResolveBindBuffer ( GLenum  target, GLuint  buffer  )

static

Definition at line 1574 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBindBuffer)(GLenum target, GLuint buffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bindBuffer = (type_glBindBuffer)
        context->getProcAddress(QLatin1String("glBindBuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->bindBuffer) {
        funcs->bindBuffer = (type_glBindBuffer)
            context->getProcAddress(QLatin1String("glBindBufferOES"));
    }
#endif
    if (!funcs->bindBuffer) {
        funcs->bindBuffer = (type_glBindBuffer)
            context->getProcAddress(QLatin1String("glBindBufferEXT"));
    }
    if (!funcs->bindBuffer) {
        funcs->bindBuffer = (type_glBindBuffer)
            context->getProcAddress(QLatin1String("glBindBufferARB"));
    }

    if (funcs->bindBuffer)
        funcs->bindBuffer(target, buffer);
    else
        funcs->bindBuffer = qglfResolveBindBuffer;
}

qglfResolveBindFramebuffer()

static void qglfResolveBindFramebuffer ( GLenum  target, GLuint  framebuffer  )

static

Definition at line 1604 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBindFramebuffer)(GLenum target, GLuint framebuffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bindFramebuffer = (type_glBindFramebuffer)
        context->getProcAddress(QLatin1String("glBindFramebuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->bindFramebuffer) {
        funcs->bindFramebuffer = (type_glBindFramebuffer)
            context->getProcAddress(QLatin1String("glBindFramebufferOES"));
    }
#endif
    if (!funcs->bindFramebuffer) {
        funcs->bindFramebuffer = (type_glBindFramebuffer)
            context->getProcAddress(QLatin1String("glBindFramebufferEXT"));
    }
    if (!funcs->bindFramebuffer) {
        funcs->bindFramebuffer = (type_glBindFramebuffer)
            context->getProcAddress(QLatin1String("glBindFramebufferARB"));
    }

    if (funcs->bindFramebuffer)
        funcs->bindFramebuffer(target, framebuffer);
    else
        funcs->bindFramebuffer = qglfResolveBindFramebuffer;
}

qglfResolveBindRenderbuffer()

static void qglfResolveBindRenderbuffer ( GLenum  target, GLuint  renderbuffer  )

static

Definition at line 1634 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bindRenderbuffer = (type_glBindRenderbuffer)
        context->getProcAddress(QLatin1String("glBindRenderbuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->bindRenderbuffer) {
        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
            context->getProcAddress(QLatin1String("glBindRenderbufferOES"));
    }
#endif
    if (!funcs->bindRenderbuffer) {
        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
            context->getProcAddress(QLatin1String("glBindRenderbufferEXT"));
    }
    if (!funcs->bindRenderbuffer) {
        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
            context->getProcAddress(QLatin1String("glBindRenderbufferARB"));
    }

    if (funcs->bindRenderbuffer)
        funcs->bindRenderbuffer(target, renderbuffer);
    else
        funcs->bindRenderbuffer = qglfResolveBindRenderbuffer;
}

qglfResolveBlendColor()

static void qglfResolveBlendColor ( GLclampf  red, GLclampf  green, GLclampf  blue, GLclampf  alpha  )

static

Definition at line 1664 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->blendColor = (type_glBlendColor)
        context->getProcAddress(QLatin1String("glBlendColor"));
#ifdef QT_OPENGL_ES
    if (!funcs->blendColor) {
        funcs->blendColor = (type_glBlendColor)
            context->getProcAddress(QLatin1String("glBlendColorOES"));
    }
#endif
    if (!funcs->blendColor) {
        funcs->blendColor = (type_glBlendColor)
            context->getProcAddress(QLatin1String("glBlendColorEXT"));
    }
    if (!funcs->blendColor) {
        funcs->blendColor = (type_glBlendColor)
            context->getProcAddress(QLatin1String("glBlendColorARB"));
    }

    if (funcs->blendColor)
        funcs->blendColor(red, green, blue, alpha);
    else
        funcs->blendColor = qglfResolveBlendColor;
}

qglfResolveBlendEquation()

static void qglfResolveBlendEquation ( GLenum  mode )

static

Definition at line 1694 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBlendEquation)(GLenum mode);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->blendEquation = (type_glBlendEquation)
        context->getProcAddress(QLatin1String("glBlendEquation"));
#ifdef QT_OPENGL_ES
    if (!funcs->blendEquation) {
        funcs->blendEquation = (type_glBlendEquation)
            context->getProcAddress(QLatin1String("glBlendEquationOES"));
    }
#endif
    if (!funcs->blendEquation) {
        funcs->blendEquation = (type_glBlendEquation)
            context->getProcAddress(QLatin1String("glBlendEquationEXT"));
    }
    if (!funcs->blendEquation) {
        funcs->blendEquation = (type_glBlendEquation)
            context->getProcAddress(QLatin1String("glBlendEquationARB"));
    }

    if (funcs->blendEquation)
        funcs->blendEquation(mode);
    else
        funcs->blendEquation = qglfResolveBlendEquation;
}

qglfResolveBlendEquationSeparate()

static void qglfResolveBlendEquationSeparate ( GLenum  modeRGB, GLenum  modeAlpha  )

static

Definition at line 1724 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
        context->getProcAddress(QLatin1String("glBlendEquationSeparate"));
#ifdef QT_OPENGL_ES
    if (!funcs->blendEquationSeparate) {
        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
            context->getProcAddress(QLatin1String("glBlendEquationSeparateOES"));
    }
#endif
    if (!funcs->blendEquationSeparate) {
        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
            context->getProcAddress(QLatin1String("glBlendEquationSeparateEXT"));
    }
    if (!funcs->blendEquationSeparate) {
        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
            context->getProcAddress(QLatin1String("glBlendEquationSeparateARB"));
    }

    if (funcs->blendEquationSeparate)
        funcs->blendEquationSeparate(modeRGB, modeAlpha);
    else
        funcs->blendEquationSeparate = qglfResolveBlendEquationSeparate;
}

qglfResolveBlendFuncSeparate()

static void qglfResolveBlendFuncSeparate ( GLenum  srcRGB, GLenum  dstRGB, GLenum  srcAlpha, GLenum  dstAlpha  )

static

Definition at line 1754 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
        context->getProcAddress(QLatin1String("glBlendFuncSeparate"));
#ifdef QT_OPENGL_ES
    if (!funcs->blendFuncSeparate) {
        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
            context->getProcAddress(QLatin1String("glBlendFuncSeparateOES"));
    }
#endif
    if (!funcs->blendFuncSeparate) {
        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
            context->getProcAddress(QLatin1String("glBlendFuncSeparateEXT"));
    }
    if (!funcs->blendFuncSeparate) {
        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
            context->getProcAddress(QLatin1String("glBlendFuncSeparateARB"));
    }

    if (funcs->blendFuncSeparate)
        funcs->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
    else
        funcs->blendFuncSeparate = qglfResolveBlendFuncSeparate;
}

qglfResolveBufferData()

static void qglfResolveBufferData ( GLenum  target, qgl_GLsizeiptr  size, const void *  data, GLenum  usage  )

static

Definition at line 1784 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBufferData)(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bufferData = (type_glBufferData)
        context->getProcAddress(QLatin1String("glBufferData"));
#ifdef QT_OPENGL_ES
    if (!funcs->bufferData) {
        funcs->bufferData = (type_glBufferData)
            context->getProcAddress(QLatin1String("glBufferDataOES"));
    }
#endif
    if (!funcs->bufferData) {
        funcs->bufferData = (type_glBufferData)
            context->getProcAddress(QLatin1String("glBufferDataEXT"));
    }
    if (!funcs->bufferData) {
        funcs->bufferData = (type_glBufferData)
            context->getProcAddress(QLatin1String("glBufferDataARB"));
    }

    if (funcs->bufferData)
        funcs->bufferData(target, size, data, usage);
    else
        funcs->bufferData = qglfResolveBufferData;
}

qglfResolveBufferSubData()

static void qglfResolveBufferSubData ( GLenum  target, qgl_GLintptr  offset, qgl_GLsizeiptr  size, const void *  data  )

static

Definition at line 1814 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glBufferSubData)(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->bufferSubData = (type_glBufferSubData)
        context->getProcAddress(QLatin1String("glBufferSubData"));
#ifdef QT_OPENGL_ES
    if (!funcs->bufferSubData) {
        funcs->bufferSubData = (type_glBufferSubData)
            context->getProcAddress(QLatin1String("glBufferSubDataOES"));
    }
#endif
    if (!funcs->bufferSubData) {
        funcs->bufferSubData = (type_glBufferSubData)
            context->getProcAddress(QLatin1String("glBufferSubDataEXT"));
    }
    if (!funcs->bufferSubData) {
        funcs->bufferSubData = (type_glBufferSubData)
            context->getProcAddress(QLatin1String("glBufferSubDataARB"));
    }

    if (funcs->bufferSubData)
        funcs->bufferSubData(target, offset, size, data);
    else
        funcs->bufferSubData = qglfResolveBufferSubData;
}

qglfResolveCheckFramebufferStatus()

static GLenum qglfResolveCheckFramebufferStatus ( GLenum  target )

static

Definition at line 1844 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLenum (QGLF_APIENTRYP type_glCheckFramebufferStatus)(GLenum target);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
        context->getProcAddress(QLatin1String("glCheckFramebufferStatus"));
#ifdef QT_OPENGL_ES
    if (!funcs->checkFramebufferStatus) {
        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
            context->getProcAddress(QLatin1String("glCheckFramebufferStatusOES"));
    }
#endif
    if (!funcs->checkFramebufferStatus) {
        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
            context->getProcAddress(QLatin1String("glCheckFramebufferStatusEXT"));
    }
    if (!funcs->checkFramebufferStatus) {
        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
            context->getProcAddress(QLatin1String("glCheckFramebufferStatusARB"));
    }

    if (funcs->checkFramebufferStatus)
        return funcs->checkFramebufferStatus(target);
    funcs->checkFramebufferStatus = qglfResolveCheckFramebufferStatus;
    return GLenum(0);
}

qglfResolveCompileShader()

static void qglfResolveCompileShader ( GLuint  shader )

static

Definition at line 1874 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glCompileShader)(GLuint shader);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->compileShader = (type_glCompileShader)
        context->getProcAddress(QLatin1String("glCompileShader"));
    if (!funcs->compileShader) {
        funcs->compileShader = (type_glCompileShader)
            context->getProcAddress(QLatin1String("glCompileShader"));
    }

    if (funcs->compileShader)
        funcs->compileShader(shader);
    else
        funcs->compileShader = qglfResolveCompileShader;
}

qglfResolveCompressedTexImage2D()

static void qglfResolveCompressedTexImage2D ( GLenum  target, GLint  level, GLenum  internalformat, GLsizei  width, GLsizei  height, GLint  border, GLsizei  imageSize, const void *  data  )

static

Definition at line 1894 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
        context->getProcAddress(QLatin1String("glCompressedTexImage2D"));
#ifdef QT_OPENGL_ES
    if (!funcs->compressedTexImage2D) {
        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexImage2DOES"));
    }
#endif
    if (!funcs->compressedTexImage2D) {
        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexImage2DEXT"));
    }
    if (!funcs->compressedTexImage2D) {
        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
    }

    if (funcs->compressedTexImage2D)
        funcs->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
    else
        funcs->compressedTexImage2D = qglfResolveCompressedTexImage2D;
}

qglfResolveCompressedTexSubImage2D()

static void qglfResolveCompressedTexSubImage2D ( GLenum  target, GLint  level, GLint  xoffset, GLint  yoffset, GLsizei  width, GLsizei  height, GLenum  format, GLsizei  imageSize, const void *  data  )

static

Definition at line 1924 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
        context->getProcAddress(QLatin1String("glCompressedTexSubImage2D"));
#ifdef QT_OPENGL_ES
    if (!funcs->compressedTexSubImage2D) {
        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DOES"));
    }
#endif
    if (!funcs->compressedTexSubImage2D) {
        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DEXT"));
    }
    if (!funcs->compressedTexSubImage2D) {
        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DARB"));
    }

    if (funcs->compressedTexSubImage2D)
        funcs->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
    else
        funcs->compressedTexSubImage2D = qglfResolveCompressedTexSubImage2D;
}

qglfResolveCreateProgram()

static GLuint qglfResolveCreateProgram ( )

static

Definition at line 1954 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLuint (QGLF_APIENTRYP type_glCreateProgram)();

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->createProgram = (type_glCreateProgram)
        context->getProcAddress(QLatin1String("glCreateProgram"));
    if (!funcs->createProgram) {
        funcs->createProgram = (type_glCreateProgram)
            context->getProcAddress(QLatin1String("glCreateProgramObjectARB"));
    }

    if (funcs->createProgram)
        return funcs->createProgram();
    funcs->createProgram = qglfResolveCreateProgram;
    return GLuint(0);
}

qglfResolveCreateShader()

static GLuint qglfResolveCreateShader ( GLenum  type )

static

Definition at line 1974 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLuint (QGLF_APIENTRYP type_glCreateShader)(GLenum type);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->createShader = (type_glCreateShader)
        context->getProcAddress(QLatin1String("glCreateShader"));
    if (!funcs->createShader) {
        funcs->createShader = (type_glCreateShader)
            context->getProcAddress(QLatin1String("glCreateShaderObjectARB"));
    }

    if (funcs->createShader)
        return funcs->createShader(type);
    funcs->createShader = qglfResolveCreateShader;
    return GLuint(0);
}

qglfResolveDeleteBuffers()

static void qglfResolveDeleteBuffers ( GLsizei  n, const GLuint *  buffers  )

static

Definition at line 1994 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDeleteBuffers)(GLsizei n, const GLuint* buffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->deleteBuffers = (type_glDeleteBuffers)
        context->getProcAddress(QLatin1String("glDeleteBuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->deleteBuffers) {
        funcs->deleteBuffers = (type_glDeleteBuffers)
            context->getProcAddress(QLatin1String("glDeleteBuffersOES"));
    }
#endif
    if (!funcs->deleteBuffers) {
        funcs->deleteBuffers = (type_glDeleteBuffers)
            context->getProcAddress(QLatin1String("glDeleteBuffersEXT"));
    }
    if (!funcs->deleteBuffers) {
        funcs->deleteBuffers = (type_glDeleteBuffers)
            context->getProcAddress(QLatin1String("glDeleteBuffersARB"));
    }

    if (funcs->deleteBuffers)
        funcs->deleteBuffers(n, buffers);
    else
        funcs->deleteBuffers = qglfResolveDeleteBuffers;
}

qglfResolveDeleteFramebuffers()

static void qglfResolveDeleteFramebuffers ( GLsizei  n, const GLuint *  framebuffers  )

static

Definition at line 2024 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
        context->getProcAddress(QLatin1String("glDeleteFramebuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->deleteFramebuffers) {
        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
            context->getProcAddress(QLatin1String("glDeleteFramebuffersOES"));
    }
#endif
    if (!funcs->deleteFramebuffers) {
        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
            context->getProcAddress(QLatin1String("glDeleteFramebuffersEXT"));
    }
    if (!funcs->deleteFramebuffers) {
        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
            context->getProcAddress(QLatin1String("glDeleteFramebuffersARB"));
    }

    if (funcs->deleteFramebuffers)
        funcs->deleteFramebuffers(n, framebuffers);
    else
        funcs->deleteFramebuffers = qglfResolveDeleteFramebuffers;
}

qglfResolveDeleteProgram()

static void qglfResolveDeleteProgram ( GLuint  program )

static

Definition at line 2054 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDeleteProgram)(GLuint program);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->deleteProgram = (type_glDeleteProgram)
        context->getProcAddress(QLatin1String("glDeleteProgram"));
    if (!funcs->deleteProgram) {
        funcs->deleteProgram = (type_glDeleteProgram)
            context->getProcAddress(QLatin1String("glDeleteObjectARB"));
    }

    if (funcs->deleteProgram)
        funcs->deleteProgram(program);
    else
        funcs->deleteProgram = qglfResolveDeleteProgram;
}

qglfResolveDeleteRenderbuffers()

static void qglfResolveDeleteRenderbuffers ( GLsizei  n, const GLuint *  renderbuffers  )

static

Definition at line 2074 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
        context->getProcAddress(QLatin1String("glDeleteRenderbuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->deleteRenderbuffers) {
        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
            context->getProcAddress(QLatin1String("glDeleteRenderbuffersOES"));
    }
#endif
    if (!funcs->deleteRenderbuffers) {
        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
            context->getProcAddress(QLatin1String("glDeleteRenderbuffersEXT"));
    }
    if (!funcs->deleteRenderbuffers) {
        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
            context->getProcAddress(QLatin1String("glDeleteRenderbuffersARB"));
    }

    if (funcs->deleteRenderbuffers)
        funcs->deleteRenderbuffers(n, renderbuffers);
    else
        funcs->deleteRenderbuffers = qglfResolveDeleteRenderbuffers;
}

qglfResolveDeleteShader()

static void qglfResolveDeleteShader ( GLuint  shader )

static

Definition at line 2104 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDeleteShader)(GLuint shader);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->deleteShader = (type_glDeleteShader)
        context->getProcAddress(QLatin1String("glDeleteShader"));
    if (!funcs->deleteShader) {
        funcs->deleteShader = (type_glDeleteShader)
            context->getProcAddress(QLatin1String("glDeleteObjectARB"));
    }

    if (funcs->deleteShader)
        funcs->deleteShader(shader);
    else
        funcs->deleteShader = qglfResolveDeleteShader;
}

qglfResolveDetachShader()

static void qglfResolveDetachShader ( GLuint  program, GLuint  shader  )

static

Definition at line 2124 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDetachShader)(GLuint program, GLuint shader);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->detachShader = (type_glDetachShader)
        context->getProcAddress(QLatin1String("glDetachShader"));
    if (!funcs->detachShader) {
        funcs->detachShader = (type_glDetachShader)
            context->getProcAddress(QLatin1String("glDetachObjectARB"));
    }

    if (funcs->detachShader)
        funcs->detachShader(program, shader);
    else
        funcs->detachShader = qglfResolveDetachShader;
}

qglfResolveDisableVertexAttribArray()

static void qglfResolveDisableVertexAttribArray ( GLuint  index )

static

Definition at line 2144 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glDisableVertexAttribArray)(GLuint index);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->disableVertexAttribArray = (type_glDisableVertexAttribArray)
        context->getProcAddress(QLatin1String("glDisableVertexAttribArray"));
    if (!funcs->disableVertexAttribArray) {
        funcs->disableVertexAttribArray = (type_glDisableVertexAttribArray)
            context->getProcAddress(QLatin1String("glDisableVertexAttribArrayARB"));
    }

    if (funcs->disableVertexAttribArray)
        funcs->disableVertexAttribArray(index);
    else
        funcs->disableVertexAttribArray = qglfResolveDisableVertexAttribArray;
}

qglfResolveEnableVertexAttribArray()

static void qglfResolveEnableVertexAttribArray ( GLuint  index )

static

Definition at line 2164 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glEnableVertexAttribArray)(GLuint index);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->enableVertexAttribArray = (type_glEnableVertexAttribArray)
        context->getProcAddress(QLatin1String("glEnableVertexAttribArray"));
    if (!funcs->enableVertexAttribArray) {
        funcs->enableVertexAttribArray = (type_glEnableVertexAttribArray)
            context->getProcAddress(QLatin1String("glEnableVertexAttribArrayARB"));
    }

    if (funcs->enableVertexAttribArray)
        funcs->enableVertexAttribArray(index);
    else
        funcs->enableVertexAttribArray = qglfResolveEnableVertexAttribArray;
}

qglfResolveFramebufferRenderbuffer()

static void qglfResolveFramebufferRenderbuffer ( GLenum  target, GLenum  attachment, GLenum  renderbuffertarget, GLuint  renderbuffer  )

static

Definition at line 2184 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
        context->getProcAddress(QLatin1String("glFramebufferRenderbuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->framebufferRenderbuffer) {
        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
            context->getProcAddress(QLatin1String("glFramebufferRenderbufferOES"));
    }
#endif
    if (!funcs->framebufferRenderbuffer) {
        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
            context->getProcAddress(QLatin1String("glFramebufferRenderbufferEXT"));
    }
    if (!funcs->framebufferRenderbuffer) {
        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
            context->getProcAddress(QLatin1String("glFramebufferRenderbufferARB"));
    }

    if (funcs->framebufferRenderbuffer)
        funcs->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
    else
        funcs->framebufferRenderbuffer = qglfResolveFramebufferRenderbuffer;
}

qglfResolveFramebufferTexture2D()

static void qglfResolveFramebufferTexture2D ( GLenum  target, GLenum  attachment, GLenum  textarget, GLuint  texture, GLint  level  )

static

Definition at line 2214 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
        context->getProcAddress(QLatin1String("glFramebufferTexture2D"));
#ifdef QT_OPENGL_ES
    if (!funcs->framebufferTexture2D) {
        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
            context->getProcAddress(QLatin1String("glFramebufferTexture2DOES"));
    }
#endif
    if (!funcs->framebufferTexture2D) {
        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
            context->getProcAddress(QLatin1String("glFramebufferTexture2DEXT"));
    }
    if (!funcs->framebufferTexture2D) {
        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
            context->getProcAddress(QLatin1String("glFramebufferTexture2DARB"));
    }

    if (funcs->framebufferTexture2D)
        funcs->framebufferTexture2D(target, attachment, textarget, texture, level);
    else
        funcs->framebufferTexture2D = qglfResolveFramebufferTexture2D;
}

qglfResolveGenBuffers()

static void qglfResolveGenBuffers ( GLsizei  n, GLuint *  buffers  )

static

Definition at line 2244 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGenBuffers)(GLsizei n, GLuint* buffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->genBuffers = (type_glGenBuffers)
        context->getProcAddress(QLatin1String("glGenBuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->genBuffers) {
        funcs->genBuffers = (type_glGenBuffers)
            context->getProcAddress(QLatin1String("glGenBuffersOES"));
    }
#endif
    if (!funcs->genBuffers) {
        funcs->genBuffers = (type_glGenBuffers)
            context->getProcAddress(QLatin1String("glGenBuffersEXT"));
    }
    if (!funcs->genBuffers) {
        funcs->genBuffers = (type_glGenBuffers)
            context->getProcAddress(QLatin1String("glGenBuffersARB"));
    }

    if (funcs->genBuffers)
        funcs->genBuffers(n, buffers);
    else
        funcs->genBuffers = qglfResolveGenBuffers;
}

qglfResolveGenerateMipmap()

static void qglfResolveGenerateMipmap ( GLenum  target )

static

Definition at line 2274 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGenerateMipmap)(GLenum target);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->generateMipmap = (type_glGenerateMipmap)
        context->getProcAddress(QLatin1String("glGenerateMipmap"));
#ifdef QT_OPENGL_ES
    if (!funcs->generateMipmap) {
        funcs->generateMipmap = (type_glGenerateMipmap)
            context->getProcAddress(QLatin1String("glGenerateMipmapOES"));
    }
#endif
    if (!funcs->generateMipmap) {
        funcs->generateMipmap = (type_glGenerateMipmap)
            context->getProcAddress(QLatin1String("glGenerateMipmapEXT"));
    }
    if (!funcs->generateMipmap) {
        funcs->generateMipmap = (type_glGenerateMipmap)
            context->getProcAddress(QLatin1String("glGenerateMipmapARB"));
    }

    if (funcs->generateMipmap)
        funcs->generateMipmap(target);
    else
        funcs->generateMipmap = qglfResolveGenerateMipmap;
}

qglfResolveGenFramebuffers()

static void qglfResolveGenFramebuffers ( GLsizei  n, GLuint *  framebuffers  )

static

Definition at line 2304 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGenFramebuffers)(GLsizei n, GLuint* framebuffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->genFramebuffers = (type_glGenFramebuffers)
        context->getProcAddress(QLatin1String("glGenFramebuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->genFramebuffers) {
        funcs->genFramebuffers = (type_glGenFramebuffers)
            context->getProcAddress(QLatin1String("glGenFramebuffersOES"));
    }
#endif
    if (!funcs->genFramebuffers) {
        funcs->genFramebuffers = (type_glGenFramebuffers)
            context->getProcAddress(QLatin1String("glGenFramebuffersEXT"));
    }
    if (!funcs->genFramebuffers) {
        funcs->genFramebuffers = (type_glGenFramebuffers)
            context->getProcAddress(QLatin1String("glGenFramebuffersARB"));
    }

    if (funcs->genFramebuffers)
        funcs->genFramebuffers(n, framebuffers);
    else
        funcs->genFramebuffers = qglfResolveGenFramebuffers;
}

qglfResolveGenRenderbuffers()

static void qglfResolveGenRenderbuffers ( GLsizei  n, GLuint *  renderbuffers  )

static

Definition at line 2334 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->genRenderbuffers = (type_glGenRenderbuffers)
        context->getProcAddress(QLatin1String("glGenRenderbuffers"));
#ifdef QT_OPENGL_ES
    if (!funcs->genRenderbuffers) {
        funcs->genRenderbuffers = (type_glGenRenderbuffers)
            context->getProcAddress(QLatin1String("glGenRenderbuffersOES"));
    }
#endif
    if (!funcs->genRenderbuffers) {
        funcs->genRenderbuffers = (type_glGenRenderbuffers)
            context->getProcAddress(QLatin1String("glGenRenderbuffersEXT"));
    }
    if (!funcs->genRenderbuffers) {
        funcs->genRenderbuffers = (type_glGenRenderbuffers)
            context->getProcAddress(QLatin1String("glGenRenderbuffersARB"));
    }

    if (funcs->genRenderbuffers)
        funcs->genRenderbuffers(n, renderbuffers);
    else
        funcs->genRenderbuffers = qglfResolveGenRenderbuffers;
}

qglfResolveGetActiveAttrib()

static void qglfResolveGetActiveAttrib ( GLuint  program, GLuint  index, GLsizei  bufsize, GLsizei *  length, GLint *  size, GLenum *  type, char *  name  )

static

Definition at line 2364 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getActiveAttrib = (type_glGetActiveAttrib)
        context->getProcAddress(QLatin1String("glGetActiveAttrib"));
    if (!funcs->getActiveAttrib) {
        funcs->getActiveAttrib = (type_glGetActiveAttrib)
            context->getProcAddress(QLatin1String("glGetActiveAttribARB"));
    }

    if (funcs->getActiveAttrib)
        funcs->getActiveAttrib(program, index, bufsize, length, size, type, name);
    else
        funcs->getActiveAttrib = qglfResolveGetActiveAttrib;
}

qglfResolveGetActiveUniform()

static void qglfResolveGetActiveUniform ( GLuint  program, GLuint  index, GLsizei  bufsize, GLsizei *  length, GLint *  size, GLenum *  type, char *  name  )

static

Definition at line 2384 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getActiveUniform = (type_glGetActiveUniform)
        context->getProcAddress(QLatin1String("glGetActiveUniform"));
    if (!funcs->getActiveUniform) {
        funcs->getActiveUniform = (type_glGetActiveUniform)
            context->getProcAddress(QLatin1String("glGetActiveUniformARB"));
    }

    if (funcs->getActiveUniform)
        funcs->getActiveUniform(program, index, bufsize, length, size, type, name);
    else
        funcs->getActiveUniform = qglfResolveGetActiveUniform;
}

qglfResolveGetAttachedShaders()

static void qglfResolveGetAttachedShaders ( GLuint  program, GLsizei  maxcount, GLsizei *  count, GLuint *  shaders  )

static

Definition at line 2404 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getAttachedShaders = (type_glGetAttachedShaders)
        context->getProcAddress(QLatin1String("glGetAttachedShaders"));
    if (!funcs->getAttachedShaders) {
        funcs->getAttachedShaders = (type_glGetAttachedShaders)
            context->getProcAddress(QLatin1String("glGetAttachedObjectsARB"));
    }

    if (funcs->getAttachedShaders)
        funcs->getAttachedShaders(program, maxcount, count, shaders);
    else
        funcs->getAttachedShaders = qglfResolveGetAttachedShaders;
}

qglfResolveGetAttribLocation()

static int qglfResolveGetAttribLocation ( GLuint  program, const char *  name  )

static

Definition at line 2424 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef int (QGLF_APIENTRYP type_glGetAttribLocation)(GLuint program, const char* name);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getAttribLocation = (type_glGetAttribLocation)
        context->getProcAddress(QLatin1String("glGetAttribLocation"));
    if (!funcs->getAttribLocation) {
        funcs->getAttribLocation = (type_glGetAttribLocation)
            context->getProcAddress(QLatin1String("glGetAttribLocationARB"));
    }

    if (funcs->getAttribLocation)
        return funcs->getAttribLocation(program, name);
    funcs->getAttribLocation = qglfResolveGetAttribLocation;
    return int(0);
}

qglfResolveGetBufferParameteriv()

static void qglfResolveGetBufferParameteriv ( GLenum  target, GLenum  pname, GLint *  params  )

static

Definition at line 2444 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
        context->getProcAddress(QLatin1String("glGetBufferParameteriv"));
#ifdef QT_OPENGL_ES
    if (!funcs->getBufferParameteriv) {
        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
            context->getProcAddress(QLatin1String("glGetBufferParameterivOES"));
    }
#endif
    if (!funcs->getBufferParameteriv) {
        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
            context->getProcAddress(QLatin1String("glGetBufferParameterivEXT"));
    }
    if (!funcs->getBufferParameteriv) {
        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
            context->getProcAddress(QLatin1String("glGetBufferParameterivARB"));
    }

    if (funcs->getBufferParameteriv)
        funcs->getBufferParameteriv(target, pname, params);
    else
        funcs->getBufferParameteriv = qglfResolveGetBufferParameteriv;
}

qglfResolveGetFramebufferAttachmentParameteriv()

static void qglfResolveGetFramebufferAttachmentParameteriv ( GLenum  target, GLenum  attachment, GLenum  pname, GLint *  params  )

static

Definition at line 2474 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
        context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameteriv"));
#ifdef QT_OPENGL_ES
    if (!funcs->getFramebufferAttachmentParameteriv) {
        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivOES"));
    }
#endif
    if (!funcs->getFramebufferAttachmentParameteriv) {
        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivEXT"));
    }
    if (!funcs->getFramebufferAttachmentParameteriv) {
        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivARB"));
    }

    if (funcs->getFramebufferAttachmentParameteriv)
        funcs->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
    else
        funcs->getFramebufferAttachmentParameteriv = qglfResolveGetFramebufferAttachmentParameteriv;
}

qglfResolveGetProgramInfoLog()

static void qglfResolveGetProgramInfoLog ( GLuint  program, GLsizei  bufsize, GLsizei *  length, char *  infolog  )

static

Definition at line 2524 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getProgramInfoLog = (type_glGetProgramInfoLog)
        context->getProcAddress(QLatin1String("glGetProgramInfoLog"));
    if (!funcs->getProgramInfoLog) {
        funcs->getProgramInfoLog = (type_glGetProgramInfoLog)
            context->getProcAddress(QLatin1String("glGetInfoLogARB"));
    }

    if (funcs->getProgramInfoLog)
        funcs->getProgramInfoLog(program, bufsize, length, infolog);
    else
        funcs->getProgramInfoLog = qglfResolveGetProgramInfoLog;
}

qglfResolveGetProgramiv()

static void qglfResolveGetProgramiv ( GLuint  program, GLenum  pname, GLint *  params  )

static

Definition at line 2504 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetProgramiv)(GLuint program, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getProgramiv = (type_glGetProgramiv)
        context->getProcAddress(QLatin1String("glGetProgramiv"));
    if (!funcs->getProgramiv) {
        funcs->getProgramiv = (type_glGetProgramiv)
            context->getProcAddress(QLatin1String("glGetObjectParameterivARB"));
    }

    if (funcs->getProgramiv)
        funcs->getProgramiv(program, pname, params);
    else
        funcs->getProgramiv = qglfResolveGetProgramiv;
}

qglfResolveGetRenderbufferParameteriv()

static void qglfResolveGetRenderbufferParameteriv ( GLenum  target, GLenum  pname, GLint *  params  )

static

Definition at line 2544 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
        context->getProcAddress(QLatin1String("glGetRenderbufferParameteriv"));
#ifdef QT_OPENGL_ES
    if (!funcs->getRenderbufferParameteriv) {
        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivOES"));
    }
#endif
    if (!funcs->getRenderbufferParameteriv) {
        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivEXT"));
    }
    if (!funcs->getRenderbufferParameteriv) {
        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivARB"));
    }

    if (funcs->getRenderbufferParameteriv)
        funcs->getRenderbufferParameteriv(target, pname, params);
    else
        funcs->getRenderbufferParameteriv = qglfResolveGetRenderbufferParameteriv;
}

qglfResolveGetShaderInfoLog()

static void qglfResolveGetShaderInfoLog ( GLuint  shader, GLsizei  bufsize, GLsizei *  length, char *  infolog  )

static

Definition at line 2594 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getShaderInfoLog = (type_glGetShaderInfoLog)
        context->getProcAddress(QLatin1String("glGetShaderInfoLog"));
    if (!funcs->getShaderInfoLog) {
        funcs->getShaderInfoLog = (type_glGetShaderInfoLog)
            context->getProcAddress(QLatin1String("glGetInfoLogARB"));
    }

    if (funcs->getShaderInfoLog)
        funcs->getShaderInfoLog(shader, bufsize, length, infolog);
    else
        funcs->getShaderInfoLog = qglfResolveGetShaderInfoLog;
}

qglfResolveGetShaderiv()

static void qglfResolveGetShaderiv ( GLuint  shader, GLenum  pname, GLint *  params  )

static

Definition at line 2574 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetShaderiv)(GLuint shader, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getShaderiv = (type_glGetShaderiv)
        context->getProcAddress(QLatin1String("glGetShaderiv"));
    if (!funcs->getShaderiv) {
        funcs->getShaderiv = (type_glGetShaderiv)
            context->getProcAddress(QLatin1String("glGetObjectParameterivARB"));
    }

    if (funcs->getShaderiv)
        funcs->getShaderiv(shader, pname, params);
    else
        funcs->getShaderiv = qglfResolveGetShaderiv;
}

qglfResolveGetShaderPrecisionFormat()

static void qglfResolveGetShaderPrecisionFormat ( GLenum  shadertype, GLenum  precisiontype, GLint *  range, GLint *  precision  )

static

Definition at line 2621 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
        context->getProcAddress(QLatin1String("glGetShaderPrecisionFormat"));
#ifdef QT_OPENGL_ES
    if (!funcs->getShaderPrecisionFormat) {
        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatOES"));
    }
#endif
    if (!funcs->getShaderPrecisionFormat) {
        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatEXT"));
    }
    if (!funcs->getShaderPrecisionFormat) {
        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatARB"));
    }

    if (!funcs->getShaderPrecisionFormat)
        funcs->getShaderPrecisionFormat = qglfSpecialGetShaderPrecisionFormat;

    funcs->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}

qglfResolveGetShaderSource()

static void qglfResolveGetShaderSource ( GLuint  shader, GLsizei  bufsize, GLsizei *  length, char *  source  )

static

Definition at line 2651 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getShaderSource = (type_glGetShaderSource)
        context->getProcAddress(QLatin1String("glGetShaderSource"));
    if (!funcs->getShaderSource) {
        funcs->getShaderSource = (type_glGetShaderSource)
            context->getProcAddress(QLatin1String("glGetShaderSourceARB"));
    }

    if (funcs->getShaderSource)
        funcs->getShaderSource(shader, bufsize, length, source);
    else
        funcs->getShaderSource = qglfResolveGetShaderSource;
}

qglfResolveGetUniformfv()

static void qglfResolveGetUniformfv ( GLuint  program, GLint  location, GLfloat *  params  )

static

Definition at line 2671 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetUniformfv)(GLuint program, GLint location, GLfloat* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getUniformfv = (type_glGetUniformfv)
        context->getProcAddress(QLatin1String("glGetUniformfv"));
    if (!funcs->getUniformfv) {
        funcs->getUniformfv = (type_glGetUniformfv)
            context->getProcAddress(QLatin1String("glGetUniformfvARB"));
    }

    if (funcs->getUniformfv)
        funcs->getUniformfv(program, location, params);
    else
        funcs->getUniformfv = qglfResolveGetUniformfv;
}

qglfResolveGetUniformiv()

static void qglfResolveGetUniformiv ( GLuint  program, GLint  location, GLint *  params  )

static

Definition at line 2691 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetUniformiv)(GLuint program, GLint location, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getUniformiv = (type_glGetUniformiv)
        context->getProcAddress(QLatin1String("glGetUniformiv"));
    if (!funcs->getUniformiv) {
        funcs->getUniformiv = (type_glGetUniformiv)
            context->getProcAddress(QLatin1String("glGetUniformivARB"));
    }

    if (funcs->getUniformiv)
        funcs->getUniformiv(program, location, params);
    else
        funcs->getUniformiv = qglfResolveGetUniformiv;
}

qglfResolveGetUniformLocation()

static int qglfResolveGetUniformLocation ( GLuint  program, const char *  name  )

static

Definition at line 2711 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef int (QGLF_APIENTRYP type_glGetUniformLocation)(GLuint program, const char* name);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getUniformLocation = (type_glGetUniformLocation)
        context->getProcAddress(QLatin1String("glGetUniformLocation"));
    if (!funcs->getUniformLocation) {
        funcs->getUniformLocation = (type_glGetUniformLocation)
            context->getProcAddress(QLatin1String("glGetUniformLocationARB"));
    }

    if (funcs->getUniformLocation)
        return funcs->getUniformLocation(program, name);
    funcs->getUniformLocation = qglfResolveGetUniformLocation;
    return int(0);
}

qglfResolveGetVertexAttribfv()

static void qglfResolveGetVertexAttribfv ( GLuint  index, GLenum  pname, GLfloat *  params  )

static

Definition at line 2731 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getVertexAttribfv = (type_glGetVertexAttribfv)
        context->getProcAddress(QLatin1String("glGetVertexAttribfv"));
    if (!funcs->getVertexAttribfv) {
        funcs->getVertexAttribfv = (type_glGetVertexAttribfv)
            context->getProcAddress(QLatin1String("glGetVertexAttribfvARB"));
    }

    if (funcs->getVertexAttribfv)
        funcs->getVertexAttribfv(index, pname, params);
    else
        funcs->getVertexAttribfv = qglfResolveGetVertexAttribfv;
}

qglfResolveGetVertexAttribiv()

static void qglfResolveGetVertexAttribiv ( GLuint  index, GLenum  pname, GLint *  params  )

static

Definition at line 2751 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getVertexAttribiv = (type_glGetVertexAttribiv)
        context->getProcAddress(QLatin1String("glGetVertexAttribiv"));
    if (!funcs->getVertexAttribiv) {
        funcs->getVertexAttribiv = (type_glGetVertexAttribiv)
            context->getProcAddress(QLatin1String("glGetVertexAttribivARB"));
    }

    if (funcs->getVertexAttribiv)
        funcs->getVertexAttribiv(index, pname, params);
    else
        funcs->getVertexAttribiv = qglfResolveGetVertexAttribiv;
}

qglfResolveGetVertexAttribPointerv()

static void qglfResolveGetVertexAttribPointerv ( GLuint  index, GLenum  pname, void **  pointer  )

static

Definition at line 2771 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->getVertexAttribPointerv = (type_glGetVertexAttribPointerv)
        context->getProcAddress(QLatin1String("glGetVertexAttribPointerv"));
    if (!funcs->getVertexAttribPointerv) {
        funcs->getVertexAttribPointerv = (type_glGetVertexAttribPointerv)
            context->getProcAddress(QLatin1String("glGetVertexAttribPointervARB"));
    }

    if (funcs->getVertexAttribPointerv)
        funcs->getVertexAttribPointerv(index, pname, pointer);
    else
        funcs->getVertexAttribPointerv = qglfResolveGetVertexAttribPointerv;
}

qglfResolveIsBuffer()

static GLboolean qglfResolveIsBuffer ( GLuint  buffer )

static

Definition at line 2791 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLboolean (QGLF_APIENTRYP type_glIsBuffer)(GLuint buffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->isBuffer = (type_glIsBuffer)
        context->getProcAddress(QLatin1String("glIsBuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->isBuffer) {
        funcs->isBuffer = (type_glIsBuffer)
            context->getProcAddress(QLatin1String("glIsBufferOES"));
    }
#endif
    if (!funcs->isBuffer) {
        funcs->isBuffer = (type_glIsBuffer)
            context->getProcAddress(QLatin1String("glIsBufferEXT"));
    }
    if (!funcs->isBuffer) {
        funcs->isBuffer = (type_glIsBuffer)
            context->getProcAddress(QLatin1String("glIsBufferARB"));
    }

    if (funcs->isBuffer)
        return funcs->isBuffer(buffer);
    funcs->isBuffer = qglfResolveIsBuffer;
    return GLboolean(0);
}

qglfResolveIsFramebuffer()

static GLboolean qglfResolveIsFramebuffer ( GLuint  framebuffer )

static

Definition at line 2821 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLboolean (QGLF_APIENTRYP type_glIsFramebuffer)(GLuint framebuffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->isFramebuffer = (type_glIsFramebuffer)
        context->getProcAddress(QLatin1String("glIsFramebuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->isFramebuffer) {
        funcs->isFramebuffer = (type_glIsFramebuffer)
            context->getProcAddress(QLatin1String("glIsFramebufferOES"));
    }
#endif
    if (!funcs->isFramebuffer) {
        funcs->isFramebuffer = (type_glIsFramebuffer)
            context->getProcAddress(QLatin1String("glIsFramebufferEXT"));
    }
    if (!funcs->isFramebuffer) {
        funcs->isFramebuffer = (type_glIsFramebuffer)
            context->getProcAddress(QLatin1String("glIsFramebufferARB"));
    }

    if (funcs->isFramebuffer)
        return funcs->isFramebuffer(framebuffer);
    funcs->isFramebuffer = qglfResolveIsFramebuffer;
    return GLboolean(0);
}

qglfResolveIsProgram()

static GLboolean qglfResolveIsProgram ( GLuint  program )

static

Definition at line 2856 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLboolean (QGLF_APIENTRYP type_glIsProgram)(GLuint program);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->isProgram = (type_glIsProgram)
        context->getProcAddress(QLatin1String("glIsProgram"));
    if (!funcs->isProgram) {
        funcs->isProgram = (type_glIsProgram)
            context->getProcAddress(QLatin1String("glIsProgramARB"));
    }

    if (!funcs->isProgram)
        funcs->isProgram = qglfSpecialIsProgram;

    return funcs->isProgram(program);
}

qglfResolveIsRenderbuffer()

static GLboolean qglfResolveIsRenderbuffer ( GLuint  renderbuffer )

static

Definition at line 2876 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLboolean (QGLF_APIENTRYP type_glIsRenderbuffer)(GLuint renderbuffer);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->isRenderbuffer = (type_glIsRenderbuffer)
        context->getProcAddress(QLatin1String("glIsRenderbuffer"));
#ifdef QT_OPENGL_ES
    if (!funcs->isRenderbuffer) {
        funcs->isRenderbuffer = (type_glIsRenderbuffer)
            context->getProcAddress(QLatin1String("glIsRenderbufferOES"));
    }
#endif
    if (!funcs->isRenderbuffer) {
        funcs->isRenderbuffer = (type_glIsRenderbuffer)
            context->getProcAddress(QLatin1String("glIsRenderbufferEXT"));
    }
    if (!funcs->isRenderbuffer) {
        funcs->isRenderbuffer = (type_glIsRenderbuffer)
            context->getProcAddress(QLatin1String("glIsRenderbufferARB"));
    }

    if (funcs->isRenderbuffer)
        return funcs->isRenderbuffer(renderbuffer);
    funcs->isRenderbuffer = qglfResolveIsRenderbuffer;
    return GLboolean(0);
}

qglfResolveIsShader()

static GLboolean qglfResolveIsShader ( GLuint  shader )

static

Definition at line 2911 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef GLboolean (QGLF_APIENTRYP type_glIsShader)(GLuint shader);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->isShader = (type_glIsShader)
        context->getProcAddress(QLatin1String("glIsShader"));
    if (!funcs->isShader) {
        funcs->isShader = (type_glIsShader)
            context->getProcAddress(QLatin1String("glIsShaderARB"));
    }

    if (!funcs->isShader)
        funcs->isShader = qglfSpecialIsShader;

    return funcs->isShader(shader);
}

qglfResolveLinkProgram()

static void qglfResolveLinkProgram ( GLuint  program )

static

Definition at line 2931 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glLinkProgram)(GLuint program);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->linkProgram = (type_glLinkProgram)
        context->getProcAddress(QLatin1String("glLinkProgram"));
    if (!funcs->linkProgram) {
        funcs->linkProgram = (type_glLinkProgram)
            context->getProcAddress(QLatin1String("glLinkProgramARB"));
    }

    if (funcs->linkProgram)
        funcs->linkProgram(program);
    else
        funcs->linkProgram = qglfResolveLinkProgram;
}

qglfResolveReleaseShaderCompiler()

static void qglfResolveReleaseShaderCompiler ( )

static

Definition at line 2955 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glReleaseShaderCompiler)();

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->releaseShaderCompiler = (type_glReleaseShaderCompiler)
        context->getProcAddress(QLatin1String("glReleaseShaderCompiler"));
    if (!funcs->releaseShaderCompiler) {
        funcs->releaseShaderCompiler = (type_glReleaseShaderCompiler)
            context->getProcAddress(QLatin1String("glReleaseShaderCompilerARB"));
    }

    if (!funcs->releaseShaderCompiler)
        funcs->releaseShaderCompiler = qglfSpecialReleaseShaderCompiler;

    funcs->releaseShaderCompiler();
}

qglfResolveRenderbufferStorage()

static void qglfResolveRenderbufferStorage ( GLenum  target, GLenum  internalformat, GLsizei  width, GLsizei  height  )

static

Definition at line 2975 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->renderbufferStorage = (type_glRenderbufferStorage)
        context->getProcAddress(QLatin1String("glRenderbufferStorage"));
#ifdef QT_OPENGL_ES
    if (!funcs->renderbufferStorage) {
        funcs->renderbufferStorage = (type_glRenderbufferStorage)
            context->getProcAddress(QLatin1String("glRenderbufferStorageOES"));
    }
#endif
    if (!funcs->renderbufferStorage) {
        funcs->renderbufferStorage = (type_glRenderbufferStorage)
            context->getProcAddress(QLatin1String("glRenderbufferStorageEXT"));
    }
    if (!funcs->renderbufferStorage) {
        funcs->renderbufferStorage = (type_glRenderbufferStorage)
            context->getProcAddress(QLatin1String("glRenderbufferStorageARB"));
    }

    if (funcs->renderbufferStorage)
        funcs->renderbufferStorage(target, internalformat, width, height);
    else
        funcs->renderbufferStorage = qglfResolveRenderbufferStorage;
}

qglfResolveSampleCoverage()

static void qglfResolveSampleCoverage ( GLclampf  value, GLboolean  invert  )

static

Definition at line 3005 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glSampleCoverage)(GLclampf value, GLboolean invert);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->sampleCoverage = (type_glSampleCoverage)
        context->getProcAddress(QLatin1String("glSampleCoverage"));
#ifdef QT_OPENGL_ES
    if (!funcs->sampleCoverage) {
        funcs->sampleCoverage = (type_glSampleCoverage)
            context->getProcAddress(QLatin1String("glSampleCoverageOES"));
    }
#endif
    if (!funcs->sampleCoverage) {
        funcs->sampleCoverage = (type_glSampleCoverage)
            context->getProcAddress(QLatin1String("glSampleCoverageEXT"));
    }
    if (!funcs->sampleCoverage) {
        funcs->sampleCoverage = (type_glSampleCoverage)
            context->getProcAddress(QLatin1String("glSampleCoverageARB"));
    }

    if (funcs->sampleCoverage)
        funcs->sampleCoverage(value, invert);
    else
        funcs->sampleCoverage = qglfResolveSampleCoverage;
}

qglfResolveShaderBinary()

static void qglfResolveShaderBinary ( GLint  n, const GLuint *  shaders, GLenum  binaryformat, const void *  binary, GLint  length  )

static

Definition at line 3035 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glShaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->shaderBinary = (type_glShaderBinary)
        context->getProcAddress(QLatin1String("glShaderBinary"));
    if (!funcs->shaderBinary) {
        funcs->shaderBinary = (type_glShaderBinary)
            context->getProcAddress(QLatin1String("glShaderBinaryARB"));
    }

    if (funcs->shaderBinary)
        funcs->shaderBinary(n, shaders, binaryformat, binary, length);
    else
        funcs->shaderBinary = qglfResolveShaderBinary;
}

qglfResolveShaderSource()

static void qglfResolveShaderSource ( GLuint  shader, GLsizei  count, const char **  string, const GLint *  length  )

static

Definition at line 3055 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glShaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->shaderSource = (type_glShaderSource)
        context->getProcAddress(QLatin1String("glShaderSource"));
    if (!funcs->shaderSource) {
        funcs->shaderSource = (type_glShaderSource)
            context->getProcAddress(QLatin1String("glShaderSourceARB"));
    }

    if (funcs->shaderSource)
        funcs->shaderSource(shader, count, string, length);
    else
        funcs->shaderSource = qglfResolveShaderSource;
}

qglfResolveStencilFuncSeparate()

static void qglfResolveStencilFuncSeparate ( GLenum  face, GLenum  func, GLint  ref, GLuint  mask  )

static

Definition at line 3075 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
        context->getProcAddress(QLatin1String("glStencilFuncSeparate"));
#ifdef QT_OPENGL_ES
    if (!funcs->stencilFuncSeparate) {
        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
            context->getProcAddress(QLatin1String("glStencilFuncSeparateOES"));
    }
#endif
    if (!funcs->stencilFuncSeparate) {
        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
            context->getProcAddress(QLatin1String("glStencilFuncSeparateEXT"));
    }
    if (!funcs->stencilFuncSeparate) {
        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
            context->getProcAddress(QLatin1String("glStencilFuncSeparateARB"));
    }

    if (funcs->stencilFuncSeparate)
        funcs->stencilFuncSeparate(face, func, ref, mask);
    else
        funcs->stencilFuncSeparate = qglfResolveStencilFuncSeparate;
}

qglfResolveStencilMaskSeparate()

static void qglfResolveStencilMaskSeparate ( GLenum  face, GLuint  mask  )

static

Definition at line 3105 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glStencilMaskSeparate)(GLenum face, GLuint mask);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
        context->getProcAddress(QLatin1String("glStencilMaskSeparate"));
#ifdef QT_OPENGL_ES
    if (!funcs->stencilMaskSeparate) {
        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
            context->getProcAddress(QLatin1String("glStencilMaskSeparateOES"));
    }
#endif
    if (!funcs->stencilMaskSeparate) {
        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
            context->getProcAddress(QLatin1String("glStencilMaskSeparateEXT"));
    }
    if (!funcs->stencilMaskSeparate) {
        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
            context->getProcAddress(QLatin1String("glStencilMaskSeparateARB"));
    }

    if (funcs->stencilMaskSeparate)
        funcs->stencilMaskSeparate(face, mask);
    else
        funcs->stencilMaskSeparate = qglfResolveStencilMaskSeparate;
}

qglfResolveStencilOpSeparate()

static void qglfResolveStencilOpSeparate ( GLenum  face, GLenum  fail, GLenum  zfail, GLenum  zpass  )

static

Definition at line 3135 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->stencilOpSeparate = (type_glStencilOpSeparate)
        context->getProcAddress(QLatin1String("glStencilOpSeparate"));
#ifdef QT_OPENGL_ES
    if (!funcs->stencilOpSeparate) {
        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
            context->getProcAddress(QLatin1String("glStencilOpSeparateOES"));
    }
#endif
    if (!funcs->stencilOpSeparate) {
        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
            context->getProcAddress(QLatin1String("glStencilOpSeparateEXT"));
    }
    if (!funcs->stencilOpSeparate) {
        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
            context->getProcAddress(QLatin1String("glStencilOpSeparateARB"));
    }

    if (funcs->stencilOpSeparate)
        funcs->stencilOpSeparate(face, fail, zfail, zpass);
    else
        funcs->stencilOpSeparate = qglfResolveStencilOpSeparate;
}

qglfResolveUniform1f()

static void qglfResolveUniform1f ( GLint  location, GLfloat  x  )

static

Definition at line 3165 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform1f)(GLint location, GLfloat x);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform1f = (type_glUniform1f)
        context->getProcAddress(QLatin1String("glUniform1f"));
    if (!funcs->uniform1f) {
        funcs->uniform1f = (type_glUniform1f)
            context->getProcAddress(QLatin1String("glUniform1fARB"));
    }

    if (funcs->uniform1f)
        funcs->uniform1f(location, x);
    else
        funcs->uniform1f = qglfResolveUniform1f;
}

qglfResolveUniform1fv()

static void qglfResolveUniform1fv ( GLint  location, GLsizei  count, const GLfloat *  v  )

static

Definition at line 3185 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform1fv)(GLint location, GLsizei count, const GLfloat* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform1fv = (type_glUniform1fv)
        context->getProcAddress(QLatin1String("glUniform1fv"));
    if (!funcs->uniform1fv) {
        funcs->uniform1fv = (type_glUniform1fv)
            context->getProcAddress(QLatin1String("glUniform1fvARB"));
    }

    if (funcs->uniform1fv)
        funcs->uniform1fv(location, count, v);
    else
        funcs->uniform1fv = qglfResolveUniform1fv;
}

qglfResolveUniform1i()

static void qglfResolveUniform1i ( GLint  location, GLint  x  )

static

Definition at line 3205 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform1i)(GLint location, GLint x);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform1i = (type_glUniform1i)
        context->getProcAddress(QLatin1String("glUniform1i"));
    if (!funcs->uniform1i) {
        funcs->uniform1i = (type_glUniform1i)
            context->getProcAddress(QLatin1String("glUniform1iARB"));
    }

    if (funcs->uniform1i)
        funcs->uniform1i(location, x);
    else
        funcs->uniform1i = qglfResolveUniform1i;
}

qglfResolveUniform1iv()

static void qglfResolveUniform1iv ( GLint  location, GLsizei  count, const GLint *  v  )

static

Definition at line 3225 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform1iv)(GLint location, GLsizei count, const GLint* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform1iv = (type_glUniform1iv)
        context->getProcAddress(QLatin1String("glUniform1iv"));
    if (!funcs->uniform1iv) {
        funcs->uniform1iv = (type_glUniform1iv)
            context->getProcAddress(QLatin1String("glUniform1ivARB"));
    }

    if (funcs->uniform1iv)
        funcs->uniform1iv(location, count, v);
    else
        funcs->uniform1iv = qglfResolveUniform1iv;
}

qglfResolveUniform2f()

static void qglfResolveUniform2f ( GLint  location, GLfloat  x, GLfloat  y  )

static

Definition at line 3245 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform2f)(GLint location, GLfloat x, GLfloat y);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform2f = (type_glUniform2f)
        context->getProcAddress(QLatin1String("glUniform2f"));
    if (!funcs->uniform2f) {
        funcs->uniform2f = (type_glUniform2f)
            context->getProcAddress(QLatin1String("glUniform2fARB"));
    }

    if (funcs->uniform2f)
        funcs->uniform2f(location, x, y);
    else
        funcs->uniform2f = qglfResolveUniform2f;
}

qglfResolveUniform2fv()

static void qglfResolveUniform2fv ( GLint  location, GLsizei  count, const GLfloat *  v  )

static

Definition at line 3265 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform2fv)(GLint location, GLsizei count, const GLfloat* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform2fv = (type_glUniform2fv)
        context->getProcAddress(QLatin1String("glUniform2fv"));
    if (!funcs->uniform2fv) {
        funcs->uniform2fv = (type_glUniform2fv)
            context->getProcAddress(QLatin1String("glUniform2fvARB"));
    }

    if (funcs->uniform2fv)
        funcs->uniform2fv(location, count, v);
    else
        funcs->uniform2fv = qglfResolveUniform2fv;
}

qglfResolveUniform2i()

static void qglfResolveUniform2i ( GLint  location, GLint  x, GLint  y  )

static

Definition at line 3285 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform2i)(GLint location, GLint x, GLint y);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform2i = (type_glUniform2i)
        context->getProcAddress(QLatin1String("glUniform2i"));
    if (!funcs->uniform2i) {
        funcs->uniform2i = (type_glUniform2i)
            context->getProcAddress(QLatin1String("glUniform2iARB"));
    }

    if (funcs->uniform2i)
        funcs->uniform2i(location, x, y);
    else
        funcs->uniform2i = qglfResolveUniform2i;
}

qglfResolveUniform2iv()

static void qglfResolveUniform2iv ( GLint  location, GLsizei  count, const GLint *  v  )

static

Definition at line 3305 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform2iv)(GLint location, GLsizei count, const GLint* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform2iv = (type_glUniform2iv)
        context->getProcAddress(QLatin1String("glUniform2iv"));
    if (!funcs->uniform2iv) {
        funcs->uniform2iv = (type_glUniform2iv)
            context->getProcAddress(QLatin1String("glUniform2ivARB"));
    }

    if (funcs->uniform2iv)
        funcs->uniform2iv(location, count, v);
    else
        funcs->uniform2iv = qglfResolveUniform2iv;
}

qglfResolveUniform3f()

static void qglfResolveUniform3f ( GLint  location, GLfloat  x, GLfloat  y, GLfloat  z  )

static

Definition at line 3325 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform3f = (type_glUniform3f)
        context->getProcAddress(QLatin1String("glUniform3f"));
    if (!funcs->uniform3f) {
        funcs->uniform3f = (type_glUniform3f)
            context->getProcAddress(QLatin1String("glUniform3fARB"));
    }

    if (funcs->uniform3f)
        funcs->uniform3f(location, x, y, z);
    else
        funcs->uniform3f = qglfResolveUniform3f;
}

qglfResolveUniform3fv()

static void qglfResolveUniform3fv ( GLint  location, GLsizei  count, const GLfloat *  v  )

static

Definition at line 3345 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform3fv)(GLint location, GLsizei count, const GLfloat* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform3fv = (type_glUniform3fv)
        context->getProcAddress(QLatin1String("glUniform3fv"));
    if (!funcs->uniform3fv) {
        funcs->uniform3fv = (type_glUniform3fv)
            context->getProcAddress(QLatin1String("glUniform3fvARB"));
    }

    if (funcs->uniform3fv)
        funcs->uniform3fv(location, count, v);
    else
        funcs->uniform3fv = qglfResolveUniform3fv;
}

qglfResolveUniform3i()

static void qglfResolveUniform3i ( GLint  location, GLint  x, GLint  y, GLint  z  )

static

Definition at line 3365 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform3i)(GLint location, GLint x, GLint y, GLint z);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform3i = (type_glUniform3i)
        context->getProcAddress(QLatin1String("glUniform3i"));
    if (!funcs->uniform3i) {
        funcs->uniform3i = (type_glUniform3i)
            context->getProcAddress(QLatin1String("glUniform3iARB"));
    }

    if (funcs->uniform3i)
        funcs->uniform3i(location, x, y, z);
    else
        funcs->uniform3i = qglfResolveUniform3i;
}

qglfResolveUniform3iv()

static void qglfResolveUniform3iv ( GLint  location, GLsizei  count, const GLint *  v  )

static

Definition at line 3385 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform3iv)(GLint location, GLsizei count, const GLint* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform3iv = (type_glUniform3iv)
        context->getProcAddress(QLatin1String("glUniform3iv"));
    if (!funcs->uniform3iv) {
        funcs->uniform3iv = (type_glUniform3iv)
            context->getProcAddress(QLatin1String("glUniform3ivARB"));
    }

    if (funcs->uniform3iv)
        funcs->uniform3iv(location, count, v);
    else
        funcs->uniform3iv = qglfResolveUniform3iv;
}

qglfResolveUniform4f()

static void qglfResolveUniform4f ( GLint  location, GLfloat  x, GLfloat  y, GLfloat  z, GLfloat  w  )

static

Definition at line 3405 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform4f = (type_glUniform4f)
        context->getProcAddress(QLatin1String("glUniform4f"));
    if (!funcs->uniform4f) {
        funcs->uniform4f = (type_glUniform4f)
            context->getProcAddress(QLatin1String("glUniform4fARB"));
    }

    if (funcs->uniform4f)
        funcs->uniform4f(location, x, y, z, w);
    else
        funcs->uniform4f = qglfResolveUniform4f;
}

qglfResolveUniform4fv()

static void qglfResolveUniform4fv ( GLint  location, GLsizei  count, const GLfloat *  v  )

static

Definition at line 3425 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform4fv)(GLint location, GLsizei count, const GLfloat* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform4fv = (type_glUniform4fv)
        context->getProcAddress(QLatin1String("glUniform4fv"));
    if (!funcs->uniform4fv) {
        funcs->uniform4fv = (type_glUniform4fv)
            context->getProcAddress(QLatin1String("glUniform4fvARB"));
    }

    if (funcs->uniform4fv)
        funcs->uniform4fv(location, count, v);
    else
        funcs->uniform4fv = qglfResolveUniform4fv;
}

qglfResolveUniform4i()

static void qglfResolveUniform4i ( GLint  location, GLint  x, GLint  y, GLint  z, GLint  w  )

static

Definition at line 3445 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform4i = (type_glUniform4i)
        context->getProcAddress(QLatin1String("glUniform4i"));
    if (!funcs->uniform4i) {
        funcs->uniform4i = (type_glUniform4i)
            context->getProcAddress(QLatin1String("glUniform4iARB"));
    }

    if (funcs->uniform4i)
        funcs->uniform4i(location, x, y, z, w);
    else
        funcs->uniform4i = qglfResolveUniform4i;
}

qglfResolveUniform4iv()

static void qglfResolveUniform4iv ( GLint  location, GLsizei  count, const GLint *  v  )

static

Definition at line 3465 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniform4iv)(GLint location, GLsizei count, const GLint* v);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniform4iv = (type_glUniform4iv)
        context->getProcAddress(QLatin1String("glUniform4iv"));
    if (!funcs->uniform4iv) {
        funcs->uniform4iv = (type_glUniform4iv)
            context->getProcAddress(QLatin1String("glUniform4ivARB"));
    }

    if (funcs->uniform4iv)
        funcs->uniform4iv(location, count, v);
    else
        funcs->uniform4iv = qglfResolveUniform4iv;
}

qglfResolveUniformMatrix2fv()

static void qglfResolveUniformMatrix2fv ( GLint  location, GLsizei  count, GLboolean  transpose, const GLfloat *  value  )

static

Definition at line 3485 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniformMatrix2fv = (type_glUniformMatrix2fv)
        context->getProcAddress(QLatin1String("glUniformMatrix2fv"));
    if (!funcs->uniformMatrix2fv) {
        funcs->uniformMatrix2fv = (type_glUniformMatrix2fv)
            context->getProcAddress(QLatin1String("glUniformMatrix2fvARB"));
    }

    if (funcs->uniformMatrix2fv)
        funcs->uniformMatrix2fv(location, count, transpose, value);
    else
        funcs->uniformMatrix2fv = qglfResolveUniformMatrix2fv;
}

qglfResolveUniformMatrix3fv()

static void qglfResolveUniformMatrix3fv ( GLint  location, GLsizei  count, GLboolean  transpose, const GLfloat *  value  )

static

Definition at line 3505 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniformMatrix3fv = (type_glUniformMatrix3fv)
        context->getProcAddress(QLatin1String("glUniformMatrix3fv"));
    if (!funcs->uniformMatrix3fv) {
        funcs->uniformMatrix3fv = (type_glUniformMatrix3fv)
            context->getProcAddress(QLatin1String("glUniformMatrix3fvARB"));
    }

    if (funcs->uniformMatrix3fv)
        funcs->uniformMatrix3fv(location, count, transpose, value);
    else
        funcs->uniformMatrix3fv = qglfResolveUniformMatrix3fv;
}

qglfResolveUniformMatrix4fv()

static void qglfResolveUniformMatrix4fv ( GLint  location, GLsizei  count, GLboolean  transpose, const GLfloat *  value  )

static

Definition at line 3525 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->uniformMatrix4fv = (type_glUniformMatrix4fv)
        context->getProcAddress(QLatin1String("glUniformMatrix4fv"));
    if (!funcs->uniformMatrix4fv) {
        funcs->uniformMatrix4fv = (type_glUniformMatrix4fv)
            context->getProcAddress(QLatin1String("glUniformMatrix4fvARB"));
    }

    if (funcs->uniformMatrix4fv)
        funcs->uniformMatrix4fv(location, count, transpose, value);
    else
        funcs->uniformMatrix4fv = qglfResolveUniformMatrix4fv;
}

qglfResolveUseProgram()

static void qglfResolveUseProgram ( GLuint  program )

static

Definition at line 3545 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glUseProgram)(GLuint program);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->useProgram = (type_glUseProgram)
        context->getProcAddress(QLatin1String("glUseProgram"));
    if (!funcs->useProgram) {
        funcs->useProgram = (type_glUseProgram)
            context->getProcAddress(QLatin1String("glUseProgramObjectARB"));
    }

    if (funcs->useProgram)
        funcs->useProgram(program);
    else
        funcs->useProgram = qglfResolveUseProgram;
}

qglfResolveValidateProgram()

static void qglfResolveValidateProgram ( GLuint  program )

static

Definition at line 3565 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glValidateProgram)(GLuint program);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->validateProgram = (type_glValidateProgram)
        context->getProcAddress(QLatin1String("glValidateProgram"));
    if (!funcs->validateProgram) {
        funcs->validateProgram = (type_glValidateProgram)
            context->getProcAddress(QLatin1String("glValidateProgramARB"));
    }

    if (funcs->validateProgram)
        funcs->validateProgram(program);
    else
        funcs->validateProgram = qglfResolveValidateProgram;
}

qglfResolveVertexAttrib1f()

static void qglfResolveVertexAttrib1f ( GLuint  indx, GLfloat  x  )

static

Definition at line 3585 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib1f)(GLuint indx, GLfloat x);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib1f = (type_glVertexAttrib1f)
        context->getProcAddress(QLatin1String("glVertexAttrib1f"));
    if (!funcs->vertexAttrib1f) {
        funcs->vertexAttrib1f = (type_glVertexAttrib1f)
            context->getProcAddress(QLatin1String("glVertexAttrib1fARB"));
    }

    if (funcs->vertexAttrib1f)
        funcs->vertexAttrib1f(indx, x);
    else
        funcs->vertexAttrib1f = qglfResolveVertexAttrib1f;
}

qglfResolveVertexAttrib1fv()

static void qglfResolveVertexAttrib1fv ( GLuint  indx, const GLfloat *  values  )

static

Definition at line 3605 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib1fv)(GLuint indx, const GLfloat* values);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib1fv = (type_glVertexAttrib1fv)
        context->getProcAddress(QLatin1String("glVertexAttrib1fv"));
    if (!funcs->vertexAttrib1fv) {
        funcs->vertexAttrib1fv = (type_glVertexAttrib1fv)
            context->getProcAddress(QLatin1String("glVertexAttrib1fvARB"));
    }

    if (funcs->vertexAttrib1fv)
        funcs->vertexAttrib1fv(indx, values);
    else
        funcs->vertexAttrib1fv = qglfResolveVertexAttrib1fv;
}

qglfResolveVertexAttrib2f()

static void qglfResolveVertexAttrib2f ( GLuint  indx, GLfloat  x, GLfloat  y  )

static

Definition at line 3625 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib2f = (type_glVertexAttrib2f)
        context->getProcAddress(QLatin1String("glVertexAttrib2f"));
    if (!funcs->vertexAttrib2f) {
        funcs->vertexAttrib2f = (type_glVertexAttrib2f)
            context->getProcAddress(QLatin1String("glVertexAttrib2fARB"));
    }

    if (funcs->vertexAttrib2f)
        funcs->vertexAttrib2f(indx, x, y);
    else
        funcs->vertexAttrib2f = qglfResolveVertexAttrib2f;
}

qglfResolveVertexAttrib2fv()

static void qglfResolveVertexAttrib2fv ( GLuint  indx, const GLfloat *  values  )

static

Definition at line 3645 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib2fv)(GLuint indx, const GLfloat* values);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib2fv = (type_glVertexAttrib2fv)
        context->getProcAddress(QLatin1String("glVertexAttrib2fv"));
    if (!funcs->vertexAttrib2fv) {
        funcs->vertexAttrib2fv = (type_glVertexAttrib2fv)
            context->getProcAddress(QLatin1String("glVertexAttrib2fvARB"));
    }

    if (funcs->vertexAttrib2fv)
        funcs->vertexAttrib2fv(indx, values);
    else
        funcs->vertexAttrib2fv = qglfResolveVertexAttrib2fv;
}

qglfResolveVertexAttrib3f()

static void qglfResolveVertexAttrib3f ( GLuint  indx, GLfloat  x, GLfloat  y, GLfloat  z  )

static

Definition at line 3665 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib3f = (type_glVertexAttrib3f)
        context->getProcAddress(QLatin1String("glVertexAttrib3f"));
    if (!funcs->vertexAttrib3f) {
        funcs->vertexAttrib3f = (type_glVertexAttrib3f)
            context->getProcAddress(QLatin1String("glVertexAttrib3fARB"));
    }

    if (funcs->vertexAttrib3f)
        funcs->vertexAttrib3f(indx, x, y, z);
    else
        funcs->vertexAttrib3f = qglfResolveVertexAttrib3f;
}

qglfResolveVertexAttrib3fv()

static void qglfResolveVertexAttrib3fv ( GLuint  indx, const GLfloat *  values  )

static

Definition at line 3685 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib3fv)(GLuint indx, const GLfloat* values);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib3fv = (type_glVertexAttrib3fv)
        context->getProcAddress(QLatin1String("glVertexAttrib3fv"));
    if (!funcs->vertexAttrib3fv) {
        funcs->vertexAttrib3fv = (type_glVertexAttrib3fv)
            context->getProcAddress(QLatin1String("glVertexAttrib3fvARB"));
    }

    if (funcs->vertexAttrib3fv)
        funcs->vertexAttrib3fv(indx, values);
    else
        funcs->vertexAttrib3fv = qglfResolveVertexAttrib3fv;
}

qglfResolveVertexAttrib4f()

static void qglfResolveVertexAttrib4f ( GLuint  indx, GLfloat  x, GLfloat  y, GLfloat  z, GLfloat  w  )

static

Definition at line 3705 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib4f = (type_glVertexAttrib4f)
        context->getProcAddress(QLatin1String("glVertexAttrib4f"));
    if (!funcs->vertexAttrib4f) {
        funcs->vertexAttrib4f = (type_glVertexAttrib4f)
            context->getProcAddress(QLatin1String("glVertexAttrib4fARB"));
    }

    if (funcs->vertexAttrib4f)
        funcs->vertexAttrib4f(indx, x, y, z, w);
    else
        funcs->vertexAttrib4f = qglfResolveVertexAttrib4f;
}

qglfResolveVertexAttrib4fv()

static void qglfResolveVertexAttrib4fv ( GLuint  indx, const GLfloat *  values  )

static

Definition at line 3725 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttrib4fv)(GLuint indx, const GLfloat* values);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttrib4fv = (type_glVertexAttrib4fv)
        context->getProcAddress(QLatin1String("glVertexAttrib4fv"));
    if (!funcs->vertexAttrib4fv) {
        funcs->vertexAttrib4fv = (type_glVertexAttrib4fv)
            context->getProcAddress(QLatin1String("glVertexAttrib4fvARB"));
    }

    if (funcs->vertexAttrib4fv)
        funcs->vertexAttrib4fv(indx, values);
    else
        funcs->vertexAttrib4fv = qglfResolveVertexAttrib4fv;
}

qglfResolveVertexAttribPointer()

static void qglfResolveVertexAttribPointer ( GLuint  indx, GLint  size, GLenum  type, GLboolean  normalized, GLsizei  stride, const void *  ptr  )

static

Definition at line 3745 of file qglfunctions.cpp.

Referenced by QGLFunctionsPrivate::QGLFunctionsPrivate().

{
    typedef void (QGLF_APIENTRYP type_glVertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);

    const QGLContext *context = QGLContext::currentContext();
    QGLFunctionsPrivate *funcs = qt_gl_functions(context);

    funcs->vertexAttribPointer = (type_glVertexAttribPointer)
        context->getProcAddress(QLatin1String("glVertexAttribPointer"));
    if (!funcs->vertexAttribPointer) {
        funcs->vertexAttribPointer = (type_glVertexAttribPointer)
            context->getProcAddress(QLatin1String("glVertexAttribPointerARB"));
    }

    if (funcs->vertexAttribPointer)
        funcs->vertexAttribPointer(indx, size, type, normalized, stride, ptr);
    else
        funcs->vertexAttribPointer = qglfResolveVertexAttribPointer;
}

qglfSpecialGetShaderPrecisionFormat()

static void qglfSpecialGetShaderPrecisionFormat ( GLenum  shadertype, GLenum  precisiontype, GLint *  range, GLint *  precision  )

static

Definition at line 2614 of file qglfunctions.cpp.

{
    Q_UNUSED(shadertype);
    Q_UNUSED(precisiontype);
    range[0] = range[1] = precision[0] = 0;
}

qglfSpecialIsProgram()

static GLboolean qglfSpecialIsProgram ( GLuint  program )

static

Definition at line 2851 of file qglfunctions.cpp.

Referenced by qglfResolveIsProgram().

{
    return program != 0;
}

qglfSpecialIsShader()

static GLboolean qglfSpecialIsShader ( GLuint  shader )

static

Definition at line 2906 of file qglfunctions.cpp.

Referenced by qglfResolveIsShader().

{
    return shader != 0;
}

qglfSpecialReleaseShaderCompiler()

static void qglfSpecialReleaseShaderCompiler ( )

static

Definition at line 2951 of file qglfunctions.cpp.

{
}

qt_gl_functions()

static QGLFunctionsPrivateEx* qt_gl_functions ( const QGLContext *  context = 0 )

static

Definition at line 167 of file qglfunctions.cpp.

Referenced by QGLFunctions::initializeGLFunctions(), qglfResolveCheckFramebufferStatus(), qglfResolveCreateProgram(), qglfResolveCreateShader(), qglfResolveGetAttribLocation(), qglfResolveGetUniformLocation(), qglfResolveIsBuffer(), qglfResolveIsFramebuffer(), qglfResolveIsProgram(), qglfResolveIsRenderbuffer(), and qglfResolveIsShader().

{
    if (!context)
        context = QGLContext::currentContext();
    Q_ASSERT(context);
    QGLFunctionsPrivateEx *funcs =
        reinterpret_cast<QGLFunctionsPrivateEx *>
            (qt_gl_functions_resource()->value(context));
#if QT_VERSION < 0x040800
    if (!funcs) {
        funcs = new QGLFunctionsPrivateEx();
        qt_gl_functions_resource()->insert(context, funcs);
    }
#endif
    return funcs;
}

qt_gl_resolve_features()

static int qt_gl_resolve_features ( )

static

Definition at line 220 of file qglfunctions.cpp.

Referenced by QGLFunctions::hasOpenGLFeature(), and QGLFunctions::openGLFeatures().

{
#if defined(QT_OPENGL_ES_2)
    int features = QGLFunctions::Multitexture |
                   QGLFunctions::Shaders |
                   QGLFunctions::Buffers |
                   QGLFunctions::Framebuffers |
                   QGLFunctions::BlendColor |
                   QGLFunctions::BlendEquation |
                   QGLFunctions::BlendEquationSeparate |
                   QGLFunctions::BlendFuncSeparate |
                   QGLFunctions::BlendSubtract |
                   QGLFunctions::CompressedTextures |
                   QGLFunctions::Multisample |
                   QGLFunctions::StencilSeparate;
    QGLExtensionMatcher extensions;
    if (extensions.match("GL_OES_texture_npot"))
        features |= QGLFunctions::NPOTTextures;
    if (extensions.match("GL_IMG_texture_npot"))
        features |= QGLFunctions::NPOTTextures;
    return features;
#elif defined(QT_OPENGL_ES)
    int features = QGLFunctions::Multitexture |
                   QGLFunctions::Buffers |
                   QGLFunctions::CompressedTextures |
                   QGLFunctions::Multisample;
    QGLExtensionMatcher extensions;
    if (extensions.match("GL_OES_framebuffer_object"))
        features |= QGLFunctions::Framebuffers;
    if (extensions.match("GL_OES_blend_equation_separate"))
        features |= QGLFunctions::BlendEquationSeparate;
    if (extensions.match("GL_OES_blend_func_separate"))
        features |= QGLFunctions::BlendFuncSeparate;
    if (extensions.match("GL_OES_blend_subtract"))
        features |= QGLFunctions::BlendSubtract;
    if (extensions.match("GL_OES_texture_npot"))
        features |= QGLFunctions::NPOTTextures;
    if (extensions.match("GL_IMG_texture_npot"))
        features |= QGLFunctions::NPOTTextures;
    return features;
#else
    int features = 0;
    QGLFormat::OpenGLVersionFlags versions = QGLFormat::openGLVersionFlags();
    QGLExtensionMatcher extensions;

    // Recognize features by extension name.
    if (extensions.match("GL_ARB_multitexture"))
        features |= QGLFunctions::Multitexture;
    if (extensions.match("GL_ARB_shader_objects"))
        features |= QGLFunctions::Shaders;
    if (extensions.match("GL_EXT_framebuffer_object") ||
            extensions.match("GL_ARB_framebuffer_object"))
        features |= QGLFunctions::Framebuffers;
    if (extensions.match("GL_EXT_blend_color"))
        features |= QGLFunctions::BlendColor;
    if (extensions.match("GL_EXT_blend_equation_separate"))
        features |= QGLFunctions::BlendEquationSeparate;
    if (extensions.match("GL_EXT_blend_func_separate"))
        features |= QGLFunctions::BlendFuncSeparate;
    if (extensions.match("GL_EXT_blend_subtract"))
        features |= QGLFunctions::BlendSubtract;
    if (extensions.match("GL_ARB_texture_compression"))
        features |= QGLFunctions::CompressedTextures;
    if (extensions.match("GL_ARB_multisample"))
        features |= QGLFunctions::Multisample;
    if (extensions.match("GL_ARB_texture_non_power_of_two"))
        features |= QGLFunctions::NPOTTextures;

    // Recognize features by minimum OpenGL version.
    if (versions & QGLFormat::OpenGL_Version_1_2) {
        features |= QGLFunctions::BlendColor |
                    QGLFunctions::BlendEquation;
    }
    if (versions & QGLFormat::OpenGL_Version_1_3) {
        features |= QGLFunctions::Multitexture |
                    QGLFunctions::CompressedTextures |
                    QGLFunctions::Multisample;
    }
    if (versions & QGLFormat::OpenGL_Version_1_4)
        features |= QGLFunctions::BlendFuncSeparate;
    if (versions & QGLFormat::OpenGL_Version_1_5)
        features |= QGLFunctions::Buffers;
    if (versions & QGLFormat::OpenGL_Version_2_0) {
        features |= QGLFunctions::Shaders |
                    QGLFunctions::StencilSeparate |
                    QGLFunctions::BlendEquationSeparate |
                    QGLFunctions::NPOTTextures;
    }
    return features;
#endif
}