QQuickRhiItem Class
La clase QQuickRhiItem es una alternativa portátil a QQuickFramebufferObject que no depende de OpenGL, sino que permite integrar el renderizado con las API de QRhi mediante Qt Quick. Más información...
| Encabezado: | #include <QQuickRhiItem> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Quick) target_link_libraries(mytarget PRIVATE Qt6::Quick) |
| qmake: | QT += quick |
| Desde: | Qt 6.7 |
| Heredan de: | QQuickItem |
Tipos públicos
| enum class | TextureFormat { RGBA8, RGBA16F, RGBA32F, RGB10A2 } |
Propiedades
|
|
Funciones públicas
| QQuickRhiItem(QQuickItem *parent = nullptr) | |
| virtual | ~QQuickRhiItem() override |
| bool | alphaBlending() const |
| QQuickRhiItem::TextureFormat | colorBufferFormat() const |
| QSize | effectiveColorBufferSize() const |
| int | fixedColorBufferHeight() const |
| int | fixedColorBufferWidth() const |
| bool | isMirrorVerticallyEnabled() const |
| int | sampleCount() const |
| void | setAlphaBlending(bool enable) |
| void | setColorBufferFormat(QQuickRhiItem::TextureFormat format) |
| void | setFixedColorBufferHeight(int height) |
| void | setFixedColorBufferWidth(int width) |
| void | setMirrorVertically(bool enable) |
| void | setSampleCount(int samples) |
Funciones públicas reimplementadas
| virtual bool | isTextureProvider() const override |
| virtual QSGTextureProvider * | textureProvider() const override |
Señales
| void | alphaBlendingChanged() |
| void | colorBufferFormatChanged() |
| void | effectiveColorBufferSizeChanged() |
| void | fixedColorBufferHeightChanged() |
| void | fixedColorBufferWidthChanged() |
| void | mirrorVerticallyChanged() |
| void | sampleCountChanged() |
Funciones protegidas
| virtual QQuickRhiItemRenderer * | createRenderer() = 0 |
| bool | isAutoRenderTargetEnabled() const |
| void | setAutoRenderTarget(bool enabled) |
Funciones protegidas reimplementadas
| virtual bool | event(QEvent *e) override |
| virtual void | geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) override |
| virtual void | releaseResources() override |
Descripción detallada
QQuickRhiItem es, en la práctica, el equivalente a QRhiWidget en el entorno de Qt Quick. Ambas clases están pensadas para ser subclasificadas y permiten registrar el renderizado basado en QRhi dirigido a un búfer de color fuera de pantalla. La imagen 2D resultante se compone posteriormente con el resto de la escena de Qt Quick.
Nota: Aunque QQuickRhiItem es una API pública de Qt, la familia de clases « QRhi » del módulo Qt GUI, que incluye QShader y QShaderDescription, ofrece garantías de compatibilidad limitadas. No hay garantías de compatibilidad de código fuente ni binaria para estas clases, lo que significa que solo se garantiza que la API funcione con la versión de Qt con la que se desarrolló la aplicación. No obstante, se pretende que los cambios que impliquen incompatibilidad a nivel de código fuente se reduzcan al mínimo y solo se realizarán en versiones menores (6.7, 6.8, etc.). qquickrhiitem.h no incluye directamente ningún encabezado relacionado con QRhi. Para utilizar esas clases al implementar una subclase de `QQuickRhiItem`, enlaza con Qt::GuiPrivate (si utilizas CMake) e incluye los encabezados adecuados con el prefijo rhi, por ejemplo #include <rhi/qrhi.h>.
QQuickRhiItem sustituye a la clase heredada ` QQuickFramebufferObject `. Esta última está intrínsecamente ligada a OpenGL / OpenGL ES, mientras que `QQuickRhiItem` funciona con las clases ` QRhi `, lo que permite ejecutar el mismo código de renderizado con Vulkan, Metal, Direct 3D 11/12 y OpenGL / OpenGL ES. Conceptual y funcionalmente son muy similares, y la migración de QQuickFramebufferObject a QQuickRhiItem es sencilla. QQuickFramebufferObject sigue estando disponible para garantizar la compatibilidad con el código de aplicaciones existentes que funciona directamente con la API de OpenGL.
Nota: QQuickRhiItem no funcionará si se utiliza la adaptación « software » del grafo de escena de Qt Quick.
En la mayoría de las plataformas, el renderizado del grafo de escena y, por lo tanto, el renderizado realizado por QQuickRhiItem se llevará a cabo en un hilo dedicado. Por este motivo, la clase QQuickRhiItem impone una separación estricta entre la implementación del elemento (la subclase de QQuickItem ) y la lógica de renderizado propiamente dicha. Toda la lógica del elemento, como las propiedades y las funciones auxiliares relacionadas con la interfaz de usuario expuestas a QML, debe ubicarse en la subclase de QQuickRhiItem. Todo lo relacionado con el renderizado debe ubicarse en la clase QQuickRhiItemRenderer. Para evitar condiciones de carrera y problemas de lectura/escritura entre dos hilos, es importante que el renderizador y el elemento nunca lean ni escriban en variables compartidas. La comunicación entre el elemento y el renderizador debe realizarse principalmente a través de la función `QQuickRhiItem::synchronize()`. Esta función se invocará en el hilo de renderizado mientras el hilo de la interfaz gráfica de usuario está bloqueado. También es posible utilizar conexiones en cola o eventos para la comunicación entre el elemento y el renderizador.
Las aplicaciones deben crear subclases tanto de `QQuickRhiItem` como de ` QQuickRhiItemRenderer`. La función virtual pura ` createRenderer()` debe reimplementarse para devolver una nueva instancia de la subclase ` QQuickRhiItemRenderer `.
Al igual que con ` QRhiWidget`, `QQuickRhiItem` gestiona automáticamente el búfer de color, que suele ser una textura 2D (`QRhiTexture`) o un ` QRhiRenderBuffer ` cuando se utiliza el multisampling. (Algunas API 3D diferencian entre texturas y búferes de renderizado, mientras que en otras el recurso nativo subyacente es el mismo; los búferes de renderizado se utilizan principalmente para permitir el multimuestreo con OpenGL ES 3.0)
El tamaño de la textura se adaptará por defecto al tamaño del elemento (teniendo en cuenta el device pixel ratio ). Si el tamaño del elemento cambia, la textura se recrea con el tamaño correcto. Si se prefiere un tamaño fijo, establezca fixedColorBufferWidth y fixedColorBufferHeight en valores distintos de cero.
QQuickRhiItem es un « texture provider » y puede utilizarse directamente en ShaderEffects y otras clases que utilicen proveedores de texturas.
Aunque no es un caso de uso principal, QQuickRhiItem también permite incorporar código de renderizado que utilice directamente una API de gráficos 3D como Vulkan, Metal, Direct 3D u OpenGL. Consulte QRhiCommandBuffer::beginExternal() para obtener más detalles sobre cómo registrar comandos nativos dentro de una pasada de renderizado de QRhi, así como QRhiTexture::createFrom() para conocer una forma de envolver una textura nativa existente y, a continuación, utilizarla con QRhi en una pasada de renderizado posterior. Consulte también QQuickGraphicsConfiguration en relación con la configuración del entorno de la API 3D nativa (p. ej., extensiones de dispositivo) y tenga en cuenta que el QQuickWindow puede asociarse a un QVulkanInstance personalizado llamando a QWindow::setVulkanInstance() con la suficiente antelación.
Nota: QQuickRhiItem siempre utiliza la misma instancia de QRhi que utiliza QQuickWindow (y, por extensión, el mismo contexto OpenGL, dispositivo Vulkan, etc.). Para elegir qué API de gráficos 3D subyacente se utiliza, llame a setGraphicsApi() en QQuickWindow con la suficiente antelación. No es posible cambiarlo una vez que se ha inicializado el grafo de escena, y todas las instancias de `QQuickRhiItem` de la escena se representarán utilizando la misma API 3D.
Un ejemplo sencillo
Consideremos la siguiente subclase de `QQuickRhiItem`. Aquí se muestra en su forma completa. Representa un único triángulo con una proyección en perspectiva, en la que el triángulo gira en función de la propiedad ` angle ` del elemento personalizado. (lo que significa que puede controlarse, por ejemplo, mediante animaciones como ` NumberAnimation ` desde QML)
class ExampleRhiItemRenderer : public QQuickRhiItemRenderer
{
public:
void initialize(QRhiCommandBuffer *cb) override;
void synchronize(QQuickRhiItem *item) override;
void render(QRhiCommandBuffer *cb) override;
private:
QRhi *m_rhi = nullptr;
std::unique_ptr<QRhiBuffer> m_vbuf;
std::unique_ptr<QRhiBuffer> m_ubuf;
std::unique_ptr<QRhiShaderResourceBindings> m_srb;
std::unique_ptr<QRhiGraphicsPipeline> m_pipeline;
QMatrix4x4 m_viewProjection;
float m_angle = 0.0f;
};
class ExampleRhiItem : public QQuickRhiItem
{
Q_OBJECT
QML_NAMED_ELEMENT(ExampleRhiItem)
Q_PROPERTY(float angle READ angle WRITE setAngle NOTIFY angleChanged)
public:
QQuickRhiItemRenderer *createRenderer() override;
float angle() const { return m_angle; }
void setAngle(float a);
signals:
void angleChanged();
private:
float m_angle = 0.0f;
};
QQuickRhiItemRenderer *ExampleRhiItem::createRenderer()
{
return new ExampleRhiItemRenderer;
}
void ExampleRhiItem::setAngle(float a)
{
if (m_angle == a)
return;
m_angle = a;
emit angleChanged();
update();
}
void ExampleRhiItemRenderer::synchronize(QQuickRhiItem *rhiItem)
{
ExampleRhiItem *item = static_cast<ExampleRhiItem *>(rhiItem);
if (item->angle() != m_angle)
m_angle = item->angle();
}
static QShader getShader(const QString &name)
{
QFile f(name);
return f.open(QIODevice::ReadOnly) ? QShader::fromSerialized(f.readAll()) : QShader();
}
static float vertexData[] = {
0.0f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.0f, 0.0f, 1.0f,
};
void ExampleRhiItemRenderer::initialize(QRhiCommandBuffer *cb)
{
if (m_rhi != rhi()) {
m_pipeline.reset();
m_rhi = rhi();
}
if (!m_pipeline) {
m_vbuf.reset(m_rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData)));
m_vbuf->create();
m_ubuf.reset(m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, 64));
m_ubuf->create();
m_srb.reset(m_rhi->newShaderResourceBindings());
m_srb->setBindings({
QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage, m_ubuf.get()),
});
m_srb->create();
m_pipeline.reset(m_rhi->newGraphicsPipeline());
m_pipeline->setShaderStages({
{ QRhiShaderStage::Vertex, getShader(QLatin1String(":/shaders/color.vert.qsb")) },
{ QRhiShaderStage::Fragment, getShader(QLatin1String(":/shaders/color.frag.qsb")) }
});
QRhiVertexInputLayout inputLayout;
inputLayout.setBindings({
{ 5 * sizeof(float) }
});
inputLayout.setAttributes({
{ 0, 0, QRhiVertexInputAttribute::Float2, 0 },
{ 0, 1, QRhiVertexInputAttribute::Float3, 2 * sizeof(float) }
});
m_pipeline->setVertexInputLayout(inputLayout);
m_pipeline->setShaderResourceBindings(m_srb.get());
m_pipeline->setRenderPassDescriptor(renderTarget()->renderPassDescriptor());
m_pipeline->create();
QRhiResourceUpdateBatch *resourceUpdates = m_rhi->nextResourceUpdateBatch();
resourceUpdates->uploadStaticBuffer(m_vbuf.get(), vertexData);
cb->resourceUpdate(resourceUpdates);
}
const QSize outputSize = renderTarget()->pixelSize();
m_viewProjection = m_rhi->clipSpaceCorrMatrix();
m_viewProjection.perspective(45.0f, outputSize.width() / (float) outputSize.height(), 0.01f, 1000.0f);
m_viewProjection.translate(0, 0, -4);
}
void ExampleRhiItemRenderer::render(QRhiCommandBuffer *cb)
{
QRhiResourceUpdateBatch *resourceUpdates = m_rhi->nextResourceUpdateBatch();
QMatrix4x4 modelViewProjection = m_viewProjection;
modelViewProjection.rotate(m_angle, 0, 1, 0);
resourceUpdates->updateDynamicBuffer(m_ubuf.get(), 0, 64, modelViewProjection.constData());
const QColor clearColor = QColor::fromRgbF(0.4f, 0.7f, 0.0f, 1.0f);
cb->beginPass(renderTarget(), clearColor, { 1.0f, 0 }, resourceUpdates);
cb->setGraphicsPipeline(m_pipeline.get());
const QSize outputSize = renderTarget()->pixelSize();
cb->setViewport(QRhiViewport(0, 0, outputSize.width(), outputSize.height()));
cb->setShaderResources();
const QRhiCommandBuffer::VertexInput vbufBinding(m_vbuf.get(), 0);
cb->setVertexInput(0, 1, &vbufBinding);
cb->draw(3);
cb->endPass();
}Cabe destacar que esta sencilla clase es casi idéntica al código mostrado en la introducción a QRhiWidget. Los shaders de vértices y de fragmentos también son los mismos. Se proporcionan como código fuente GLSL al estilo de Vulkan y deben ser procesados primero por la infraestructura de shaders de Qt. Esto se consigue ejecutando manualmente la herramienta de línea de comandos qsb o utilizando la función qt_add_shaders() en CMake. El QQuickRhiItem carga estos archivos .qsb preprocesados que se incluyen con la aplicación. Consulte Qt Shader Tools para obtener más información sobre la infraestructura de traducción de sombreadores de Qt.
color.vert
#version 440
layout(location = 0) in vec4 position;
layout(location = 1) in vec3 color;
layout(location = 0) out vec3 v_color;
layout(std140, binding = 0) uniform buf {
mat4 mvp;
};
void main()
{
v_color = color;
gl_Position = mvp * position;
}color.frag
#version 440
layout(location = 0) in vec3 v_color;
layout(location = 0) out vec4 fragColor;
void main()
{
fragColor = vec4(v_color, 1.0);
}Una vez integrado en QML (véase QML_NAMED_ELEMENT), nuestro elemento personalizado se puede instanciar en cualquier escena. (tras importar el archivo URI correspondiente, especificado para qt_add_qml_module() en el proyecto CMake)
ExampleRhiItem {
anchors.fill: parent
anchors.margins: 10
NumberAnimation on angle { from: 0; to: 360; duration: 5000; loops: Animation.Infinite }
}Consulte «Grafo de escena - Elemento de textura RHI» para ver un ejemplo más complejo.
Véase también QQuickRhiItemRenderer, Gráfico de escena: elemento de textura RHI, QRhi y Gráfico de escena y renderizado.
Documentación sobre tipos de miembros
enum class QQuickRhiItem::TextureFormat
Especifica el formato de la textura de fondo sobre la que se renderiza el ` QQuickRhiItem `.
| Constante | Valor | Descripción |
|---|---|---|
QQuickRhiItem::TextureFormat::RGBA8 | 0 | Véase QRhiTexture::RGBA8. Este es el valor por defecto. |
QQuickRhiItem::TextureFormat::RGBA16F | 1 | Véase « QRhiTexture::RGBA16F ». |
QQuickRhiItem::TextureFormat::RGBA32F | 2 | Consulte QRhiTexture::RGBA32F. |
QQuickRhiItem::TextureFormat::RGB10A2 | 3 | Consulte QRhiTexture::RGB10A2. |
Véase también QRhiTexture.
Documentación de la propiedad
alphaBlending : bool
Determina si la mezcla está siempre activada al dibujar el cuadrilátero texturizado con el contenido generado por QQuickRhiItem y su renderizador.
El valor por defecto es « false ». Esto se debe a motivos de rendimiento: si no hay semitransparencia, dado que el « QQuickRhiItemRenderer » se borra con un color opaco y nunca renderiza fragmentos con alfa inferior a 1, no tiene sentido habilitar la mezcla.
Si la subclase de QQuickRhiItemRenderer realiza el renderizado con semitransparencia, establece esta propiedad en «true».
Nota: En determinadas condiciones, la mezcla seguirá produciéndose independientemente del valor de esta propiedad. Por ejemplo, si el « opacity » del elemento (más concretamente, la opacidad combinada heredada de la cadena principal) es inferior a 1, la mezcla se activará automáticamente incluso cuando esta propiedad esté establecida en «false».
Nota: El gráfico de escena de « Qt Quick » se basa en el alfa premultiplicado y espera que este sea así. Por ejemplo, si la intención es borrar el fondo en el renderizador a un valor de alfa de 0,5, asegúrate de multiplicar también por 0,5 los valores de color de borrado del rojo, el verde y el azul. De lo contrario, los resultados de la mezcla serán incorrectos.
Funciones de acceso:
| bool | alphaBlending() const |
| void | setAlphaBlending(bool enable) |
Señal de notificador:
| void | alphaBlendingChanged() |
colorBufferFormat : TextureFormat
Esta propiedad controla el formato de la textura utilizada como búfer de color. El valor por defecto es TextureFormat::RGBA8. QQuickRhiItem admite el renderizado en un subconjunto de los formatos compatibles con QRhiTexture. Solo deben especificarse los formatos que QRhi::isTextureFormatSupported() indique que son compatibles; de lo contrario, el renderizado no funcionará.
Nota: Establecer un nuevo formato cuando el elemento y su renderizador ya están inicializados y se han renderizado implica que todos los objetos QRhiGraphicsPipeline creados por el renderizador pueden quedar inutilizables, si el QRhiRenderPassDescriptor asociado resulta ahora incompatible debido al formato de textura diferente. Al igual que al cambiar sampleCount de forma dinámica, esto significa que las implementaciones de initialize() o render() deben encargarse de liberar los pipelines existentes y crear otros nuevos.
Funciones de acceso:
| QQuickRhiItem::TextureFormat | colorBufferFormat() const |
| void | setColorBufferFormat(QQuickRhiItem::TextureFormat format) |
Señal del notificador:
| void | colorBufferFormatChanged() |
[read-only] effectiveColorBufferSize : QSize
Esta propiedad muestra el tamaño, en píxeles, del búfer de color subyacente (el « QRhiTexture » o « QRhiRenderBuffer »). Está pensada para su uso en el hilo de la interfaz gráfica de usuario (principal), en enlaces QML o en JavaScript.
Nota: Las implementacionesde QQuickRhiItemRenderer, que operan en el hilo de renderizado del grafo de escena, no deben utilizar esta propiedad. En su lugar, deben consultar el tamaño a través de render target.
Nota: El valor está disponible de forma asíncrona desde la perspectiva del hilo principal, en el sentido de que el valor cambia cuando se produce el renderizado en el hilo de renderizado. Esto significa que esta propiedad resulta útil principalmente en los enlaces QML. El código de la aplicación no debe dar por sentado que el valor ya está actualizado cuando se construye el objeto ` QQuickRhiItem `.
Esta es una propiedad de solo lectura.
Funciones de acceso:
| QSize | effectiveColorBufferSize() const |
Señal del notificador:
| void | effectiveColorBufferSizeChanged() |
fixedColorBufferHeight : int
La altura fija, en píxeles, de la textura asociada al elemento. Es relevante cuando se desea un tamaño fijo de textura que no dependa del tamaño del elemento. Este tamaño no afecta a la geometría del elemento (su tamaño y ubicación dentro de la escena), lo que significa que el contenido de la textura aparecerá estirado (ampliado) o reducido en el área del elemento.
Por defecto, el valor es ` 0`. Un valor de 0 significa que el tamaño de la textura se adapta al del elemento. (texture size = item size * device pixel ratio).
Consulta fixedColorBufferWidth para obtener más información sobre los casos de uso para establecer un ancho y una altura fijos.
Funciones de acceso:
| int | fixedColorBufferHeight() const |
| void | setFixedColorBufferHeight(int height) |
Señal de notificador:
| void | fixedColorBufferHeightChanged() |
fixedColorBufferWidth : int
El ancho fijo, en píxeles, de la textura o el búfer de renderizado asociado al elemento. Es relevante cuando se desea un tamaño fijo del búfer de color que no dependa del tamaño del elemento. Este tamaño no afecta a la geometría del elemento (su tamaño y ubicación dentro de la escena), lo que significa que el contenido de la textura aparecerá estirado (ampliado) o reducido en el área del elemento.
Por ejemplo, establecer un tamaño que sea exactamente el doble del tamaño (en píxeles) del elemento equivale, en la práctica, a realizar un supermuestreo 2x (renderizar al doble de resolución y, a continuación, reducir la escala de forma implícita al texturizar el cuadrilátero correspondiente al elemento en la escena). Por otro lado, establecer un tamaño que sea la mitad del tamaño en píxeles del elemento equivale, en la práctica, a renderizar a la mitad de la resolución y, a continuación, ampliar los resultados.
Por defecto, el valor es ` 0`. Un valor de 0 significa que el tamaño de la textura sigue el del elemento. (texture size = item size * device pixel ratio).
Nota: La relación de píxeles del dispositivo (el factor de escala del compositor del sistema) puede tener un gran impacto en el rendimiento, ya que un factor de escala de 2 (200 %) implica renderizar al doble de resolución, es decir, el doble de lo que el desarrollador y el diseñador de la interfaz de usuario perciben como el tamaño del elemento, para luego reducir efectivamente la escala del contenido, de forma similar a lo que ocurre al establecer esta propiedad en el doble del tamaño en píxeles del elemento en un sistema donde la relación de píxeles del dispositivo es 1. Por lo tanto, se espera que esta propiedad se utilice en contadas ocasiones con tamaños superiores al tamaño en píxeles del elemento, ya que muchos sistemas de escritorio modernos no tienen ni la necesidad ni el margen de rendimiento para ello, cuando el sistema ya utiliza de por sí una relación de píxeles del dispositivo superior a 1. En cambio, el principal caso de uso de esta propiedad es establecer un tamaño menor, con el fin de renderizar a una resolución razonablemente más baja en lugar de seguir ciegamente la geometría del elemento (y quizás de la ventana), por grande que sea.
Funciones de acceso:
| int | fixedColorBufferWidth() const |
| void | setFixedColorBufferWidth(int width) |
Señal de notificación:
| void | fixedColorBufferWidthChanged() |
mirrorVertically : bool
Esta propiedad controla si se invierten las coordenadas UV de la textura al dibujar el cuadrilátero texturizado. No tiene ningún efecto sobre el contenido del búfer de color fuera de pantalla ni sobre el renderizado implementado por QQuickRhiItemRenderer.
El valor por defecto es false.
Funciones de acceso:
| bool | isMirrorVerticallyEnabled() const |
| void | setMirrorVertically(bool enable) |
Señal de notificador:
| void | mirrorVerticallyChanged() |
sampleCount : int
Esta propiedad controla el número de muestras para el antialiasing de múltiples muestras. Por defecto, el valor es 1, lo que significa que el MSAA está desactivado.
Los valores válidos son 1, 4, 8 y, en ocasiones, 16 y 32. Se puede utilizar ` QRhi::supportedSampleCounts()` para consultar el número de muestras admitidas en tiempo de ejecución, pero normalmente las aplicaciones deben solicitar 1 (sin MSAA), 4x (MSAA normal) u 8x (MSAA alto).
Nota: Establecer un nuevo valor implica que todos los objetos ` QRhiGraphicsPipeline ` creados por el renderizador deben utilizar el mismo número de muestras a partir de ese momento. Los objetos ` QRhiGraphicsPipeline ` existentes creados con un número de muestras diferente ya no deben utilizarse. Cuando el valor cambia, todos los búferes de color y de profundidad-plantilla se destruyen y se vuelven a crear automáticamente, y se vuelve a invocar ` initialize()`. Sin embargo, cuando ` isAutoRenderTargetEnabled()` está en ` false`, corresponderá a la aplicación gestionar esto en lo que respecta al búfer de profundidad-plantilla o a los búferes de color adicionales.
Cambiar el número de muestras del valor predeterminado 1 a un valor superior implica que ` colorTexture()` pasa a ser ` nullptr ` y que ` msaaColorBuffer()` empieza a devolver un objeto válido. Volver a 1 (o 0) implica lo contrario: en la siguiente llamada a `initialize()`, `msaaColorBuffer()` devolverá ` nullptr`, mientras que `colorTexture()` volverá a ser válida. Además, resolveTexture() devuelve un QRhiTexture válido (no multimuestra) siempre que el número de muestras sea mayor que 1 (es decir, cuando se esté utilizando MSAA).
Funciones de acceso:
| int | sampleCount() const |
| void | setSampleCount(int samples) |
Señal de notificación:
| void | sampleCountChanged() |
Véase también QQuickRhiItemRenderer::msaaColorBuffer() y QQuickRhiItemRenderer::resolveTexture().
Documentación de funciones de miembro
[explicit] QQuickRhiItem::QQuickRhiItem(QQuickItem *parent = nullptr)
Crea un nuevo objeto `QQuickRhiItem` con el ` parent` indicado.
[override virtual noexcept] QQuickRhiItem::~QQuickRhiItem()
Destructor.
[pure virtual protected] QQuickRhiItemRenderer *QQuickRhiItem::createRenderer()
Reimplementa esta función para crear y devolver una nueva instancia de una subclase de ` QQuickRhiItemRenderer `.
Esta función se llamará en el hilo de renderizado mientras el hilo de la interfaz gráfica de usuario esté bloqueado.
[override virtual protected] bool QQuickRhiItem::event(QEvent *e)
Reimplementa: QQuickItem::event(QEvent *ev).
[override virtual protected] void QQuickRhiItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
Reimplementa: ` QQuickItem::geometryChange` (`const QRectF &newGeometry`, `const QRectF &oldGeometry`).
[protected] bool QQuickRhiItem::isAutoRenderTargetEnabled() const
Devuelve la configuración actual de gestión automática de los búferes de profundidad y estarcido y de los destinos de renderizado.
Por defecto, este valor es true.
Véase también setAutoRenderTarget().
[override virtual] bool QQuickRhiItem::isTextureProvider() const
Reimplementa: ` QQuickItem::isTextureProvider()` const.
[override virtual protected] void QQuickRhiItem::releaseResources()
Reimplementa: QQuickItem::releaseResources().
[protected] void QQuickRhiItem::setAutoRenderTarget(bool enabled)
Determina si el elemento crea y mantiene automáticamente un « QRhiRenderBuffer » de profundidad-plantilla y un « QRhiTextureRenderTarget ». El valor por defecto es « true ». Para desactivar esta función, llámala lo antes posible, por ejemplo, desde el constructor de la clase derivada, estableciendo « enabled » en « false ».
En modo automático, el tamaño y el número de muestras del búfer de profundidad-estencil siguen la configuración de la textura del búfer de color. En modo no automático, renderTarget() y depthStencilBuffer() siempre devuelven nullptr y, por lo tanto, corresponde a la implementación de initialize() de la aplicación encargarse de configurar y gestionar estos objetos.
[override virtual] QSGTextureProvider *QQuickRhiItem::textureProvider() const
Reimplementa: ` QQuickItem::textureProvider()` const.
© 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.