En esta página

Effect QML Type

Componente básico para crear un efecto de posprocesamiento. Más...

Import Statement: import QtQuick3D
Inherits:

Object3D

Propiedades

Descripción detallada

El tipo «Efecto» permite al usuario implementar sus propios efectos de posprocesamiento para QtQuick3D.

Efectos de posprocesamiento

Un efecto de posprocesamiento es, conceptualmente, muy similar a la opción « ShaderEffect » de Qt Quick. Cuando hay un efecto, la escena se renderiza primero en una textura independiente. A continuación, el efecto se aplica dibujando un cuadrilátero texturizado en el destino de renderizado principal, dependiendo de la render mode del View3D. El efecto puede proporcionar un sombreador de vértices, un sombreador de fragmentos o ambos. Los efectos siempre se aplican a toda la escena, según View3D.

Los efectos se asocian con el SceneEnvironment en la propiedad SceneEnvironment::effects. Esta propiedad es una lista: los efectos se pueden encadenar; se aplican en el orden en que aparecen en la lista, utilizando la salida del paso anterior como entrada para el siguiente, y la salida del último efecto define el contenido del View3D.

Nota: SceneEnvironment y ExtendedSceneEnvironment proporcionan un conjunto de efectos integrados, como profundidad de campo, resplandor/bloom, destellos de lente, corrección de color y viñeteado. Valora siempre primero si estos son suficientes para las necesidades de la aplicación y da preferencia al uso de las funciones integradas en lugar de implementar un efecto de posprocesamiento personalizado.

Los efectos son similares a custom materials en muchos aspectos. Sin embargo, un material personalizado está asociado a un modelo y se encarga del sombreado de esa malla concreta. Por su parte, el sombreador de vértices de un efecto siempre recibe un cuadrilátero (por ejemplo, dos triángulos) como entrada, mientras que su sombreador de fragmentos muestrea la textura con el contenido de la escena.

A diferencia de los materiales personalizados, los efectos admiten múltiples pasadas. Para muchos efectos esto no es necesario, y cuando surge la necesidad de aplicar varios efectos, a menudo se pueden lograr resultados idénticos encadenando varios efectos en the SceneEnvironment. Esto también se demuestra en el ejemplo de «Efecto personalizado ». Sin embargo, las pasadas tienen la posibilidad de solicitar búferes de color adicionales (textura) y especificar a cuál de estos búferes adicionales envían su salida. Esto permite implementar técnicas de procesamiento de imágenes más complejas, ya que las pasadas posteriores pueden utilizar entonces uno o más de estos búferes adicionales, además del contenido original de la escena, como entrada. Si es necesario, estos búferes adicionales pueden tener una duración prolongada, lo que significa que su contenido se conserva entre fotogramas, lo que permite implementar efectos que se basan en la acumulación de contenido de varios fotogramas, como el desenfoque de movimiento.

En comparación con el 2D de Qt Quick's ShaderEffect, los efectos de posprocesamiento 3D tienen la ventaja de poder trabajar con datos del búfer de profundidad, así como la capacidad de implementar múltiples pasadas con búferes intermedios. Además, se amplían las capacidades relacionadas con las texturas: Qt Quick 3D permite un control más preciso sobre los modos de filtrado y permite que los efectos funcionen con formatos de textura distintos de RGBA8, por ejemplo, formatos de punto flotante.

Nota: Los efectosde posprocesamiento están disponibles actualmente cuando el « View3D » tiene su « renderMode » configurado en « Offscreen », « Underlay » o « Overlay ». Los efectos no se renderizarán en el modo « Inline ».

Nota: Al utilizar efectos de posprocesamiento, los shaders proporcionados por la aplicación deben esperar datos de color lineales sin mapeo de tonos aplicado. El mapeo de tonos que se realiza durante la pasada de renderizado principal (o durante el renderizado del skybox, si hay uno) cuando tonemapMode se establece en un valor distinto de SceneEnvironment.TonemapModeNone, se desactiva automáticamente cuando hay al menos un efecto de posprocesamiento especificado en SceneEnvironment. El último efecto de la cadena (más concretamente, la última pasada del último efecto de la cadena) verá automáticamente modificado su sombreador de fragmentos para que realice el mismo mapeo de tonos que realizaría la pasada de renderizado principal.

Nota: Los efectos que realizan su propio mapeo de tonos deben utilizarse en una « SceneEnvironment » (cadena de renderizado) en la que se haya desactivado el mapeo de tonos integrado, configurando « tonemapMode » como « SceneEnvironment.TonemapModeNone ».

Nota: Por defecto, la textura utilizada como entrada de los efectos se crea con un formato de textura de punto flotante, como RGBA de 16 bits en punto flotante. El formato de la textura de salida es el mismo, ya que por defecto sigue el formato de entrada. Esto se puede anular utilizando Buffer y un nombre vacío. El valor predeterminado RGBA16F resulta útil porque permite trabajar con datos lineales sin mapeo de tonos sin que se recorten los valores de color que se encuentran fuera del rango 0-1.

Exposición de datos a los shaders

Al igual que con ` CustomMaterial ` o ` ShaderEffect`, las propiedades dinámicas de un objeto `Effect` se pueden modificar y animar utilizando las funciones habituales de QML y ` Qt Quick `, y los valores se exponen a los sombreadores automáticamente. La siguiente lista muestra cómo se asignan las propiedades:

  • bool, int, real -> bool, int, float
  • QColor, color -> vec4, y el color se convierte a lineal, suponiendo un espacio sRGB para el valor de color especificado en QML. Los colores integrados de Qt, como "green", también se encuentran en el espacio de color sRGB, y se realiza la misma conversión para todas las propiedades de color de DefaultMaterial y PrincipledMaterial, por lo que este comportamiento de Effect coincide con los anteriores.
  • QRect, QRectF, rect → vec4
  • QPoint, QPointF, point, QSize, QSizeF, size -> vec2
  • QVector2D, vector2d -> vec3
  • QVector3D, vector3d -> vec3
  • QVector4D, vector4d -> vec4
  • QMatrix4x4, matrix4x4 -> mat4
  • QQuaternion, quaternion -> vec4, el valor escalar es w
  • TextureInput -> sampler2D o samplerCube, dependiendo de si se utiliza Texture o CubeMapTexture en la propiedad de textura de TextureInput. Establecer la propiedad enabled en false hace que se exponga una textura ficticia al sombreador, lo que significa que los sombreadores siguen funcionando, pero muestrearán una textura con contenido de imagen negro opaco. Ten en cuenta que las propiedades de los muestreadores siempre deben hacer referencia a un objeto TextureInput, y no directamente a un Texture. En cuanto a las propiedades Texture, las relacionadas con la fuente, el mosaico y el filtrado son las únicas que se tienen en cuenta de forma implícita con los efectos, ya que el resto (como las transformaciones UV) depende de que los sombreadores personalizados las implementen como consideren oportuno.

Nota: Cuando un uniforme al que se hace referencia en el código del sombreador no tiene una propiedad correspondiente, se producirá un error de compilación del sombreador al procesar el efecto en tiempo de ejecución. Hay algunas excepciones a esto, como los uniformes de muestreador, a los que se les asigna una textura ficticia cuando no existe una propiedad QML correspondiente; pero, como norma general, todos los uniformes y muestreadores deben tener una propiedad correspondiente declarada en el objeto Effect.

Introducción a los efectos definidos por el usuario

Un efecto de posprocesamiento personalizado requiere, como mínimo, un objeto Effect y un fragmento de código de sombreador de fragmentos. Algunos efectos también necesitarán un sombreador de vértices personalizado.

Como ejemplo sencillo, creemos un efecto que combine el contenido de la escena con una imagen, al tiempo que modifica el valor del canal rojo de forma animada:

Effect {
    id: simpleEffect
    property TextureInput tex: TextureInput {
        texture: Texture { source: "image.png" }
    }
    property real redLevel
    NumberAnimation on redLevel { from: 0; to: 1; duration: 5000; loops: -1 }
    passes: Pass {
       shaders: Shader {
           stage: Shader.Fragment
           shader: "effect.frag"
       }
    }
}
void MAIN()
{
    vec4 c = texture(tex, TEXTURE_UV);
    c.r *= redLevel;
    FRAGCOLOR = c * texture(INPUT, INPUT_UV);
}

Aquí, la textura con la imagen image.png se expone al sombreador con el nombre tex. El valor de redLevel está disponible en el sombreador en un uniforme float con el mismo nombre.

El sombreador de fragmentos debe contener una función llamada « MAIN ». El color final del fragmento viene determinado por « FRAGCOLOR ». Se puede acceder a la textura de entrada principal, con el contenido de la escena de « View3D », a través de un « sampler2D » con el nombre « INPUT ». Las coordenadas UV del cuadrilátero se encuentran en INPUT_UV. Estos valores UV siempre son adecuados para el muestreo de INPUT, independientemente de la API gráfica subyacente en tiempo de ejecución (y, por lo tanto, independientemente de la dirección del eje Y en las imágenes, ya que Qt Quick 3D aplica automáticamente los ajustes necesarios). El muestreo de la textura con nuestra imagen externa se realiza mediante TEXTURE_UV. INPUT_UV no es adecuado en aplicaciones multiplataforma, ya que es necesario invertir el eje V para adaptarse a las diferencias en el sistema de coordenadas mencionadas anteriormente, utilizando una lógica diferente para las texturas basadas en imágenes y las texturas utilizadas como objetivos de renderizado. Afortunadamente, el motor se encarga de todo esto, por lo que el shader no necesita ninguna lógica adicional para ello.

Una vez que «simpleEffect» está disponible, se puede asociar a la lista de efectos de un « View3D » en SceneEnvironment:

environment: SceneEnvironment {
    effects: [ simpleEffect ]
}

El resultado sería algo parecido a lo siguiente, con la escena original a la izquierda y el efecto aplicado a la derecha:

Tres objetos 3D diferentes

Tres objetos 3D diferentes con el logotipo de Qt transparente superpuesto, creando un efecto de pantalla completa

Nota: El valor de la propiedad « shader » en el shader es una URL, tal y como es habitual en QML y en « Qt Quick », que hace referencia al archivo que contiene el fragmento de código del shader, y funciona de manera muy similar a ShaderEffect o Image.source. Solo se admiten los esquemas file y qrc. También es posible omitir el esquema file, lo que permite especificar una ruta relativa de forma cómoda. Dicha ruta se resuelve en relación con la ubicación del componente (el archivo .qml ).

Nota: El códigodel sombreador siempre se proporciona utilizando GLSL al estilo de Vulkan, independientemente de la API gráfica que utilice Qt en tiempo de ejecución.

Nota: El código de los sombreadores de vértices y fragmentos proporcionado por el efecto no constituye, por sí solo, sombreadores GLSL completos. Más bien, proporciona una función « MAIN » y, opcionalmente, un conjunto de declaraciones « VARYING », que luego son completadas con código de sombreador adicional por parte del motor.

Nota: El ejemplo anterior no es compatible con el modo de renderizado multivista opcional que se utiliza en algunas aplicaciones de RV/RA. Para que funcione tanto con el modo multivista como sin él, modifica MAIN() de la siguiente manera:

void MAIN()
{
    vec4 c = texture(tex, TEXTURE_UV);
    c.r *= redLevel;
#if QSHADER_VIEW_COUNT >= 2
    FRAGCOLOR = c * texture(INPUT, vec3(INPUT_UV, VIEW_INDEX));
#else
    FRAGCOLOR = c * texture(INPUT, INPUT_UV);
#endif
}

Efectos con sombreadores de vértices

Un sombreador de vértices, cuando está presente, debe proporcionar una función llamada MAIN. En la gran mayoría de los casos, el sombreador de vértices personalizado no querrá proporcionar su propio cálculo de la posición homogénea del vértice, pero es posible hacerlo utilizando POSITION, VERTEX y MODELVIEWPROJECTION_MATRIX. Cuando POSITION no está presente en el código del sombreador personalizado, Qt Quick 3D inyectará automáticamente una instrucción equivalente a POSITION = MODELVIEWPROJECTION_MATRIX * vec4(VERTEX, 1.0);.

Para pasar datos entre los sombreadores de vértices y de fragmentos, utiliza la palabra clave VARYING. Internamente, esto se transformará en la declaración adecuada de salida de vértices o de entrada de fragmentos. El sombreador de fragmentos puede utilizar la misma declaración, lo que permite leer el valor interpolado para el fragmento actual.

Veamos un ejemplo que, en la práctica, es muy similar al efecto integrado «DistortionSpiral»:

VARYING vec2 center_vec;
void MAIN()
{
    center_vec = INPUT_UV - vec2(0.5, 0.5);
    center_vec.y *= INPUT_SIZE.y / INPUT_SIZE.x;
}
VARYING vec2 center_vec;
void MAIN()
{
    float radius = 0.25;
    float dist_to_center = length(center_vec) / radius;
    vec2 texcoord = INPUT_UV;
    if (dist_to_center <= 1.0) {
        float rotation_amount = (1.0 - dist_to_center) * (1.0 - dist_to_center);
        float r = radians(360.0) * rotation_amount / 4.0 * FRAMEBUFFER_Y_UP;
        mat2 rotation = mat2(cos(r), sin(r), -sin(r), cos(r));
        texcoord = vec2(0.5, 0.5) + rotation * (INPUT_UV - vec2(0.5, 0.5));
    }
    FRAGCOLOR = texture(INPUT, texcoord);
}

La lista « passes » del objeto Effect debería especificar ahora tanto los fragmentos de vértice como los de fragmento:

passes: Pass {
   shaders: [
       Shader {
           stage: Shader.Vertex
           shader: "effect.vert"
       },
       Shader {
           stage: Shader.Fragment
           shader: "effect.frag"
       }
    ]
}

El resultado final es el siguiente:

Tres objetos 3D diferentes

Vista distorsionada de tres objetos 3D diferentes que muestra el efecto del sombreador de vértices

Palabras clave especiales en los sombreadores de efectos

  • VARYING - Declara una salida de vértice o una entrada de fragmento, dependiendo del tipo de sombreador actual.
  • MAIN - Esta función debe estar siempre presente en un shader de efecto.
  • FRAGCOLOR - vec4: el color final del fragmento; la salida del sombreador de fragmentos. (solo sombreador de fragmentos)
  • POSITION - vec4: la posición homogénea calculada en el shader de vértices. (solo shader de vértices)
  • MODELVIEWPROJECTION_MATRIX - mat4 - La matriz de transformación del cuadrilátero de pantalla.
  • VERTEX - vec3 - Los vértices del cuadrante; la entrada al sombreador de vértices. (solo sombreador de vértices)
  • INPUT - sampler2D o sampler2DArray - El muestreador de la textura de entrada con la escena renderizada en ella, a menos que un paso redirija su entrada a través de un objeto BufferInput, en cuyo caso INPUT hace referencia a la textura del búfer de color adicional a la que hace referencia BufferInput. Con el renderizado multivista habilitado, lo cual puede ser relevante para aplicaciones de RV/RA, se trata de un sampler2DArray, mientras que la textura de entrada se convierte en una matriz de texturas 2D.
  • INPUT_UV - vec2 - Coordenadas UV para el muestreo de INPUT.
  • TEXTURE_UV - vec2: coordenadas UV adecuadas para el muestreo de una textura cuyo contenido se ha cargado desde un archivo de imagen.
  • INPUT_SIZE - vec2 - El tamaño de la textura INPUT, en píxeles.
  • OUTPUT_SIZE - vec2 - El tamaño del búfer de salida, en píxeles. Suele ser igual al de INPUT_SIZE, a menos que el paso envíe la salida a un búfer adicional con un multiplicador de tamaño aplicado.
  • FRAME - float: un contador de fotogramas que se incrementa tras cada fotograma de View3D.
  • DEPTH_TEXTURE - sampler2D o sampler2DArray: una textura de profundidad con el contenido del búfer de profundidad de los objetos opacos de la escena. Al igual que con CustomMaterial, la presencia de esta palabra clave en el sombreador activa la generación automática de la textura de profundidad.
  • NORMAL_ROUGHNESS_TEXTURE - sampler2D - Una textura con las normales en el espacio mundial y la rugosidad del material de los objetos opacos en la parte de la escena visible en ese momento. Al igual que con CustomMaterial, la presencia de esta palabra clave en el shader implica una pasada de renderizado adicional para generar la textura de normales.
  • VIEW_INDEX - uint: con el renderizado multivista habilitado, este es el índice de vista actual, disponible tanto en los sombreadores de vértices como en los de fragmentos. Siempre es 0 cuando no se utiliza el renderizado multivista.
  • PROJECTION_MATRIX - mat4: la matriz de proyección. Ten en cuenta que, con el renderizado multivista, se trata de una matriz de matrices.
  • INVERSE_PROJECTION_MATRIX - mat4, la matriz de proyección inversa. Ten en cuenta que, con el renderizado multivista, se trata de una matriz de matrices.
  • VIEW_MATRIX -> mat4, la matriz de vista (cámara). Ten en cuenta que, con el renderizado multivista, se trata de una matriz de matrices.
  • float NDC_Y_UP - El valor es 1 cuando el eje Y apunta hacia arriba en el espacio de coordenadas normalizadas del dispositivo, y -1 cuando el eje Y apunta hacia abajo. El eje Y apunta hacia abajo cuando el renderizado se realiza con Vulkan.
  • float FRAMEBUFFER_Y_UP: el valor es 1 cuando el eje Y apunta hacia arriba en el sistema de coordenadas de los framebuffers (texturas), lo que significa que (0, 0) es la esquina inferior izquierda. El valor es -1 cuando el eje Y apunta hacia abajo, siendo (0, 0) la esquina superior izquierda.
  • float NEAR_CLIP_VALUE - El valor es -1 cuando el rango del plano de recorte comienza en -1 y llega hasta 1. Esto es así cuando se utiliza OpenGL para el renderizado. Para otros motores de renderizado, el valor de esta propiedad será 0, lo que significa que el rango del plano de recorte va de 0 a 1.

Creación de efectos multipaso

Un efecto multipaso suele utilizar más de un conjunto de sombreadores y hace uso de las propiedades output y commands. Cada entrada de la lista de pases se traduce en un pase de renderizado que dibuja un cuadrilátero en la textura de salida del pase, al tiempo que muestrea la textura de entrada del efecto y, opcionalmente, también otras texturas.

La estructura típica de un efecto de múltiples pasadas puede ser la siguiente:

passes: [
    Pass {
        shaders: [
            Shader {
                stage: Shader.Vertex
                shader: "pass1.vert"
            },
            Shader {
                stage: Shader.Fragment
                shader: "pass1.frag"
            }
            // This pass outputs to the intermediate texture described
            // by the Buffer object.
            output: intermediateColorBuffer
        ],
    },
    Pass {
        shaders: [
            Shader {
                stage: Shader.Vertex
                shader: "pass2.vert"
            },
            Shader {
                stage: Shader.Fragment
                shader: "pass2.frag"
            }
            // The output of the last pass needs no redirection, it is
            // the final result of the effect.
        ],
        commands: [
            // This pass reads from the intermediate texture, meaning
            // INPUT in the shader will refer to the texture associated
            // with the Buffer.
            BufferInput {
                buffer: intermediateColorBuffer
            }
        ]
    }
]

¿Qué es « intermediateColorBuffer »?

Buffer {
    id: intermediateColorBuffer
    name: "tempBuffer"
    // format: Buffer.RGBA8
    // textureFilterOperation: Buffer.Linear
    // textureCoordOperation: Buffer.ClampToEdge
}

Las propiedades comentadas no son necesarias si los valores deseados coinciden con los predeterminados.

Internamente, la presencia de este objeto «Buffer» y su referencia desde la propiedad « output » de un «Pass» da lugar a la creación de una textura cuyo tamaño coincide con el de « View3D », y por tanto con el tamaño de las texturas de entrada y salida implícitas. Cuando esto no sea lo deseado, se puede utilizar la propiedad sizeMultiplier para obtener una textura intermedia con un tamaño diferente. Esto puede dar lugar a que los uniformes INPUT_SIZE y OUTPUT_SIZE del shader tengan valores diferentes.

Por defecto, el efecto no puede dar por sentado que las texturas conserven su contenido entre fotogramas. Cuando se crea una nueva textura intermedia, se borra y se establece en « vec4(0.0) ». Posteriormente, la misma textura puede reutilizarse para otro fin. Por lo tanto, las pasadas del efecto siempre deben escribir en toda la textura, sin hacer suposiciones sobre su contenido al inicio de la pasada. Hay una excepción a esto: los objetos de búfer con « bufferFlags » (Vida útil del búfer) establecido en «Buffer.SceneLifetime». Esto indica que la textura está asociada de forma permanente a una pasada del efecto y no se reutilizará para otros fines. El contenido de dichos búferes de color se conserva entre fotogramas. Esto se suele utilizar de forma alterna en efectos como el desenfoque de movimiento: el primer paso toma el búfer persistente como entrada, además de la textura de entrada principal del efecto, y envía el resultado a otro búfer intermedio, mientras que el segundo paso envía el resultado al búfer persistente. De este modo, en el primer fotograma, la primera pasada muestrea una textura vacía (transparente), mientras que en los fotogramas siguientes muestrea la salida de la segunda pasada del fotograma anterior. A continuación, una tercera pasada puede fusionar la entrada del efecto y la salida de la segunda pasada.

El tipo de comando « BufferInput » se utiliza para exponer búferes de textura personalizados a la pasada de renderizado.

Por ejemplo, para acceder a « someBuffer » en los shaders de la pasada de renderizado con el nombre « mySampler », se puede añadir lo siguiente a su lista de comandos:

BufferInput { buffer: someBuffer; sampler: "mySampler" }

Si no se especifica el nombre de « sampler », se utilizará « INPUT » como valor por defecto.

Los búferes pueden resultar útiles para compartir resultados intermedios entre pasadas de renderizado.

Para exponer texturas precargadas al efecto, se debe utilizar en su lugar « TextureInput ». Estas se pueden definir como propiedades del propio efecto y los shaders podrán acceder a ellas automáticamente mediante sus nombres de propiedad.

property TextureInput tex: TextureInput {
    texture: Texture { source: "image.png" }
}

En este caso, ` tex ` es un muestreador válido en todos los sombreadores de todas las pasadas del efecto.

En cuanto a los valores uniformes procedentes de las propiedades, todas las pasadas del efecto leen los mismos valores en sus sombreadores. Si es necesario, es posible sobrescribir el valor de un uniforme solo para una pasada determinada. Esto se consigue añadiendo el comando SetUniformValue a la lista de comandos de la pasada.

Nota: El parámetro « target » del configurador de valores uniformes específico de cada paso solo puede hacer referencia a un nombre que sea el nombre de una propiedad del efecto. Puede sobrescribir el valor del uniforme correspondiente a una propiedad, pero no puede introducir nuevos uniformes.

Consideraciones sobre el rendimiento

Ten en cuenta el mayor consumo de recursos y la posible reducción del rendimiento al utilizar efectos de posprocesamiento. Al igual que ocurre con las capas « Qt Quick » y « ShaderEffect », renderizar la escena en una textura y luego utilizarla para texturizar un cuadrilátero no es una operación barata, especialmente en hardware de gama baja con una potencia de procesamiento de fragmentos limitada. La cantidad de memoria gráfica adicional necesaria, así como el aumento de la carga de la GPU, dependen del tamaño de la « View3D » (que, en dispositivos integrados sin sistema de ventanas, a menudo puede ser tan grande como la resolución de la pantalla). Los efectos de múltiples pasadas, así como la aplicación de múltiples efectos, aumentan aún más los requisitos de recursos y rendimiento.

Por lo tanto, es muy recomendable asegurarse, en una fase temprana del ciclo de vida del desarrollo, de que el dispositivo de destino y la pila gráfica sean capaces de gestionar los efectos incluidos en el diseño de la escena 3D a la resolución de pantalla del producto final.

Aunque es inevitable con las técnicas que lo requieren, el « DEPTH_TEXTURE » implica una pasada de renderizado adicional para generar el contenido de esa textura, lo que también puede suponer una carga para el hardware menos potente. Por lo tanto, utiliza el « DEPTH_TEXTURE » en los shaders del efecto solo cuando sea imprescindible.

La complejidad de las operaciones en los shaders también es importante. Al igual que con el « CustomMaterial », un shader de fragmentos subóptimo puede provocar fácilmente una reducción del rendimiento del renderizado.

Ten cuidado con « sizeMultiplier in Buffer » cuando se utilicen valores superiores a 1. Por ejemplo, un multiplicador de 4 implica crear y, a continuación, renderizar en una textura que tiene cuatro veces el tamaño de la « View3D ». Al igual que ocurre con los mapas de sombras y el multimuestreo o supermuestreo, el mayor consumo de recursos y el menor rendimiento pueden superar rápidamente los beneficios de una mejor calidad en sistemas con potencia de GPU limitada.

Consideraciones sobre la RV/RA

Al desarrollar aplicaciones para realidad virtual o aumentada utilizando Qt Quick 3D XR, los efectos de posprocesamiento son funcionales y están disponibles para su uso. Sin embargo, los diseñadores y desarrolladores deben prestar especial atención a comprender qué efectos y de qué tipo tienen sentido en un entorno de realidad virtual. Algunos efectos, incluidos algunos de los integrados en ExtendedSceneEnvironment o en el módulo Effects (ya en desuso), no proporcionan una buena experiencia visual en un entorno de RV, pudiendo incluso afectar físicamente al usuario (provocando, por ejemplo, mareos o náuseas).

Cuando se habilita el modo de renderizado multivista, más eficiente, en una aplicación de RV/RA, no hay un paso de renderizado independiente para los contenidos del ojo izquierdo y del derecho. En su lugar, todo se realiza en una sola pasada, utilizando una matriz de texturas 2D con dos capas en lugar de dos texturas 2D independientes. Esto también significa que muchos búferes intermedios, es decir, texturas de color o de profundidad, deberán convertirse en matrices de texturas en este modo. Esto, a su vez, tiene implicaciones para los materiales personalizados y los efectos de posprocesamiento. Texturas como la textura de entrada (INPUT) y la textura de profundidad (DEPTH_TEXTURE) se convierten en matrices de texturas 2D, expuestas en el shader como un ` sampler2DArray ` en lugar de ` sampler2D`. Esto tiene implicaciones para funciones GLSL como `texture()`, `textureLod()` o `textureSize()`. La coordenada UV es, por tanto, un vec3, no un vec2. Por su parte, textureSize() devuelve un vec3, no un vec2. Los efectos que estén pensados para funcionar independientemente del modo de renderizado pueden escribirse con un ifdef adecuado:

#if QSHADER_VIEW_COUNT >= 2
    vec4 c = texture(INPUT, vec3(INPUT_UV, VIEW_INDEX));
#else
    vec4 c = texture(INPUT, INPUT_UV);
#endif

También puede resultar útil definir macros que gestionen ambos casos. Por ejemplo:

#if QSHADER_VIEW_COUNT >= 2
#define SAMPLE_INPUT(uv) texture(INPUT, vec3(uv, VIEW_INDEX))
#define SAMPLE_DEPTH(uv) texture(DEPTH_TEXTURE, vec3(uv, VIEW_INDEX)).r
#define PROJECTION PROJECTION_MATRIX[VIEW_INDEX]
#define INVERSE_PROJECTION INVERSE_PROJECTION_MATRIX[VIEW_INDEX]
#else
#define SAMPLE_INPUT(uv) texture(INPUT, uv)
#define SAMPLE_DEPTH(uv) texture(DEPTH_TEXTURE, uv).r
#define PROJECTION PROJECTION_MATRIX
#define INVERSE_PROJECTION INVERSE_PROJECTION_MATRIX
#endif

Esto no se aplica a ` NORMAL_ROUGHNESS_TEXTURE `, que siempre es una textura 2D, incluso cuando el renderizado multivista está activo:

#define SAMPLE_NORMAL(uv) normalize(texture(NORMAL_ROUGHNESS_TEXTURE, uv).rgb)

Nota: La presencia de palabras clave como « DEPTH_TEXTURE » desencadena pasadas de renderizado adicionales, y las variables uniformes como « INVERSE_PROJECTION_MATRIX » se calculan y establecen en cuanto aparece la palabra clave en cualquier parte del fragmento de shader. Esto supone un mayor coste, tanto en términos de rendimiento como de uso de recursos. Por lo tanto, se recomienda añadir dichos #defines únicamente cuando las texturas y matrices vayan a utilizarse realmente en el efecto.

Véase también Shader, Pass, Buffer, BufferInput y Qt Quick 3D - Ejemplo de efecto personalizado.

Documentación de propiedades

passes : list [read-only]

Contiene una lista de los render passes implementados por el efecto.

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