Obsolete Members for Qt3DRender

Die folgenden Mitglieder der Klasse „ Qt3DRender “ sind veraltet. Sie werden bereitgestellt, um die Funktionsfähigkeit von altem Quellcode zu gewährleisten. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Namensräume

Klassen

Namespaces

[deprecated] namespace Qt3DRender::Quick

Dieser Namensraum ist veraltet. Wir raten dringend davon ab, ihn in neuem Code zu verwenden.

[deprecated] namespace Qt3DRender::Render

Dieser Namensraum ist veraltet. Wir raten dringend davon ab, ihn in neuem Code zu verwenden.

Klassen

[deprecated] class Qt3DRender::QAbstractLight

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QAbstractRayCaster

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Qt3DRender::QAbstractRayCaster ist eine abstrakte Basisklasse für das Raycasting in einer 3D-Szene. „ Qt3DRender::QAbstractRayCaster “ kann nicht direkt instanziiert werden, sondern nur über seine Unterklassen. „QAbstractRayCaster“ legt gemeinsame Eigenschaften für alle Raycaster fest, wie beispielsweise den Ausführungsmodus und die Ebenenbehandlung, während die tatsächlichen Details des Raycastings den Unterklassen überlassen bleiben.

Das Raycasting unterscheidet sich vom Picking (unter Verwendung von ` Qt3DRender::QObjectPicker`) dadurch, dass es keine Mausereignisse zur Auslösung benötigt.

Standardmäßig sind die Instanzen von ` Qt3DRender::QAbstractRayCaster ` deaktiviert. Bei Aktivierung wird der angegebene Strahl in jedem Frame auf sich überschneidende Objekte geprüft. Die Eigenschaft ` QAbstractRayCaster::hits ` wird mit den Ergebnissen des Ray Castings aktualisiert, auch wenn keine Objekte gefunden werden.

Mit dem „ Qt3DRender::QPickingSettings “ lässt sich das Raycasting steuern, beispielsweise welche Primitive geprüft werden und wie die Ergebnisse zurückgegeben werden.

Darüber hinaus können „ Qt3DRender::QLayer “-Komponenten verwendet werden, um zu steuern, wie Entitäten oder Teilgraphen von Entitäten auf das Raycasting reagieren.

Siehe auch „ Qt3DRender::QRayCaster“ , „ Qt3DRender::QScreenRayCaster “, „ Qt3DRender::QObjectPicker “, „ Qt3DRender::QPickingSettings “ und „ Qt3DRender::QNoPicking “.

[deprecated] class Qt3DRender::QAbstractTexture

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse `QAbstractTexture` sollte nicht direkt, sondern über eine ihrer Unterklassen verwendet werden. Jede Unterklasse implementiert ein bestimmtes Texturziel (2D, 2DArray, 3D, CubeMap ...). Jede Unterklasse stellt eine Reihe von Funktoren für jede Ebene, jede CubeMap-Fläche und jede Mipmap-Stufe bereit. Das Backend nutzt diese Funktoren wiederum, um eine entsprechende OpenGL-Textur ordnungsgemäß mit Daten zu füllen. Es wird erwartet, dass der Funktor so wenig Verarbeitung wie möglich durchführt, um die Erzeugung und das Hochladen von Texturen nicht zu verlangsamen. Wenn der Inhalt einer Textur das Ergebnis eines langsamen prozeduralen Generierungsprozesses ist, wird empfohlen, diesen nicht direkt in einem Funktor zu implementieren.

Alle Texturen sind eindeutig. Wenn Sie dieselbe Textur zweimal instanziieren, werden auf der GPU zwei identische Texturen erstellt; es findet keine gemeinsame Nutzung statt.

[deprecated] class Qt3DRender::QAbstractTextureImage

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QAbstractTextureImage sollte verwendet werden, um Bilddaten an einen „ QAbstractTexture “ zu übergeben. Es enthält die erforderlichen Informationen: Mipmap-Ebene, Ebene und Würfelseite, um die Daten an der richtigen Stelle in eine OpenGL-Textur zu laden.

Die eigentlichen Daten werden über einen ` QTextureImageDataGenerator ` bereitgestellt, der im Backend von Aspect-Jobs ausgeführt wird. Von `QAbstractTextureImage` sollte eine Unterklasse erstellt werden, um einen Funktor sowie gegebenenfalls zusätzliche Eigenschaften bereitzustellen, die der Funktor zum Laden der eigentlichen Daten benötigt.

[deprecated] class Qt3DRender::QAlphaCoverage

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „ Qt3DRender::QAlphaCoverage “ aktiviert den „Alpha-to-Coverage“-Multisampling-Modus. Ist dieser aktiviert, wird der Fragment-Alpha-Wert als Abdeckungsgrad für das Sample verwendet und mit dem Fragment-Abdeckungswert kombiniert. „ Qt3DRender::QAlphaCoverage “ hat keine Auswirkung, wenn Multisampling deaktiviert ist. „Alpha-to-Coverage“ ist besonders nützlich, wenn eine reihenunabhängige Überblendung erforderlich ist, beispielsweise beim Rendern von Blättern, Gras und anderer üppiger Vegetation.

Es kann einem „ QRenderPass “ hinzugefügt werden, indem „ QRenderPass::addRenderState()“ aufgerufen wird:

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);

Oder an ein „ QRenderStateSet “ durch Aufruf von ` 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);

Siehe auch „ Qt3DRender::QMultiSampleAntiAliasing “.

[deprecated] class Qt3DRender::QAlphaTest

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Wie in der OpenGL-Dokumentation erläutert, verwirft der Alpha-Test ein Fragment in Abhängigkeit vom Ergebnis eines Vergleichs zwischen dem Alpha-Wert des eingehenden Fragments und einem konstanten Referenzwert.

[deprecated] class Qt3DRender::QBlendEquation

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Mischungsgleichung wird verwendet, um zu bestimmen, wie ein neues Pixel mit einem bereits im Framebuffer vorhandenen Pixel kombiniert wird.

[deprecated] class Qt3DRender::QBlendEquationArguments

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

OpenGL vor Version 3.0: Legt für alle Zeichnungspuffer denselben Blend-Status fest (ein QBlendEquationArguments). OpenGL 3.0 bis vor Version 4.0: Legt für alle Draw-Buffer denselben Blend-Status fest, ermöglicht jedoch das Deaktivieren des Blendings für bestimmte Buffer (ein `QBlendEquationArguments` zum Festlegen von `glBlendFunc`, `n` `QBlendEquationArguments` zum Aktivieren/Deaktivieren von Draw-Buffern) OpenGL 4.0+: Der Blend-Status kann für jeden Draw-Buffer individuell festgelegt werden.

[deprecated] class Qt3DRender::QBlitFramebuffer

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Dieser Knoten fügt einen „ glBlitFrameBuffer “ oder ein Äquivalent in den Befehlsstrom ein. Dies bietet eine effizientere Methode zum Kopieren von Rechtecken zwischen Texturen oder Oberflächen-Backbuffern, die von „ QRenderTarget “ umschlossen sind, als das Zeichnen von texturierten Vierecken. Außerdem wird die Skalierung mit der angegebenen Interpolationsmethode unterstützt.

[deprecated] class Qt3DRender::QBufferCapture

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QCamera

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QCameraLens

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QCameraSelector

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Mit einem „ Qt3DRender::QCameraSelector “ kann die Kamera ausgewählt werden, die vom FrameGraph beim Zeichnen der Entitäten verwendet wird.

[deprecated] class Qt3DRender::QClearBuffers

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QClearBuffers “-FrameGraph-Knoten ermöglicht das Löschen bestimmter Render-Zielpuffer mit bestimmten Werten.

[deprecated] class Qt3DRender::QClipPlane

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Standardmäßig unterstützt OpenGL bis zu 8 zusätzliche Clipping-Ebenen. Mit `Qt3DCore::QClipPlane` lässt sich eine dieser zusätzlichen Ebenen aktivieren. Diese Ebenen können dann in den Shadern mithilfe von `gl_ClipDistance[i]` manipuliert werden, wobei `i` zwischen 0 und 7 variiert. Die zugrunde liegende Implementierung unterstützt möglicherweise mehr als 8 Clipping-Ebenen, dies wird jedoch nicht garantiert.

[deprecated] class Qt3DRender::QColorMask

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Standardmäßig ist die Eigenschaft für jede Farbkomponente (Rot, Grün, Blau, Alpha) auf „ true “ gesetzt, was bedeutet, dass sie in den Bildspeicher geschrieben werden. Wenn eine der Farbkomponenten auf „ false “ gesetzt wird, wird verhindert, dass sie in den Bildspeicher geschrieben wird.

[deprecated] class Qt3DRender::QComputeCommand

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QComputeCommand “ wird verwendet, um Aufgaben für den Compute-Shader zu vergeben. Der Compute-Shader wird in der Komponente „ QMaterial “ derselben Entität angegeben, der der „QComputeCommand“ hinzugefügt wurde. Die Eigenschaften „ workGroupX “, „ workGroupY “ und „ workGroupZ “ legen die Arbeitsgruppengrößen für den Aufruf des Compute-Shaders fest. Der Knoten „ Qt3DRender::QDispatchCompute “ muss im FrameGraph vorhanden sein, damit die Befehle tatsächlich ausgeführt werden können.

[deprecated] class Qt3DRender::QCullFace

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QCullFace legt fest, ob die vorderen oder hinteren Facetten ausgeblendet werden. Zu den Facetten zählen Dreiecke, Vierecke, Polygone und Rechtecke.

Sie kann hinzugefügt werden, indem die Methode `addRenderState()` auf einem ` QRenderPass` aufgerufen wird:

// 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);

Oder durch Aufruf der Methode `addRenderState()` auf einem ` 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);

Siehe auch „ QFrontFace “.

[deprecated] class Qt3DRender::QDebugOverlay

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Wird ein `QDebugOverlay` in einem Zweig eines benutzerdefinierten Framegraphs platziert, wird ein Overlay mit Szenendetails zusammen mit der Szene gerendert.

Der Standard-QForwardRenderer enthält einen QDebugOverlay-Knoten, der über die Eigenschaft QForwardRenderer::showDebugOverlay aktiviert werden kann.

[deprecated] class Qt3DRender::QDepthRange

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Standardmäßig schreibt OpenGL Tiefeninformationen der Szene im Bereich [0,0; 1,0] in den Tiefenpuffer, wobei 0,0 der nahen Clip-Ebene und 1,0 der fernen Clip-Ebene entspricht. Mit `QDepthRange` lassen sich diese Werte auf einen anderen Bereich abbilden, sodass Teile der Szene stets vor oder hinter anderen Teilen gerendert werden. Gültige Werte für „near“ und „far“ liegen zwischen 0 und 1.

[deprecated] class Qt3DRender::QDepthTest

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine QDepthTest-Klasse wird verwendet, um Tiefenprüfungen mit einer bestimmten Tiefenprüfungsfunktion zu ermöglichen. Die Tiefenprüfung ermöglicht das Schreiben von Fragmentfarbwerten, wenn die Tiefenprüfung bestanden wird, und lehnt Fragmente ab, die die Prüfung nicht bestehen. Der Tiefentest verwendet die Tiefenfunktion, um den Tiefenwert der Fragmente mit dem Wert im Z-Puffer zu vergleichen. Verfügt die zugrunde liegende Oberfläche nicht über einen Z-Puffer, führt QDepthTest keine Aktion aus.

Siehe auch QAlphaTest und QStencilTest.

[deprecated] class Qt3DRender::QDirectionalLight

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein gerichtetes Licht ist eine Lichtquelle, die sich ähnlich wie Sonnenlicht verhält. Das Licht eines gerichteten Lichts trifft alle Objekte aus derselben Richtung und mit derselben Intensität, unabhängig davon, wo sie sich in der Szene befinden.

[deprecated] class Qt3DRender::QDispatchCompute

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QDispatchCompute “ ermöglicht die Ausgabe von Aufgaben, die vom Compute-Shader auf der GPU ausgeführt werden sollen. Die Eigenschaften „ workGroupX “, „ workGroupY “ und „ workGroupZ “ legen die Arbeitsgruppengrößen für den Aufruf des Compute-Shaders fest. „ QComputeCommand “-Komponenten müssen zu Entitäten hinzugefügt werden, um Qt3D anzuweisen, die Materialien und die Geometrie aus den Entitäten für den Compute-Aufruf auszuwählen. Die Arbeitsgruppengrößen für den Shader-Aufruf entsprechen dem Maximum der in „QDispatchCompute“ und „ QComputeCommand “ angegebenen Arbeitsgruppengrößen.

[deprecated] class Qt3DRender::QDithering

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine „ Qt3DRender::QDithering “-Klasse aktiviert das Dithering. Beim Dithering wird den Farbwerten Rauschen hinzugefügt, um Quantisierungsfehler zu randomisieren und so großflächige Muster im endgültigen Bild, wie z. B. Streifenbildung, zu verhindern. Dithering ist besonders nützlich beim Rendern auf eine Oberfläche mit geringer Farbtiefe, wie z. B. RGB565 oder RGBA4444.

[deprecated] class Qt3DRender::QEffect

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „QEffect“ vereint eine Reihe von Techniken und die von diesen Techniken verwendeten Parameter, um einen Rendering-Effekt für ein Material zu erzeugen.

Eine QEffect-Instanz sollte nach Möglichkeit von mehreren „ QMaterial “-Instanzen gemeinsam genutzt werden.

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);

Ein auf einem QEffect definierter „ QParameter “ überschreibt den (gleichnamigen) Parameter, der in QTechnique und QRenderPass definiert ist, wird jedoch von den Parametern in QRenderPassFilter, QTechniqueFilter und QMaterial überschrieben.

Siehe auch QMaterial, QTechnique und QParameter.

[deprecated] class Qt3DRender::QEnvironmentLight

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QEnvironmentLight verwendet Cubemaps zur Implementierung von bildbasierter Beleuchtung (IBL), einer Technik, die häufig in Verbindung mit physikalisch basiertem Rendering (PBR) eingesetzt wird. Die Cubemaps basieren in der Regel auf High-Dynamic-Range-Bildern (HDR) in einem geeigneten OpenGL-Format (z. B. RGBA16F), das den erweiterten Wertebereich verarbeiten kann.

Es gibt eine Vielzahl von Tools, mit denen sich die von QEnvironmentLight benötigten Cubemaps erstellen lassen. Einige Beispiele hierfür sind

• cmftStudio
• IBLBaker
• Lys

HDRI Haven stellt zahlreiche CC0-lizenzierte HDR-Bilder zur Verfügung, die als Ausgangsmaterial für die oben genannten Tools verwendet werden können.

[deprecated] class Qt3DRender::QFilterKey

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Filterschlüssel werden von QTechnique und QRenderPass verwendet, um festzulegen, in welcher Phase des Renderings die Technik oder der Render-Durchlauf angewendet wird.

[deprecated] class Qt3DRender::QFrameGraphNode

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Diese Klasse wird selten direkt instanziiert, da sie kein spezifisches Verhalten für Frame-Graphen bietet, obwohl sie sich gut zum Gruppieren anderer Knoten in dynamischen Frame-Graphen eignet. Das eigentliche Verhalten wird von den Unterklassen bereitgestellt.

Die Unterklassen sind:

[deprecated] class Qt3DRender::QFrontFace

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein ` Qt3DRender::QFrontFace ` legt die Wicklungsrichtung der nach vorne gerichteten Polygone fest.

Siehe auch „ QCullFace “.

[deprecated] class Qt3DRender::QFrustumCulling

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine QFrustumCulling-Klasse ermöglicht das Frustum-Culling der zeichnungsfähigen Entitäten auf der Grundlage der Kameraperspektive und der QGeometry-Grenzen der Entitäten. Ist QFrustumCulling im FrameGraph vorhanden, werden nur die Entitäten gezeichnet, deren QGeometry-Grenzen sich mit dem Kamera-Frustum, d. h. dem Sichtfeld der Kamera, überschneiden. Ist „QFrustumCulling“ nicht vorhanden, werden alle darstellbaren Objekte gezeichnet. Die Kamera wird durch einen „ QCameraSelector “-Frame-Graph-Knoten in der aktuellen Hierarchie ausgewählt. Frustum-Culling kann bei komplexen gerenderten Szenen viel GPU-Rechenzeit einsparen.

Siehe auch „ QCameraSelector “.

[deprecated] class Qt3DRender::QGeometryRenderer

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QGeometryRenderer “ enthält alle Informationen, die zum Zeichnen einer „ Qt3DCore::QGeometry “ erforderlich sind. Ein „QGeometry“ enthält die Koordinaten der Geometriedaten – „QGeometryRenderer“ legt fest, wie diese Daten zu interpretieren sind.

[deprecated] class Qt3DRender::QGraphicsApiFilter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QLayer

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Qt3DRender::QLayer Funktioniert in Verbindung mit dem „ Qt3DRender::QLayerFilter “ im FrameGraph.

Ein `QLayer` kann auf einen Teilbaum von Entitäten angewendet werden, indem die Eigenschaft `recursive` auf `true` gesetzt wird.

 #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);

...

Siehe auch „ Qt3DRender::QLayerFilter “.

[deprecated] class Qt3DRender::QLayerFilter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QLayerFilter “ kann verwendet werden, um dem Renderer mitzuteilen, welche Ebene(n) in diesem Zweig des Frame-Graphs gezeichnet werden sollen. „QLayerFilter“ wählt anhand der „ QLayer “-Instanzen, die dem „QLayerFilter“ hinzugefügt wurden, sowie anhand der Komponenten von „ Qt3DCore::QEntity “ aus, welche Entitäten gezeichnet werden sollen.

QLayerFilter kann so konfiguriert werden, dass Entitäten mit einem bestimmten ` QLayer ` je nach der Eigenschaft ` filterMode ` ausgewählt oder verworfen werden. Standardmäßig werden Entitäten ausgewählt, die auf eines der ` QLayer `-Objekte verweisen, auf die auch das ` QLayerFilter ` verweist (AcceptAnyMatchingLayers).

Innerhalb des FrameGraph-Baums können mehrere „ QLayerFilter “-Knoten in einem Zweig verschachtelt sein, der von der Wurzel zu einem Blatt führt. In diesem Fall wird die Filterung zunächst auf alle Entitäten der Szene angewendet, wobei die vom ersten deklarierten „ QLayerFilter “ festgelegte Filtermethode verwendet wird. Anschließend wird die gefilterte Teilmenge der Entitäten erneut anhand der Filtermethode gefiltert, die für den zweiten deklarierten „ QLayerFilter “ festgelegt wurde. Dieser Vorgang wird so lange wiederholt, bis alle „ QLayerFilter “-Knoten des Zweigs verarbeitet wurden.

[deprecated] class Qt3DRender::QLevelOfDetail

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Mit „QLevelOfDetail“ lässt sich die Darstellung einer Entität je nach Entfernung zum Betrachter oder ihrer Größe auf dem Bildschirm steuern.

Um die Rendering-Leistung zu verbessern, können sehr kleine Objekte mit deutlich weniger Details in Geometrie oder Textur gerendert werden.

Die Komponente wird durch die Festlegung von Schwellenwerten gesteuert, die entweder als Entfernungen zur Kamera oder als Bildschirmgröße interpretiert werden.

Wenn sich der Blickwinkel ändert, ändert sich die Eigenschaft „ currentIndex “, um den entsprechenden Wert im Bereichsarray widerzuspiegeln.

Die Eigenschaft „ currentIndex “ kann dann beispielsweise verwendet werden, um Objekte zu aktivieren oder zu deaktivieren, das Material zu ändern usw.

Die „ LevelOfDetail “-Komponente kann nicht von mehreren „ entities “ gemeinsam genutzt werden.

 #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

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QLevelOfDetailSwitch

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Diese Komponente ist einer Entität zugeordnet. Wenn sich der Abstand der Entität zur Kamera ändert, deaktiviert der `QLevelOfDetailSwitch` alle untergeordneten Entitäten mit Ausnahme derjenigen, die dem Index `Qt3DRender::QLevelOfDetailSwitch::currentIndex` entspricht.

[deprecated] class Qt3DRender::QLineWidth

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QMaterial

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QMaterial bietet eine Möglichkeit, die Darstellung eines „ entity “ festzulegen. Jeder Aspekt kann eine eigene Unterklasse von QMaterial definieren, sodass ein Material zur Beschreibung eines visuellen Elements verwendet werden kann; beispielsweise die Art und Weise, wie Schall von einem Element reflektiert werden soll, die Temperatur einer Oberfläche und so weiter.

An sich führt ein QMaterial keine Aktion aus. Erst wenn es auf einen „ QEffect “-Knoten verweist, wird ein QMaterial nützlich.

In der Praxis kommt es häufig vor, dass ein einzelnes „ QEffect “ von mehreren QMaterial-Komponenten referenziert wird. Dies ermöglicht es, Effekte, Techniken, Durchgänge und Shader nur einmal zu erstellen, während das Material durch Hinzufügen von „ QParameter “-Instanzen festgelegt werden kann.

Ein in einem QMaterial definiertes „ QParameter “ überschreibt Parameter (mit demselben Namen), die in „ QEffect “, „ QTechnique “ und „ QRenderPass “ definiert sind, wird jedoch von Parametern in „ QRenderPassFilter “ und „ QTechniqueFilter “ überschrieben.

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)));

Siehe auch QEffect, QTechnique und QParameter.

[deprecated] class Qt3DRender::QMemoryBarrier

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QMemoryBarrier “-FrameGraph-Knoten wird verwendet, um zu einem bestimmten Zeitpunkt des Renderings eine bestimmte Speicherbarriere zu setzen. Dies ist erforderlich, um Zeichen- und Rechenbefehle auf der GPU ordnungsgemäß zu synchronisieren.

Die Barriere definiert die Reihenfolge der Speicheroperationen, die von einem vorhergehenden Befehl ausgelöst werden. Das bedeutet: Wenn Befehl1 einen Puffer bearbeitet, der in einem nachfolgenden Befehl2 als Vertex-Attributpuffer verwendet werden soll, sollte die Speicherbarriere nach Befehl1 platziert und der entsprechende Barrieretyp für den Vertex-Attributpuffer festgelegt werden.

Wird ein „QMemoryBarrier“-Knoten in einem FrameGraph-Zweig gefunden, wird die Barriere vor jedem Zeichen- oder Rechenbefehl durchgesetzt, selbst wenn diese tiefer im Zweig definiert sind.

Für das OpenGL-Rendering finden Sie auf dieser Seite weitere Informationen zum Speichermodell.

[deprecated] class Qt3DRender::QMesh

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Lädt Mesh-Daten aus externen Dateien in verschiedenen Formaten. „ Qt3DRender::QMesh “ lädt die Daten in ein einziges Mesh.

In Qt3D 5.9 unterstützt QMesh die folgenden Formate:

• Wavefront OBJ
• Stanford Triangle Format PLY
• STL (STereoLithography)

QMesh unterstützt außerdem das folgende Format, sofern das SDK installiert ist und das FBX-Geometrie-Lader-Plugin kompiliert wurde und vorhanden ist:

• Autodesk FBX

Wenn Sie eine gesamte Szene aus mehreren Objekten laden möchten, sollten Sie stattdessen lieber den „ Qt3DRender::QSceneLoader “ verwenden.

Siehe auch „ Qt3DRender::QSceneLoader “.

[deprecated] class Qt3DRender::QMultiSampleAntiAliasing

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine „ Qt3DRender::QMultiSampleAntiAliasing “-Klasse ermöglicht Multisample-Antialiasing.

Sie kann einem „ QRenderPass “ hinzugefügt werden, indem „ QRenderPass::addRenderState()“ aufgerufen wird:

QRenderPass *renderPass = new QRenderPass();

QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderPass->addRenderState(msaa);

Oder einem „ QRenderStateSet “ durch Aufruf von ` QRenderStateSet::addRenderState()`:

QRenderStateSet *renderStateSet = new QRenderStateSet();

QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderStateSet->addRenderState(msaa);

Damit Multisampling wirksam wird, muss das Renderziel mit aktiviertem Multisampling zugewiesen worden sein:

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);

Außerdem muss der Shader-Code Multisampling-Sampler-Typen und `texelFetch()` anstelle von `texture()` verwenden.

Wenn Sie beispielsweise folgenden Code haben

#version 150

uniform sampler2D colorTexture;
in vec2 texCoord;
out vec4 fragColor;

void main()
{
    fragColor = texture(colorTexture, texCoord);
}

können Sie ihn wie folgt umschreiben:

#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;
}

[deprecated] class Qt3DRender::QNoDepthMask

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine „ Qt3DRender::QNoDepthMask “-Klasse deaktiviert das Schreiben der Fragmenttiefe in den Tiefenpuffer.

Siehe auch „ Qt3DRender::QDepthTest “.

[deprecated] class Qt3DRender::QNoDraw

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Qt3DRender::QNoDraw Sie sollte verwendet werden, wenn der FrameGraph einige Render-Zustände einrichten oder einige Puffer leeren muss, ohne dass ein Mesh gezeichnet werden muss. Sie hat denselben Effekt wie ein „ Qt3DRender::QRenderPassFilter “, der mit keiner der verfügbaren „ Qt3DRender::QRenderPass “-Instanzen der Szene übereinstimmt, jedoch ohne den Overhead, der durch die tatsächliche Durchführung der Filterung entsteht.

Wenn deaktiviert, verhindert ein „ Qt3DRender::QNoDraw “-Knoten nicht, dass die Szene gerendert wird. Das Umschalten der „enabled“-Eigenschaft ist daher eine Möglichkeit, einen „ Qt3DRender::QNoDraw “ aktiv oder inaktiv zu machen.

Qt3DRender::QNoDraw Wird üblicherweise als untergeordneter Knoten eines „Qt3DRenderR::QClearBuffers“-Knotens verwendet, um das Zeichnen der Szene bei mehreren Renderdurchläufen zu verhindern.

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

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Wenn deaktiviert, verhindert ein „ Qt3DRender::QNoPicking “-Knoten nicht, dass eine Auswahl durchgeführt wird. Das Umschalten der Eigenschaft „enabled“ ist daher eine Möglichkeit, einen „ Qt3DRender::QNoPicking “ zu aktivieren oder zu deaktivieren.

Bei der Verwendung mehrerer Unteransichtsfenster im FrameGraph kann „QNoPicking“ nützlich sein, um Auswahlkonflikte zwischen überlappenden oder nicht sichtbaren Ansichtsfenstern zu vermeiden. Es kann auch als Optimierung eingesetzt werden, um unnötigen Aufwand für ausgeblendete Ansichtsfenster oder für Bereiche der Szene zu vermeiden, in denen keine Auswahl erforderlich ist.

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);
....

Siehe auch Qt3DRender::QObjectPicker, Qt3DRender::QRayCaster und Qt3DRender::QScreenRayCaster.

[deprecated] class Qt3DRender::QObjectPicker

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Für jede Kombination aus Viewport und Kamera wird beim Auswählen ein Strahl durch die Szene geworfen, um Entitäten zu finden, deren Begrenzungsvolumen den Strahl schneidet. Das Begrenzungsvolumen wird anhand der Werte im Attributpuffer berechnet, der durch das Attribut `boundingVolumePositionAttribute` der Geometrie festgelegt wird.

Die Signale „ pressed()“, „ released()“, „ clicked()“, „ moved()“, „ entered()“ und „ exited()“ werden ausgelöst, wenn das durch die Eigenschaft „pickAttribute“ definierte Begrenzungsvolumen einen Strahl schneidet.

Die meisten Signale enthalten eine Instanz von „ QPickEvent “. Ist „QPickingSettings::pickMode()“ auf „ QPickingSettings::TrianglePicking “ gesetzt, ist der tatsächliche Typ des „pick“-Parameters „ QPickTriangleEvent “.

Pick-Abfragen werden beim Drücken und Loslassen der Maustaste durchgeführt. Ist das Ziehen aktiviert, finden Abfragen zudem bei jeder Mausbewegung statt, solange eine Taste gedrückt ist. Ist das Hover-Verhalten aktiviert, finden Abfragen bei jeder Mausbewegung statt, auch wenn keine Taste gedrückt ist.

Informationen zu allgemeinen Ray-Casting-Abfragen finden Sie unter Qt3DRender::QRayCaster und Qt3DRender::QScreenRayCaster.

Siehe auch Qt3DRender::QPickingSettings, Qt3DCore::QGeometry, Qt3DCore::QAttribute, Qt3DRender::QPickEvent, Qt3DRender::QPickTriangleEvent und Qt3DRender::QNoPicking.

[deprecated] class Qt3DRender::QPaintedTextureImage

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein `QPaintedTextureImage` bietet die Möglichkeit, ein Texturbild (und damit eine OpenGL-Textur) über eine ` QPainter` anzugeben. Die Breite und Höhe des Texturbilds können über die Eigenschaften `width`, `height` oder `size` festgelegt werden.

Ein `QPaintedTextureImage` muss unterklassifiziert und die virtuelle Funktion ` paint()` implementiert werden. Jedes Mal, wenn ` update()` für das `QPaintedTextureImage` aufgerufen wird, wird die Funktion ` paint()` aufgerufen und das resultierende Bild hochgeladen.

Das `QPaintedTextureImage` muss an ein ` QAbstractTexture` angehängt sein.

[deprecated] class Qt3DRender::QParameter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Auf einen `QParameter` kann über ` QRenderPass`, ` QTechnique`, ` QEffect`, ` QMaterial`, ` QTechniqueFilter` oder ` QRenderPassFilter` verwiesen werden. Zur Laufzeit wird der in einem `QParameter` enthaltene Wert – je nachdem, welcher Shader für einen bestimmten Schritt des Renderings ausgewählt ist – konvertiert und hochgeladen, sofern der Shader ein `uniform` enthält, dessen Name mit dem des `QParameter` übereinstimmt.

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;

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];

Was die Texturunterstützung betrifft, sollte der QParameter-Wert auf die entsprechende Unterklasse von „ QAbstractTexture “ gesetzt werden, die dem Sampler-Typ der Shader-Uniform entspricht.

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 diffuseTexture

Siehe auch „ QAbstractTexture “.

[deprecated] class Qt3DRender::QPickEvent

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Sie wird in den meisten Signalen der Komponente „ QObjectPicker “ als Parameter übergeben, wenn die Auswahl erfolgreich war.

Siehe auch „ QPickingSettings “, „ QPickTriangleEvent “ und „ QObjectPicker “.

[deprecated] class Qt3DRender::QPickLineEvent

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Siehe auch QPickEvent.

[deprecated] class Qt3DRender::QPickPointEvent

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Siehe auch QPickEvent.

[deprecated] class Qt3DRender::QPickTriangleEvent

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Wenn QPickingSettings::pickMode() auf „ QPickingSettings::TrianglePicking “ gesetzt ist, übertragen die Signale von „ QObjectPicker “ eine Instanz von QPickTriangleEvent.

Diese enthält die Details des ausgewählten Dreiecks.

Siehe auch „ QPickingSettings “, „ QPickEvent “ und „ QObjectPicker “.

[since 6.0, deprecated] class Qt3DRender::QPickingProxy

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Das Auswählen kann ein rechenintensiver Vorgang sein, insbesondere wenn das Mesh viele Scheitelpunkte enthält. Mit `QPickProxy` lässt sich eine alternative Geometrie bereitstellen – in der Regel mit weniger Primitiven –, die für die Auswahl verwendet wird, während die ` GeometryRenderer `-Instanz für das Rendern genutzt wird.

Diese Klasse wurde in Qt 6.0 eingeführt.

[deprecated] class Qt3DRender::QPickingSettings

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Auswahl-Einstellungen legen fest, wie die Entitätsauswahl gehandhabt wird. Weitere Informationen zur Entitätsauswahl finden Sie in der Dokumentation zu den Komponenten „ QObjectPicker “ und „ QRayCaster “.

Bei der Verwendung von „ QObjectPicker “-Komponenten wird das Picking durch Mausereignisse ausgelöst.

Bei Verwendung von „ QRayCaster “- oder „ QScreenRayCaster “-Komponenten kann die Auswahl explizit durch die Anwendung ausgelöst werden.

In beiden Fällen wird ein Strahl durch die Szene geworfen, um Geometrie zu finden, die den Strahl schneidet.

Siehe auch QObjectPicker, QPickEvent, QPickTriangleEvent, QRayCaster und QScreenRayCaster.

[deprecated] class Qt3DRender::QPointLight

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine Punktlichtquelle ist eine Lichtquelle, die Licht von einem einzigen Punkt aus in alle Richtungen abstrahlt. Konzeptionell ähnelt dies dem Licht einer herkömmlichen Glühbirne.

Eine Punktlichtquelle verwendet drei Abschwächungsfaktoren, um zu beschreiben, wie die Lichtintensität mit zunehmender Entfernung abnimmt. Diese Faktoren sind so konzipiert, dass sie gemeinsam zur Berechnung der Gesamtabschwächung verwendet werden. Für die Materialien in Qt3D Extras wird die folgende Formel verwendet, wobei „distance“ die Entfernung von der Lichtquelle zur gerenderten Oberfläche ist:

totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));

Benutzerdefinierte Materialien können diese Faktoren nach Belieben anders interpretieren.

[deprecated] class Qt3DRender::QPointSize

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Wenn die Eigenschaft „ sizeMode “ auf „ SizeMode::Fixed “ gesetzt ist, wird der Wert mithilfe von „glPointSize()“ festgelegt, sofern verfügbar. Bei Verwendung von „ SizeMode::Programmable “ muss „gl_PointSize“ innerhalb der Shader-Programme festgelegt werden; der an diese „ RenderState “ übergebene Wert wird in diesem Fall ignoriert.

[deprecated] class Qt3DRender::QPolygonOffset

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine QPolygonOffset-Klasse fügt vor dem Tiefentest und dem Tiefenschreibvorgang einen Versatz zum Fragmenttiefenwert hinzu. Der Versatz kann verwendet werden, um Z-Kämpfe beim Rendern von Polygonen mit sehr ähnlichen Tiefenwerten, wie z. B. Decals, zu vermeiden.

[deprecated] class Qt3DRender::QProximityFilter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Mit einem „ Qt3DRender::QProximityFilter “ können Entitäten ausgewählt werden, die gerendert werden sollen, wenn sie sich innerhalb eines bestimmten Abstandsschwellenwerts zu einer anderen Entität befinden.

[deprecated] class Qt3DRender::QRasterMode

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „QRasterMode“ dient zur Steuerung des Rasterisierungsschritts der Primitive zum Zeitpunkt der Darstellung. Damit lässt sich festlegen, ob nur Punkte oder Kanten angezeigt werden sollen oder ob eine Primitive ausgefüllt werden soll.

Siehe auch QAlphaTest und QStencilTest.

[deprecated] class Qt3DRender::QRayCaster

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Der 3D-Strahl wird durch seinen Ursprung, seine Richtung und seine Länge definiert. Er wird von den Transformationen beeinflusst, die auf die Entität angewendet werden, zu der er gehört.

Ray-Casting-Tests werden in jedem Frame durchgeführt, solange die Komponente aktiviert ist. Die Eigenschaft „hits“ wird mit der Liste der Schnittpunkte aktualisiert.

Siehe auch QAbstractRayCaster, QScreenRayCaster und QNoPicking.

[deprecated] class Qt3DRender::QRayCasterHit

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Qt3DRender::QRayCasterHit Enthält die Details eines erfolgreichen Treffers, wenn ein Strahl mithilfe einer „ Qt3DRender::QRayCaster “- oder „ Qt3DRender::QScreenRayCaster “-Komponente durch ein Modell geworfen wird.

Siehe auch „ Qt3DRender::QRayCaster “, „ Qt3DRender::QScreenRayCaster “ und „ Qt3DRender::QPickingSettings “.

[deprecated] class Qt3DRender::QRenderAspect

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QRenderCapabilities

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QRenderCapabilities liefert Details zu den grafischen Funktionen, die zur Laufzeit verfügbar sind. Sie kann beispielsweise dazu verwendet werden, um zu entscheiden, welcher Codepfad für bestimmte Algorithmen verwendet werden soll – je nachdem, ob Compute-Shader verfügbar sind oder nicht.

[deprecated] class Qt3DRender::QRenderCapture

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QRenderCapture wird verwendet, um das Rendering in jeder Renderphase als Bild zu erfassen. Die Erfassung muss vom Benutzer initiiert werden, und pro Erfassungsanforderung wird ein Bild zurückgegeben. Der Benutzer kann mehrere Render-Erfassungsanforderungen gleichzeitig auslösen, jedoch wird pro QRenderCapture-Instanz pro Bild nur eine Anforderung bearbeitet.

[deprecated] class Qt3DRender::QRenderCaptureReply

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein Objekt, das das Bild von QRenderCapture::requestCapture empfängt.

[deprecated] class Qt3DRender::QRenderPass

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QRenderPass “ spezifiziert einen einzelnen Rendering-Durchlauf – eine Instanz der Ausführung eines Shader-Programms –, der von „ Qt3DRender::QTechnique “ verwendet wird. Ein Rendering-Durchlauf besteht aus einem „ Qt3DRender::QShaderProgram “ sowie einer Liste von „ Qt3DRender::QFilterKey “-Objekten, einer Liste von „ Qt3DRender::QRenderState “-Objekten und einer Liste von „ Qt3DRender::QParameter “-Objekten.

QRenderPass führt den „ QShaderProgram “ unter Verwendung der angegebenen „ QRenderState “- und „ QParameter “-Knoten aus, wenn mindestens einer der referenzierten „ QFilterKey “-Knoten mit einem der „ QFilterKey “-Knoten in „ QRenderPassFilter “ übereinstimmt oder wenn keine „ QFilterKey “-Knoten angegeben sind und kein „ QRenderPassFilter “ im FrameGraph vorhanden ist.

Wenn der QRenderPass einen „ QParameter “ definiert, wird dieser durch einen „ QParameter “ mit demselben Namen überschrieben, sofern dieser in einem der mit dem Pass zur Laufzeit verknüpften „ QTechnique “, „ QEffect “, „ QMaterial “, „ QTechniqueFilter “ oder „ QRenderPassFilter “ vorhanden ist. Dies kann dennoch nützlich sein, um sinnvolle Standardwerte festzulegen.

Zum Zeitpunkt der Darstellung wird für jeden Blattknoten des FrameGraphs ein Basis-Darstellungszustand aufgezeichnet, indem die Zustände aller „ QRenderStateSet “-Knoten im FrameGraph-Zweig akkumuliert werden. Jeder QRenderPass kann diesen Basis-Darstellungszustand überschreiben, indem er seine eigenen „ QRenderState “-Knoten angibt.

// 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);

Siehe auch „ QRenderPassFilter“ , „ QFilterKey “, „ QParameter “, „ QRenderState “, „ QEffect “ und „ QTechnique “.

[deprecated] class Qt3DRender::QRenderPassFilter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QRenderPassFilter “-FrameGraph-Knoten wird verwendet, um auszuwählen, welche „ Qt3DRender::QRenderPass “-Objekte zum Zeichnen ausgewählt werden. „QRenderPassFilter“ gibt eine Liste von „ Qt3DRender::QFilterKey “-Objekten und „ Qt3DRender::QParameter “-Objekten an. Wenn „QRenderPassFilter“ im FrameGraph vorhanden ist, werden nur die „ QRenderPass “-Objekte zum Rendern ausgewählt, deren „ Qt3DRender::QFilterKey “-Objekte mit den Schlüsseln in „QRenderPassFilter“ übereinstimmen. Ist kein „QRenderPassFilter“ vorhanden, werden alle „ QRenderPass “-Objekte für die Darstellung ausgewählt. Die Parameter in der Liste können verwendet werden, um Werte für Shader-Parameter festzulegen. Die Parameter in „QRenderPassFilter“ überschreiben die Parameter in „ QTechniqueFilter “, „ QMaterial “, „ QEffect “, „ QTechnique “ und „ QRenderPass “.

[deprecated] class Qt3DRender::QRenderSettings

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Komponente „QRenderSettings“ muss als Komponente der Stammentität der Szene festgelegt werden. Sie legt die Render-Richtlinien und Auswahl-Einstellungen fest und beherbergt zudem den aktiven FrameGraph.

[deprecated] class Qt3DRender::QRenderState

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „ Qt3DRender::QRenderState “ ist eine abstrakte Basisklasse für alle Render-Zustände. „QRenderState“ kann nicht direkt instanziiert werden, sondern nur über ihre Unterklassen.

[deprecated] class Qt3DRender::QRenderStateSet

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die in einem „QRenderStateSet“ festgelegten Zustände gelten global, im Gegensatz zu den materialbezogenen Zuständen, die in einem „ QRenderPass “ festgelegt werden können. Standardmäßig führt ein leeres „QRenderStateSet“ dazu, dass bei der Ausführung alle Renderzustände deaktiviert werden. Durch Hinzufügen eines „ QRenderState “-Zustands wird dieser Renderzustand zur Laufzeit explizit aktiviert.

Der „ RenderStateSet “ wird aktiviert, wenn er zum aktiven Frame-Graph hinzugefügt wird:

// 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);

Siehe auch „ QRenderState “ und „ QRenderPass “.

[deprecated] class Qt3DRender::QRenderSurfaceSelector

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Mit dem Parameter „ Qt3DRender::QRenderSurfaceSelector “ kann die Oberfläche ausgewählt werden, auf der Qt3D den Inhalt rendert. Bei der Oberfläche kann es sich entweder um eine Fensteroberfläche oder um eine Offscreen-Oberfläche handeln. Der Parameter „ externalRenderTargetSize “ dient dazu, die tatsächliche Größe der Oberfläche anzugeben, wenn eine Offscreen-Oberfläche verwendet wird.

Wenn das System eine DPI-Skalierung verwendet, können die logische Oberflächengröße, die für Mausereignisse verwendet wird, und die tatsächliche „physikalische“ Größe der Oberfläche voneinander abweichen. „ surfacePixelRatio “ ist der Faktor zur Umrechnung der logischen Größe in die physikalische Größe.

Siehe auch „ QWindow “, „ QOffscreenSurface “ und „ QSurface “.

[deprecated] class Qt3DRender::QRenderTarget

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QRenderTarget “ besteht aus „ Qt3DRender::QRenderTargetOutput “-Objekten, die die Puffer angeben, in die das Render-Target rendert. Der Benutzer kann MRT (Multiple Render Targets) festlegen, indem er mehrere Texturen an verschiedene Anheftungspunkte anbringt. Das Ergebnis ist undefiniert, wenn der Benutzer versucht, mehrere Texturen an denselben Anheftungspunkt anzubringen. Zum Zeitpunkt des Renderns werden nur die im „ Qt3DRender::QRenderTargetSelector “ angegebenen Zeichnungspuffer verwendet.

[deprecated] class Qt3DRender::QRenderTargetOutput

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein `QRenderTargetOutput` legt den Anheftungspunkt und die Parameter für eine Textur fest, die an ein Renderziel angeheftet wird. Zusätzlich zum Anheftungspunkt können die Mip-Stufe der Textur, die Ebene und die Cubemap-Fläche angegeben werden. Die an das `QRenderTargetOutput` angeheftete Textur muss mit den angegebenen Parametern kompatibel sein.

[deprecated] class Qt3DRender::QRenderTargetSelector

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QRenderTargetSelector “ wird verwendet, um aktive „ Qt3DRender::QRenderTarget “ für den „FrameGraph“ auszuwählen. Wenn ein „QRenderTargetSelector“ im „FrameGraph“ vorhanden ist, wird das Rendering in „QTexture“-Objekte oder Zeichnungspuffer umgeleitet, anstatt auf die in „ Qt3DRender::QRenderSurfaceSelector “ angegebene Oberfläche.

[deprecated] class Qt3DRender::QSceneLoader

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Bei einer 3D-Quelldatei versucht der „ Qt3DRender::QSceneLoader “, diese zu analysieren und einen Baum aus „ Qt3DCore::QEntity “-Objekten mit den entsprechenden Komponenten „ Qt3DRender::QGeometryRenderer “, „ Qt3DCore::QTransform “ und „ Qt3DRender::QMaterial “ aufzubauen.

Der Loader versucht, anhand der Eigenschaften der Modelldatei das am besten geeignete Material zu ermitteln. Wenn Sie ein benutzerdefiniertes Material verwenden möchten, müssen Sie die Baumstruktur durchlaufen und die standardmäßig zugeordneten Materialien durch Ihre eigenen ersetzen.

Wie der Name schon sagt, lädt „ Qt3DRender::QSceneLoader “ einen kompletten Szenen-Teilbaum. Wenn Sie ein einzelnes Geometrieelement laden möchten, sollten Sie stattdessen „ Qt3DRender::QMesh “ verwenden.

Qt3DRender::QSceneLoader stützt sich intern auf die Verwendung von Plugins, um eine Vielzahl von 3D-Dateiformaten zu unterstützen. Hier finden Sie eine Liste der von Qt3D unterstützten Formate.

Siehe auch „ Qt3DRender::QMesh “ und „ Qt3DRender::QGeometryRenderer “.

[deprecated] class Qt3DRender::QScissorTest

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine QScissorTest-Klasse ermöglicht den „Scissor-Test“, bei dem Bildausschnitte außerhalb des rechteckigen Bildschirmbereichs verworfen werden, der durch die Eigenschaften „left“, „bottom“, „width“ und „height“ festgelegt wird.

[deprecated] class Qt3DRender::QScreenRayCaster

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Mit `QScreenRayCaster` lassen sich Raycasting-Tests durchführen, indem Koordinaten im Bildschirmraum angegeben werden, anhand derer ein tatsächlicher 3D-Strahl zwischen der Nah- und der Fernebene konstruiert wird.

Siehe auch QRayCaster und QNoPicking.

[deprecated] class Qt3DRender::QSeamlessCubemap

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ist diese Klasse in einem Zustandssatz vorhanden, wird die nahtlose Cubemap-Texturfilterung aktiviert, wie sie von der Erweiterung GL_ARB_seamless_cubemap bereitgestellt wird (sofern verfügbar).

[deprecated] class Qt3DRender::QSetFence

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Fences ermöglichen die Synchronisierung von GPU- und CPU-Workloads. GPU-Befehle sind in der Regel nicht blockierend. Bei ihrer Ausgabe werden Befehle in Befehlspuffer eingefügt, die zu einem späteren Zeitpunkt von der GPU gelesen werden. In manchen Fällen möchten Sie die Verarbeitung fortsetzen oder einen bestimmten Befehl erst dann ausführen, wenn Sie sicher sind, dass ein Befehl von der Hardware ausgeführt wurde. Fences bieten eine Möglichkeit, dies zu erreichen. Dies ist besonders wichtig bei der Verwendung von Engines von Drittanbietern mit Qt3D: Qt3D sollte erst dann auf gemeinsam genutzte Ressourcen zugreifen, wenn sicher ist, dass die Befehle der anderen Engine die Änderung der Ressource abgeschlossen haben.

`QSetFence` ist ein FrameGraph-Knoten, der einen Fence in den Befehlsstrom einfügt. Er kann dann in Verbindung mit ` QWaitFence ` verwendet werden oder durch Extrahieren des zugrunde liegenden Handles.

Die „handle“-Eigenschaft wird aktualisiert, sobald der Renderer die zugrunde liegende Fence-Ressource erstellt hat. Der Handle bleibt gültig, solange er sich im „unsignaled“-Zustand befindet. Sobald er den „signaled“-Zustand erreicht hat, wird er zerstört und ein neuer Handle erstellt. Das bedeutet, dass je nachdem, wie lange es dauert, bis der Fence signalisiert wird, derselbe Handle über mehrere Frames hinweg verwendet werden könnte.

[deprecated] class Qt3DRender::QShaderData

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QShaderImage

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Um den Inhalt von Texturen für Lese- und Schreibvorgänge in einem Shader verfügbar zu machen, müssen sie als `QShaderImage` bereitgestellt werden. Texturen können aus mehreren Mip-Ebenen, Ebenen und Flächen bestehen. Durch die Deklaration eines `QShaderImage` lässt sich zudem festlegen, auf welche Ebene, Ebene oder Fläche des Texturinhaltes zugegriffen werden soll.

Damit QShaderImage ordnungsgemäß funktioniert, muss es als Wert eines „ QParameter “ zugewiesen werden und auf ein gültiges „ Qt3DRender::QAbstractTexture “ verweisen.

Handelt es sich bei der referenzierten Textur um ein eindimensionales Array, ein zweidimensionales Array, eine dreidimensionale Textur, eine Cube-Map, ein Cube-Map-Array oder eine zweidimensionale Multisample-Array-Textur, ist es möglich, entweder die gesamte Texturstufe oder eine einzelne Ebene bzw. Fläche der Texturstufe zu binden. Dies lässt sich über die Eigenschaft „ layered “ steuern.

Die Unterstützung für QShaderImage ist nur in OpenGL 4 und teilweise in OpenGL ES 3.1 und 3.2 verfügbar.

OpenGL 4 unterstützt die folgenden Bildtypen:

OpenGL ES 3.1 unterstützt die folgenden Bildtypen:

OpenGL ES 3.2 unterstützt alle Bildtypen von OpenGL ES 3.1 sowie die folgenden:

Die erwartete Verwendung würde wie folgt aussehen:

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

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein Shader-Programm besteht aus mehreren verschiedenen Shadern, wie beispielsweise Vertex- und Fragment-Shadern.

Qt3D füllt automatisch eine Reihe von Standard-Uniforms aus, wenn diese während der Shader-Introspektionsphase erkannt werden.

RHI-Unterstützung

Beim Schreiben von GLSL-450-Shader-Code zur Verwendung mit dem RHI-Backend von „ Qt 3D “ werden die Standard-Uniforms als zwei Uniform-Buffer-Objekte bereitgestellt.

Die Bindungspositionen hierfür sind auf Bindung 0 für RenderView-Uniforms und auf Bindung 1 für Command-Uniforms festgelegt.

#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);
}

Verwenden Sie für benutzerdefinierte Uniform-Buffer-Objekte eine Bindung ab 2 oder „auto“, damit Qt 3D die Bindung automatisch ermittelt. Achten Sie darauf, die Konsistenz zwischen den verschiedenen Shader-Stufen zu wahren.

#version 450 core

layout(std140, binding = auto) uniform my_uniforms {
  vec4 myColor;
};

layout(location=0) out vec4 fragColor;

void main()
{
    fragColor = myColor;
}

Bei der Übergabe von Werten an Uniforms gibt es keine Änderungen.

Im obigen Beispiel könnte die Einstellung von „myColor“ wie folgt erfolgen:

QParameter *parameter = new QParameter();
parameter->setName("myColor");
parameter->setValue(QVariant::fromValue(QColor(Qt::blue)));

Texturen müssen weiterhin als eigenständige Uniforms definiert werden.

#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

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein Shader-Programmierwerkzeug besteht aus mehreren verschiedenen Shader-Graphen, die zur Generierung von Shader-Code verwendet werden.

Es wird ein Cache mit generiertem Shader-Code verwaltet. Generierte Shader werden standardmäßig unter „ QStandardPaths::writableLocation “ (QStandardPaths::TempLocation) gespeichert. Dieser Pfad kann überschrieben werden, indem die Umgebungsvariable QT3D_WRITABLE_CACHE_PATH auf einen gültigen, beschreibbaren Pfad gesetzt wird.

Die Verwendung des Caches kann durch Setzen der Umgebungsvariable QT3D_DISABLE_SHADER_CACHE deaktiviert werden.

In den meisten Fällen werden Änderungen an einem Graphen von Qt 3D erkannt und ein neuer Cache-Eintrag generiert. Ein Fall, in dem dies nicht geschieht, ist, wenn Code-Schnipsel, die von einem Graphen eingebunden werden, geändert werden. Um dies zu umgehen, kann das Leeren des Cache-Verzeichnisses oder das Setzen der Umgebungsvariable `QT3D_REBUILD_SHADER_CACHE` verwendet werden, um die erneute Generierung des Shader-Codes zu erzwingen.

[deprecated] class Qt3DRender::QSharedGLTexture

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Je nach dem von Qt 3D verwendeten Rendering-Modus ist der gemeinsam genutzte Kontext entweder:

• qt_gl_global_share_context, wenn „ Qt 3D “ das Rendering steuert. Wenn das Attribut „ Qt::AA_ShareOpenGLContexts “ in der Klasse „QApplication“ gesetzt wird, führt dies automatisch dazu, dass QOpenGLWidget-Instanzen ihren Kontext mit „qt_gl_global_share_context“ teilen.
• der gemeinsam genutzte Kontext aus der „ QtQuick “-Szene. Möglicherweise müssen Sie jedoch eine Unterklasse von ` QWindow ` erstellen oder `QtQuickRenderControl` verwenden, um die Kontrolle darüber zu haben, um welchen gemeinsam genutzten Kontext es sich handelt – ab Version 5.13 ist dies jedoch `qt_gl_global_share_context`.

Jede Engine eines Drittanbieters, die ihren Kontext mit dem „ Qt 3D “-Renderer teilt, kann nun Textur-IDs bereitstellen, auf die von der „ Qt 3D “-Textur verwiesen wird.

Sie können auf die Angabe der Textureigenschaften verzichten; „ Qt 3D “ versucht zur Laufzeit, diese zu ermitteln. Wenn Sie sie kennen, können Sie sie natürlich angeben, um „ Qt 3D “ zusätzliche Arbeit zu ersparen.

Beachten Sie, dass Sie bei der Verwendung benutzerdefinierter Materialien und Shader den richtigen Sampler-Typ angeben müssen.

[deprecated] class Qt3DRender::QSortPolicy

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine ` Qt3DRender::QSortPolicy `-Klasse speichert den vom `FrameGraph` verwendeten Sortiertyp. Die Sortiertypen legen fest, wie zeichnungsfähige Entitäten vor dem Zeichnen sortiert werden, um die Zeichenreihenfolge zu bestimmen. Wenn `QSortPolicy` im `FrameGraph` vorhanden ist, wird der Sortiermechanismus durch die Liste ` sortTypes ` bestimmt. Es können mehrere Sortierarten gleichzeitig verwendet werden. Ist „QSortPolicy“ im FrameGraph nicht vorhanden, werden die Elemente in der Reihenfolge gezeichnet, in der sie in der Elementhierarchie erscheinen.

[deprecated] class Qt3DRender::QSpotLight

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein Spotlight ist eine Lichtquelle, die einen Lichtkegel in eine bestimmte Richtung ausstrahlt.

Ein Spotlight verwendet drei Dämpfungsfaktoren, um zu beschreiben, wie die Lichtintensität mit zunehmender Entfernung abnimmt. Diese Faktoren sind so konzipiert, dass sie gemeinsam zur Berechnung der Gesamtdämpfung herangezogen werden. Für die Materialien in Qt3D Extras wird die folgende Formel verwendet, wobei „distance“ die Entfernung vom Licht zur gerenderten Oberfläche angibt:

totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));

Benutzerdefinierte Materialien können diese Faktoren nach Belieben anders interpretieren.

[deprecated] class Qt3DRender::QStencilMask

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine ` Qt3DRender::QStencilMask `-Klasse legt eine Schreibmaske für die Stencil-Werte nach dem Stencil-Test fest. Die Maske kann für vorderseitige und rückseitige Polygone separat festgelegt werden. Der Fragment-Stencil-Wert wird mit der Maske logisch UND-verknüpft, bevor er in den Stencil-Puffer geschrieben wird.

Siehe auch ` Qt3DRender::QStencilTest`.

[deprecated] class Qt3DRender::QStencilOperation

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine „ Qt3DRender::QStencilOperation “-Klasse legt die Stencil-Operationen für die nach vorne und nach hinten gerichteten Polygone fest. Die Stencil-Operationen steuern, was mit einem Fragment geschieht, wenn der Stencil- und der Tiefentest bestanden oder nicht bestanden werden.

Siehe auch „ Qt3DRender::QStencilTest “.

[deprecated] class Qt3DRender::QStencilOperationArguments

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „ Qt3DRender::QStencilOperationArguments “ legt die Argumente für die Stencil-Operationen fest.

Siehe auch „ Qt3DRender::QStencilOperation “.

[deprecated] class Qt3DRender::QStencilTest

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Eine „ Qt3DRender::QStencilTest “-Klasse legt Argumente für den Stencil-Test fest. Der Stencil-Test besteht aus drei Argumenten: der Stencil-Testfunktion, der Stencil-Testmaske und dem Stencil-Referenzwert. Mit „QStencilTest“ können diese Argumente sowohl für vorderseitige als auch für rückseitige Polygone separat festgelegt werden.

Siehe auch „ Qt3DRender::QStencilMask “ und „ Qt3DRender::QStencilOperation “.

[deprecated] class Qt3DRender::QStencilTestArguments

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Die Klasse „ Qt3DRender::QStencilTestArguments “ legt die Argumente für den Stencil-Test fest.

[deprecated] class Qt3DRender::QSubtreeEnabler

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Zwar lassen sich `QFrameGraphNodes` über die Eigenschaft ` enabled ` einzeln aktivieren und deaktivieren, doch kann dies mühsam werden, wenn ein ganzer Pfad ein- oder ausgeschaltet werden soll. `QSubtreeEnabler` ist ein Komfortknoten, der diesen Anwendungsfall vereinfacht, da alle seine untergeordneten Knoten über einen einzigen Schalter gesteuert werden können.

QSubtreeEnabler ist standardmäßig aktiviert.

[deprecated] class Qt3DRender::QTechnique

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QTechnique “ gibt eine Reihe von „ Qt3DRender::QRenderPass “-Objekten, „ Qt3DRender::QFilterKey “-Objekten, „ Qt3DRender::QParameter “-Objekten und einen „ Qt3DRender::QGraphicsApiFilter “ an, die zusammen eine Rendering-Technik definieren, die die jeweilige Grafik-API darstellen kann. Die Filtertasten werden von „ Qt3DRender::QTechniqueFilter “ verwendet, um bestimmte Techniken an bestimmten Stellen des FrameGraphs auszuwählen. Ein auf einem „QTechnique“-Knoten definierter „ QParameter “ überschreibt den (gleichnamigen) Parameter, der in „ QRenderPass “ definiert ist, wird jedoch von den Parametern in „ QRenderPassFilter “, „ QTechniqueFilter “, „ QMaterial “ und „ QEffect “ überschrieben.

Beim Erstellen eines „ QEffect “, der auf mehrere Versionen einer Grafik-API abzielt, ist es sinnvoll, mehrere „QTechnique“-Knoten zu erstellen, bei denen jeweils der Parameter „ graphicsApiFilter “ so eingestellt ist, dass er einer der angestrebten GL-Versionen entspricht. Zur Laufzeit wählt der Qt3D-Renderer die am besten geeignete „QTechnique“ aus, basierend darauf, welche Grafik-API-Versionen unterstützt werden, und (falls angegeben) anhand der „ QFilterKey “-Knoten, die eine bestimmte „ QTechniqueFilter “ im FrameGraph erfüllen.

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);

Siehe auch QEffect, QRenderPass und QTechniqueFilter.

[deprecated] class Qt3DRender::QTechniqueFilter

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Ein „ Qt3DRender::QTechniqueFilter “ legt fest, welche Techniken vom FrameGraph beim Rendern der Entitäten verwendet werden. „QTechniqueFilter“ gibt eine Liste von „ Qt3DRender::QFilterKey “-Objekten und „ Qt3DRender::QParameter “-Objekten an. Wenn „QTechniqueFilter“ im FrameGraph vorhanden ist, werden nur die Techniken verwendet, die mit den Schlüsseln in der Liste übereinstimmen. Die Parameter in der Liste können verwendet werden, um Werte für Shader-Parameter festzulegen. Die Parameter in `QTechniqueFilter` überschreiben die Parameter in ` QMaterial`, ` QEffect`, ` QTechnique ` und ` QRenderPass`, werden jedoch von den Parametern in ` QRenderPassFilter` überschrieben.

[deprecated] class Qt3DRender::QTexture1D

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture1DArray

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture2D

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture2DArray

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture2DMultisample

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture2DMultisampleArray

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTexture3D

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureBuffer

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureCubeMap

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureCubeMapArray

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureData

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureDataUpdate

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Der eigentliche Dateninhalt ist in einem „ QTextureImageDataPtr “-Mitglied enthalten. Zusätzliche Mitglieder ermöglichen es, den x-, y- und z-Versatz der Inhaltsaktualisierung sowie gegebenenfalls die Ebene, die Mip-Stufe und die Fläche anzugeben.

Siehe auch „ QAbstractTexture “.

[deprecated] class Qt3DRender::QTextureImage

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Sie enthält die erforderlichen Informationen – Mipmap-Ebene, Ebene, Würfelseite und Quell-URL –, um Daten an der richtigen Stelle in eine OpenGL-Textur zu laden.

[deprecated] class Qt3DRender::QTextureImageData

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureImageDataGenerator

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

QTextureImageDataGenerator ist ein Datenanbieter für QAbstractTexture. Mit QTextureImageDataGenerator lässt sich Qt3D um weitere Möglichkeiten zum Laden von Texturbilddaten erweitern und es werden benutzerdefinierte Formate sowie Formate unterstützt, die Qt3D von Haus aus nicht unterstützt. Die Daten werden von der ` QTextureImageDataPtr ` zurückgegeben, die die Daten enthält, die in die Textur geladen werden sollen. QTextureImageDataGenerator wird im Backend durch Aspect-Jobs ausgeführt.

[deprecated] class Qt3DRender::QTextureLoader

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureRectangle

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QTextureWrapMode

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

[deprecated] class Qt3DRender::QViewport

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Qt3DRender::QViewport Die Szene legt fest, auf welchen Teil der Renderfläche Qt3D rendert. Der Bereich außerhalb des Ansichtsfensters bleibt unberührt. Außerdem steuert sie globale Parameter für das Rendering in diesem Ansichtsfenster, wie beispielsweise den Gammawert.

[deprecated] class Qt3DRender::QWaitFence

Diese Klasse ist veraltet. Wir raten dringend davon ab, sie in neuem Code zu verwenden.

Fences ermöglichen die Synchronisierung von GPU- und CPU-Workloads. GPU-Befehle sind in der Regel nicht blockierend. Bei ihrer Ausgabe werden Befehle in Befehlspuffer eingefügt, die zu einem späteren Zeitpunkt von der GPU gelesen werden. In manchen Fällen möchten Sie die Verarbeitung fortsetzen oder einen bestimmten Befehl erst dann ausführen, wenn Sie sicher sind, dass ein Befehl von der Hardware ausgeführt wurde. Fences bieten eine Möglichkeit, dies zu erreichen. Dies ist besonders wichtig bei der Verwendung von Engines von Drittanbietern mit Qt3D: Qt3D sollte nur dann auf gemeinsam genutzte Ressourcen zugreifen, wenn sicher ist, dass die Befehle der anderen Engine die Änderung der Ressource abgeschlossen haben.

QWaitFence ist ein FrameGraph-Knoten, der erzwingt, dass gewartet wird, bis er signalisiert wird, bevor nachfolgende Befehle in den Befehlsstrom eingefügt werden. Er kann dann in Verbindung mit QSetFence verwendet werden und enthält Eigenschaften, mit denen konfiguriert werden kann, wie lange gewartet werden soll und ob auf der CPU-Seite blockiert werden soll.