En esta página

QOpenGLShaderProgram Class

La clase QOpenGLShaderProgram permite vincular y utilizar programas de sombreado de OpenGL. Más información...

Encabezado: #include <QOpenGLShaderProgram>
CMake: find_package(Qt6 REQUIRED COMPONENTS OpenGL)
target_link_libraries(mytarget PRIVATE Qt6::OpenGL)
qmake: QT += opengl
Heredado de: QObject

Funciones públicas

QOpenGLShaderProgram(QObject*parent = nullptr)
virtual ~QOpenGLShaderProgram()
bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const char*fuente)
bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const QByteArray&fuente)
bool addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const QString&fuente)
bool addCacheableShaderFromSourceFile(QOpenGLShader::ShaderType tipo, const QString&nombre_archivo)
bool addShader(QOpenGLShader*shader)
bool addShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const char*fuente)
bool addShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const QByteArray&fuente)
bool addShaderFromSourceCode(QOpenGLShader::ShaderType tipo, const QString&fuente)
bool addShaderFromSourceFile(QOpenGLShader::ShaderType tipo, const QString&nombreArchivo)
int attributeLocation(const char*name) const
int attributeLocation(const QByteArray&name) const
int attributeLocation(const QString&nombre) const
bool bind()
void bindAttributeLocation(const char*nombre, int ubicación)
void bindAttributeLocation(const QByteArray&nombre, int posición)
void bindAttributeLocation(const QString&nombre, int posición)
bool create()
QList<float> defaultInnerTessellationLevels() const
QList<float> defaultOuterTessellationLevels() const
void disableAttributeArray(int ubicación)
void disableAttributeArray(const char*nombre)
void enableAttributeArray(int ubicación)
void enableAttributeArray(const char*nombre)
bool isLinked() const
virtual bool link()
QString log() const
int maxGeometryOutputVertices() const
int patchVertexCount() const
GLuint programId() const
void release()
void removeAllShaders()
void removeShader(QOpenGLShader*shader)
void setAttributeArray(int ubicación, const QVector2D*valores, int paso = 0)
void setAttributeArray(int ubicación, const QVector3D*valores, int paso = 0)
void setAttributeArray(int ubicación, const QVector4D*valores, int paso = 0)
void setAttributeArray(int ubicación, const GLfloat*valores, int tamañoDeTupla, int paso = 0)
void setAttributeArray(int ubicación, GLenum tipo, const void*valores, int tamañoDeTupla, int paso = 0)
void setAttributeArray(const char*nombre, const QVector2D*valores, int paso = 0)
void setAttributeArray(const char*nombre, const QVector3D*valores, int paso = 0)
void setAttributeArray(const char*nombre, const QVector4D*valores, int paso = 0)
void setAttributeArray(const char*nombre, const GLfloat*valores, int tamañoDeTupla, int paso = 0)
void setAttributeArray(const char*nombre, GLenum tipo, const void*valores, int tamañoDeTupla, int paso = 0)
void setAttributeBuffer(int ubicación, GLenum tipo, int desplazamiento, int tamañoDeTupla, int paso = 0)
void setAttributeBuffer(const char*nombre, GLenum tipo, int desplazamiento, int tamañoDeTupla, int paso = 0)
void setAttributeValue(int ubicación, GLfloat valor)
void setAttributeValue(int ubicación, const QColor&valor)
void setAttributeValue(int ubicación, const QVector2D&valor)
void setAttributeValue(int ubicación, const QVector3D&valor)
void setAttributeValue(int ubicación, const QVector4D&valor)
void setAttributeValue(int ubicación, GLfloat x, GLfloat y)
void setAttributeValue(int ubicación, GLfloat x, GLfloat y, GLfloat z)
void setAttributeValue(int ubicación, const GLfloat*valores, int columnas, int filas)
void setAttributeValue(int ubicación, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void setAttributeValue(const char*nombre, GLfloat valor)
void setAttributeValue(const char*nombre, const QColor&valor)
void setAttributeValue(const char*nombre, const QVector2D&valor)
void setAttributeValue(const char*nombre, const QVector3D&valor)
void setAttributeValue(const char*nombre, const QVector4D&valor)
void setAttributeValue(const char*nombre, GLfloat x, GLfloat y)
void setAttributeValue(const char*nombre, GLfloat x, GLfloat y, GLfloat z)
void setAttributeValue(const char*nombre, const GLfloat*valores, int columnas, int filas)
void setAttributeValue(const char*nombre, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void setDefaultInnerTessellationLevels(const QList<float>&niveles)
void setDefaultOuterTessellationLevels(const QList<float>&niveles)
void setPatchVertexCount(int count)
void setUniformValue(int ubicación, GLfloat valor)
void setUniformValue(int ubicación, GLint valor)
void setUniformValue(const char*nombre, const QMatrix3x4&valor)
void setUniformValue(const char*nombre, const QMatrix4x2&valor)
void setUniformValue(const char*nombre, const QMatrix4x3&valor)
void setUniformValue(const char*nombre, const QMatrix4x4&valor)
void setUniformValue(const char*nombre, const QPoint&punto)
void setUniformValue(const char*nombre, const QPointF&punto)
void setUniformValue(const char*nombre, const QSize&tamaño)
void setUniformValue(const char*nombre, const QSizeF&tamaño)
void setUniformValue(const char*nombre, const QTransform&valor)
void setUniformValue(const char*nombre, const QVector2D&valor)
void setUniformValue(const char*nombre, const QVector3D&valor)
void setUniformValue(const char*nombre, const QVector4D&valor)
void setUniformValue(int ubicación, const GLfloat[2][2] valor)
void setUniformValue(int ubicación, const GLfloat[3][3] valor)
void setUniformValue(int ubicación, const GLfloat[4][4] valor)
void setUniformValue(const char*nombre, GLfloat x, GLfloat y)
void setUniformValue(const char*nombre, GLfloat x, GLfloat y, GLfloat z)
void setUniformValue(const char*nombre, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void setUniformValue(int ubicación, GLuint valor)
void setUniformValue(int ubicación, const QColor&color)
void setUniformValue(int ubicación, const QMatrix2x2&valor)
void setUniformValue(int ubicación, const QMatrix2x3&valor)
void setUniformValue(int ubicación, const QMatrix2x4&valor)
void setUniformValue(int ubicación, const QMatrix3x2&valor)
void setUniformValue(int ubicación, const QMatrix3x3&valor)
void setUniformValue(int ubicación, const QMatrix3x4&valor)
void setUniformValue(int ubicación, const QMatrix4x2&valor)
void setUniformValue(int ubicación, const QMatrix4x3&valor)
void setUniformValue(int ubicación, const QMatrix4x4&valor)
void setUniformValue(int ubicación, const QPoint&punto)
void setUniformValue(int ubicación, const QPointF&punto)
void setUniformValue(int ubicación, const QSize&tamaño)
void setUniformValue(int ubicación, const QSizeF&tamaño)
void setUniformValue(int ubicación, const QTransform&valor)
void setUniformValue(int ubicación, const QVector2D&valor)
void setUniformValue(int ubicación, const QVector3D&valor)
void setUniformValue(int ubicación, const QVector4D&valor)
void setUniformValue(int ubicación, GLfloat x, GLfloat y)
void setUniformValue(int ubicación, GLfloat x, GLfloat y, GLfloat z)
void setUniformValue(int ubicación, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void setUniformValue(const char*nombre, GLfloat valor)
void setUniformValue(const char*nombre, GLint valor)
void setUniformValue(const char*nombre, GLuint valor)
void setUniformValue(const char*nombre, const GLfloat[2][2] valor)
void setUniformValue(const char*nombre, const GLfloat[3][3] valor)
void setUniformValue(const char*nombre, const GLfloat[4][4] valor)
void setUniformValue(const char*nombre, const QColor&color)
void setUniformValue(const char*nombre, const QMatrix2x2&valor)
void setUniformValue(const char*nombre, const QMatrix2x3&valor)
void setUniformValue(const char*nombre, const QMatrix2x4&valor)
void setUniformValue(const char*nombre, const QMatrix3x2&valor)
void setUniformValue(const char*nombre, const QMatrix3x3&valor)
void setUniformValueArray(int ubicación, const GLint*valores, int recuento)
void setUniformValueArray(int ubicación, const GLuint*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix2x2*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix2x3*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix2x4*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix3x2*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix3x3*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix3x4*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix4x2*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix4x3*valores, int recuento)
void setUniformValueArray(int ubicación, const QMatrix4x4*valores, int recuento)
void setUniformValueArray(int ubicación, const QVector2D*valores, int recuento)
void setUniformValueArray(int ubicación, const QVector3D*valores, int recuento)
void setUniformValueArray(int ubicación, const QVector4D*valores, int recuento)
void setUniformValueArray(int ubicación, const GLfloat*valores, int recuento, int tamañoDeTupla)
void setUniformValueArray(const char*nombre, const GLint*valores, int recuento)
void setUniformValueArray(const char*nombre, const GLuint*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix2x2*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix2x3*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix2x4*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix3x2*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix3x3*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix3x4*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix4x2*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix4x3*valores, int recuento)
void setUniformValueArray(const char*nombre, const QMatrix4x4*valores, int recuento)
void setUniformValueArray(const char*nombre, const QVector2D*valores, int recuento)
void setUniformValueArray(const char*nombre, const QVector3D*valores, int recuento)
void setUniformValueArray(const char*nombre, const QVector4D*valores, int recuento)
void setUniformValueArray(const char*nombre, const GLfloat*valores, int recuento, int tamañoTuple)
QList<QOpenGLShader *> shaders() const
int uniformLocation(const char*name) const
int uniformLocation(const QByteArray&name) const
int uniformLocation(const QString&nombre) const

Miembros públicos estáticos

bool hasOpenGLShaderPrograms(QOpenGLContext *context = nullptr)

Descripción detallada

Introducción

Esta clase admite programas de sombreado escritos en el lenguaje de sombreado de OpenGL (GLSL) y en el lenguaje de sombreado de OpenGL/ES (GLSL/ES).

QOpenGLShader Las clases `QOpenGLShader` y `QOpenGLShaderProgram` protegen al programador de los detalles de la compilación y el enlace de los sombreadores de vértices y de fragmentos.

El siguiente ejemplo crea un programa de sombreador de vértices utilizando el código fuente proporcionado code. Una vez compilado y enlazado, el programa de sombreador se activa en el QOpenGLContext actual llamando a QOpenGLShaderProgram::bind():

QOpenGLShader shader(QOpenGLShader::Vertex);
shader.compileSourceCode(code);

QOpenGLShaderProgram program(context);
program.addShader(&shader);
program.link();

program.bind();

Escribir sombreadores portables

Los programas de sombreadores pueden resultar difíciles de reutilizar entre distintas implementaciones de OpenGL debido a los distintos niveles de compatibilidad con los atributos de vértice y las variables uniformes estándar. En concreto, GLSL/ES carece de todas las variables estándar que están presentes en los sistemas OpenGL de escritorio: gl_Vertex, gl_Normal, gl_Color, etc. El OpenGL de escritorio carece de los calificadores de variables highp, mediump y lowp.

La clase `QOpenGLShaderProgram` facilita el proceso de escritura de shaders portables al anteponer a todos los programas de shader las siguientes líneas en OpenGL de escritorio:

#define highp
#define mediump
#define lowp

Esto permite ejecutar la mayoría de los programas de shader GLSL/ES en sistemas de escritorio. El programador debe limitarse únicamente a las características presentes en GLSL/ES y evitar los nombres de variables estándar que solo funcionan en el entorno de escritorio.

Ejemplo sencillo de shader

program.addShaderFromSourceCode(QOpenGLShader::Vertex,
    "attribute highp vec4 vertex;\n"
    "uniform highp mat4 matrix;\n"
    "void main(void)\n"
    "{\n"
    "   gl_Position = matrix * vertex;\n"
    "}");
program.addShaderFromSourceCode(QOpenGLShader::Fragment,
    "uniform mediump vec4 color;\n"
    "void main(void)\n"
    "{\n"
    "   gl_FragColor = color;\n"
    "}");
program.link();
program.bind();

int vertexLocation = program.attributeLocation("vertex");
int matrixLocation = program.uniformLocation("matrix");
int colorLocation = program.uniformLocation("color");

Con el programa de shader anterior activo, podemos dibujar un triángulo verde de la siguiente manera:

static GLfloat const triangleVertices[] = {
    60.0f,  10.0f,  0.0f,
    110.0f, 110.0f, 0.0f,
    10.0f,  110.0f, 0.0f
};

QColor color(0, 255, 0, 255);

QMatrix4x4 pmvMatrix;
pmvMatrix.ortho(rect());

program.enableAttributeArray(vertexLocation);
program.setAttributeArray(vertexLocation, triangleVertices, 3);
program.setUniformValue(matrixLocation, pmvMatrix);
program.setUniformValue(colorLocation, color);

glDrawArrays(GL_TRIANGLES, 0, 3);

program.disableAttributeArray(vertexLocation);

Shaders y programas binarios

Los shaders binarios pueden especificarse utilizando ` glShaderBinary() ` sobre el valor de retorno de ` QOpenGLShader::shaderId()`. La instancia ` QOpenGLShader ` que contiene el binario puede añadirse entonces al programa de shader con ` addShader()` y enlazarse de la forma habitual con ` link()`.

Los programas binarios pueden especificarse utilizando ` glProgramBinaryOES() ` sobre el valor devuelto por ` programId()`. A continuación, la aplicación debe llamar a ` link()`, que detectará que el programa ya ha sido especificado y enlazado, lo que permite realizar otras operaciones sobre el programa de sombreador. El identificador del programa de sombreador puede crearse explícitamente utilizando la función ` create()`.

Almacenamiento en caché de binarios de programas

A partir de Qt 5.9, se ha incorporado de forma nativa la compatibilidad con el almacenamiento en caché de los binarios de los programas en el disco. Para habilitar esta función, utilice addCacheableShaderFromSourceCode() y addCacheableShaderFromSourceFile(). Con un contexto OpenGL ES 3.x o compatibilidad con GL_ARB_get_program_binary, esto almacenará en caché de forma transparente los binarios de programa en QStandardPaths::CacheLocation. Cuando no haya compatibilidad disponible, llamar a las variantes de función almacenables en caché es equivalente a llamar a las normales.

Nota: Algunos controladores no disponen de formatos binarios, aunque anuncien la extensión u ofrezcan OpenGL ES 3.0. En este caso, la compatibilidad con binarios de programa quedará desactivada.

Consideraciones de seguridad

Se espera que todos los datos utilizados por `QOpenGLShaderProgram` sean de confianza. El código fuente del shader se pasa, posiblemente tras modificaciones mínimas, al compilador de la implementación subyacente de OpenGL, que es una «caja negra» desde la perspectiva de Qt.

Advertencia: Se recomienda a los desarrolladoresde aplicaciones que evalúen cuidadosamente las posibles implicaciones antes de pasar contenido proporcionado por el usuario a funciones como addShaderFromSourceFile().

Véase también QOpenGLShader.

Documentación de la función miembro

[explicit] QOpenGLShaderProgram::QOpenGLShaderProgram(QObject *parent = nullptr)

Crea un nuevo programa de sombreado y lo asocia a parent. El programa no será válido hasta que se llame a addShader().

El programa de sombreado se asociará al ` QOpenGLContext` actual.

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

[virtual noexcept] QOpenGLShaderProgram::~QOpenGLShaderProgram()

Elimina este programa de sombreado.

bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source)

Registra el shader de los archivos especificados type y source en este programa. A diferencia de addShaderFromSourceCode(), esta función no realiza la compilación. La compilación se aplaza hasta link(), y puede que ni siquiera se lleve a cabo, ya que link() puede utilizar un binario del programa procedente de la caché de shaders en disco de Qt. Esto suele traducirse en un aumento significativo del rendimiento.

Devuelve «true» si el shader se ha registrado o, en caso de no estar almacenado en caché, se ha compilado correctamente; «false» si se ha producido un error. Los mensajes de error de compilación pueden recuperarse mediante log().

Cuando la caché de disco está desactivada, por ejemplo mediante Qt::AA_DisableShaderDiskCache, o el contexto de OpenGL no admite binarios de contexto, llamar a esta función equivale a addShaderFromSourceCode().

Véanse también addShaderFromSourceCode() y addCacheableShaderFromSourceFile().

bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray &source)

Registra el shader de los archivos especificados type y source en este programa. A diferencia de addShaderFromSourceCode(), esta función no realiza la compilación. La compilación se aplaza hasta link(), y puede que ni siquiera se lleve a cabo, ya que link() podría utilizar un binario del programa procedente de la caché de shaders en disco de Qt XML. Esto suele traducirse en un aumento significativo del rendimiento.

Devuelve «true» si el shader se ha registrado o, en caso de no estar almacenado en caché, se ha compilado correctamente; devuelve «false» si se ha producido un error. Los mensajes de error de compilación pueden recuperarse mediante log().

Cuando la caché de disco está desactivada, por ejemplo mediante Qt::AA_DisableShaderDiskCache, o el contexto de OpenGL no admite binarios de contexto, llamar a esta función equivale a addShaderFromSourceCode().

Esta es una función sobrecargada.

Véanse también addShaderFromSourceCode() y addCacheableShaderFromSourceFile().

bool QOpenGLShaderProgram::addCacheableShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString &source)

Registra el shader de los archivos especificados type y source en este programa. A diferencia de addShaderFromSourceCode(), esta función no realiza la compilación. La compilación se aplaza hasta link(), y es posible que ni siquiera se lleve a cabo, ya que link() puede utilizar un binario del programa procedente de la caché de shaders en disco de Qt. Esto suele traducirse en un aumento significativo del rendimiento.

Cuando la caché de disco está desactivada, por ejemplo mediante Qt::AA_DisableShaderDiskCache, o el contexto de OpenGL no admite binarios de contexto, llamar a esta función equivale a addShaderFromSourceCode().

Esta es una función sobrecargada.

Véanse también addShaderFromSourceCode() y addCacheableShaderFromSourceFile().

bool QOpenGLShaderProgram::addCacheableShaderFromSourceFile(QOpenGLShader::ShaderType type, const QString &fileName)

Registra el shader de los archivos especificados type y fileName en este programa. A diferencia de addShaderFromSourceFile(), esta función no realiza la compilación. La compilación se aplaza hasta link(), y es posible que ni siquiera se lleve a cabo, ya que link() puede utilizar un binario del programa procedente de la caché de shaders en disco de Qt. Esto suele traducirse en un aumento significativo del rendimiento.

Devuelve «true» si el archivo se ha leído correctamente, y «false» si no se ha podido abrir el archivo o si ha fallado la compilación normal (sin caché) del sombreador. Los mensajes de error de compilación pueden recuperarse mediante log().

Cuando la caché de disco está desactivada, por ejemplo mediante Qt::AA_DisableShaderDiskCache, o el contexto de OpenGL no admite binarios de contexto, llamar a esta función equivale a addShaderFromSourceFile().

Véanse también addShaderFromSourceFile() y addCacheableShaderFromSourceCode().

bool QOpenGLShaderProgram::addShader(QOpenGLShader *shader)

Añade un objeto « shader » compilado a este programa de sombreador. Devuelve « true » si se ha podido añadir el sombreador; en caso contrario, devuelve «false».

La propiedad del objeto ` shader ` sigue correspondiendo a quien realiza la llamada. No se eliminará cuando se elimine esta instancia de ` QOpenGLShaderProgram `. Esto permite a quien realiza la llamada añadir el mismo sombreador a varios programas de sombreado.

Véanse también addShaderFromSourceCode(), addShaderFromSourceFile(), removeShader(), link() y removeAllShaders().

bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const char *source)

Compila source como un shader del type especificado y lo añade a este programa de shaders. Devuelve true si la compilación se ha realizado correctamente; en caso contrario, devuelve false. Los errores y advertencias de compilación estarán disponibles a través de log().

Esta función está pensada como un atajo para añadir rápidamente sombreadores de vértices y de fragmentos a un programa de sombreado sin necesidad de crear primero una instancia de QOpenGLShader.

Véanse también addShader(), addShaderFromSourceFile(), removeShader(), link(), log() y removeAllShaders().

bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QByteArray &source)

Compila source como un shader del type especificado y lo añade a este programa de shaders. Devuelve true si la compilación se ha realizado correctamente; en caso contrario, devuelve false. Los errores y advertencias de compilación estarán disponibles a través de log().

Esta función está pensada como un atajo para añadir rápidamente sombreadores de vértices y de fragmentos a un programa de sombreado sin tener que crear primero una instancia de QOpenGLShader.

Se trata de una función sobrecargada.

Véanse también addShader(), addShaderFromSourceFile(), removeShader(), link(), log() y removeAllShaders().

bool QOpenGLShaderProgram::addShaderFromSourceCode(QOpenGLShader::ShaderType type, const QString &source)

Compila source como un shader del type especificado y lo añade a este programa de shaders. Devuelve true si la compilación se ha realizado correctamente; en caso contrario, devuelve false. Los errores y advertencias de compilación estarán disponibles a través de log().

Esta función está pensada como un atajo para añadir rápidamente sombreadores de vértices y de fragmentos a un programa de sombreado sin tener que crear primero una instancia de QOpenGLShader.

Se trata de una función sobrecargada.

Véanse también addShader(), addShaderFromSourceFile(), removeShader(), link(), log() y removeAllShaders().

bool QOpenGLShaderProgram::addShaderFromSourceFile(QOpenGLShader::ShaderType type, const QString &fileName)

Compila el contenido de fileName como un shader del type especificado y lo añade a este programa de shaders. Devuelve true si la compilación se ha realizado correctamente; en caso contrario, devuelve false. Los errores y advertencias de compilación estarán disponibles a través de log().

Esta función está pensada como un atajo para añadir rápidamente shaders de vértices y de fragmentos a un programa de shaders sin tener que crear primero una instancia de QOpenGLShader.

Véanse también addShader() y addShaderFromSourceCode().

int QOpenGLShaderProgram::attributeLocation(const char *name) const

Devuelve la posición del atributo « name » dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si « name » no es un atributo válido para este programa de sombreado.

Véase también uniformLocation() y bindAttributeLocation().

int QOpenGLShaderProgram::attributeLocation(const QByteArray &name) const

Devuelve la posición del atributo « name » dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si « name » no es un atributo válido para este programa de sombreado.

Esta es una función sobrecargada.

Véase también uniformLocation() y bindAttributeLocation().

int QOpenGLShaderProgram::attributeLocation(const QString &name) const

Devuelve la posición del atributo « name » dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si « name » no es un atributo válido para este programa de sombreado.

Esta es una función sobrecargada.

Véase también uniformLocation() y bindAttributeLocation().

bool QOpenGLShaderProgram::bind()

Asigna este programa de sombreado a la función « QOpenGLContext » activa y lo convierte en el programa de sombreado actual. Se libera cualquier programa de sombreado asignado anteriormente. Esto equivale a llamar a « glUseProgram() » en « programId()». Devuelve « true » si el programa se ha asignado correctamente; en caso contrario, devuelve «false». Si el programa de sombreado aún no se ha enlazado, o es necesario volver a enlazarlo, esta función llamará a « link()».

Véase también link() y release().

void QOpenGLShaderProgram::bindAttributeLocation(const char *name, int location)

Asigna el atributo « name » a la dirección especificada « location ». Esta función puede invocarse antes o después de que el programa haya sido enlazado. A cualquier atributo que no se haya asignado explícitamente al enlazar el programa se le asignará una ubicación automáticamente.

Si esta función se invoca después de que el programa haya sido enlazado, será necesario volver a enlazar el programa para que el cambio surta efecto.

Véase también attributeLocation().

void QOpenGLShaderProgram::bindAttributeLocation(const QByteArray &name, int location)

Asigna el atributo « name » a la dirección especificada « location ». Esta función puede invocarse antes o después de que el programa haya sido enlazado. A cualquier atributo que no se haya asignado explícitamente al enlazar el programa se le asignará una ubicación automáticamente.

Cuando esta función se invoca después de que el programa se haya enlazado, será necesario volver a enlazar el programa para que el cambio surta efecto.

Se trata de una función sobrecargada.

Véase también attributeLocation().

void QOpenGLShaderProgram::bindAttributeLocation(const QString &name, int location)

Asigna el atributo « name » a la dirección especificada « location ». Esta función puede invocarse antes o después de que el programa haya sido enlazado. A cualquier atributo que no se haya asignado explícitamente al enlazar el programa se le asignarán ubicaciones automáticamente.

Cuando esta función se invoca después de que el programa haya sido enlazado, será necesario volver a enlazar el programa para que el cambio surta efecto.

Se trata de una función sobrecargada.

Véase también attributeLocation().

bool QOpenGLShaderProgram::create()

Solicita que se cree inmediatamente el identificador del programa de sombreado. Devuelve ` true ` si se realiza correctamente; ` false ` en caso contrario.

Esta función resulta especialmente útil cuando se combina QOpenGLShaderProgram con otras funciones de OpenGL que operan directamente sobre el identificador del programa de sombreado, como GL_OES_get_program_binary.

Cuando el programa de sombreado se utiliza de forma normal, su identificador se creará según sea necesario.

Véase también programId().

QList<float> QOpenGLShaderProgram::defaultInnerTessellationLevels() const

Devuelve los niveles de teselación interna predeterminados que utilizará el generador de primitivas de teselación en caso de que el shader de control de teselación no los proporcione. Para obtener más información sobre OpenGL y los shaders de teselación, consulta «Shaders de teselación de OpenGL».

Devuelve un ` QList ` de valores flotantes que describe los niveles de teselación interna. El vector siempre tendrá dos elementos, pero no todos ellos tienen sentido para todos los modos de teselación.

Nota: Esto devuelve el valor del estado global de OpenGL. No es específico de esta instancia de ` QOpenGLShaderProgram `.

Nota: Esta función solo es compatible con OpenGL >= 4.0 y no devolverá resultados válidos con OpenGL ES 3.2.

Véase también setDefaultInnerTessellationLevels() y defaultOuterTessellationLevels().

QList<float> QOpenGLShaderProgram::defaultOuterTessellationLevels() const

Devuelve los niveles de teselación externos predeterminados que utilizará el generador de primitivas de teselación en caso de que el shader de control de teselación no los proporcione. Para obtener más información sobre OpenGL y los shaders de teselación, consulta «Shaders de teselación de OpenGL».

Devuelve un ` QList ` de valores flotantes que describen los niveles de teselación externos. El vector siempre tendrá cuatro elementos, aunque no todos ellos tienen sentido para todos los modos de teselación.

Nota: Devuelve el valor del estado global de OpenGL. No es específico de esta instancia de ` QOpenGLShaderProgram `.

Nota: Esta función solo es compatible con OpenGL >= 4.0 y no devolverá resultados válidos con OpenGL ES 3.2.

Véase también setDefaultOuterTessellationLevels() y defaultInnerTessellationLevels().

void QOpenGLShaderProgram::disableAttributeArray(int location)

Desactiva la matriz de vértices en location en este programa de sombreado, que se había activado mediante una llamada previa a enableAttributeArray().

Véase también enableAttributeArray(), setAttributeArray(), setAttributeValue() y setUniformValue().

void QOpenGLShaderProgram::disableAttributeArray(const char *name)

Desactiva la matriz de vértices denominada « name » en este programa de sombreado, que se había activado mediante una llamada previa a « enableAttributeArray()».

Esta es una función sobrecargada.

Véanse también enableAttributeArray(), setAttributeArray(), setAttributeValue() y setUniformValue().

void QOpenGLShaderProgram::enableAttributeArray(int location)

Activa la matriz de vértices en location en este programa de sombreado, de modo que el programa de sombreado utilice el valor establecido por setAttributeArray() en location.

Véase también disableAttributeArray(), setAttributeArray(), setAttributeValue() y setUniformValue().

void QOpenGLShaderProgram::enableAttributeArray(const char *name)

Habilita la matriz de vértices denominada « name » en este programa de sombreado, de modo que el programa de sombreado utilice el valor establecido mediante setAttributeArray() en name.

Se trata de una función sobrecargada.

Véanse también disableAttributeArray(), setAttributeArray(), setAttributeValue() y setUniformValue().

[static] bool QOpenGLShaderProgram::hasOpenGLShaderPrograms(QOpenGLContext *context = nullptr)

Devuelve « true » si este sistema es compatible con los programas de sombreado escritos en el lenguaje de sombreado de OpenGL (GLSL); en caso contrario, devuelve «false».

La variable context se utiliza para resolver las extensiones GLSL. Si context es nullptr, se utiliza QOpenGLContext::currentContext().

bool QOpenGLShaderProgram::isLinked() const

Devuelve ` true ` si este programa de sombreado se ha enlazado; en caso contrario, devuelve `false`.

Véase también link().

Enlaza los shaders que se han añadido a este programa mediante ` addShader()`. Devuelve ` true ` si el enlace se ha realizado correctamente; en caso contrario, devuelve `false`. Si el enlace falla, los mensajes de error se pueden recuperar mediante ` log()`.

Las subclases pueden sobrescribir esta función para inicializar atributos y variables uniformes que se utilizarán en programas de sombreador específicos.

Si el programa de sombreado ya estaba enlazado, volver a llamar a esta función forzará su reenlazado.

Cuando se han añadido sombreadores a este programa mediante addCacheableShaderFromSourceCode() o addCacheableShaderFromSourceFile(), se admiten binarios del programa y, si hay un binario almacenado en caché disponible en el disco, se omiten la compilación y la vinculación propiamente dichas. En su lugar, link() inicializará el programa con el blob binario mediante glProgramBinary(). Si no hay una versión en caché del programa o si se generó con una versión diferente del controlador, los shaders se compilarán a partir del código fuente y el programa se enlazará normalmente. Esto permite actualizar sin problemas los controladores gráficos, sin tener que preocuparse por posibles formatos binarios incompatibles.

Véase también addShader() y log().

QString QOpenGLShaderProgram::log() const

Devuelve los errores y advertencias que se produjeron durante la última llamada a link() o addShader(), junto con el código fuente especificado explícitamente.

Véase también link().

int QOpenGLShaderProgram::maxGeometryOutputVertices() const

Devuelve el límite de hardware relativo al número de vértices que puede generar un sombreador geométrico.

int QOpenGLShaderProgram::patchVertexCount() const

Devuelve el número de vértices por parche que se utilizarán durante el renderizado.

Nota: Esto devuelve el valor del estado global de OpenGL. No es específico de esta instancia de ` QOpenGLShaderProgram `.

Véase también setPatchVertexCount().

GLuint QOpenGLShaderProgram::programId() const

Devuelve el identificador de OpenGL asociado a este programa de sombreador.

Véase también QOpenGLShader::shaderId().

void QOpenGLShaderProgram::release()

Libera el programa de sombreado activo del ` QOpenGLContext` actual. Esto equivale a llamar a ` glUseProgram(0)`.

Véase también bind().

void QOpenGLShaderProgram::removeAllShaders()

Elimina todos los shaders que se habían añadido anteriormente a este programa. Los objetos ` QOpenGLShader ` correspondientes a los shaders no se eliminarán si se han creado externamente. Los objetos ` QOpenGLShader ` creados internamente por ` QOpenGLShaderProgram ` sí se eliminarán.

Véase también addShader() y removeShader().

void QOpenGLShaderProgram::removeShader(QOpenGLShader *shader)

Elimina « shader » de este programa de sombreado. El objeto no se elimina.

El programa de sombreado debe ser válido en el QOpenGLContext actual.

Véase también « addShader()», « link()» y « removeAllShaders()».

void QOpenGLShaderProgram::setAttributeArray(int location, const QVector2D *values, int stride = 0)

Establece una matriz de vértices 2D values en el atributo location de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre el location. De lo contrario, se utilizará el valor especificado con setAttributeValue() para location.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(int location, const QVector3D *values, int stride = 0)

Establece una matriz de vértices 3D values en el atributo location de este programa de sombreado. El valor stride indica el número de bytes entre vértices. Un valor predeterminado stride de cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre location. De lo contrario, se utilizará el valor especificado con setAttributeValue() para location.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(int location, const QVector4D *values, int stride = 0)

Establece una matriz de vértices 4D values en el atributo de location en este programa de sombreado. El parámetro stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre location. De lo contrario, se utilizará el valor especificado con setAttributeValue() para location.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(int location, const GLfloat *values, int tupleSize, int stride = 0)

Establece una matriz de vértices values en el atributo location de este programa de sombreado. El tupleSize indica el número de componentes por vértice (1, 2, 3 o 4), y el stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() en location. De lo contrario, se utilizará el valor especificado con setAttributeValue() para location.

Véanse también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(int location, GLenum type, const void *values, int tupleSize, int stride = 0)

Establece una matriz de vértices values en el atributo location de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están agrupados de forma densa en values.

El type indica el tipo de elementos de la matriz values, normalmente GL_FLOAT, GL_UNSIGNED_BYTE, etc. El tupleSize indica el número de componentes por vértice: 1, 2, 3 o 4.

La matriz se activará cuando se llame a enableAttributeArray() sobre location. De lo contrario, se utilizará el valor especificado con setAttributeValue() para location.

La función setAttributeBuffer() se puede utilizar para establecer el array de atributos en una posición dentro de un búfer de vértices.

Nota: Se habilitarála normalización . Si no se desea esto, llame a glVertexAttribPointer directamente a través de QOpenGLFunctions.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray(), disableAttributeArray() y setAttributeBuffer().

void QOpenGLShaderProgram::setAttributeArray(const char *name, const QVector2D *values, int stride = 0)

Establece una matriz de vértices 2D values en el atributo denominado name de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre name. De lo contrario, se utilizará el valor especificado con setAttributeValue() para name.

Se trata de una función sobrecargada.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(const char *name, const QVector3D *values, int stride = 0)

Establece una matriz de vértices 3D values en el atributo denominado name de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre name. De lo contrario, se utilizará el valor especificado con setAttributeValue() para name.

Se trata de una función sobrecargada.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(const char *name, const QVector4D *values, int stride = 0)

Establece una matriz de vértices 4D values en el atributo denominado name de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() sobre name. De lo contrario, se utilizará el valor especificado con setAttributeValue() para name.

Se trata de una función sobrecargada.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(const char *name, const GLfloat *values, int tupleSize, int stride = 0)

Establece una matriz de vértices values en el atributo denominado name de este programa de sombreado. El tupleSize indica el número de componentes por vértice (1, 2, 3 o 4), y el stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

La matriz se activará cuando se llame a enableAttributeArray() en name. De lo contrario, se utilizará el valor especificado con setAttributeValue() para name.

Se trata de una función sobrecargada.

Véase también setAttributeValue(), setUniformValue(), enableAttributeArray() y disableAttributeArray().

void QOpenGLShaderProgram::setAttributeArray(const char *name, GLenum type, const void *values, int tupleSize, int stride = 0)

Establece una matriz de vértices values en el atributo denominado name de este programa de sombreado. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en values.

El type indica el tipo de elementos de la matriz values, normalmente GL_FLOAT, GL_UNSIGNED_BYTE, etc. El tupleSize indica el número de componentes por vértice: 1, 2, 3 o 4.

La matriz se activará cuando se llame a enableAttributeArray() sobre name. De lo contrario, se utilizará el valor especificado con setAttributeValue() para name.

La función setAttributeBuffer() puede utilizarse para establecer la matriz de atributos en una posición dentro de un búfer de vértices.

Se trata de una función sobrecargada.

Véanse también setAttributeValue(), setUniformValue(), enableAttributeArray(), disableAttributeArray() y setAttributeBuffer().

void QOpenGLShaderProgram::setAttributeBuffer(int location, GLenum type, int offset, int tupleSize, int stride = 0)

Establece una matriz de valores de vértices en el atributo location de este programa de sombreado, comenzando en una offset específica del búfer de vértices vinculado actualmente. El stride indica el número de bytes entre vértices. Un valor predeterminado de stride igual a cero indica que los vértices están empaquetados de forma densa en la matriz de valores.

El type indica el tipo de elementos de la matriz de valores de vértices, normalmente GL_FLOAT, GL_UNSIGNED_BYTE, etc. El tupleSize indica el número de componentes por vértice: 1, 2, 3 o 4.

La matriz se activará cuando se llame a ` enableAttributeArray()` sobre ` location`. De lo contrario, se utilizará el valor especificado con ` setAttributeValue()` para ` location `.

Nota: Se habilitarála normalización . Si no se desea que así sea, llame a glVertexAttribPointer directamente a través de QOpenGLFunctions.

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

void QOpenGLShaderProgram::setAttributeBuffer(const char *name, GLenum type, int offset, int tupleSize, int stride = 0)

Establece una matriz de valores de vértices en el atributo denominado « name » de este programa de sombreado, comenzando en un « offset » específico del búfer de vértices vinculado actualmente. El « stride » indica el número de bytes entre vértices. Un valor predeterminado de « stride » igual a cero indica que los vértices están empaquetados de forma densa en la matriz de valores.

El type indica el tipo de elementos de la matriz de valores de vértices, normalmente GL_FLOAT, GL_UNSIGNED_BYTE, etc. El tupleSize indica el número de componentes por vértice: 1, 2, 3 o 4.

La matriz se activará cuando se llame a ` enableAttributeArray()` sobre ` name`. De lo contrario, se utilizará el valor especificado con ` setAttributeValue()` para ` name `.

Esta es una función sobrecargada.

Véase también setAttributeArray().

void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat value)

Establece el atributo « location » del contexto actual en « value ».

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, const QColor &value)

Establece el atributo « location » del contexto actual en « value ».

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, const QVector2D &value)

Establece el atributo « location » del contexto actual en « value ».

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, const QVector3D &value)

Establece el atributo « location » del contexto actual en « value ».

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, const QVector4D &value)

Establece el atributo « location » del contexto actual en « value ».

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat x, GLfloat y)

Establece el atributo de « location » en el contexto actual en el vector 2D (x, y).

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat x, GLfloat y, GLfloat z)

Establece el atributo « location » del contexto actual en el vector 3D (x, y, z).

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, const GLfloat *values, int columns, int rows)

Establece el atributo « location » del contexto actual con el contenido de « values », que contiene elementos « columns », cada uno de los cuales está formado por elementos « rows ». El valor de « rows » debe ser 1, 2, 3 o 4. Esta función se utiliza habitualmente para establecer valores de matrices y vectores de columna.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Establece el atributo de « location » en el contexto actual en el vector 4D (x, y, z, w).

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat value)

Establece el atributo denominado « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, const QColor &value)

Establece el atributo denominado « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector2D &value)

Establece el atributo denominado « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector3D &value)

Establece el atributo denominado « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

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

void QOpenGLShaderProgram::setAttributeValue(const char *name, const QVector4D &value)

Establece el atributo denominado « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat x, GLfloat y)

Establece el atributo denominado « name » en el contexto actual en el vector 2D (x, y).

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat x, GLfloat y, GLfloat z)

Establece el atributo denominado « name » en el contexto actual con el vector 3D (x, y, z).

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, const GLfloat *values, int columns, int rows)

Establece el atributo denominado « name » en el contexto actual con el contenido de « values », que contiene elementos « columns », cada uno de los cuales está formado por elementos « rows ». El valor de « rows » debe ser 1, 2, 3 o 4. Esta función se utiliza habitualmente para establecer valores de matrices y vectores de columna.

Se trata de una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setAttributeValue(const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Establece el atributo denominado « name » en el contexto actual con el vector 4D (x, y, z, w).

Esta es una función sobrecargada.

Véase también setUniformValue().

void QOpenGLShaderProgram::setDefaultInnerTessellationLevels(const QList<float> &levels)

Establece los niveles de teselación externos predeterminados que utilizará el generador de primitivas de teselación en caso de que el sombreador de control de teselación no los envíe a levels. Para obtener más detalles sobre OpenGL y los sombreadores de teselación, consulta «Sombreadores de teselación de OpenGL».

El argumento ` levels ` debe ser un ` QList ` compuesto por 2 valores de tipo `float`. No todos los valores tienen sentido para todos los modos de teselación. Si se especifica un vector con menos de 2 elementos, a los elementos restantes se les asignará un valor por defecto de 1.

Nota: Esto modifica el estado global de OpenGL y no es específico de esta instancia de « QOpenGLShaderProgram ». Debes llamar a esta función en tu función de renderizado cuando sea necesario, ya que « QOpenGLShaderProgram » no lo aplicará por ti. Se trata de una función puramente de conveniencia.

Nota: Esta función solo está disponible con OpenGL >= 4.0 y no es compatible con OpenGL ES 3.2.

Véase también defaultInnerTessellationLevels() y setDefaultOuterTessellationLevels().

void QOpenGLShaderProgram::setDefaultOuterTessellationLevels(const QList<float> &levels)

Establece los niveles de teselación externos predeterminados que utilizará el generador de primitivas de teselación en caso de que el shader de control de teselación no los envíe a levels. Para obtener más detalles sobre OpenGL y los shaders de teselación, consulta «Shaders de teselación de OpenGL».

El argumento ` levels ` debe ser un ` QList ` compuesto por 4 valores flotantes. No todos los valores tienen sentido para todos los modos de teselación. Si se especifica un vector con menos de 4 elementos, a los elementos restantes se les asignará un valor por defecto de 1.

Nota: Esto modifica el estado global de OpenGL y no es específico de esta instancia de ` QOpenGLShaderProgram `. Debes llamar a esta función en tu función de renderizado cuando sea necesario, ya que ` QOpenGLShaderProgram ` no lo aplicará por ti. Se trata de una función puramente de conveniencia.

Nota: Esta función solo está disponible con OpenGL >= 4.0 y no es compatible con OpenGL ES 3.2.

Véase también defaultOuterTessellationLevels() y setDefaultInnerTessellationLevels().

void QOpenGLShaderProgram::setPatchVertexCount(int count)

Utiliza esta función para especificar a OpenGL el número de vértices de un «patch» para la función « count ». Un «patch» es una primitiva personalizada de OpenGL cuya interpretación viene definida íntegramente por las etapas del sombreador de teselación. Por lo tanto, llamar a esta función solo tiene sentido cuando se utiliza un « QOpenGLShaderProgram » que contenga sombreadores de la etapa de teselación. Al utilizar la teselación de OpenGL, la única primitiva que se puede renderizar con las funciones « glDraw*() » es « GL_PATCHES ».

Esto equivale a llamar a glPatchParameteri(GL_PATCH_VERTICES, count).

Nota: Esto modifica el estado global de OpenGL y no es específico de esta instancia de QOpenGLShaderProgram. Debes llamar a esta función en tu función de renderizado cuando sea necesario, ya que QOpenGLShaderProgram no lo aplicará por ti. Se trata de una función puramente de conveniencia.

Véase también patchVertexCount().

void QOpenGLShaderProgram::setUniformValue(int location, GLfloat value)

Establece la variable «uniform» de location en el contexto actual en « value ».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, GLint value)

Establece la variable «uniform» de location en el contexto actual en value.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x4 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 3x4 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos de GLSL como `mat3x4`, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de `vec4`.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x2 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 4x2 value.

Nota: Esta función no es compatible con matrices no cuadradas, es decir, con tipos de GLSL como mat4x2, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vectores de tipo vec2.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x3 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 4x3 « value ».

Nota: Esta función no es compatible con matrices no cuadradas, es decir, con tipos de GLSL como mat4x3, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vectores de tipo vec3.

Esta es una función sobrecargada.

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

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix4x4 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 4x4 « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QPoint &point)

Establece la variable uniforme asociada a name en el contexto actual en las coordenadas x e y de point.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QPointF &point)

Establece la variable uniforme asociada a name en el contexto actual en las coordenadas x e y de point.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QSize &size)

Establece la variable «uniform» asociada a name en el contexto actual con el ancho y la altura de la imagen especificada en size.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QSizeF &size)

Establece la variable «uniform» asociada a name en el contexto actual con el ancho y la altura del elemento size proporcionado.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QTransform &value)

Establece la variable uniforme denominada « name » en el contexto actual en una matriz de transformación 3x3 « value », especificada como un valor de tipo « QTransform ».

Para establecer un valor de « QTransform » como una matriz de 4x4 en un shader, utiliza « setUniformValue(name, QMatrix4x4(value)) ».

Se trata de una función sobrecargada.

void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector2D &value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector3D &value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QVector4D &value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat[2][2] value)

Establece la variable «uniform» en « location » en el contexto actual como una matriz 2x2 « value ». Los elementos de la matriz deben especificarse en orden por columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat[3][3] value)

Establece la variable «uniform» en « location » en el contexto actual como una matriz de 3x3 « value ». Los elementos de la matriz deben especificarse en orden de columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const GLfloat[4][4] value)

Establece la variable «uniform» de location en el contexto actual como una matriz de 4x4 value. Los elementos de la matriz deben especificarse en orden de columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat x, GLfloat y)

Establece la variable uniforme denominada « name » en el contexto actual como el vector bidimensional (x, y).

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat x, GLfloat y, GLfloat z)

Establece la variable uniforme denominada « name » en el contexto actual como el vector 3D (x, y, z).

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Establece la variable uniforme denominada « name » en el contexto actual como el vector 4D (x, y, z, w).

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, GLuint value)

Establece la variable uniforme « location » en el contexto actual en « value ». Esta función debe utilizarse al establecer los valores del muestreador.

Nota: Esta función no tiene en cuenta la compatibilidad con «unsigned int» en las versiones modernas de OpenGL y, por lo tanto, trata « value » como un «GLint» y llama a «glUniform1i».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QColor &color)

Establece la variable «uniform» en location, en el contexto actual, con los componentes de rojo, verde, azul y alfa de color.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x2 &value)

Establece la variable «uniform» en « location » en el contexto actual como una matriz de 2x2 « value ».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x3 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz de 2x3 « value ».

Nota: Esta función no es compatible con matrices no cuadradas, es decir, con tipos GLSL como `mat2x3`, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de `vec3`.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix2x4 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz 2x4 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos GLSL como mat2x4, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vec4.

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

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x2 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz de 3x2 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos GLSL como mat3x2, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable «uniform» como una matriz de «vec2».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x3 &value)

Establece la variable uniforme « location » en el contexto actual como una matriz de 3x3 « value ».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix3x4 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz de 3x4 « value ».

Nota: Esta función no es compatible con matrices no cuadradas, es decir, con tipos GLSL como mat3x4, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vec4.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x2 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz de 4x2 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos GLSL como mat4x2, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable «uniform» como una matriz de «vec2».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x3 &value)

Establece la variable «uniform» « location » en el contexto actual como una matriz 4x3 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos GLSL como `mat4x3`, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable `uniform` como una matriz de `vec3`.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QMatrix4x4 &value)

Establece la variable uniforme « location » en el contexto actual como una matriz de 4x4 « value ».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QPoint &point)

Establece la variable «uniform» de location en el contexto actual con las coordenadas x e y de point.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QPointF &point)

Establece la variable «uniform» de location en el contexto actual con las coordenadas x e y de point.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QSize &size)

Establece la variable «uniform» de location en el contexto actual con el ancho y la altura del elemento size especificado.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QSizeF &size)

Establece la variable «uniform» de location en el contexto actual con el ancho y la altura del elemento size indicado.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QTransform &value)

Establece la variable «uniform» en « location » del contexto actual en una matriz de transformación 3x3 « value », especificada como un valor de « QTransform ».

Para establecer un valor de « QTransform » como una matriz de 4x4 en un shader, utiliza « setUniformValue(location, QMatrix4x4(value)) ».

void QOpenGLShaderProgram::setUniformValue(int location, const QVector2D &value)

Establece la variable «uniform» de location en el contexto actual en value.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QVector3D &value)

Establece el valor de la variable «uniform» en location, en el contexto actual, en value.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, const QVector4D &value)

Establece la variable «uniform» de « location » en el contexto actual en « value ».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, GLfloat x, GLfloat y)

Establece la variable «uniform» de location en el contexto actual como el vector bidimensional (x, y).

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, GLfloat x, GLfloat y, GLfloat z)

Establece la variable uniforme « location » en el contexto actual como el vector 3D (x, y, z).

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(int location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)

Establece la variable « location » del contexto actual en el vector 4D (x, y, z, w).

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLfloat value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLint value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, GLuint value)

Establece la variable uniforme denominada « name » en el contexto actual en « value ». Esta función debe utilizarse al establecer los valores del muestreador.

Nota: Esta función no tiene en cuenta la compatibilidad con «unsigned int» en las versiones modernas de OpenGL y, por lo tanto, trata « value » como un «GLint» y llama a «glUniform1i».

Se trata de una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat[2][2] value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz 2x2 value. Los elementos de la matriz deben especificarse en orden de columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat[3][3] value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 3x3 « value ». Los elementos de la matriz deben especificarse en orden de columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const GLfloat[4][4] value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 4x4 « value ». Los elementos de la matriz deben especificarse en orden de columnas.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QColor &color)

Establece la variable uniforme denominada « name » en el contexto actual con los componentes de rojo, verde, azul y alfa de « color ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x2 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz 2x2 « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x3 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz 2x3 value.

Nota: Esta función no admite matrices no cuadradas, es decir, tipos GLSL como mat2x3, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vec3.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix2x4 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 2x4 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos de GLSL como mat2x4, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vec4.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x2 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 3x2 « value ».

Nota: Esta función no admite matrices no cuadradas, es decir, tipos de GLSL como mat3x2, que están presentes en las versiones modernas de OpenGL. En su lugar, trata la variable uniforme como una matriz de vec2.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValue(const char *name, const QMatrix3x3 &value)

Establece la variable uniforme denominada « name » en el contexto actual como una matriz de 3x3 « value ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const GLint *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de count de values.

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

void QOpenGLShaderProgram::setUniformValueArray(int location, const GLuint *values, int count)

Establece la matriz de variables uniformes « location » en el contexto actual con los elementos « count » de « values ». Esta sobrecarga debe utilizarse al establecer una matriz de valores de muestreador.

Nota: Esta función no tiene en cuenta la compatibilidad con «unsigned int» en las versiones modernas de OpenGL y, por lo tanto, trata « values » como un «GLint» y llama a «glUniform1iv».

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x2 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 2x2 de count, que son values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x3 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 2x3 de count, que son values.

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

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix2x4 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 2x4 de count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x2 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 3x2 de count, que son values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x3 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 3x3 de count, que son los de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix3x4 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 3x4 de count, que son values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x2 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 4x2 de count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x3 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 4x3 de count, que son los de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QMatrix4x4 *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos de la matriz 4x4 de count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector2D *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos del vector 2D count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector3D *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos del vector 3D count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const QVector4D *values, int count)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos del vector 4D de count de values.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(int location, const GLfloat *values, int count, int tupleSize)

Establece la matriz de variables uniformes de location en el contexto actual con los elementos count de values. Cada elemento tiene tupleSize componentes. El tupleSize debe ser 1, 2, 3 o 4.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const GLint *values, int count)

Establece el array de variables « name » del contexto actual con los elementos « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const GLuint *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos « count » de « values ». Esta sobrecarga debe utilizarse al establecer una matriz de valores de muestreo.

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x2 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 2x2 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x3 *values, int count)

Establece la matriz variable uniforme denominada « name » en el contexto actual con los elementos de la matriz 2x3 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix2x4 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 2x4 de « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x2 *values, int count)

Establece la matriz variable uniforme denominada « name » en el contexto actual con los elementos de la matriz 3x2 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x3 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 3x3 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix3x4 *values, int count)

Establece la matriz variable uniforme denominada « name » en el contexto actual con los elementos de la matriz 3x4 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x2 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 4x2 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x3 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 4x3 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QMatrix4x4 *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos de la matriz 4x4 « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector2D *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos del vector bidimensional « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector3D *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos del vector 3D « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const QVector4D *values, int count)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos del vector 4D « count » de « values ».

Esta es una función sobrecargada.

Véase también setAttributeValue().

void QOpenGLShaderProgram::setUniformValueArray(const char *name, const GLfloat *values, int count, int tupleSize)

Establece la matriz de variables uniformes denominada « name » en el contexto actual con los elementos « count » de « values ». Cada elemento tiene componentes « tupleSize ». El « tupleSize » debe ser 1, 2, 3 o 4.

Esta es una función sobrecargada.

Véase también setAttributeValue().

QList<QOpenGLShader *> QOpenGLShaderProgram::shaders() const

Devuelve una lista de todos los shaders que se han añadido a este programa de shaders mediante la función addShader().

Véanse también las funciones ` addShader()` y ` removeShader()`.

int QOpenGLShaderProgram::uniformLocation(const char *name) const

Devuelve la posición de la variable uniforme name dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si name no es una variable uniforme válida para este programa de sombreado.

Véase también attributeLocation().

int QOpenGLShaderProgram::uniformLocation(const QByteArray &name) const

Devuelve la posición de la variable uniforme « name » dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si « name » no es una variable uniforme válida para este programa de sombreado.

Esta es una función sobrecargada.

Véase también attributeLocation().

int QOpenGLShaderProgram::uniformLocation(const QString &name) const

Devuelve la posición de la variable uniforme « name » dentro de la lista de parámetros de este programa de sombreado. Devuelve -1 si « name » no es una variable uniforme válida para este programa de sombreado.

Esta es una función sobrecargada.

Véase también attributeLocation().

© 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.