Obsolete Members for Qt3DRender
Los siguientes miembros de la clase ` Qt3DRender ` están obsoletos. Se incluyen para que el código fuente antiguo siga funcionando. Recomendamos encarecidamente no utilizarlos en código nuevo.
Espacios de nombres
Clases
(deprecated) class | QAbstractLight |
(deprecated) class | QAbstractRayCaster |
(deprecated) class | QAbstractTexture |
(deprecated) class | QAbstractTextureImage |
(deprecated) class | QAlphaCoverage |
(deprecated) class | QAlphaTest |
(deprecated) class | QBlendEquation |
(deprecated) class | QBlendEquationArguments |
(deprecated) class | QBlitFramebuffer |
(deprecated) class | QBufferCapture |
(deprecated) class | QCamera |
(deprecated) class | QCameraLens |
(deprecated) class | QCameraSelector |
(deprecated) class | QClearBuffers |
(deprecated) class | QClipPlane |
(deprecated) class | QColorMask |
(deprecated) class | QComputeCommand |
(deprecated) class | QCullFace |
(deprecated) class | QDebugOverlay |
(deprecated) class | QDepthRange |
(deprecated) class | QDepthTest |
(deprecated) class | QDirectionalLight |
(deprecated) class | QDispatchCompute |
(deprecated) class | QDithering |
(deprecated) class | QEffect |
(deprecated) class | QEnvironmentLight |
(deprecated) class | QFilterKey |
(deprecated) class | QFrameGraphNode |
(deprecated) class | QFrontFace |
(deprecated) class | QFrustumCulling |
(deprecated) class | QGeometryRenderer |
(deprecated) class | QGraphicsApiFilter |
(deprecated) class | QLayer |
(deprecated) class | QLayerFilter |
(deprecated) class | QLevelOfDetail |
(deprecated) class | QLevelOfDetailBoundingSphere |
(deprecated) class | QLevelOfDetailSwitch |
(deprecated) class | QLineWidth |
(deprecated) class | QMaterial |
(deprecated) class | QMemoryBarrier |
(deprecated) class | QMesh |
(deprecated) class | QMultiSampleAntiAliasing |
(deprecated) class | QNoDepthMask |
(deprecated) class | QNoDraw |
(deprecated) class | QNoPicking |
(deprecated) class | QObjectPicker |
(deprecated) class | QPaintedTextureImage |
(deprecated) class | QParameter |
(deprecated) class | QPickEvent |
(deprecated) class | QPickLineEvent |
(deprecated) class | QPickPointEvent |
(deprecated) class | QPickTriangleEvent |
(since 6.0, deprecated) class | QPickingProxy |
(deprecated) class | QPickingSettings |
(deprecated) class | QPointLight |
(deprecated) class | QPointSize |
(deprecated) class | QPolygonOffset |
(deprecated) class | QProximityFilter |
(deprecated) class | QRasterMode |
(deprecated) class | QRayCaster |
(deprecated) class | QRayCasterHit |
(deprecated) class | QRenderAspect |
(deprecated) class | QRenderCapabilities |
(deprecated) class | QRenderCapture |
(deprecated) class | QRenderCaptureReply |
(deprecated) class | QRenderPass |
(deprecated) class | QRenderPassFilter |
(deprecated) class | QRenderSettings |
(deprecated) class | QRenderState |
(deprecated) class | QRenderStateSet |
(deprecated) class | QRenderSurfaceSelector |
(deprecated) class | QRenderTarget |
(deprecated) class | QRenderTargetOutput |
(deprecated) class | QRenderTargetSelector |
(deprecated) class | QSceneLoader |
(deprecated) class | QScissorTest |
(deprecated) class | QScreenRayCaster |
(deprecated) class | QSeamlessCubemap |
(deprecated) class | QSetFence |
(deprecated) class | QShaderData |
(deprecated) class | QShaderImage |
(deprecated) class | QShaderProgram |
(deprecated) class | QShaderProgramBuilder |
(deprecated) class | QSharedGLTexture |
(deprecated) class | QSortPolicy |
(deprecated) class | QSpotLight |
(deprecated) class | QStencilMask |
(deprecated) class | QStencilOperation |
(deprecated) class | QStencilOperationArguments |
(deprecated) class | QStencilTest |
(deprecated) class | QStencilTestArguments |
(deprecated) class | QSubtreeEnabler |
(deprecated) class | QTechnique |
(deprecated) class | QTechniqueFilter |
(deprecated) class | QTexture1D |
(deprecated) class | QTexture1DArray |
(deprecated) class | QTexture2D |
(deprecated) class | QTexture2DArray |
(deprecated) class | QTexture2DMultisample |
(deprecated) class | QTexture2DMultisampleArray |
(deprecated) class | QTexture3D |
(deprecated) class | QTextureBuffer |
(deprecated) class | QTextureCubeMap |
(deprecated) class | QTextureCubeMapArray |
(deprecated) class | QTextureData |
(deprecated) class | QTextureDataUpdate |
(deprecated) class | QTextureImage |
(deprecated) class | QTextureImageData |
(deprecated) class | QTextureImageDataGenerator |
(deprecated) class | QTextureLoader |
(deprecated) class | QTextureRectangle |
(deprecated) class | QTextureWrapMode |
(deprecated) class | QViewport |
(deprecated) class | QWaitFence |
Espacios de nombres
[deprecated] namespace Qt3DRender::Quick
Este espacio de nombres está en desuso. Recomendamos encarecidamente no utilizarlo en código nuevo.
[deprecated] namespace Qt3DRender::Render
Este espacio de nombres está obsoleto. Recomendamos encarecidamente no utilizarlo en código nuevo.
Clases
[deprecated] class Qt3DRender::QAbstractLight
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QAbstractRayCaster
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Qt3DRender::QAbstractRayCaster Es una clase base abstracta para lanzar rayos en una escena 3D. Qt3DRender::QAbstractRayCaster no se puede instanciar directamente, sino a través de sus subclases. QAbstractRayCaster especifica propiedades comunes para todos los lanzadores de rayos, como el modo de ejecución y la gestión de capas, mientras que deja los detalles concretos del lanzamiento de rayos a las subclases.
El lanzamiento de rayos se diferencia de la selección (mediante Qt3DRender::QObjectPicker) en que no requiere eventos del ratón para activarse.
Por defecto, las instancias de ` Qt3DRender::QAbstractRayCaster ` están desactivadas. Cuando se activan, el rayo especificado se comprueba en cada fotograma para detectar objetos con los que se cruce. La propiedad ` QAbstractRayCaster::hits ` se actualizará con los resultados del trazado de rayos, incluso si no se encuentran objetos.
El ` Qt3DRender::QPickingSettings ` se puede utilizar para controlar el trazado de rayos, por ejemplo, qué primitivas se comprueban y cómo se devuelven los resultados.
Además, los componentes de « Qt3DRender::QLayer » pueden utilizarse para controlar cómo reaccionan las entidades, o los subgrafos de entidades, al lanzamiento de rayos.
Nota: Los componentes derivados de `QAbstractRayCaster` no deben compartirse entre varias entidades.
Véase también Qt3DRender::QRayCaster, Qt3DRender::QScreenRayCaster, Qt3DRender::QObjectPicker, Qt3DRender::QPickingSettings y Qt3DRender::QNoPicking.
[deprecated] class Qt3DRender::QAbstractTexture
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase `QAbstractTexture` no debe utilizarse directamente, sino a través de una de sus subclases. Cada subclase implementa un destino de textura determinado (2D, 2DArray, 3D, CubeMap, etc.). Cada subclase proporciona un conjunto de functores para cada capa, cara del mapa cúbico y nivel de mipmap. A su vez, el backend utiliza esos funtores para rellenar correctamente con datos la textura OpenGL correspondiente. Se espera que el funtor realice el mínimo procesamiento posible para no ralentizar la generación y la carga de texturas. Si el contenido de una textura es el resultado de un proceso de generación procedural lento, se recomienda no implementarlo directamente en un funtor.
Todas las texturas son únicas. Si instancias dos veces la misma textura, se crearán dos texturas idénticas en la GPU; no se producirá ningún tipo de uso compartido.
[deprecated] class Qt3DRender::QAbstractTextureImage
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Se debe utilizar `QAbstractTextureImage` como medio para proporcionar datos de imagen a un ` QAbstractTexture`. Contiene la información necesaria: nivel de mipmap, capa y cara del cubo, y carga los datos en el lugar adecuado dentro de una textura de OpenGL.
Los datos reales se proporcionan a través de un ` QTextureImageDataGenerator `, que será ejecutado por los trabajos de Aspect en el backend. Se debe crear una subclase de `QAbstractTextureImage` para proporcionar un functor y, en su caso, las propiedades adicionales que este necesite para cargar los datos reales.
Nota: QAbstractTextureImage nunca debe compartirse. Si no se respeta esta regla, cabe esperar fallos del sistema o, en el mejor de los casos, un comportamiento indefinido.
[deprecated] class Qt3DRender::QAlphaCoverage
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QAlphaCoverage ` habilita el modo de multimuestreo «alfa a cobertura». Cuando está habilitado, el valor alfa del fragmento se utiliza como cobertura para la muestra y se combina con el valor de cobertura del fragmento. ` Qt3DRender::QAlphaCoverage ` no realiza ninguna acción si el multimuestreo está deshabilitado. El modo «alfa a cobertura» resulta especialmente útil cuando se requiere una mezcla independiente del orden, por ejemplo, al renderizar hojas, hierba y otra vegetación densa.
Se puede añadir a un ` QRenderPass ` llamando a ` QRenderPass::addRenderState()`:
QRenderPass *renderPass = new QRenderPass();
// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();
// Add the render states to the render pass
renderPass->addRenderState(alphaCoverage);
renderPass->addRenderState(multiSampleAntialiasing);O a un « QRenderStateSet » llamando a QRenderStateSet::addRenderState():
QRenderStateSet *renderStateSet = new QRenderStateSet();
// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();
// Add the render states to the render state set
renderStateSet->addRenderState(alphaCoverage);
renderStateSet->addRenderState(multiSampleAntialiasing);Véase también Qt3DRender::QMultiSampleAntiAliasing.
[deprecated] class Qt3DRender::QAlphaTest
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Tal y como explica la documentación de OpenGL, la prueba alfa descarta un fragmento en función del resultado de una comparación entre el valor alfa del fragmento entrante y un valor de referencia constante.
[deprecated] class Qt3DRender::QBlendEquation
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La ecuación de mezcla se utiliza para determinar cómo se combina un nuevo píxel con uno que ya se encuentra en el búfer de imagen.
[deprecated] class Qt3DRender::QBlendEquationArguments
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
OpenGL anterior a la versión 3.0: Establece el mismo estado de mezcla para todos los búferes de dibujo (un QBlendEquationArguments). OpenGL 3.0-pre4.0: Establece el mismo estado de mezcla para todos los búferes de dibujo, pero permite desactivar la mezcla para búferes concretos (un QBlendEquationArguments para configurar glBlendFunc, n QBlendEquationArguments para activar o desactivar los búferes de dibujo). OpenGL 4.0 y posteriores: Permite establecer el estado de mezcla de forma individual para cada búfer de dibujo.
[deprecated] class Qt3DRender::QBlitFramebuffer
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Este nodo inserta un « glBlitFrameBuffer » o un equivalente en el flujo de comandos. Esto proporciona un método más eficiente para copiar rectángulos entre texturas o búferes de fondo de superficies envueltos por « QRenderTarget » que dibujar cuadriláteros texturizados. También admite el escalado con el método de interpolación especificado.
Nota: En la práctica, el nodo QBlitFramebuffer se suele utilizar en combinación con QNoDraw, ya que un blit no debería implicar la emisión de llamadas de dibujo para ninguna entidad.
[deprecated] class Qt3DRender::QBufferCapture
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QCamera
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QCameraLens
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QCameraSelector
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Se puede utilizar un objeto ` Qt3DRender::QCameraSelector ` para seleccionar la cámara que utiliza FrameGraph al dibujar las entidades.
[deprecated] class Qt3DRender::QClearBuffers
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un nodo FrameGraph de tipo « Qt3DRender::QClearBuffers » permite borrar los búferes de destino de renderizado específicos con valores concretos.
[deprecated] class Qt3DRender::QClipPlane
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Por defecto, OpenGL admite hasta 8 planos de recorte adicionales. Qt3DCore::QClipPlane permite habilitar uno de estos planos adicionales. A continuación, estos planos se pueden manipular en los shaders utilizando gl_ClipDistance[i], donde i varía entre 0 y 7. Es posible que la implementación subyacente admita más de 8 planos de recorte, pero no está garantizado.
[deprecated] class Qt3DRender::QColorMask
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Por defecto, la propiedad de cada componente de color (rojo, verde, azul, alfa) está establecida en « true », lo que significa que se escribirán en el búfer de fotogramas. Si se establece cualquiera de los componentes de color en « false », se evitará que se escriba en el búfer de fotogramas.
[deprecated] class Qt3DRender::QComputeCommand
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un ` Qt3DRender::QComputeCommand ` se utiliza para enviar trabajo al sombreador de cálculo. El sombreador de cálculo se especifica en el componente ` QMaterial ` de la misma entidad a la que se añade el `QComputeCommand`. Las propiedades ` workGroupX`, ` workGroupY ` y ` workGroupZ ` especifican los tamaños de los grupos de trabajo para la invocación del sombreador de cálculo. El nodo ` Qt3DRender::QDispatchCompute ` debe estar presente en el `FrameGraph` para que se puedan enviar realmente los comandos.
Nota: Si la política de renderizado se establece en « Qt3DRender::QRenderSettings::OnDemand » y no hay cambios en la escena, el « ComputeCommand » no se invocará repetidamente. Debe establecerse la política de renderizado « Qt3DRender::QRenderSettings::Always » para que el « ComputeCommand » se invoque repetidamente si no hay otros cambios en la escena que provoquen el renderizado de un nuevo fotograma.
[deprecated] class Qt3DRender::QCullFace
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QCullFace establece si se eliminan las caras delanteras o traseras. Las caras incluyen triángulos, cuadriláteros, polígonos y rectángulos.
Se puede añadir llamando al método addRenderState() en un QRenderPass:
// using namespace Qt3DRender;
QRenderPass *renderPass = new QRenderPass();
// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);
// Add the render state to the render pass
renderPass->addRenderState(cullFront);O bien llamando al método addRenderState() en un ` QRenderStateSet`:
// using namespace Qt3DRender;
QRenderStateSet *renderStateSet = new QRenderStateSet();
// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);
// Add the render state to the render pass
renderStateSet->addRenderState(cullFront);Véase también QFrontFace.
[deprecated] class Qt3DRender::QDebugOverlay
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Al colocar un QDebugOverlay en una rama de un framegraph personalizado, se renderizará una superposición con los detalles de la escena junto con la propia escena.
El QForwardRenderer estándar incluye un nodo QDebugOverlay que se puede habilitar mediante la propiedad QForwardRenderer::showDebugOverlay.
[deprecated] class Qt3DRender::QDepthRange
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Por defecto, OpenGL escribe la información de profundidad de la escena en el búfer de profundidad en el rango [0,0; 1,0], donde 0,0 corresponde al plano de recorte cercano y 1,0 al plano de recorte lejano. QDepthRange permite asignar estos valores a un intervalo diferente, de modo que algunas partes de la escena se representen siempre delante o detrás de otras. Los valores válidos para «cercano» y «lejano» están comprendidos entre 0 y 1.
[deprecated] class Qt3DRender::QDepthTest
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QDepthTest se utiliza para habilitar la comprobación de profundidad con una función de comprobación de profundidad determinada. La comprobación de profundidad permite escribir los valores de color de los fragmentos cuando se supera la comprobación, y rechaza los fragmentos que no la superan. La prueba de profundidad utiliza la función de profundidad para comparar el valor de profundidad de los fragmentos con el valor del búfer Z. Si la superficie subyacente no dispone de búfer Z, QDepthTest no realiza ninguna acción.
Véase también QAlphaTest y QStencilTest.
[deprecated] class Qt3DRender::QDirectionalLight
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una luz direccional es una fuente de luz que se comporta de forma similar a la luz solar. La luz procedente de una luz direccional incide sobre todos los objetos desde la misma dirección y con la misma intensidad, independientemente de dónde se encuentren en la escena.
[deprecated] class Qt3DRender::QDispatchCompute
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un « Qt3DRender::QDispatchCompute » permite enviar trabajo para que el shader de cálculo se ejecute en la GPU. Las propiedades « workGroupX », « workGroupY » y « workGroupZ » especifican los tamaños de los grupos de trabajo para la invocación del shader de cálculo. Es necesario añadir componentes « QComputeCommand » a las entidades para indicar a Qt3D que seleccione los materiales y la geometría de las entidades para la invocación del shader de cálculo. El tamaño de los grupos de trabajo para la invocación del sombreador será el máximo de los tamaños de grupo de trabajo especificados en QDispatchCompute y QComputeCommand.
[deprecated] class Qt3DRender::QDithering
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QDithering ` habilita el dithering. El dithering añade ruido a los valores de color para aleatorizar el error de cuantificación, con el fin de evitar que aparezcan patrones a gran escala en la imagen final, como las bandas. El dithering resulta especialmente útil al renderizar en una superficie con baja profundidad de color, como RGB565 o RGBA4444.
[deprecated] class Qt3DRender::QEffect
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QEffect combina un conjunto de técnicas y los parámetros que estas utilizan para generar un efecto de renderizado para un material.
Siempre que sea posible, una instancia de QEffect debería compartirse entre varias instancias de QMaterial.
Nota: El nodoQEffect no se puede desactivar.
QEffect *effect = new QEffect();
// Create technique, render pass and shader
QTechnique *gl3Technique = new QTechnique();
QRenderPass *gl3Pass = new QRenderPass();
QShaderProgram *glShader = new QShaderProgram();
// Set the shader on the render pass
gl3Pass->setShaderProgram(glShader);
// Add the pass to the technique
gl3Technique->addRenderPass(gl3Pass);
// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
// Add the technique to the effect
effect->addTechnique(gl3Technique);Un ` QParameter ` definido en un `QEffect` anula el parámetro (del mismo nombre) definido en QTechnique y QRenderPass, pero es anulado por el parámetro de QRenderPassFilter, QTechniqueFilter y QMaterial.
Véase también QMaterial, QTechnique y QParameter.
[deprecated] class Qt3DRender::QEnvironmentLight
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QEnvironmentLight utiliza cubemaps para implementar la iluminación basada en imágenes (IBL), una técnica que suele utilizarse junto con el renderizado basado en la física (PBR). Normalmente, se espera que los cubemaps se basen en imágenes de alto rango dinámico (HDR), con un formato OpenGL adecuado (como RGBA16F) que pueda gestionar el mayor rango de valores.
Existen diversas herramientas que pueden utilizarse para generar los cubemaps que necesita QEnvironmentLight. Algunos ejemplos son
HDRI Haven ofrece numerosas imágenes HDR con licencia CC0 que pueden utilizarse como material de partida para las herramientas mencionadas anteriormente.
[deprecated] class Qt3DRender::QFilterKey
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Las claves de filtro son utilizadas por QTechnique y QRenderPass para especificar en qué fase del renderizado se utiliza la técnica o la pasada de renderizado.
Nota: El nodoQFilterKey no se puede desactivar.
[deprecated] class Qt3DRender::QFrameGraphNode
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Esta clase rara vez se instancia directamente, ya que no proporciona ningún comportamiento específico de grafos de fotogramas, aunque puede resultar útil para agrupar otros nodos en grafos de fotogramas dinámicos. El comportamiento real proviene de las subclases.
Las subclases son:
| clase | descripción |
|---|---|
| Qt3DRender::QCameraSelector | Selecciona una cámara de entre todas las disponibles en la escena |
| Qt3DRender::QClearBuffers | Especifica qué búferes se deben borrar y con qué valores |
| Qt3DRender::QDispatchCompute | Especificar los núcleos de operación de cálculo |
| Qt3DRender::QFrustumCulling | Habilitar el culling del frustum |
| Qt3DRender::QLayerFilter | Selecciona qué capas se van a dibujar |
| Qt3DRender::QNoDraw | Desactivar el dibujo |
| Qt3DRender::QRenderPassFilter | Selecciona qué pasadas de renderizado se deben dibujar |
| Qt3DRender::QRenderStateSet | Establecer los estados de renderizado |
| Qt3DRender::QRenderSurfaceSelector | Seleccionar en qué superficie dibujar |
| Qt3DRender::QRenderTargetSelector | Selecciona en qué « QRenderTarget » dibujar |
| Qt3DRender::QSortPolicy | Especificar cómo se ordenan las entidades para determinar el orden de dibujo |
| Qt3DRender::QTechniqueFilter | Selecciona qué técnicas se van a utilizar para el dibujo |
| Qt3DRender::QViewport | Especificar la ventana gráfica |
| Qt3DRender::QMemoryBarrier | Coloca una barrera de memoria |
[deprecated] class Qt3DRender::QFrontFace
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un ` Qt3DRender::QFrontFace ` establece el sentido de enrollamiento de los polígonos orientados hacia delante.
Véase también QCullFace.
[deprecated] class Qt3DRender::QFrustumCulling
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QFrustumCulling permite el culling de frustum de las entidades dibujables en función de la vista de la cámara y los límites de QGeometry de las entidades. Si QFrustumCulling está presente en el FrameGraph, solo se dibujan las entidades cuyos límites de QGeometry se cruzan con el frustum de la cámara, es decir, con la vista de la cámara. Si no está presente QFrustumCulling, se dibujarán todas las entidades dibujables. La cámara se selecciona mediante un nodo « QCameraSelector » del grafo de fotogramas en la jerarquía actual. El culling de frustum puede ahorrar mucho tiempo de procesamiento de la GPU cuando la escena renderizada es compleja.
Véase también QCameraSelector.
[deprecated] class Qt3DRender::QGeometryRenderer
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un ` Qt3DRender::QGeometryRenderer ` contiene toda la información necesaria para dibujar un ` Qt3DCore::QGeometry`. Un `QGeometry` contiene las coordenadas de los datos geométricos; `QGeometryRenderer` especifica cómo interpretar dichos datos.
[deprecated] class Qt3DRender::QGraphicsApiFilter
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QLayer
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Qt3DRender::QLayer Funciona junto con la clase « Qt3DRender::QLayerFilter » en el FrameGraph.
Se puede aplicar un QLayer a un subárbol de entidades estableciendo la propiedad «recursive» en «true».
#include <Qt3DCore/QEntity>
#include <Qt3DRender/QGeometryRenderer>
#include <Qt3DRender/QLayer>
#include <Qt3DRender/QLayerFilter>
#include <Qt3DRender/QViewport>
// Scene
Qt3DCore::QEntity *rootEntity = new Qt3DCore::Qt3DCore::QEntity;
Qt3DCore::QEntity *renderableEntity = new Qt3DCore::Qt3DCore::QEntity(rootEntity);
Qt3DRender::QGeometryRenderer *geometryRenderer = new Qt3DCore::QGeometryRenderer(renderableEntity);
Qt3DRender::QLayer *layer1 = new Qt3DCore::QLayer(renderableEntity);
layer1->setRecursive(true);
renderableEntity->addComponent(geometryRenderer);
renderableEntity->addComponent(layer1);
...
// FrameGraph
Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport;
Qt3DRender::QLayerFilter *layerFilter = new Qt3DRender::QLayerFilter(viewport);
layerFilter->addLayer(layer1);
...Véase también « Qt3DRender::QLayerFilter ».
[deprecated] class Qt3DRender::QLayerFilter
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Se puede utilizar un « Qt3DRender::QLayerFilter » para indicar al renderizador qué capa o capas debe dibujar en esa rama del gráfico de fotogramas. «QLayerFilter» selecciona qué entidades dibujar en función de las instancias de « QLayer » añadidas a «QLayerFilter» y como componentes de « Qt3DCore::QEntity ».
QLayerFilter puede configurarse para seleccionar o descartar entidades con un QLayer específico en función de la propiedad filterMode. Por defecto, se seleccionan las entidades que hacen referencia a uno de los objetos QLayer a los que también hace referencia el QLayerFilter (AcceptAnyMatchingLayers).
Dentro del árbol FrameGraph, pueden anidarse varios nodos « QLayerFilter » en una rama que va desde la raíz hasta una hoja. En ese caso, el filtrado se aplicará primero a todas las entidades de la escena utilizando el método de filtrado especificado por el primer QLayerFilter declarado. A continuación, el subconjunto filtrado de entidades se filtrará de nuevo según el método de filtrado establecido en el segundo QLayerFilter declarado. Este proceso se repite hasta que se hayan procesado todos los nodos QLayerFilter de la rama.
[deprecated] class Qt3DRender::QLevelOfDetail
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QLevelOfDetail se puede utilizar para controlar la representación de una entidad en función de la distancia al observador o del tamaño en pantalla.
Para mejorar el rendimiento del renderizado, los objetos muy pequeños pueden representarse con muchos menos detalles, tanto en geometría como en textura.
El componente se controla especificando umbrales de valores que se interpretan como distancias desde la cámara o como tamaño de pantalla.
A medida que cambia el punto de vista, la propiedad ` currentIndex ` cambiará para reflejar el valor correspondiente en la matriz de rangos.
La propiedad « currentIndex » puede utilizarse, por ejemplo, para activar o desactivar entidades, cambiar el material, etc.
El componente « LevelOfDetail » no se puede compartir entre varios « entities ».
#include <Qt3DCore/QEntity>
#include <Qt3DRender/QGeometryRenderer>
#include <Qt3DRender/QLevelOfDetail>
// Scene
Qt3DCore::QEntity *rootEntity = new Qt3DCore::Qt3DCore::QEntity;
Qt3DCore::QEntity *renderableEntity = new Qt3DCore::QEntity(rootEntity);
Qt3DRender::QGeometryRenderer *geometryRenderer = new Qt3DCore::QGeometryRenderer(renderableEntity);
renderableEntity->addComponent(geometryRenderer);
Qt3DRender::QLevelOfDetail* lod = new Qt3Render::QLevelOfDetail(renderableEntity);
QList<qreal> thresholds = {20, 35, 50, 65};
lod->setThresholds(thresholds);
lod->setCamera(mainCamera);
renderableEntity->addComponent(lod);
// connect to QLevelOfDetail::currentIndexChanged to toggle rendering
...[deprecated] class Qt3DRender::QLevelOfDetailBoundingSphere
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QLevelOfDetailSwitch
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Este componente está asignado a una entidad. Cuando la entidad cambia de distancia con respecto a la cámara, QLevelOfDetailSwitch desactivará todas las entidades secundarias excepto la que coincida con el índice Qt3DRender::QLevelOfDetailSwitch::currentIndex.
[deprecated] class Qt3DRender::QLineWidth
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QMaterial
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QMaterial ofrece una forma de especificar la representación de un entity. Cualquier aspecto puede definir su propia subclase de QMaterial, de modo que un Material pueda utilizarse para describir un elemento visual; por ejemplo, la forma en que el sonido debe reflejarse en un elemento, la temperatura de una superficie, etc.
Por sí solo, un QMaterial no hace nada. Solo cuando hace referencia a un nodo de « QEffect » es cuando un QMaterial resulta útil.
En la práctica, suele ocurrir que varios componentes QMaterial hacen referencia a un mismo QEffect. Esto permite crear los efectos, las técnicas, las pasadas y los sombreadores una sola vez, al tiempo que permite especificar el material añadiendo instancias de QParameter.
Un « QParameter » definido en un QMaterial anula el parámetro (del mismo nombre) definido en un « QEffect », « QTechnique » y « QRenderPass », pero queda anulado por el parámetro de « QRenderPassFilter » y « QTechniqueFilter ».
QMaterial *material1 = new QMaterial();
QMaterial *material2 = new QMaterial();
// Create effect, technique, render pass and shader
QEffect *effect = new QEffect();
QTechnique *gl3Technique = new QTechnique();
QRenderPass *gl3Pass = new QRenderPass();
QShaderProgram *glShader = new QShaderProgram();
// Set the shader on the render pass
gl3Pass->setShaderProgram(glShader);
// Add the pass to the technique
gl3Technique->addRenderPass(gl3Pass);
// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
// Add the technique to the effect
effect->addTechnique(gl3Technique);
// Set the effect on the materials
material1->setEffect(effect);
material2->setEffect(effect);
// Set different parameters on the materials
const QString parameterName = QStringLiteral("color");
material1->addParameter(new QParameter(parameterName, QColor::fromRgbF(0.0f, 1.0f, 0.0f, 1.0f)));
material2->addParameter(new QParameter(parameterName, QColor::fromRgbF(1.0f, 1.0f, 1.0f, 1.0f)));Véase también QEffect, QTechnique y QParameter.
[deprecated] class Qt3DRender::QMemoryBarrier
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un nodo FrameGraph de tipo « Qt3DRender::QMemoryBarrier » se utiliza para colocar una barrera de memoria específica en un momento concreto del renderizado. Esto es necesario para sincronizar correctamente los comandos de dibujo y cálculo en la GPU.
La barrera define el orden de las operaciones de memoria emitidas por un comando anterior. Esto significa que, si el comando 1 está manipulando un búfer que se va a utilizar como búfer de atributos de vértices en un comando 2 posterior, la barrera de memoria debe colocarse después del comando 1 y debe establecerse el tipo de barrera adecuado para el búfer de atributos de vértices.
Cuando se encuentra un nodo «QMemoryBarrier» en una rama de FrameGraph, la barrera se aplicará antes de cualquier comando de dibujo o cálculo, incluso si estos están definidos más adelante en la rama.
Para el renderizado con OpenGL, esta página ofrece más información sobre el modelo de memoria.
[deprecated] class Qt3DRender::QMesh
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Carga datos de malla desde archivos externos en diversos formatos. Qt3DRender::QMesh carga los datos en una única malla.
En Qt3D 5.9, QMesh admite los siguientes formatos:
- Wavefront OBJ
- Formato de triángulos de Stanford (PLY)
- STL (STereoLithography)
QMesh también admitirá el siguiente formato si se ha instalado el SDK y se ha compilado y localizado el complemento de carga de geometría FBX:
- Autodesk FBX
Si deseas cargar una escena completa compuesta por varios objetos, es mejor que utilices la herramienta « Qt3DRender::QSceneLoader » (Cargar escena completa).
Véase también Qt3DRender::QSceneLoader.
[deprecated] class Qt3DRender::QMultiSampleAntiAliasing
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase « Qt3DRender::QMultiSampleAntiAliasing » permite el antialiasing multimuestra.
Se puede añadir a un ` QRenderPass ` llamando a ` QRenderPass::addRenderState()`:
QRenderPass *renderPass = new QRenderPass();
QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderPass->addRenderState(msaa);O bien, a un ` QRenderStateSet ` llamando a ` QRenderStateSet::addRenderState()`:
QRenderStateSet *renderStateSet = new QRenderStateSet();
QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderStateSet->addRenderState(msaa);Para que el multimuestreo surta efecto, el destino de renderizado debe haberse asignado con el multimuestreo habilitado:
QTexture2DMultisample *colorTex = new QTexture2DMultisample;
colorTex->setFormat(QAbstractTexture::RGBA8_UNorm);
colorTex->setWidth(1024);
colorTex->setHeight(1024);
QRenderTargetOutput *color = new QRenderTargetOutput;
color->setAttachmentPoint(QRenderTargetOutput::Color0);
color->setTexture(colorTex);
QTexture2DMultisample *depthStencilTex = new QTexture2DMultisample;
depthStencilTex->setFormat(QAbstractTexture::RGBA8_UNorm);
depthStencilTex->setWidth(1024);
depthStencilTex->setHeight(1024);
QRenderTargetOutput *depthStencil = new QRenderTargetOutput;
depthStencil->setAttachmentPoint(QRenderTargetOutput::DepthStencil);
depthStencil->setTexture(depthStencilTex);
Qt3DRender::QRenderTarget *renderTarget = new Qt3DRender::QRenderTarget;
renderTarget->addOutput(color);
renderTarget->addOutput(depthStencil);Además, el código del shader debe utilizar tipos de muestreador de multimuestreo y texelFetch() en lugar de texture().
Por ejemplo, si tienes un código como
#version 150
uniform sampler2D colorTexture;
in vec2 texCoord;
out vec4 fragColor;
void main()
{
fragColor = texture(colorTexture, texCoord);
}puedes reescribirlo así
#version 150
uniform sampler2DMS colorTexture;
in vec2 texCoord;
out vec4 fragColor;
void main()
{
ivec2 tc = ivec2(floor(textureSize(colorTexture) * texCoord));
vec4 c = texelFetch(colorTexture, tc, 0) +
texelFetch(colorTexture, tc, 1) +
texelFetch(colorTexture, tc, 2) +
texelFetch(colorTexture, tc, 3);
fragColor = c / 4.0;
}Nota: Cuando se utiliza OpenGL como API gráfica, se llamará a glEnable(GL_MULTISAMPLE) si se ha añadido QMultiSampleAntiAliasing a los estados de renderizado.
[deprecated] class Qt3DRender::QNoDepthMask
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase « Qt3DRender::QNoDepthMask » desactiva la escritura de la profundidad de los fragmentos en el búfer de profundidad.
Véase también ` Qt3DRender::QDepthTest`.
[deprecated] class Qt3DRender::QNoDraw
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Qt3DRender::QNoDraw Debe utilizarse cuando FrameGraph necesite configurar algunos estados de renderizado o borrar algunos búferes sin que sea necesario dibujar ninguna malla. Tiene el mismo efecto que disponer de un « Qt3DRender::QRenderPassFilter » que no coincida con ninguna de las instancias « Qt3DRender::QRenderPass » disponibles de la escena, pero sin el coste adicional que supone realizar realmente el filtrado.
Cuando está desactivado, un nodo « Qt3DRender::QNoDraw » no impedirá que se renderice la escena. Por lo tanto, activar o desactivar la propiedad «enabled» es una forma de hacer que un « Qt3DRender::QNoDraw » esté activo o inactivo.
Qt3DRender::QNoDraw Suele utilizarse como elemento secundario de un nodo Qt3DRender::QClearBuffers para evitar que se dibuje la escena cuando hay varias pasadas de renderizado.
Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
Qt3DRender::QCameraSelector *cameraSelector = new Qt3DRender::QCameraSelector(viewport);
Qt3DRender::QClearBuffers *clearBuffers = new Qt3DRender::QClearBuffers(cameraSelector);
clearBuffers->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);
Qt3DRender::QNoDraw *noDraw = new Qt3DRender::QNoDraw(clearBuffers);
Qt3DRender::QRenderPassFilter *mainPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....
Qt3DRender::QRenderPassFilter *previewPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....[deprecated] class Qt3DRender::QNoPicking
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Cuando está desactivado, un nodo « Qt3DRender::QNoPicking » no impedirá que se realice la selección. Por lo tanto, activar o desactivar la propiedad «enabled» es una forma de activar o desactivar un « Qt3DRender::QNoPicking ».
Cuando se utilizan varias subventanas de visualización en el FrameGraph, «QNoPicking» puede resultar útil para evitar conflictos de selección entre ventanas de visualización superpuestas o no visibles. También puede utilizarse como optimización para evitar trabajo innecesario en ventanas de visualización ocultas o en secciones de las escenas que no requieran ninguna selección.
Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
Qt3DRender::QCameraSelector *cameraSelector = new Qt3DRender::QCameraSelector(viewport);
Qt3DRender::QNoPicking *noPicking = new Qt3DRender::QNoPicking(cameraSelector);
Qt3DRender::QClearBuffers *clearBuffers = new Qt3DRender::QClearBuffers(noPicking);
clearBuffers->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);
Qt3DRender::QRenderPassFilter *mainPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....
Qt3DRender::QRenderPassFilter *previewPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....Véase también Qt3DRender::QObjectPicker, Qt3DRender::QRayCaster y Qt3DRender::QScreenRayCaster.
[deprecated] class Qt3DRender::QObjectPicker
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Para cada combinación de ventana gráfica y cámara, la selección lanza un rayo a través de la escena para encontrar entidades cuyo volumen delimitador se cruce con el rayo. El volumen delimitador se calcula utilizando los valores del búfer de atributos especificado por el atributo `boundingVolumePositionAttribute` de la geometría.
Las señales pressed(), released(), clicked(), moved(), entered() y exited() se emiten cuando el volumen delimitador definido por la propiedad pickAttribute se cruza con un rayo.
La mayoría de las señales transportan una instancia de ` QPickEvent `. Si `QPickingSettings::pickMode()` está establecido en ` QPickingSettings::TrianglePicking`, el tipo real del parámetro de selección será ` QPickTriangleEvent`.
Las consultas de selección se realizan al pulsar y al soltar el botón del ratón. Si está habilitado el arrastre, las consultas también se producen con cada movimiento del ratón mientras se mantenga pulsado cualquier botón. Si está habilitado el paso del cursor, las consultas se producen con cada movimiento del ratón, incluso si no se pulsa ningún botón.
Para consultas generalizadas de ray casting, consulta Qt3DRender::QRayCaster y Qt3DRender::QScreenRayCaster.
Nota: Las instancias de este componente no deben compartirse; si no se respeta esta condición, es muy probable que se produzca un comportamiento indefinido.
Nota: El valor del plano lejano de la cámara afecta a la selección y produce resultados incorrectos debido a la precisión de los números en coma flotante si es superior a ~100 000.
Véase también Qt3DRender::QPickingSettings, Qt3DCore::QGeometry, Qt3DCore::QAttribute, Qt3DRender::QPickEvent, Qt3DRender::QPickTriangleEvent y Qt3DRender::QNoPicking.
[deprecated] class Qt3DRender::QPaintedTextureImage
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una clase `QPaintedTextureImage` permite especificar una imagen de textura (y, por lo tanto, una textura de OpenGL) mediante un ` QPainter`. El ancho y la altura de la imagen de textura se pueden especificar mediante las propiedades `width`, `height` o `size`.
Un `QPaintedTextureImage` debe ser subclasificado y debe implementarse la función virtual ` paint()`. Cada vez que se llama a ` update()` en el `QPaintedTextureImage`, se invoca la función ` paint()` y se carga la imagen resultante.
El objeto `QPaintedTextureImage` debe estar asociado a algún objeto ` QAbstractTexture`.
[deprecated] class Qt3DRender::QParameter
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Se puede hacer referencia a un `QParameter` mediante ` QRenderPass`, ` QTechnique`, ` QEffect`, ` QMaterial`, ` QTechniqueFilter` o ` QRenderPassFilter`. En tiempo de ejecución, dependiendo del shader seleccionado para un paso determinado del renderizado, el valor contenido en un `QParameter` se convertirá y se cargará si el shader contiene un uniforme cuyo nombre coincida con el del `QParameter`.
QParameter *param = new QParameter();
param->setName(QStringLiteral("diffuseColor"));
param->setValue(QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));
// Alternatively you can create and set a QParameter this way
QParameter *param2 = new QParameter(QStringLiteral("diffuseColor"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));
// Such QParameters will work with the following GLSL uniform shader declarations
// uniform vec4 diffuseColor;
// uniform vec3 diffuseColor;
// uniform vec2 diffuseColor;
// uniform float diffuseColor;Nota: hay que tener cuidado para garantizar que el valor envuelto por un QParameter pueda realmente convertirse a lo que espera el uniforme real. Proporcionar un valor almacenado como int cuando el uniforme real del sombreador es de tipo float podría dar lugar a comportamientos indefinidos.
Nota: cuando el uniforme de destino es una matriz, el nombre debe ser el nombre del uniforme con [0] añadido al final.
Nota: El nodoQParameter no se puede desactivar.
QParameter *param = new QParameter();
QVariantList values = QVariantList() << 0.0f << 1.0f << 2.0f << 3.0f << 4.0f << 883.0f << 1340.0f << 1584.0f;
param->setName(QStringLiteral("diffuseValues[0]"));
param->setValue(values);
// Matching GLSL shader uniform declaration
// uniform float diffuseValues[8];En lo que respecta a la compatibilidad con texturas, el valor de QParameter debe establecerse en la subclase adecuada de QAbstractTexture que coincida con el tipo de muestreador del uniforme del sombreador.
QTexture2D *texture = new QTexture2D();
...
QParameter *param = new QParameter();
param->setName(QStringLiteral("diffuseTexture"));
param->setValue(QVariant::fromValue(texture));
// Works with the following GLSL uniform shader declaration
// uniform sampler2D diffuseTextureVéase también QAbstractTexture.
[deprecated] class Qt3DRender::QPickEvent
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Se recibe como parámetro en la mayoría de las señales del componente QObjectPicker cuando la selección se realiza correctamente.
Véase también QPickingSettings, QPickTriangleEvent y QObjectPicker.
[deprecated] class Qt3DRender::QPickLineEvent
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Véase también QPickEvent.
[deprecated] class Qt3DRender::QPickPointEvent
Esta clase está en desuso. Recomendamos encarecidamente no utilizarla en código nuevo.
Véase también QPickEvent.
[deprecated] class Qt3DRender::QPickTriangleEvent
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Cuando QPickingSettings::pickMode() se establece en « QPickingSettings::TrianglePicking », las señales de QObjectPicker transportarán una instancia de QPickTriangleEvent.
Esta contiene los detalles del triángulo que se ha seleccionado.
Nota: En el caso del renderizado indexado, los índices de los puntos son relativos a la matriz de coordenadas, no a la matriz de índices.
Véase también QPickingSettings, QPickEvent y QObjectPicker.
[since 6.0, deprecated] class Qt3DRender::QPickingProxy
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La selección puede ser una operación costosa, especialmente si la malla tiene muchos vértices. Se puede utilizar QPickProxy para proporcionar una geometría alternativa, normalmente con menos primitivas, que se utilizará para la selección, mientras que la instancia de GeometryRenderer se utilizará para el renderizado.
Nota: No utilices un QPickingProxy si la aplicación requiere que las coordenadas de selección coincidan con la malla renderizada.
Nota: El algoritmo de selección utiliza una jerarquía de volúmenes delimitadores para descartar aquellas entidades cuyo volumen delimitador no se cruza con el rayo de selección. Para dicha jerarquía, se utilizará el volumen delimitador de la entidad renderizada (o uno establecido explícitamente mediante un componente QBoundingVolume) en lugar del del proxy.
Esta clase se introdujo en Qt 6.0.
[deprecated] class Qt3DRender::QPickingSettings
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La configuración de selección determina cómo se gestiona la selección de entidades. Para obtener más detalles sobre la selección de entidades, consulta la documentación de los componentes QObjectPicker y QRayCaster.
Al utilizar los componentes QObjectPicker, la selección se activa mediante eventos del ratón.
Al utilizar los componentes QRayCaster o QScreenRayCaster, la selección puede activarse explícitamente desde la aplicación.
En ambos casos, se proyectará un rayo a través de la escena para encontrar la geometría que se cruce con él.
Véase también QObjectPicker, QPickEvent, QPickTriangleEvent, QRayCaster y QScreenRayCaster.
[deprecated] class Qt3DRender::QPointLight
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una luz puntual es una fuente de luz que emite luz en todas las direcciones desde un único punto. Conceptualmente, es similar a la luz que emite una bombilla estándar.
Una luz puntual utiliza tres factores de atenuación para describir cómo disminuye la intensidad de la luz con la distancia. Estos factores están diseñados para utilizarse conjuntamente en el cálculo de la atenuación total. Para los materiales de Qt3D Extras se utiliza la siguiente fórmula, donde «distancia» es la distancia desde la luz hasta la superficie que se está renderizando:
totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));Los materiales personalizados pueden optar por interpretar estos factores de forma diferente.
[deprecated] class Qt3DRender::QPointSize
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Cuando la propiedad « sizeMode » se establece en « SizeMode::Fixed », el valor se establece mediante «glPointSize()», si está disponible. Cuando se utiliza « SizeMode::Programmable », «gl_PointSize» debe establecerse dentro de los programas de sombreado; en ese caso, se ignora el valor proporcionado a esta « RenderState ».
[deprecated] class Qt3DRender::QPolygonOffset
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QPolygonOffset añade un desplazamiento al valor de profundidad del fragmento antes de la prueba de profundidad y la escritura de profundidad. El desplazamiento se puede utilizar para evitar el «z-fighting» al renderizar polígonos con valores de profundidad muy próximos entre sí, como las calcomanías.
[deprecated] class Qt3DRender::QProximityFilter
Esta clase está en desuso. Recomendamos encarecidamente no utilizarla en código nuevo.
Se puede utilizar un « Qt3DRender::QProximityFilter » para seleccionar las entidades que se van a representar cuando se sitúan dentro de un umbral de distancia determinado respecto a otra entidad.
[deprecated] class Qt3DRender::QRasterMode
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QRasterMode se utiliza para controlar la etapa de rasterización de las primitivas en el momento del renderizado. Se puede utilizar para elegir si solo queremos mostrar puntos, aristas o rellenar una primitiva.
Nota: Esta función no es compatible con el renderizado en plataformas OpenGL ES 2.0.
Véase también QAlphaTest y QStencilTest.
[deprecated] class Qt3DRender::QRayCaster
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
El rayo 3D se define por su origen, dirección y longitud. Se verá afectado por las transformaciones aplicadas a la entidad a la que pertenece.
Las pruebas de trazado de rayos se realizarán en cada fotograma siempre que el componente esté habilitado. La propiedad «hits» se actualizará con la lista de intersecciones.
Véase también QAbstractRayCaster, QScreenRayCaster y QNoPicking.
[deprecated] class Qt3DRender::QRayCasterHit
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Qt3DRender::QRayCasterHit Contiene los detalles de un impacto correcto al lanzar un rayo a través de un modelo utilizando un componente Qt3DRender::QRayCaster o Qt3DRender::QScreenRayCaster.
Véase también Qt3DRender::QRayCaster, Qt3DRender::QScreenRayCaster y Qt3DRender::QPickingSettings.
[deprecated] class Qt3DRender::QRenderAspect
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QRenderCapabilities
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QRenderCapabilities proporciona detalles sobre las características gráficas disponibles en tiempo de ejecución. Se puede utilizar para decidir qué ruta de código emplear para determinados algoritmos, por ejemplo, en función de si hay shaders de cálculo disponibles o no.
[deprecated] class Qt3DRender::QRenderCapture
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QRenderCapture se utiliza para capturar el renderizado en una imagen en cualquier fase del proceso. La captura debe ser iniciada por el usuario y se devuelve una imagen por cada solicitud de captura. El usuario puede enviar varias solicitudes de captura de renderizado simultáneamente, pero solo se atiende una solicitud por instancia de QRenderCapture por fotograma.
[deprecated] class Qt3DRender::QRenderCaptureReply
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un objeto que recibe la imagen de QRenderCapture::requestCapture.
[deprecated] class Qt3DRender::QRenderPass
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un « Qt3DRender::QRenderPass » especifica una única pasada de renderizado —una instancia de ejecución del programa de sombreado— utilizada por « Qt3DRender::QTechnique ». La pasada de renderizado consta de un « Qt3DRender::QShaderProgram » y una lista de objetos « Qt3DRender::QFilterKey », una lista de objetos « Qt3DRender::QRenderState » y una lista de objetos « Qt3DRender::QParameter ».
QRenderPass ejecuta el QShaderProgram utilizando los nodos QRenderState y QParameter proporcionados cuando al menos uno de los nodos QFilterKey a los que se hace referencia coincide con cualquiera de los nodos QFilterKey de QRenderPassFilter o cuando no se especifican nodos QFilterKey y no hay ningún QRenderPassFilter presente en el FrameGraph.
Si el QRenderPass define un ` QParameter`, este quedará anulado por un ` QParameter ` con el mismo nombre si existe en cualquiera de los ` QTechnique`, ` QEffect`, ` QMaterial`, ` QTechniqueFilter` o ` QRenderPassFilter ` asociados al paso en tiempo de ejecución. Esto puede seguir siendo útil para definir valores predeterminados razonables.
En el momento del renderizado, para cada nodo hoja del FrameGraph se registra un estado de renderizado base mediante la acumulación de los estados definidos por todos los nodos QRenderStateSet de la rama del FrameGraph. Cada QRenderPass puede sobrescribir este estado de renderizado base especificando sus propios nodos QRenderState.
// Create the render passes
QRenderPass *pass = new QRenderPass();
// Create shader program
QShaderProgram *glShader = new QShaderProgram();
// Set the shader on the render pass
pass->setShaderProgram(glShader);
// Create a FilterKey
QFilterKey *filterKey = new QFilterKey();
filterKey->setName(QStringLiteral("name"));
fitlerKey->setValue(QStringLiteral("zFillPass"));
// Add the FilterKey to the pass
pass->addFilterKey(filterKey);
// Create a QParameter
QParameter *colorParameter = new QParameter(QStringLiteral("color"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));
// Add parameter to pass
pass->addParameter(colorParameter);
// Create a QRenderState
QDepthTest *depthTest = new QDepthTest();
// Add the render state to the pass
pass->addRenderState(depthTest);Véase también QRenderPassFilter, QFilterKey, QParameter, QRenderState, QEffect y QTechnique.
[deprecated] class Qt3DRender::QRenderPassFilter
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un nodo « Qt3DRender::QRenderPassFilter » de FrameGraph se utiliza para seleccionar qué objetos « Qt3DRender::QRenderPass » se van a dibujar. «QRenderPassFilter» especifica una lista de objetos « Qt3DRender::QFilterKey » y « Qt3DRender::QParameter ». Cuando «QRenderPassFilter» está presente en el FrameGraph, solo se seleccionan para el renderizado los objetos « QRenderPass » cuyos objetos « Qt3DRender::QFilterKey » coincidan con las claves de «QRenderPassFilter». Si no hay ningún QRenderPassFilter, se seleccionan todos los objetos QRenderPass para su renderizado. Los parámetros de la lista pueden utilizarse para establecer valores para los parámetros del shader. Los parámetros de QRenderPassFilter anulan los parámetros de QTechniqueFilter, QMaterial, QEffect, QTechnique y QRenderPass.
[deprecated] class Qt3DRender::QRenderSettings
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
El componente QRenderSettings debe configurarse como un componente de la entidad raíz de la escena. Especifica la política de renderizado y la configuración de selección, además de albergar el FrameGraph activo.
[deprecated] class Qt3DRender::QRenderState
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QRenderState ` es una clase base abstracta para todos los estados de renderizado. No se puede instanciar `QRenderState` directamente, sino a través de sus subclases.
[deprecated] class Qt3DRender::QRenderStateSet
Esta clase está en desuso. Recomendamos encarecidamente no utilizarla en código nuevo.
Los estados establecidos en un `QRenderStateSet` se aplican de forma global, a diferencia de los estados por material que se pueden establecer en un ` QRenderPass`. Por defecto, un `QRenderStateSet` vacío provocará que todos los estados de renderizado queden desactivados al ejecutarse. Añadir un estado ` QRenderState ` activa explícitamente ese estado de renderizado en tiempo de ejecución.
El ` RenderStateSet ` se habilita al añadirlo al gráfico de fotogramas activo:
// using namespace Qt3DRender;
Qt3DCore::QEntity *rootEntity = new Qt3DCore::QEntity();
QRenderSettings *renderSettings = new QRenderSettings();
QViewport *viewport = new QViewport();
QCameraSelector *cameraSelector = new QCameraSelector(viewport);
QClearBuffers *clearBuffers = new QClearBuffers(cameraSelector);
clearBuffers->setBuffers(QClearBuffers::ColorDepthBuffer);
QRenderStateSet *renderStateSet = new QRenderStateSet(cameraSelector);
QCullFace *cullFace = new QCullFace(renderStateSet);
cullFace->setMode(QCullFace::Front);
renderStateSet->addRenderState(cullFace);
renderSettings->setActiveFrameGraph(viewport);
rootEntity->addComponent(renderSettings);Véase también « QRenderState » y « QRenderPass ».
[deprecated] class Qt3DRender::QRenderSurfaceSelector
Esta clase está en desuso. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QRenderSurfaceSelector ` se puede utilizar para seleccionar la superficie en la que Qt3D representa el contenido. La superficie puede ser una superficie de ventana o una superficie fuera de pantalla. La clase ` externalRenderTargetSize ` se utiliza para especificar el tamaño real de la superficie cuando se utiliza una superficie fuera de pantalla.
Cuando el sistema utiliza el escalado DPI, el tamaño lógico de la superficie —que se utiliza para los eventos del ratón— y el tamaño «físico» real de la superficie pueden diferir. El parámetro « surfacePixelRatio » es el factor que permite convertir el tamaño lógico en el tamaño físico.
Véase también « QWindow », « QOffscreenSurface » y « QSurface ».
[deprecated] class Qt3DRender::QRenderTarget
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un « Qt3DRender::QRenderTarget » se compone de objetos « Qt3DRender::QRenderTargetOutput », que especifican los búferes a los que se realiza el renderizado. El usuario puede especificar MRT (Multiple Render Targets) adjuntando varias texturas a diferentes puntos de adjunción. Los resultados son indefinidos si el usuario intenta adjuntar varias texturas al mismo punto de adjunción. En el momento del renderizado, solo se utilizan los búferes de dibujo especificados en el « Qt3DRender::QRenderTargetSelector ».
[deprecated] class Qt3DRender::QRenderTargetOutput
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un QRenderTargetOutput especifica el punto de unión y los parámetros de la textura que se adjunta al destino de renderizado. Además del punto de unión, se pueden especificar el nivel MIP de la textura, la capa y la cara del mapa cúbico. La textura adjunta al QRenderTargetOutput debe ser compatible con los parámetros indicados.
Nota: Los puntos de acoplamiento«Left» y «Right» son valores especiales. No hacen referencia a objetos de destino de renderizado, sino a cualquiera de los búferes traseros utilizados para el renderizado estéreo.
[deprecated] class Qt3DRender::QRenderTargetSelector
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un « Qt3DRender::QRenderTargetSelector » se utiliza para seleccionar un « Qt3DRender::QRenderTarget » activo para el «FrameGraph». Cuando hay un «QRenderTargetSelector» presente en el «FrameGraph», el renderizado se dirige a objetos «QTexture» o a búferes de dibujo, en lugar de a la superficie especificada en el « Qt3DRender::QRenderSurfaceSelector ».
[deprecated] class Qt3DRender::QSceneLoader
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
A partir de un archivo fuente 3D, el cargador « Qt3DRender::QSceneLoader » intentará analizarlo y construir un árbol de objetos « Qt3DCore::QEntity » con los componentes adecuados « Qt3DRender::QGeometryRenderer », « Qt3DCore::QTransform » y « Qt3DRender::QMaterial ».
El cargador intentará determinar el mejor material que se debe utilizar basándose en las propiedades del archivo del modelo. Si deseas utilizar un material personalizado, tendrás que recorrer el árbol y sustituir los materiales predeterminados asociados por los tuyos.
Como su nombre indica, « Qt3DRender::QSceneLoader » carga un subárbol completo de la escena. Si deseas cargar un único elemento geométrico, es mejor que utilices « Qt3DRender::QMesh » en su lugar.
Qt3DRender::QSceneLoader A nivel interno, se basa en el uso de complementos para admitir una amplia variedad de formatos de archivo 3D. A continuación se muestra una lista de los formatos compatibles con Qt3D.
Nota: este componente no debe compartirse entre varias instancias de ` Qt3DCore::QEntity `. Se produciría un comportamiento indefinido.
Véase también « Qt3DRender::QMesh » y « Qt3DRender::QGeometryRenderer ».
[deprecated] class Qt3DRender::QScissorTest
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase QScissorTest habilita la prueba de tijera, que descarta los fragmentos situados fuera del área rectangular de la pantalla especificada por las propiedades «left», «bottom», «width» y «height».
[deprecated] class Qt3DRender::QScreenRayCaster
Esta clase está en desuso. Recomendamos encarecidamente no utilizarla en código nuevo.
QScreenRayCaster se puede utilizar para realizar pruebas de proyección de rayos especificando coordenadas en el espacio de la pantalla, que se utilizarán para construir un rayo 3D real entre los planos cercano y lejano.
Véase también QRayCaster y QNoPicking.
[deprecated] class Qt3DRender::QSeamlessCubemap
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Cuando está presente en un conjunto de estados, habilita el filtrado de texturas de cubemap sin costuras que proporciona la extensión GL_ARB_seamless_cubemap (si está disponible).
[deprecated] class Qt3DRender::QSetFence
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Las «fences» permiten sincronizar las cargas de trabajo de la GPU y la CPU. Los comandos de la GPU suelen ser de tipo no bloqueante. Cuando se emiten, los comandos se insertan en búferes de comandos que la GPU leerá más tarde. En algunos casos, es posible que se desee continuar con el procesamiento o emitir un comando específico solo cuando se tenga la certeza de que el hardware ha ejecutado un comando. Las vallas (fences) son una forma de hacerlo. Esto resulta especialmente importante cuando se utilizan motores de terceros con Qt3D, ya que Qt3D solo debe acceder a los recursos compartidos cuando sepamos que los comandos del otro motor han terminado de modificar el recurso.
QSetFence es un nodo de FrameGraph que inserta una valla en el flujo de comandos. Posteriormente, se puede utilizar junto con QWaitFence o extrayendo el identificador subyacente.
La propiedad «handle» se actualizará una vez que el renderizador haya creado el recurso de barrera subyacente. El identificador seguirá siendo válido mientras permanezca en estado «unsignaled». Una vez que alcance el estado «signaled», se destruirá y se creará un nuevo identificador. Esto significa que, dependiendo del tiempo que tarde la barrera en pasar al estado «signaled», el mismo identificador podría utilizarse durante varios fotogramas.
[deprecated] class Qt3DRender::QShaderData
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Nota: Al crear subclases y añadir propiedades a `QShaderData`, ten en cuenta que, si necesitas anidar un ` Qt3DRender::QShaderData` interno, el tipo de datos de la propiedad debe ser ` Qt3DRender::QShaderData*` en lugar del nombre de tu subclase.
[deprecated] class Qt3DRender::QShaderImage
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Para que el contenido de las texturas esté disponible para operaciones de lectura y escritura en un shader, es necesario exponerlas como QShaderImage. Las texturas pueden estar compuestas por varios niveles mip, capas y caras. Además, al declarar un QShaderImage se puede especificar a qué nivel, capa o cara del contenido de la textura se desea acceder.
Para que QShaderImage funcione correctamente, debe asignarse como valor de un ` QParameter` y hacer referencia a un ` Qt3DRender::QAbstractTexture ` válido.
Si la textura a la que se hace referencia es una matriz unidimensional, bidimensional o tridimensional, un mapa cúbico, una matriz de mapas cúbicos o una textura de matriz bidimensional multimuestra, es posible vincular bien todo el nivel de textura, bien una sola capa o cara de dicho nivel. Esto se puede controlar mediante la propiedad ` layered `.
La compatibilidad con QShaderImage solo está disponible con OpenGL 4 y, de forma parcial, con OpenGL ES 3.1 y 3.2.
OpenGL 4 admite los siguientes tipos de imagen:
| Tipo GLSL | Enumeración de tipos de OpenGL | Tipo de textura |
|---|---|---|
| image1D | GL_IMAGE_1D | QTexture1D |
| imagen2D | GL_IMAGE_2D | QTexture2D |
| imagen3D | GL_IMAGE_3D | QTexture3D |
| imagen2DRect | GL_IMAGE_2D_RECT | QTextureRectangle |
| imageCube | GL_IMAGE_CUBE | QTextureCubeMap |
| imageBuffer | GL_IMAGE_BUFFER | QTextureBuffer |
| matriz1Ddeimágenes | GL_IMAGE_1D_ARRAY | QTexture1DArray |
| matriz2Ddeimagen | GL_IMAGE_2D_ARRAY | QTexture2DArray |
| matriz de imagen cúbica | GL_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
| image2DMS | GL_IMAGE_2D_MULTISAMPLE | QTexture2DMultisample |
| image2DMSArray | GL_IMAGE_2D_MULTISAMPLE_ARRAY | QTexture2DMultisampleArray |
| iimage1D | GL_INT_IMAGE_1D | QTexture1D |
| iimage2D | GL_INT_IMAGE_2D | QTexture2D |
| iimage3D | GL_INT_IMAGE_3D | QTexture3D |
| iimage2DRect | GL_INT_IMAGE_2D_RECT | QTextureRectangle |
| iimageCube | GL_INT_IMAGE_CUBE | QTextureCubeMap |
| iimageBuffer | GL_INT_IMAGE_BUFFER | QTextureBuffer |
| iimage1DArray | GL_INT_IMAGE_1D_ARRAY | QTexture1DArray |
| iimage2DArray | GL_INT_IMAGE_2D_ARRAY | QTexture2DArray |
| iimageCubeArray | GL_INT_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
| iimage2DMS | GL_INT_IMAGE_2D_MULTISAMPLE | QTexture2DMultisample |
| iimage2DMSArray | GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY | QTexture2DMultisampleArray |
| uimage1D | GL_UNSIGNED_INT_IMAGE_1D | QTexture1D |
| uimage2D | GL_UNSIGNED_INT_IMAGE_2D | QTexture2D |
| uimage3D | GL_UNSIGNED_INT_IMAGE_3D | QTexture3D |
| uimage2DRect | GL_UNSIGNED_INT_IMAGE_2D_RECT | QTextureRectangle |
| uimageCube | GL_UNSIGNED_INT_IMAGE_CUBE | QTextureCubeMap |
| uimageBuffer | GL_UNSIGNED_INT_IMAGE_BUFFER | QTextureBuffer |
| uimage1DArray | GL_UNSIGNED_INT_IMAGE_1D_ARRAY | QTexture1DArray |
| uimage2DArray | GL_UNSIGNED_INT_IMAGE_2D_ARRAY | QTexture2DArray |
| uimageCubeArray | GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
| uimage2DMS | GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE | QTexture2DMultisample |
| uimage2DMSArray | GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY | QTexture2DMultisampleArray |
OpenGL ES 3.1 admite los siguientes tipos de imagen:
| Tipo GLSL | Enumeración de tipo OpenGL | Tipo de textura |
|---|---|---|
| image2D | GL_IMAGE_2D | QTexture2D |
| image3D | GL_IMAGE_3D | QTexture3D |
| imageCube | GL_IMAGE_CUBE | QTextureCubeMap |
| imagen2DArray | GL_IMAGE_2D_ARRAY | QTexture2DArray |
| iimage2D | GL_INT_IMAGE_2D | QTexture2D |
| iimage3D | GL_INT_IMAGE_3D | QTexture3D |
| iimageCube | GL_INT_IMAGE_CUBE | QTextureCubeMap |
| iimage2DArray | GL_INT_IMAGE_2D_ARRAY | QTexture2DArray |
| uimage2D | GL_UNSIGNED_INT_IMAGE_2D | QTexture2D |
| uimage3D | GL_UNSIGNED_INT_IMAGE_3D | QTexture3D |
| uimageCube | GL_UNSIGNED_INT_IMAGE_CUBE | QTextureCubeMap |
| uimage2DArray | GL_UNSIGNED_INT_IMAGE_2D_ARRAY | QTexture2DArray |
OpenGL ES 3.2 es compatible con todos los tipos de imagen de OpenGL ES 3.1, así como con los siguientes:
| Tipo GLSL | Enumeración de tipo de OpenGL | Tipo de textura |
|---|---|---|
| imageBuffer | GL_IMAGE_BUFFER | QTextureBuffer |
| imageCubeArray | GL_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
| iimageBuffer | GL_IMAGE_BUFFER | QTextureBuffer |
| iimageCubeArray | GL_INT_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
| uimageBuffer | GL_UNSIGNED_INT_IMAGE_BUFFER | QTextureBuffer |
| uimageCubeArray | GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY | QTextureCubeMapArray |
El uso previsto sería algo así:
Qt3DRender::QTexture2D *tex2D = new Qt3DRender::QTexture2D();
...
Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial();
...
Qt3DRender::QParameter *imageParameter = new Qt3DRender::QParameter();
Qt3DRender::QShaderImage *shaderImage = new Qt3DRender::QShaderImage();
shaderImage->setTexture(tex2D);
imageParameter->setName("imageUniformName");
imageParameter->setValue(QVariant::fromValue(shaderImage));
material->addParameter(imageParamenter);[deprecated] class Qt3DRender::QShaderProgram
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un programa de sombreado consta de varios sombreadores diferentes, como los sombreadores de vértices y de fragmentos.
Qt3D rellenará automáticamente un conjunto de uniformes predeterminados si se encuentran durante la fase de introspección del sombreador.
| Uniforme predeterminado | Nombre del parámetro Qt3D asociado | Declaración GLSL |
|---|---|---|
| ModelMatrix | modelMatrix | uniform mat4 modelMatrix; |
| ViewMatrix | viewMatrix | uniform mat4 viewMatrix; |
| Matriz de proyección | matriz de proyección | uniform mat4 matrizDeProyección; |
| Matriz de vista del modelo | modelView | uniform mat4 matrizVistaModelo; |
| matriz de proyección de la vista | matrizDeProyecciónDeVista | uniform mat4 matriz de proyección de vista; |
| Matriz de modelo-vista-proyección | modelViewProjection mvp | uniform mat4 modelViewProjection; uniform mat4 mvp; |
| Matriz inversa del modelo | matrizInversaDelModelo | uniform mat4 inverseModelMatrix; |
| Matriz de vista inversa | matriz de vista inversa | uniform mat4 matrizInversaDeVista; |
| Matriz de proyección inversa | matriz de proyección inversa | uniform mat4 matriz de proyección inversa; |
| Matriz inversa del modelo-vista | inverseModelView | uniform mat4 inverseModelView; |
| Matriz de proyección inversa de la vista | matriz inversa de proyección de vista | uniform mat4 matriz de proyección inversa de la vista; |
| Matriz de proyección inversa del modelo y la vista | matriz inversa de proyección del modelo-vista | uniform mat4 inversa de la matriz de proyección modelo-vista; |
| MatrizNormalDelModelo | matrizNormalDelModelo | uniform mat3 matrizNormalDelModelo; |
| MatrizNormalVistaModelo | modelViewNormal | uniform mat3 modelViewNormal; |
| Matriz de ventana gráfica | matriz de ventana gráfica | uniform mat4 viewportMatrix; |
| Matriz inversa de la ventana de visualización | inverseViewportMatrix | uniform mat4 inverseViewportMatrix; |
| AspectRatio (anchura de la superficie / altura de la superficie) | aspectRatio | uniform float aspectRatio; |
| Exposición | exposición | uniform float exposición; |
| Gamma | gamma | gamma uniforme en coma flotante; |
| Tiempo (en nanosegundos) | tiempo | tiempo de tipo float uniforme; |
| EyePosition | eyePosition | uniform vec3 posición del ojo; |
| Paleta de texturizado | skinningPalette[0] | const int maxJoints = 100; uniform mat4 skinningPalette[maxJoints]; |
Compatibilidad con RHI
Al escribir código de shader GLSL 450 para utilizarlo con el backend RHI de Qt 3D, los uniformes predeterminados se proporcionarán como 2 objetos de búfer uniformes.
Las ubicaciones de enlace para estos se establecen en el enlace 0 para los uniformes de RenderView y en el 1 para los uniformes de comando.
#version 450 core
layout(location = 0) in vec3 vertexPosition;
layout(std140, binding = 0) uniform qt3d_render_view_uniforms {
mat4 viewMatrix;
mat4 projectionMatrix;
mat4 uncorrectedProjectionMatrix;
mat4 clipCorrectionMatrix;
mat4 viewProjectionMatrix;
mat4 inverseViewMatrix;
mat4 inverseProjectionMatrix;
mat4 inverseViewProjectionMatrix;
mat4 viewportMatrix;
mat4 inverseViewportMatrix;
vec4 textureTransformMatrix;
vec3 eyePosition;
float aspectRatio;
float gamma;
float exposure;
float time;
float yUpInNDC;
float yUpInFBO;
};
layout(std140, binding = 1) uniform qt3d_command_uniforms {
mat4 modelMatrix;
mat4 inverseModelMatrix;
mat4 modelViewMatrix;
mat3 modelNormalMatrix;
mat4 inverseModelViewMatrix;
mat4 modelViewProjection;
mat4 inverseModelViewProjectionMatrix;
};
void main()
{
gl_Position = (projectionMatrix * viewMatrix * modelMatrix * vertexPosition);
}Para los objetos de búfer uniformes definidos por el usuario, utiliza una ubicación de enlace a partir de la 2 o «auto» para que Qt 3D determine el enlace automáticamente. Asegúrate de mantener la coherencia entre las diferentes etapas del shader.
#version 450 core
layout(std140, binding = auto) uniform my_uniforms {
vec4 myColor;
};
layout(location=0) out vec4 fragColor;
void main()
{
fragColor = myColor;
}No hay ningún cambio en lo que respecta a proporcionar valores a los uniformes.
Para el ejemplo anterior, la configuración de myColor podría realizarse de la siguiente manera:
QParameter *parameter = new QParameter();
parameter->setName("myColor");
parameter->setValue(QVariant::fromValue(QColor(Qt::blue)));Las texturas deben seguir definiéndose como uniformes independientes.
#version 450 core
layout(binding=0) uniform sampler2D source;
layout(location=0) out vec4 fragColor;
void main()
{
fragColor = texture(source, vec2(0.5, 0.5));
}[deprecated] class Qt3DRender::QShaderProgramBuilder
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un generador de programas de shaders consta de varios gráficos de shaders diferentes que se utilizan para generar código de shaders.
Se mantiene una caché del código de sombreador generado. Los sombreadores generados se guardan, por defecto, en QStandardPaths::writableLocation(QStandardPaths::TempLocation)). Esta ruta se puede sobrescribir estableciendo la variable de entorno QT3D_WRITABLE_CACHE_PATH en una ruta válida en la que se pueda escribir.
El uso de la caché se puede desactivar configurando la variable de entorno QT3D_DISABLE_SHADER_CACHE.
En la mayoría de los casos, los cambios realizados en un gráfico son detectados por Qt 3D y se generará una nueva entrada en la caché. Un caso en el que esto no ocurre es cuando se modifican fragmentos de código incluidos en un gráfico. Para solucionarlo, se puede vaciar el directorio de caché o establecer la variable de entorno QT3D_REBUILD_SHADER_CACHE para forzar la regeneración del código del sombreador.
[deprecated] class Qt3DRender::QSharedGLTexture
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Dependiendo del modo de renderizado utilizado por Qt 3D, el contexto compartido será:
- `qt_gl_global_share_context` cuando se deja que Qt 3D se encargue del renderizado. Al establecer el atributo ` Qt::AA_ShareOpenGLContexts ` en la clase `QApplication`, esto hará que, automáticamente, las instancias de `QOpenGLWidget` compartan su contexto con `qt_gl_global_share_context`.
- el contexto compartido de la escena de QtQuick. Es posible que tengas que crear una subclase de QWindow o utilizar QtQuickRenderControl para controlar cuál es ese contexto compartido; no obstante, a partir de la versión 5.13 es qt_gl_global_share_context.
Cualquier motor de terceros que comparta su contexto con el renderizador « Qt 3D » ahora puede proporcionar identificadores de textura a los que hará referencia la textura de « Qt 3D ».
Puedes omitir la especificación de las propiedades de la textura; Qt 3D intentará determinar cuáles son en tiempo de ejecución. Si las conoces, por supuesto puedes proporcionarlas, evitando así trabajo adicional para Qt 3D.
Ten en cuenta que, si utilizas materiales y sombreadores personalizados, debes especificar el tipo de muestreador correcto que se va a utilizar.
[deprecated] class Qt3DRender::QSortPolicy
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una clase ` Qt3DRender::QSortPolicy ` almacena el tipo de ordenación utilizado por el `FrameGraph`. Los tipos de ordenación determinan cómo se ordenan las entidades dibujables antes de su representación, con el fin de establecer el orden de dibujo. Cuando `QSortPolicy` está presente en el `FrameGraph`, el mecanismo de ordenación viene determinado por la lista ` sortTypes `. Se pueden utilizar varios tipos de ordenación simultáneamente. Si no hay ninguna instancia de `QSortPolicy` en el `FrameGraph`, las entidades se dibujan en el orden en que aparecen en la jerarquía de entidades.
[deprecated] class Qt3DRender::QSpotLight
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un foco es una fuente de luz que emite un cono de luz en una dirección concreta.
Un foco utiliza tres factores de atenuación para describir cómo disminuye la intensidad de la luz con la distancia. Estos factores están diseñados para utilizarse conjuntamente a la hora de calcular la atenuación total. Para los materiales de Qt3D Extras se utiliza la siguiente fórmula, donde «distancia» es la distancia desde la luz hasta la superficie que se está renderizando:
totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));Los materiales personalizados pueden optar por interpretar estos factores de forma diferente.
[deprecated] class Qt3DRender::QStencilMask
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una clase ` Qt3DRender::QStencilMask ` especifica una máscara de escritura para los valores de estarcido tras la prueba de estarcido. La máscara se puede especificar por separado para los polígonos orientados hacia delante y hacia atrás. El valor de estarcido del fragmento se combina mediante la operación «AND» con la máscara antes de escribirse en el búfer de estarcido.
Véase también Qt3DRender::QStencilTest.
[deprecated] class Qt3DRender::QStencilOperation
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Una clase ` Qt3DRender::QStencilOperation ` especifica las operaciones de estarcido para los polígonos orientados hacia delante y hacia atrás. Las operaciones de estarcido controlan qué se hace con el fragmento cuando la prueba de estarcido y la de profundidad se superan o se fallan.
Véase también Qt3DRender::QStencilTest.
[deprecated] class Qt3DRender::QStencilOperationArguments
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QStencilOperationArguments ` especifica los argumentos para las operaciones de estarcido.
Véase también Qt3DRender::QStencilOperation.
[deprecated] class Qt3DRender::QStencilTest
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QStencilTest ` especifica los argumentos para la prueba de estarcido. La prueba de estarcido consta de tres argumentos: la función de prueba de estarcido, la máscara de prueba de estarcido y el valor de referencia de estarcido. `QStencilTest` permite configurar estos argumentos por separado tanto para los polígonos orientados hacia delante como para los orientados hacia atrás.
Véanse también Qt3DRender::QStencilMask y Qt3DRender::QStencilOperation.
[deprecated] class Qt3DRender::QStencilTestArguments
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
La clase ` Qt3DRender::QStencilTestArguments ` especifica los argumentos para la prueba de estarcido.
[deprecated] class Qt3DRender::QSubtreeEnabler
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Aunque los QFrameGraphNodes se pueden activar y desactivar individualmente mediante la propiedad enabled, esto puede resultar tedioso cuando es necesario activar o desactivar una ruta completa. QSubtreeEnabler es un nodo de conveniencia que simplifica enormemente este caso de uso, ya que permite controlar todos sus elementos hijos mediante un único conmutador.
QSubtreeEnabler está activado por defecto.
[deprecated] class Qt3DRender::QTechnique
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un ` Qt3DRender::QTechnique ` especifica un conjunto de objetos ` Qt3DRender::QRenderPass `, ` Qt3DRender::QFilterKey `, ` Qt3DRender::QParameter ` y un ` Qt3DRender::QGraphicsApiFilter`, que en conjunto definen una técnica de renderizado que la API gráfica dada puede representar. Qt3DRender::QTechniqueFilter utiliza las claves de filtro para seleccionar técnicas específicas en partes concretas del FrameGraph. Un QParameter definido en un QTechnique anula el parámetro (del mismo nombre) definido en QRenderPass, pero queda anulado por el parámetro de QRenderPassFilter, QTechniqueFilter, QMaterial y QEffect.
Al crear un « QEffect » destinado a varias versiones de una API gráfica, resulta útil crear varios nodos «QTechnique», cada uno con un « graphicsApiFilter » configurado para que coincida con una de las versiones de GL a las que va dirigido. En tiempo de ejecución, el renderizador de Qt3D seleccionará la QTechnique más adecuada en función de las versiones de la API gráfica compatibles y (si se ha especificado) de los nodos « QFilterKey » que cumplan con un « QTechniqueFilter » determinado en el FrameGraph.
Nota: Cuando se utiliza OpenGL como API gráfica para el renderizado, Qt3D se basa en el valor de « QSurfaceFormat » devuelto por « QSurfaceFormat::defaultFormat()» en tiempo de ejecución para decidir cuál es la versión de GL más adecuada disponible. Si necesitas personalizar el « QSurfaceFormat », no olvides aplicarlo mediante « QSurfaceFormat::setDefaultFormat()». Establecer el valor de « QSurfaceFormat » en la vista probablemente no tendrá ningún efecto sobre el renderizado relacionado con Qt3D.
Nota: El nodo `QTechnique ` no se puede desactivar.
QTechnique *gl3Technique = new QTechnique();
// Create the render passes
QRenderPass *firstPass = new QRenderPass();
QRenderPass *secondPass = new QRenderPass();
// Add the passes to the technique
gl3Technique->addRenderPass(firstPass);
gl3Technique->addRenderPass(secondPass);
// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
// Create a FilterKey
QFilterKey *filterKey = new QFilterKey();
filterKey->setName(QStringLiteral("name"));
fitlerKey->setValue(QStringLiteral("zFillPass"));
// Add the FilterKey to the Technique
gl3Technique->addFilterKey(filterKey);
// Create a QParameter
QParameter *colorParameter = new QParameter(QStringLiteral("color"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));
// Add parameter to technique
gl3Technique->addParameter(colorParameter);Véase también QEffect, QRenderPass y QTechniqueFilter.
[deprecated] class Qt3DRender::QTechniqueFilter
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Un « Qt3DRender::QTechniqueFilter » especifica qué técnicas utiliza el FrameGraph al renderizar las entidades. «QTechniqueFilter» especifica una lista de objetos « Qt3DRender::QFilterKey » y « Qt3DRender::QParameter ». Cuando «QTechniqueFilter» está presente en el FrameGraph, solo se utilizan para el renderizado las técnicas que coinciden con las claves de la lista. Los parámetros de la lista pueden utilizarse para establecer valores para los parámetros del shader. Los parámetros de QTechniqueFilter anulan los parámetros de QMaterial, QEffect, QTechnique y QRenderPass, pero son anulados por los parámetros de QRenderPassFilter.
[deprecated] class Qt3DRender::QTexture1D
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture1DArray
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture2D
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture2DArray
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture2DMultisample
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture2DMultisampleArray
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTexture3D
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureBuffer
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureCubeMap
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureCubeMapArray
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureData
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureDataUpdate
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
El contenido real de los datos se encuentra en un miembro de tipo ` QTextureImageDataPtr `. Otros miembros permiten especificar el desplazamiento x, y, z de la actualización del contenido, así como la capa, el nivel de mip y la cara correspondientes.
Véase también QAbstractTexture.
[deprecated] class Qt3DRender::QTextureImage
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Contiene la información necesaria (nivel de mipmap, capa, cara del cubo y URL de origen) para cargar los datos en la ubicación adecuada dentro de una textura de OpenGL.
[deprecated] class Qt3DRender::QTextureImageData
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureImageDataGenerator
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
QTextureImageDataGenerator es un proveedor de datos para QAbstractTexture. QTextureImageDataGenerator puede utilizarse para ampliar Qt3D con más formas de cargar datos de imágenes de texturas, así como para admitir formatos definidos por el usuario y formatos que Qt3D no admite de forma nativa. Los datos se devuelven a través del ` QTextureImageDataPtr `, que contiene los datos que se cargarán en la textura. QTextureImageDataGenerator se ejecuta mediante tareas de Aspect en el backend.
[deprecated] class Qt3DRender::QTextureLoader
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureRectangle
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QTextureWrapMode
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
[deprecated] class Qt3DRender::QViewport
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Qt3DRender::QViewport La clase de la escena especifica en qué parte de la superficie de renderizado está realizando Qt3D el renderizado. El área fuera de la ventana de visualización no se modifica. También controla los parámetros globales del renderizado en esa ventana de visualización, como el gamma.
[deprecated] class Qt3DRender::QWaitFence
Esta clase está obsoleta. Recomendamos encarecidamente no utilizarla en código nuevo.
Las «fences» permiten sincronizar las cargas de trabajo de la GPU y la CPU. Los comandos de la GPU suelen ser no bloqueantes. Cuando se emiten, los comandos se insertan en búferes de comandos que la GPU leerá más adelante. En algunos casos, es posible que quieras continuar con el procesamiento o emitir un comando específico solo cuando estés seguro de que el hardware ha ejecutado un comando. Las «fences» son una forma de hacerlo. Esto resulta especialmente importante al utilizar motores de terceros con Qt3D, ya que Qt3D solo debe acceder a los recursos compartidos cuando sepamos que los comandos del otro motor han terminado de modificar el recurso.
QWaitFence es un nodo de FrameGraph que obliga a esperar a que se active antes de que se inserten los comandos posteriores en el flujo de comandos. Se puede utilizar junto con QSetFence y contiene propiedades para configurar cuánto tiempo debe esperar y si debe bloquearse en el lado de la CPU.
Nota: « Qt 3D » carga los recursos de la GPU (texturas, sombreadores, búferes) antes de emitir llamadas de dibujo.
© 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.