En esta página

QOpenGLFunctions Class

La clase QOpenGLFunctions ofrece acceso multiplataforma a la API de OpenGL ES 2.0. Más información...

Encabezado: #include <QOpenGLFunctions>
CMake: find_package(Qt6 REQUIRED COMPONENTS Gui)
target_link_libraries(mytarget PRIVATE Qt6::Gui)
qmake: QT += gui
Heredado por:

QOpenGLExtraFunctions

Tipos públicos

enum OpenGLFeature { Multitexture, Shaders, Buffers, Framebuffers, BlendColor, …, MultipleRenderTargets }
flags OpenGLFeatures

Funciones públicas

QOpenGLFunctions()
QOpenGLFunctions(QOpenGLContext*context)
~QOpenGLFunctions()
void glActiveTexture(GLenum textura)
void glAttachShader(GLuint programa, GLuint sombreador)
void glBindAttribLocation(GLuint programa, GLuint índice, const char*nombre)
void glBindBuffer(GLenum destino, GLuint búfer)
void glBindFramebuffer(GLenum destino, GLuint búfer de fotogramas)
void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
void glBindTexture(GLenum target, GLuint texture)
void glBlendColor(GLclampf rojo, GLclampf verde, GLclampf azul, GLclampf alfa)
void glBlendEquation(GLenum modo)
void glBlendEquationSeparate(GLenum modoRGB, GLenum modoAlpha)
void glBlendFunc(GLenum sfactor, GLenum dfactor)
void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
void glBufferData(GLenum target, qopengl_GLsizeiptr size, const void*data, GLenum usage)
void glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void*data)
GLenum glCheckFramebufferStatus(GLenum target)
void glClear(GLbitfield mask)
void glClearColor(GLclampf rojo, GLclampf verde, GLclampf azul, GLclampf alfa)
void glClearDepthf(GLclampf profundidad)
void glClearStencil(GLint s)
void glColorMask(GLboolean rojo, GLboolean verde, GLboolean azul, GLboolean alfa)
void glCompileShader(GLuint shader)
void glCompressedTexImage2D(GLenum destino, GLint nivel, GLenum formato interno, GLsizei ancho, GLsizei alto, GLint borde, GLsizei tamañoImagen, const void*datos)
void glCompressedTexSubImage2D(GLenum destino, GLint nivel, GLint desplazamiento x, GLint desplazamiento y, GLsizei ancho, GLsizei alto, GLenum formato, GLsizei tamañoImagen, const void*datos)
void glCopyTexImage2D(GLenum destino, GLint nivel, GLenum formato interno, GLint x, GLint y, GLsizei ancho, GLsizei alto, GLint borde)
void glCopyTexSubImage2D(GLenum destino, GLint nivel, GLint desplazamiento_x, GLint desplazamiento_y, GLint x, GLint y, GLsizei ancho, GLsizei alto)
GLuint glCreateProgram()
GLuint glCreateShader(GLenum tipo)
void glCullFace(GLenum modo)
void glDeleteBuffers(GLsizei n, const GLuint*buffers)
void glDeleteFramebuffers(GLsizei n, const GLuint*framebuffers)
void glDeleteProgram(GLuint program)
void glDeleteRenderbuffers(GLsizei n, const GLuint*renderbuffers)
void glDeleteShader(GLuint shader)
void glDeleteTextures(GLsizei n, const GLuint*texturas)
void glDepthFunc(GLenum func)
void glDepthMask(GLboolean flag)
void glDepthRangef(GLclampf zNear, GLclampf zFar)
void glDetachShader(GLuint program, GLuint shader)
void glDisable(GLenum cap)
void glDisableVertexAttribArray(GLuint índice)
void glDrawArrays(GLenum modo, GLint primero, GLsizei recuento)
void glDrawElements(GLenum modo, GLsizei recuento, GLenum tipo, const GLvoid*índices)
void glEnable(GLenum cap)
void glEnableVertexAttribArray(GLuint índice)
void glFinish()
void glFlush()
void glFramebufferRenderbuffer(GLenum destino, GLenum acoplamiento, GLenum destino del búfer de renderizado, GLuint búfer de renderizado)
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
void glFrontFace(GLenum modo)
void glGenBuffers(GLsizei n, GLuint*buffers)
void glGenFramebuffers(GLsizei n, GLuint*framebuffers)
void glGenRenderbuffers(GLsizei n, GLuint*renderbuffers)
void glGenTextures(GLsizei n, GLuint*texturas)
void glGenerateMipmap(GLenum target)
void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei*length, GLint*size, GLenum*type, char*name)
void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei*length, GLint*size, GLenum*type, char*name)
void glGetAttachedShaders(GLuint programa, GLsizei recuentoMáx, GLsizei*recuento, GLuint*shaders)
GLint glGetAttribLocation(GLuint program, const char*name)
void glGetBooleanv(GLenum pname, GLboolean*params)
void glGetBufferParameteriv(GLenum target, GLenum pname, GLint*params)
GLenum glGetError()
void glGetFloatv(GLenum pname, GLfloat*params)
void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint*params)
void glGetIntegerv(GLenum pname, GLint*params)
void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei*length, char*infolog)
void glGetProgramiv(GLuint program, GLenum pname, GLint*params)
void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint*params)
void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei*length, char*infolog)
void glGetShaderPrecisionFormat(GLenum tipo de sombreador, GLenum tipo de precisión, GLint*rango, GLint*precisión)
void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei*length, char*source)
void glGetShaderiv(GLuint shader, GLenum pname, GLint*params)
const GLubyte *glGetString(GLenum name)
void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat*params)
void glGetTexParameteriv(GLenum destino, GLenum nombre_p, GLint*parámetros)
GLint glGetUniformLocation(GLuint program, const char*name)
void glGetUniformfv(GLuint program, GLint location, GLfloat*params)
void glGetUniformiv(GLuint program, GLint location, GLint*params)
void glGetVertexAttribPointerv(GLuint índice, GLenum nombre_p, void**puntero)
void glGetVertexAttribfv(GLuint índice, GLenum pname, GLfloat*parámetros)
void glGetVertexAttribiv(GLuint índice, GLenum nombre_parámetro, GLint*parámetros)
void glHint(GLenum destino, GLenum modo)
GLboolean glIsBuffer(GLuint buffer)
GLboolean glIsEnabled(GLenum cap)
GLboolean glIsFramebuffer(GLuint framebuffer)
GLboolean glIsProgram(GLuint program)
GLboolean glIsRenderbuffer(GLuint renderbuffer)
GLboolean glIsShader(GLuint shader)
GLboolean glIsTexture(GLuint textura)
void glLineWidth(GLfloat ancho)
void glLinkProgram(GLuint programa)
void glPixelStorei(GLenum pname, GLint param)
void glPolygonOffset(GLfloat factor, GLfloat unidades)
void glReadPixels(GLint x, GLint y, GLsizei anchura, GLsizei altura, GLenum formato, GLenum tipo, GLvoid*píxeles)
void glReleaseShaderCompiler()
void glRenderbufferStorage(GLenum destino, GLenum formato interno, GLsizei ancho, GLsizei alto)
void glSampleCoverage(GLclampf value, GLboolean invert)
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
void glShaderBinary(GLint n, const GLuint*shaders, GLenum binaryformat, const void*binary, GLint length)
void glShaderSource(GLuint shader, GLsizei count, const char**string, const GLint*length)
void glStencilFunc(GLenum func, GLint ref, GLuint mask)
void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
void glStencilMask(GLuint máscara)
void glStencilMaskSeparate(GLenum cara, GLuint máscara)
void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
void glStencilOpSeparate(GLenum cara, GLenum fallo, GLenum falloZ, GLenum pasoZ)
void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid*pixels)
void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
void glTexParameterfv(GLenum destino, GLenum nombreParámetro, const GLfloat*parámetros)
void glTexParameteri(GLenum target, GLenum pname, GLint param)
void glTexParameteriv(GLenum target, GLenum pname, const GLint*params)
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid*pixels)
void glUniform1f(GLint location, GLfloat x)
void glUniform1fv(GLint ubicación, GLsizei recuento, const GLfloat*v)
void glUniform1i(GLint ubicación, GLint x)
void glUniform1iv(GLint ubicación, GLsizei recuento, const GLint*v)
void glUniform2f(GLint ubicación, GLfloat x, GLfloat y)
void glUniform2fv(GLint ubicación, GLsizei recuento, const GLfloat*v)
void glUniform2i(GLint ubicación, GLint x, GLint y)
void glUniform2iv(GLint location, GLsizei count, const GLint*v)
void glUniform3f(GLint ubicación, GLfloat x, GLfloat y, GLfloat z)
void glUniform3fv(GLint ubicación, GLsizei recuento, const GLfloat*v)
void glUniform3i(GLint ubicación, GLint x, GLint y, GLint z)
void glUniform3iv(GLint ubicación, GLsizei recuento, const GLint*v)
void glUniform4f(GLint ubicación, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glUniform4fv(GLint ubicación, GLsizei recuento, const GLfloat*v)
void glUniform4i(GLint ubicación, GLint x, GLint y, GLint z, GLint w)
void glUniform4iv(GLint location, GLsizei count, const GLint*v)
void glUniformMatrix2fv(GLint ubicación, GLsizei recuento, GLboolean transposición, const GLfloat*valor)
void glUniformMatrix3fv(GLint ubicación, GLsizei recuento, GLboolean transposición, const GLfloat*valor)
void glUniformMatrix4fv(GLint ubicación, GLsizei recuento, GLboolean transposición, const GLfloat*valor)
void glUseProgram(GLuint program)
void glValidateProgram(GLuint program)
void glVertexAttrib1f(GLuint indx, GLfloat x)
void glVertexAttrib1fv(GLuint indx, const GLfloat*values)
void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
void glVertexAttrib2fv(GLuint indx, const GLfloat*values)
void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
void glVertexAttrib3fv(GLuint indx, const GLfloat*values)
void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void glVertexAttrib4fv(GLuint indx, const GLfloat*values)
void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void*ptr)
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
bool hasOpenGLFeature(QOpenGLFunctions::OpenGLFeature feature) const
void initializeOpenGLFunctions()
QOpenGLFunctions::OpenGLFeatures openGLFeatures() const

Descripción detallada

OpenGL ES 2.0 define un subconjunto de la especificación OpenGL que es común a muchas implementaciones de OpenGL, tanto de escritorio como integradas. Sin embargo, puede resultar complicado utilizar las funciones de ese subconjunto, ya que deben resolverse manualmente en los sistemas de escritorio.

QOpenGLFunctions proporciona una API garantizada que está disponible en todos los sistemas OpenGL y se encarga de la resolución de funciones en los sistemas que lo necesitan. La forma recomendada de utilizar QOpenGLFunctions es mediante herencia directa:

class MyGLWindow : public QWindow, protected QOpenGLFunctions
{
    Q_OBJECT
public:
    explicit MyGLWindow(QScreen *screen = nullptr);

protected:
    void initializeGL();
    void paintGL();

    QOpenGLContext *m_context;
};

MyGLWindow::MyGLWindow(QScreen *screen)
  : QWindow(screen)
{
    setSurfaceType(OpenGLSurface);
    create();

    // Create an OpenGL context
    m_context = new QOpenGLContext;
    m_context->create();

    // Setup scene and render it
    initializeGL();
    paintGL();
};

void MyGLWindow::initializeGL()
{
    m_context->makeCurrent(this);
    initializeOpenGLFunctions();
}

La función ` paintGL() ` puede entonces utilizar cualquiera de las funciones de OpenGL ES 2.0 sin necesidad de resolución explícita, como ` glActiveTexture()` en el siguiente ejemplo:

void MyGLWindow::paintGL()
{
    m_context->makeCurrent(this);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, textureId);
    // ...
    m_context->swapBuffers(this);
    m_context->doneCurrent();
}

QOpenGLFunctions también se puede utilizar directamente para la invocación ad hoc de funciones de OpenGL ES 2.0 en todas las plataformas:

QOpenGLFunctions glFuncs(QOpenGLContext::currentContext());
glFuncs.glActiveTexture(GL_TEXTURE1);

Un enfoque alternativo consiste en consultar la instancia de `QOpenGLFunctions` asociada al contexto. Esto resulta algo más rápido que el enfoque anterior, ya que evita la creación de una nueva instancia; sin embargo, la diferencia es bastante pequeña, dado que las estructuras de datos internas se comparten y la resolución de funciones solo se produce una vez para un contexto determinado, independientemente del número de instancias de `QOpenGLFunctions` inicializadas para él.

QOpenGLFunctions *glFuncs = QOpenGLContext::currentContext()->functions();
glFuncs->glActiveTexture(GL_TEXTURE1);

QOpenGLFunctions proporciona envoltorios para todas las funciones de OpenGL ES 2.0, incluido el subconjunto común de OpenGL 1.x y ES 2.0. Aunque dichas funciones, por ejemplo ` glClear()` o ` glDrawArrays()`, también pueden invocarse directamente —siempre que la aplicación esté enlazada con la biblioteca OpenGL específica de la plataforma—, invocarlas a través de `QOpenGLFunctions` permite cargar dinámicamente la implementación de OpenGL.

Las funciones hasOpenGLFeature() y openGLFeatures() pueden utilizarse para determinar si la implementación de OpenGL cuenta con una característica importante de OpenGL ES 2.0. Por ejemplo, el siguiente código comprueba si hay disponibles texturas que no sean potencias de dos:

QOpenGLFunctions funcs(QOpenGLContext::currentContext());
bool npot = funcs.hasOpenGLFeature(QOpenGLFunctions::NPOTTextures);

Consideraciones de seguridad

QOpenGLFunctions es una capa de despacho ligera que expone la API de OpenGL ES 2.0 tal cual. Los argumentos se reenvían tal cual a la implementación subyacente de OpenGL, que es una dependencia de la plataforma de confianza y dentro del mismo proceso. Qt no inspecciona, valida ni depura las enumeraciones, los tamaños, los desplazamientos ni los punteros que se le pasan, y no actúa sobre los resultados devueltos. Por lo tanto, llamar a una función miembro aquí equivale a llamar directamente a la función OpenGL correspondiente, y se aplican sin modificaciones las reglas de las especificaciones de OpenGL y OpenGL ES. Incumplirlas da lugar a un comportamiento indefinido en la implementación de Qt OpenGL, no a un fallo controlado por parte de Qt.

Tenga en cuenta, en particular, que las funciones que aceptan un puntero del lado del cliente junto con un tamaño o una descripción de formato, como glTexImage2D(), glBufferData(), glDrawElements() y glReadPixels(), hacen que esa memoria se lea o se escriba según lo indicado por los demás argumentos. Por lo tanto, los tamaños que no coinciden con el búfer realmente proporcionado constituyen un acceso fuera de límites en el propio espacio de direcciones de la aplicación, y no solo un error por parte del controlador.

Advertencia: Se espera quetodos los datos pasados a través de QOpenGLFunctions sean de confianza. Se recomienda a los desarrolladores de aplicaciones que consideren cuidadosamente las posibles implicaciones antes de derivar cualquier dato del contenido proporcionado por el usuario que no forme parte de la aplicación y no esté bajo el control de los desarrolladores. Consulte QOpenGLContext para obtener más información.

Véase también QOpenGLContext y QSurfaceFormat.

Documentación sobre tipos de miembros

enum QOpenGLFunctions::OpenGLFeature
flags QOpenGLFunctions::OpenGLFeatures

Esta enumeración define las características de OpenGL y OpenGL ES cuya presencia puede depender de la implementación.

ConstanteValorDescripción
QOpenGLFunctions::Multitexture0x0001glActiveTextureLa función () está disponible.
QOpenGLFunctions::Shaders0x0002Las funciones de shader están disponibles.
QOpenGLFunctions::Buffers0x0004Hay disponibles funciones de búfer de vértices y de índices.
QOpenGLFunctions::Framebuffers0x0008Hay disponibles funciones para objetos de framebuffer.
QOpenGLFunctions::BlendColor0x0010glBlendColor() está disponible.
QOpenGLFunctions::BlendEquation0x0020glBlendEquation() está disponible.
QOpenGLFunctions::BlendEquationSeparate0x0040glBlendEquationSeparate() está disponible.
QOpenGLFunctions::BlendEquationAdvanced0x20000Hay disponibles ecuaciones de mezcla avanzadas.
QOpenGLFunctions::BlendFuncSeparate0x0080glBlendFuncSeparate() está disponible.
QOpenGLFunctions::BlendSubtract0x0100El modo de sustracción de mezcla está disponible.
QOpenGLFunctions::CompressedTextures0x0200Hay disponibles funciones de texturas comprimidas.
QOpenGLFunctions::Multisample0x0400glSampleCoverageLa función () está disponible.
QOpenGLFunctions::StencilSeparate0x0800Hay disponibles funciones de plantilla independientes.
QOpenGLFunctions::NPOTTextures0x1000Hay disponibles texturas que no son potencias de dos.
QOpenGLFunctions::NPOTTextureRepeat0x2000Las texturas que no son potencias de dos pueden utilizar GL_REPEAT como parámetro de envoltura.
QOpenGLFunctions::FixedFunctionPipeline0x4000Está disponible el canal de funciones fijas.
QOpenGLFunctions::TextureRGFormats0x8000Están disponibles los formatos de textura GL_RED y GL_RG.
QOpenGLFunctions::MultipleRenderTargets0x10000Hay disponibles múltiples anexos de color para objetos framebuffer.

El tipo OpenGLFeatures es un typedef para QFlags<OpenGLFeature>. Almacena una combinación OR de valores de OpenGLFeature.

Documentación de las funciones miembro

QOpenGLFunctions::QOpenGLFunctions()

Crea un resolutor de funciones por defecto. El resolutor no se puede utilizar hasta que se llame a ` initializeOpenGLFunctions()` para especificar el contexto.

Véase también ` initializeOpenGLFunctions()`.

[explicit] QOpenGLFunctions::QOpenGLFunctions(QOpenGLContext *context)

Crea un resolutor de funciones para context. Si context es nullptr, el resolutor se creará para la página actual QOpenGLContext.

El contexto o cualquier otro contexto del grupo debe ser el actual.

Un objeto creado de esta forma solo se puede utilizar con context y otros contextos que lo compartan. Utiliza initializeOpenGLFunctions() para cambiar la asociación de contexto del objeto.

Véase también initializeOpenGLFunctions().

[noexcept] QOpenGLFunctions::~QOpenGLFunctions()

Elimina este resolutor de funciones.

void QOpenGLFunctions::glActiveTexture(GLenum texture)

Función de conveniencia que llama a glActiveTexture(texture).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glActiveTexture().

void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)

Función de conveniencia que llama a glAttachShader(program, shader).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glAttachShader().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char *name)

Función de conveniencia que llama a glBindAttribLocation(program, index, name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBindAttribLocation().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glBindBuffer(GLenum target, GLuint buffer)

Función de conveniencia que llama a glBindBuffer(target, buffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBindBuffer().

void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffer)

Función de conveniencia que llama a glBindFramebuffer(target, framebuffer).

Ten en cuenta que Qt traducirá un argumento framebuffer con valor 0 al defaultFramebufferObject() del QOpenGLContext vinculado actualmente.

Para obtener más información, consulte la documentación de OpenGL ES 3.X sobre glBindFramebuffer().

void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)

Función de conveniencia que llama a glBindRenderbuffer(target, renderbuffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBindRenderbuffer().

void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)

Función de conveniencia que llama a glBindTexture(target, texture).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBindTexture().

void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

Función de conveniencia que llama a glBlendColor(red, green, blue, alpha).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBlendColor().

void QOpenGLFunctions::glBlendEquation(GLenum mode)

Función de conveniencia que llama a glBlendEquation(mode).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBlendEquation().

void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)

Función de conveniencia que llama a glBlendEquationSeparate(modeRGB, modeAlpha).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBlendEquationSeparate().

void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)

Función de conveniencia que llama a glBlendFunc(sfactor, dfactor).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBlendFunc().

void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)

Función de conveniencia que llama a glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBlendFuncSeparate().

void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void *data, GLenum usage)

Función de conveniencia que llama a glBufferData(target, size, data, usage).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBufferData().

void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void *data)

Función de conveniencia que llama a glBufferSubData(target, offset, size, data).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glBufferSubData().

GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)

Función de conveniencia que llama a glCheckFramebufferStatus(target).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCheckFramebufferStatus().

void QOpenGLFunctions::glClear(GLbitfield mask)

Función de conveniencia que llama a glClear(mask).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glClear().

void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

Función de conveniencia que llama a glClearColor(red, green, blue, alpha).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glClearColor().

void QOpenGLFunctions::glClearDepthf(GLclampf depth)

Función de conveniencia que llama a glClearDepth(depth) en sistemas OpenGL de escritorio y a glClearDepthf(depth) en sistemas OpenGL ES integrados.

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glClearDepthf().

void QOpenGLFunctions::glClearStencil(GLint s)

Función de conveniencia que llama a glClearStencil(s).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glClearStencil().

void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)

Función de conveniencia que llama a glColorMask(red, green, blue, alpha).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glColorMask().

void QOpenGLFunctions::glCompileShader(GLuint shader)

Función de conveniencia que llama a glCompileShader(shader).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCompileShader().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)

Función de conveniencia que llama a glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCompressedTexImage2D().

void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)

Función de conveniencia que llama a glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCompressedTexSubImage2D().

void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)

Función de conveniencia que llama a glCopyTexImage2D(target, level, internalformat, x, y, width, height, border).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCopyTexImage2D().

void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)

Función de conveniencia que llama a glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCopyTexSubImage2D().

GLuint QOpenGLFunctions::glCreateProgram()

Función de conveniencia que llama a glCreateProgram().

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCreateProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

GLuint QOpenGLFunctions::glCreateShader(GLenum type)

Función de conveniencia que llama a glCreateShader(type).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCreateShader().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glCullFace(GLenum mode)

Función de conveniencia que llama a glCullFace(mode).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glCullFace().

void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint *buffers)

Función de conveniencia que llama a glDeleteBuffers(n, buffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteBuffers().

void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)

Función de conveniencia que llama a glDeleteFramebuffers(n, framebuffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteFramebuffers().

void QOpenGLFunctions::glDeleteProgram(GLuint program)

Función de conveniencia que llama a glDeleteProgram(program).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)

Función de conveniencia que llama a glDeleteRenderbuffers(n, renderbuffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteRenderbuffers().

void QOpenGLFunctions::glDeleteShader(GLuint shader)

Función de conveniencia que llama a glDeleteShader(shader).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteShader().

Esta función de conveniencia no realizará ninguna acción en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint *textures)

Función de conveniencia que llama a `glDeleteTextures(n, textures)`.

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDeleteTextures().

void QOpenGLFunctions::glDepthFunc(GLenum func)

Función de conveniencia que llama a glDepthFunc(func).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDepthFunc().

void QOpenGLFunctions::glDepthMask(GLboolean flag)

Función de conveniencia que llama a glDepthMask(flag).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDepthMask().

void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)

Función de conveniencia que llama a glDepthRange(zNear, zFar) en sistemas OpenGL de escritorio y a glDepthRangef(zNear, zFar) en sistemas OpenGL ES integrados.

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDepthRangef().

void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)

Función de conveniencia que llama a glDetachShader(program, shader).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDetachShader().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glDisable(GLenum cap)

Función de conveniencia que llama a glDisable(cap).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDisable().

void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)

Función de conveniencia que llama a glDisableVertexAttribArray(index).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDisableVertexAttribArray().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei count)

Función de conveniencia que llama a glDrawArrays(mode, first, count).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDrawArrays().

void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

Función de conveniencia que llama a glDrawElements(mode, count, type, indices).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glDrawElements().

void QOpenGLFunctions::glEnable(GLenum cap)

Función de conveniencia que llama a glEnable(cap).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glEnable().

void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)

Función de conveniencia que llama a glEnableVertexAttribArray(index).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glEnableVertexAttribArray().

Esta función de conveniencia no tendrá ningún efecto en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glFinish()

Función de conveniencia que llama a glFinish().

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glFinish().

void QOpenGLFunctions::glFlush()

Función de conveniencia que llama a glFlush().

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glFlush().

void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)

Función de conveniencia que llama a glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glFramebufferRenderbuffer().

void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)

Función de conveniencia que llama a glFramebufferTexture2D(target, attachment, textarget, texture, level).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glFramebufferTexture2D().

void QOpenGLFunctions::glFrontFace(GLenum mode)

Función de conveniencia que llama a glFrontFace(mode).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glFrontFace().

void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint *buffers)

Función de conveniencia que llama a glGenBuffers(n, buffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGenBuffers().

void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint *framebuffers)

Función de conveniencia que llama a glGenFramebuffers(n, framebuffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGenFramebuffers().

void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)

Función de conveniencia que llama a glGenRenderbuffers(n, renderbuffers).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGenRenderbuffers().

void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint *textures)

Función de conveniencia que llama a glGenTextures(n, textures).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGenTextures().

void QOpenGLFunctions::glGenerateMipmap(GLenum target)

Función de conveniencia que llama a glGenerateMipmap(target).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGenerateMipmap().

void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name)

Función de conveniencia que llama a glGetActiveAttrib(program, index, bufsize, length, size, type, name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetActiveAttrib().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name)

Función de conveniencia que llama a glGetActiveUniform(program, index, bufsize, length, size, type, name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetActiveUniform().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count, GLuint *shaders)

Función de conveniencia que llama a glGetAttachedShaders(program, maxcount, count, shaders).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetAttachedShaders().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char *name)

Función de conveniencia que llama a glGetAttribLocation(program, name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetAttribLocation().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean *params)

Función de conveniencia que llama a glGetBooleanv(pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetBooleanv().

void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetBufferParameteriv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetBufferParameteriv().

GLenum QOpenGLFunctions::glGetError()

Función de conveniencia que llama a glGetError().

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetError().

void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat *params)

Función de conveniencia que llama a glGetFloatv(pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetFloatv().

void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetFramebufferAttachmentParameteriv(target, attachment, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetFramebufferAttachmentParameteriv().

void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint *params)

Función de conveniencia que llama a glGetIntegerv(pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetIntegerv().

void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length, char *infolog)

Función de conveniencia que llama a glGetProgramInfoLog(program, bufsize, length, infolog).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetProgramInfoLog().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetProgramiv(program, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetProgramiv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetRenderbufferParameteriv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetRenderbufferParameteriv().

void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, char *infolog)

Función de conveniencia que llama a glGetShaderInfoLog(shader, bufsize, length, infolog).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetShaderInfoLog().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)

Función de conveniencia que llama a glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetShaderPrecisionFormat().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, char *source)

Función de conveniencia que llama a glGetShaderSource(shader, bufsize, length, source).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetShaderSource().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetShaderiv(shader, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetShaderiv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

const GLubyte *QOpenGLFunctions::glGetString(GLenum name)

Función de conveniencia que llama a glGetString(name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetString().

void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)

Función de conveniencia que llama a glGetTexParameterfv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetTexParameterfv().

void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetTexParameteriv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetTexParameteriv().

GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char *name)

Función de conveniencia que llama a glGetUniformLocation(program, name).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetUniformLocation().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat *params)

Función de conveniencia que llama a glGetUniformfv(program, location, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetUniformfv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint *params)

Función de conveniencia que llama a glGetUniformiv(program, location, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetUniformiv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)

Función de conveniencia que llama a glGetVertexAttribPointerv(index, pname, pointer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetVertexAttribPointerv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)

Función de conveniencia que llama a glGetVertexAttribfv(index, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetVertexAttribfv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)

Función de conveniencia que llama a glGetVertexAttribiv(index, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glGetVertexAttribiv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glHint(GLenum target, GLenum mode)

Función de conveniencia que llama a glHint(target, mode).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glHint().

GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)

Función de conveniencia que llama a glIsBuffer(buffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsBuffer().

GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)

Función de conveniencia que llama a glIsEnabled(cap).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsEnabled().

GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)

Función de conveniencia que llama a glIsFramebuffer(framebuffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsFramebuffer().

GLboolean QOpenGLFunctions::glIsProgram(GLuint program)

Función de conveniencia que llama a glIsProgram(program).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)

Función de conveniencia que llama a glIsRenderbuffer(renderbuffer).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsRenderbuffer().

GLboolean QOpenGLFunctions::glIsShader(GLuint shader)

Función de conveniencia que llama a glIsShader(shader).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsShader().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)

Función de conveniencia que llama a glIsTexture(texture).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glIsTexture().

void QOpenGLFunctions::glLineWidth(GLfloat width)

Función de conveniencia que llama a glLineWidth(width).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glLineWidth().

void QOpenGLFunctions::glLinkProgram(GLuint program)

Función de conveniencia que llama a glLinkProgram(program).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glLinkProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)

Función de conveniencia que llama a glPixelStorei(pname, param).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glPixelStorei().

void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)

Función de conveniencia que llama a glPolygonOffset(factor, units).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glPolygonOffset().

void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)

Función de conveniencia que llama a glReadPixels(x, y, width, height, format, type, pixels).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glReadPixels().

void QOpenGLFunctions::glReleaseShaderCompiler()

Función de conveniencia que llama a glReleaseShaderCompiler().

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glReleaseShaderCompiler().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)

Función de conveniencia que llama a glRenderbufferStorage(target, internalformat, width, height).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glRenderbufferStorage().

void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)

Función de conveniencia que llama a glSampleCoverage(value, invert).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glSampleCoverage().

void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)

Función de conveniencia que llama a glScissor(x, y, width, height).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glScissor().

void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint *shaders, GLenum binaryformat, const void *binary, GLint length)

Función de conveniencia que llama a glShaderBinary(n, shaders, binaryformat, binary, length).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glShaderBinary().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char **string, const GLint *length)

Función de conveniencia que llama a glShaderSource(shader, count, string, length).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glShaderSource().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)

Función de conveniencia que llama a glStencilFunc(func, ref, mask).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilFunc().

void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)

Función de conveniencia que llama a glStencilFuncSeparate(face, func, ref, mask).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilFuncSeparate().

void QOpenGLFunctions::glStencilMask(GLuint mask)

Función de conveniencia que llama a glStencilMask(mask).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilMask().

void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)

Función de conveniencia que llama a glStencilMaskSeparate(face, mask).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilMaskSeparate().

void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)

Función de conveniencia que llama a glStencilOp(fail, zfail, zpass).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilOp().

void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)

Función de conveniencia que llama a glStencilOpSeparate(face, fail, zfail, zpass).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glStencilOpSeparate().

void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)

Función de conveniencia que llama a glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexImage2D().

void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLfloat param)

Función de conveniencia que llama a glTexParameterf(target, pname, param).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexParameterf().

void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)

Función de conveniencia que llama a glTexParameterfv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexParameterfv().

void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint param)

Función de conveniencia que llama a glTexParameteri(target, pname, param).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexParameteri().

void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)

Función de conveniencia que llama a glTexParameteriv(target, pname, params).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexParameteriv().

void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)

Función de conveniencia que invoca a glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glTexSubImage2D().

void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)

Función de conveniencia que llama a glUniform1f(location, x).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform1f().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat *v)

Función de conveniencia que llama a glUniform1fv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform1fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform1i(GLint location, GLint x)

Función de conveniencia que llama a glUniform1i(location, x).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform1i().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint *v)

Función de conveniencia que llama a glUniform1iv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform1iv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)

Función de conveniencia que llama a glUniform2f(location, x, y).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform2f().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat *v)

Función de conveniencia que llama a glUniform2fv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform2fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)

Función de conveniencia que llama a glUniform2i(location, x, y).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform2i().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint *v)

Función de conveniencia que llama a glUniform2iv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform2iv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)

Función de conveniencia que llama a glUniform3f(location, x, y, z).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform3f().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat *v)

Función de conveniencia que llama a glUniform3fv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform3fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)

Función de conveniencia que llama a glUniform3i(location, x, y, z).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform3i().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint *v)

Función de conveniencia que llama a glUniform3iv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform3iv().

Esta función de conveniencia no tendrá ningún efecto en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Función de conveniencia que invoca a glUniform4f(location, x, y, z, w).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform4f().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat *v)

Función de conveniencia que llama a glUniform4fv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform4fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)

Función de conveniencia que llama a glUniform4i(location, x, y, z, w).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform4i().

Esta función de conveniencia no tendrá ningún efecto en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint *v)

Función de conveniencia que llama a glUniform4iv(location, count, v).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniform4iv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

Función de conveniencia que llama a glUniformMatrix2fv(location, count, transpose, value).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniformMatrix2fv().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

Función de conveniencia que llama a glUniformMatrix3fv(location, count, transpose, value).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniformMatrix3fv().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)

Función de conveniencia que llama a glUniformMatrix4fv(location, count, transpose, value).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUniformMatrix4fv().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glUseProgram(GLuint program)

Función de conveniencia que llama a glUseProgram(program).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glUseProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glValidateProgram(GLuint program)

Función de conveniencia que llama a glValidateProgram(program).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glValidateProgram().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)

Función de conveniencia que llama a glVertexAttrib1f(indx, x).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib1f().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat *values)

Función de conveniencia que llama a glVertexAttrib1fv(indx, values).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib1fv().

Esta función de conveniencia no realizará ninguna acción en sistemas con OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)

Función de conveniencia que llama a glVertexAttrib2f(indx, x, y).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib2f().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat *values)

Función de conveniencia que llama a glVertexAttrib2fv(indx, values).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib2fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)

Función de conveniencia que llama a glVertexAttrib3f(indx, x, y, z).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib3f().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat *values)

Función de conveniencia que llama a glVertexAttrib3fv(indx, values).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib3fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Función de conveniencia que llama a glVertexAttrib4f(indx, x, y, z, w).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib4f().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat *values)

Función de conveniencia que llama a glVertexAttrib4fv(indx, values).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttrib4fv().

Esta función de conveniencia no realizará ninguna acción en sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *ptr)

Función de conveniencia que llama a glVertexAttribPointer(indx, size, type, normalized, stride, ptr).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glVertexAttribPointer().

Esta función de conveniencia no tendrá ningún efecto en los sistemas OpenGL ES 1.x.

void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)

Función de conveniencia que llama a glViewport(x, y, width, height).

Para obtener más información, consulta la documentación de OpenGL ES 3.X sobre glViewport().

bool QOpenGLFunctions::hasOpenGLFeature(QOpenGLFunctions::OpenGLFeature feature) const

Devuelve ` true ` si ` feature ` está presente en la implementación de OpenGL de este sistema; en caso contrario, devuelve `false`.

Se da por supuesto que el QOpenGLContext asociado a este resolutor de funciones está actualizado.

Véase también openGLFeatures().

void QOpenGLFunctions::initializeOpenGLFunctions()

Inicializa la resolución de funciones de OpenGL para el contexto actual.

Tras llamar a esta función, el objeto ` QOpenGLFunctions ` solo se puede utilizar con el contexto actual y con otros contextos que lo compartan. Vuelve a llamar a `initializeOpenGLFunctions()` para cambiar la asociación del objeto con el contexto.

QOpenGLFunctions::OpenGLFeatures QOpenGLFunctions::openGLFeatures() const

Devuelve el conjunto de características disponibles en la implementación de OpenGL de este sistema.

Se da por supuesto que la función « QOpenGLContext » asociada a este resolutor de funciones está actualizada.

Véase también hasOpenGLFeature().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.