| blitframebuffer.cpp |
|
3353 |
- |
| blitframebuffer_p.h |
|
1797 |
- |
| buffercapture.cpp |
|
469 |
- |
| buffercapture_p.h |
|
799 |
- |
| cameraselectornode.cpp |
|
1187 |
- |
| cameraselectornode_p.h |
|
1055 |
- |
| clearbuffers.cpp |
|
2658 |
- |
| clearbuffers_p.h |
|
1861 |
- |
| debugoverlay.cpp |
|
479 |
- |
| debugoverlay_p.h |
|
794 |
- |
| dispatchcompute.cpp |
|
1506 |
- |
| dispatchcompute_p.h |
|
1220 |
- |
| framegraphnode.cpp |
|
2951 |
- |
| framegraphnode_p.h |
|
3912 |
- |
| framegraphvisitor.cpp |
|
2243 |
- |
| framegraphvisitor_p.h |
|
1322 |
- |
| frustumculling.cpp |
|
494 |
- |
| frustumculling_p.h |
|
863 |
- |
| layerfilternode.cpp |
|
1543 |
- |
| layerfilternode_p.h |
|
1284 |
- |
| memorybarrier.cpp |
|
1050 |
- |
| memorybarrier_p.h |
|
1076 |
- |
| nodraw.cpp |
|
464 |
- |
| nodraw_p.h |
|
815 |
- |
| nopicking.cpp |
|
430 |
- |
| nopicking_p.h |
|
805 |
- |
| proximityfilter.cpp |
|
1138 |
- |
| proximityfilter_p.h |
|
1381 |
- |
| qblitframebuffer.cpp |
!
\class Qt3DRender::QBlitFramebuffer
\inmodule Qt3DRender
\since 5.10
\ingroup framegraph
\brief FrameGraph node to transfer a rectangle of pixel values from one
region of a render target to another.
This node inserts a \c glBlitFrameBuffer or an equivalent into the command
stream. This provides a more efficient method for copying rectangles
between textures or surface backbuffers wrapped by QRenderTarget than
drawing textured quads. It also supports scaling with the specified
interpolation method.
\note In practice the QBlitFramebuffer node will often be used in
combination with QNoDraw since a blit should not involve issuing draw calls
for any entities.
|
12121 |
- |
| qblitframebuffer.h |
|
3108 |
- |
| qblitframebuffer_p.h |
|
1250 |
- |
| qbuffercapture.cpp |
!
\internal
|
919 |
- |
| qbuffercapture.h |
|
694 |
- |
| qbuffercapture_p.h |
|
824 |
- |
| qcameraselector.cpp |
!
\class Qt3DRender::QCameraSelector
\inmodule Qt3DRender
\since 5.5
\ingroup framegraph
\brief Class to allow for selection of camera to be used.
A Qt3DRender::QCameraSelector can be used to select the camera, which is used
by the FrameGraph when drawing the entities.
|
2700 |
- |
| qcameraselector.h |
|
1110 |
- |
| qcameraselector_p.h |
|
903 |
- |
| qclearbuffers.cpp |
!
\class Qt3DRender::QClearBuffers
\inmodule Qt3DRender
\since 5.7
\ingroup framegraph
\brief Class to clear buffers.
A Qt3DRender::QClearBuffers FrameGraph node enables clearing of the specific
render target buffers with specific values.
|
5165 |
- |
| qclearbuffers.h |
|
2562 |
- |
| qclearbuffers_p.h |
|
995 |
- |
| qdebugoverlay.cpp |
!
\class Qt3DRender::QDebugOverlay
\inmodule Qt3DRender
\ingroup framegraph
\brief Enables a visual overlay with scene details.
Placing a QDebugOverlay in one branch of a custom framegraph will cause an overlay
with scene details to be rendered along with the scene.
The standard QForwardRenderer includes a QDebugOverlay node that can be enabled via
the QForwardRenderer::showDebugOverlay property.
|
1638 |
- |
| qdebugoverlay.h |
|
617 |
- |
| qdebugoverlay_p.h |
|
857 |
- |
| qdispatchcompute.cpp |
!
\class Qt3DRender::QDispatchCompute
\inmodule Qt3DRender
\since 5.7
\ingroup framegraph
\brief FrameGraph node to issue work for the compute shader on GPU.
A Qt3DRender::QDispatchCompute allows work to be issued for the compute shader to
run on the GPU. The workGroupX, workGroupY and workGroupZ properties specify the work group
sizes for the compute shader invocation. QComputeCommand components need to be added
to entities to instruct Qt3D to select the materials and geometry from the entities
for the compute invocation. The work group sizes for the shader invocation will be
the maximum of the work group sizes specified in QDispatchCompute and QComputeCommand.
|
3552 |
- |
| qdispatchcompute.h |
|
1313 |
- |
| qdispatchcompute_p.h |
|
969 |
- |
| qframegraphnode.cpp |
|
11772 |
- |
| qframegraphnode.h |
|
941 |
- |
| qframegraphnode_p.h |
|
1363 |
- |
| qfrustumculling.cpp |
!
\class Qt3DRender::QFrustumCulling
\inmodule Qt3DRender
\since 5.7
\ingroup framegraph
\brief Enable frustum culling for the FrameGraph.
A QFrustumCulling class enables frustum culling of the drawable entities based on
the camera view and QGeometry bounds of the entities. If QFrustumCulling is present in
the FrameGraph, only the entities whose QGeometry bounds intersect with the camera
frustum, i.e. the view of the camera, are drawn. If QFrustumCulling is not present,
all drawable entities will be drawn. The camera is selected by a QCameraSelector
frame graph node in the current hierarchy. Frustum culling can save a lot of GPU
processing time when the rendered scene is complex.
\sa QCameraSelector
|
2108 |
- |
| qfrustumculling.h |
|
583 |
- |
| qlayerfilter.cpp |
!
\class Qt3DRender::QLayerFilter
\inmodule Qt3DRender
\since 5.5
\brief Controls layers drawn in a frame graph branch.
A Qt3DRender::QLayerFilter can be used to instruct the renderer as to
which layer(s) to draw in that branch of the frame graph. QLayerFilter
selects which entities to draw based on the QLayer instance(s) added to
the QLayerFilter and as components to Qt3DCore::QEntity.
QLayerFilter can be configured to select or discard entities with a
specific \l QLayer depending on the filterMode property. By default,
entities referencing one of the \l QLayer objects that are also being
referenced by the \l QLayerFilter are selected (AcceptAnyMatchingLayers).
Within the FrameGraph tree, multiple \l QLayerFilter nodes can be nested
within a branch going from root to a leaf. In that case the filtering will
first operate on all entities of the scene using the filtering method
specified by the first declared \l QLayerFilter. Then the filtered subset
of entities will be filtered again based on the filtering method set on the
second \l QLayerFilter declared. This is then repeated until all \l
QLayerFilter nodes of the branch have been consumed.
|
6717 |
- |
| qlayerfilter.h |
|
1359 |
- |
| qlayerfilter_p.h |
|
913 |
- |
| qmemorybarrier.cpp |
!
\class Qt3DRender::QMemoryBarrier
\inmodule Qt3DRender
\since 5.9
\ingroup framegraph
\brief Class to emplace a memory barrier.
A Qt3DRender::QMemoryBarrier FrameGraph node is used to emplace a specific
memory barrier at a specific time of the rendering. This is required to
properly synchronize drawing and compute commands on the GPU.
The barrier defines the ordering of memory operations issued by a prior
command. This means that if command1 is manipulating a buffer that is to be
used as a vertex attribute buffer in a following command2, then the memory
barrier should be placed after command1 and setting the appropriate barrier
type for vertex attribute buffer.
When a QMemoryBarrier node is found in a FrameGraph branch, the barrier
will be enforced prior to any draw or compute command even if these are
defined deeper in the branch.
For OpenGL rendering, this page gives more info about the
\l {https://www.opengl.org/wiki/Memory_Model}{Memory Model}
|
3856 |
- |
| qmemorybarrier.h |
|
1579 |
- |
| qmemorybarrier_p.h |
|
886 |
- |
| qnodraw.cpp |
!
\class Qt3DRender::QNoDraw
\inmodule Qt3DRender
\brief When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this
prevents the renderer from rendering any primitive.
Qt3DRender::QNoDraw should be used when the FrameGraph needs to set up some render
states or clear some buffers without requiring any mesh to be drawn. It has
the same effect as having a Qt3DRender::QRenderPassFilter that matches none of
available Qt3DRender::QRenderPass instances of the scene without the overhead cost
of actually performing the filtering.
When disabled, a Qt3DRender::QNoDraw node won't prevent the scene from
being rendered. Toggling the enabled property is therefore a way to make a
Qt3DRender::QNoDraw active or inactive.
Qt3DRender::QNoDraw is usually used as a child of a
Qt3DRendeR::QClearBuffers node to prevent from drawing the scene when there
are multiple render passes.
\code
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);
....
\endcode
\since 5.5
|
3409 |
- |
| qnodraw.h |
|
545 |
- |
| qnopicking.cpp |
!
\class Qt3DRender::QNoPicking
\inmodule Qt3DRender
\since 5.14
\brief When a Qt3DRender::QNoPicking node is present in a FrameGraph
branch, this prevents the render aspect from performing picking selection
for the given branch.
When disabled, a Qt3DRender::QNoPicking node won't prevent picking from
being performed. Toggling the enabled property is therefore a way to make a
Qt3DRender::QNoPicking active or inactive.
When using multiple subviewports in the FrameGraph, QNoPicking can be
useful to prevent picking conflicts between overlapping viewports or non
visual ones. It can also be used as an optimization to prevent unnecessary
work for hidden viewports or for sections of the scenes which don't require
any picking.
\code
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);
....
\endcode
\sa Qt3DRender::QObjectPicker, Qt3DRender::QRayCaster, Qt3DRender::QScreenRayCaster
|
3263 |
- |
| qnopicking.h |
|
553 |
- |
| qproximityfilter.cpp |
!
\class Qt3DRender::QProximityFilter
\inmodule Qt3DRender
\since 5.10
\brief Select entities which are within a distance threshold of a target
entity.
A \l Qt3DRender::QProximityFilter can be used to select entities to render
when they are placed within a given distance threshold of another entity.
|
3539 |
- |
| qproximityfilter.h |
|
1352 |
- |
| qproximityfilter_p.h |
|
929 |
- |
| qrendercapture.cpp |
!
\class Qt3DRender::QRenderCapture
\inheaderfile Qt3DRender/QRenderCapture
\inmodule Qt3DRender
\brief Frame graph node for render capture.
The QRenderCapture is used to capture rendering into an image at any render stage.
Capturing must be initiated by the user and one image is returned per capture request.
User can issue multiple render capture requests simultaniously, but only one request
is served per QRenderCapture instance per frame.
\since 5.8
|
8717 |
- |
| qrendercapture.h |
|
1500 |
- |
| qrendercapture_p.h |
|
1819 |
- |
| qrenderpassfilter.cpp |
!
\class Qt3DRender::QRenderPassFilter
\inmodule Qt3DRender
\since 5.7
\brief Provides storage for vectors of Filter Keys and Parameters.
A Qt3DRender::QRenderPassFilter FrameGraph node is used to select which
Qt3DRender::QRenderPass objects are selected for drawing. QRenderPassFilter
specifies a list of Qt3DRender::QFilterKey objects and Qt3DRender::QParameter objects.
When QRenderPassFilter is present in the FrameGraph, only the QRenderPass objects,
whose Qt3DRender::QFilterKey objects match the keys in QRenderPassFilter are
selected for rendering. If no QRenderPassFilter is present, then all QRenderPass
objects are selected for rendering. The parameters in the list can be used
to set values for shader parameters. The parameters in QRenderPassFilter
override parameters in QTechniqueFilter, QMaterial, QEffect, QTechnique and QRenderPass.
|
5589 |
- |
| qrenderpassfilter.h |
|
1174 |
- |
| qrenderpassfilter_p.h |
|
990 |
- |
| qrenderstateset.cpp |
!
\class Qt3DRender::QRenderStateSet
\inmodule Qt3DRender
\since 5.5
\brief The QRenderStateSet \l {QFrameGraphNode}{FrameGraph} node offers a way of
specifying a set of QRenderState objects to be applied during the execution
of a framegraph branch.
States set on a QRenderStateSet are set globally, contrary to the per-material
states that can be set on a QRenderPass. By default, an empty
QRenderStateSet will result in all render states being disabled when
executed. Adding a QRenderState state explicitly enables that render
state at runtime.
The RenderStateSet is enabled when added to the active frame graph:
\code
// 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);
\endcode
\sa QRenderState, QRenderPass
|
5359 |
- |
| qrenderstateset.h |
|
943 |
- |
| qrenderstateset_p.h |
|
893 |
- |
| qrendersurfaceselector.cpp |
!
\class Qt3DRender::QRenderSurfaceSelector
\inmodule Qt3DRender
\brief Provides a way of specifying the render surface.
\since 5.7
The Qt3DRender::QRenderSurfaceSelector can be used to select the surface, where
Qt3D renders the content. The surface can either be window surface or offscreen
surface. The externalRenderTargetSize is used to specify the actual size of the
surface when offscreen surface is used.
When DPI scaling is used by the system, the logical surface size, which is used
by mouse events, and the actual 'physical' size of the surface can differ.
The surfacePixelRatio is the factor to convert the logical size to the physical
size.
\sa QWindow, QOffscreenSurface, QSurface
|
8745 |
- |
| qrendersurfaceselector.h |
|
1745 |
- |
| qrendersurfaceselector_p.h |
|
1628 |
- |
| qrendertargetselector.cpp |
!
\class Qt3DRender::QRenderTargetSelector
\inmodule Qt3DRender
\since 5.7
\brief Provides a way of specifying a render target.
A Qt3DRender::QRenderTargetSelector is used to select active Qt3DRender::QRenderTarget
for the FrameGraph. When QRenderTargetSelector is present in the FrameGraph,
the rendering is directed into QTexture objects or draw buffers instead of the surface
specified in the Qt3DRender::QRenderSurfaceSelector.
|
2870 |
- |
| qrendertargetselector.h |
|
1339 |
- |
| qrendertargetselector_p.h |
|
981 |
- |
| qsetfence.cpp |
!
\class Qt3DRender::QSetFence
\inmodule Qt3DRender
\brief FrameGraphNode used to insert a fence in the graphics command stream.
Fence allow to synchronosize GPU and CPU workloads. GPU commands usually
are non-blocking. When issued, commands are inserted in command buffers
which will be read at a later time by the GPU. In some cases, you want to
continue processing or issue specific command only when you are sure a
command has been executed by the hardware. Fences are a way to do so. This
is especially important when using 3rd party engines with Qt3D, Qt3D should
only access shared resources when we know the other engine command are done
modifying the resource.
QSetFence is a FrameGraph node that inserts a fence into the command
stream. It can then be used in conjunction with \l QWaitFence or by
extracting the underlying handle.
The handle property will be updated once the renderer has created the
underlying fence resource. The handle will remain valid as long as it
remains in the unsignaled state. Once it has reached the signaled state, it
will be destroyed and a new handle will be created. That means that
depending on how long it takes for the fence to be signaled, the same
handle could be used over several frames.
\since 5.13
|
3344 |
- |
| qsetfence.h |
|
1156 |
- |
| qsetfence_p.h |
|
1042 |
- |
| qsortpolicy.cpp |
!
\class Qt3DRender::QSortPolicy
\inmodule Qt3DRender
\brief Provides storage for the sort types to be used.
\since 5.7
\inherits Qt3DRender::QFrameGraphNode
A Qt3DRender::QSortPolicy class stores the sorting type used by the FrameGraph.
The sort types determine how drawable entities are sorted before drawing to
determine the drawing order. When QSortPolicy is present in the FrameGraph,
the sorting mechanism is determined by the sortTypes list. Multiple sort types
can be used simultaneously. If QSortPolicy is not present in the FrameGraph,
entities are drawn in the order they appear in the entity hierarchy.
|
4740 |
- |
| qsortpolicy.h |
|
1422 |
- |
| qsortpolicy_p.h |
|
1341 |
- |
| qsubtreeenabler.cpp |
!
\class Qt3DRender::QSubtreeEnabler
\inmodule Qt3DRender
\brief Enables or disables entire subtrees of framegraph nodes.
\since 5.14
While QFrameGraphNodes can be individually enabled and disabled via the
\c enabled property, this can become tedious when an entire path
needs to be turned on or off. QSubtreeEnabler is a convenience node
that makes this use case trivial, allowing all of its children to be
controlled by a single switch.
QSubtreeEnabler is enabled by default.
|
3900 |
- |
| qsubtreeenabler.h |
|
1047 |
- |
| qsubtreeenabler_p.h |
|
904 |
- |
| qtechniquefilter.cpp |
!
\class Qt3DRender::QTechniqueFilter
\inmodule Qt3DRender
\since 5.7
\brief A QFrameGraphNode used to select QTechniques to use.
A Qt3DRender::QTechniqueFilter specifies which techniques are used
by the FrameGraph when rendering the entities. QTechniqueFilter specifies
a list of Qt3DRender::QFilterKey objects and Qt3DRender::QParameter objects.
When QTechniqueFilter is present in the FrameGraph, only the techiques matching
the keys in the list are used for rendering. The parameters in the list can be used
to set values for shader parameters. The parameters in QTechniqueFilter
override parameters in QMaterial, QEffect, QTechnique and QRenderPass, but are overridden
by parameters in QRenderPassFilter.
|
5465 |
- |
| qtechniquefilter.h |
|
1111 |
- |
| qtechniquefilter_p.h |
|
997 |
- |
| qviewport.cpp |
!
\class Qt3DRender::QViewport
\inmodule Qt3DRender
\brief A viewport on the Qt3D Scene.
\since 5.7
\inherits Qt3DRender::QFrameGraphNode
Qt3DRender::QViewport of the scene specifies at which portion of the render surface Qt3D
is rendering to. Area outside the viewport is left untouched. It also controls global parameters
to the rendering in that viewport like gamma.
|
3122 |
- |
| qviewport.h |
|
1246 |
- |
| qviewport_p.h |
|
862 |
- |
| qwaitfence.cpp |
!
\class Qt3DRender::QWaitFence
\inmodule Qt3DRender
\brief FrameGraphNode used to wait for a fence in the graphics command
stream to become signaled.
Fence allow to synchronosize GPU and CPU workloads. GPU commands usually
are non-blocking. When issued, commands are inserted in command buffers
which will be read at a later time by the GPU. In some cases, you want to
continue processing or issue specific command only when you are sure a
command has been executed by the hardware. Fences are a way to do so. This
is especially important when using 3rd party engines with Qt3D, Qt3D should
only access shared resources when we know the other engine command are done
modifying the resource.
QWaitFence is a FrameGraph node that will force to wait for it to become
signaled before subsequent commands are inserted into the command stream.
It can then be used in conjunction with \l QSetFence and contains
properties to configure how long it should wait and whether it should block
on the CPU side.
\note Qt 3D uploads GPU resources (Texture, Shaders, Buffers) before
issuing draw calls.
\since 5.13
|
4368 |
- |
| qwaitfence.h |
|
1682 |
- |
| qwaitfence_p.h |
|
889 |
- |
| rendercapture.cpp |
|
2926 |
- |
| rendercapture_p.h |
|
1318 |
- |
| renderpassfilternode.cpp |
|
1889 |
- |
| renderpassfilternode_p.h |
|
1378 |
- |
| rendersurfaceselector.cpp |
|
2630 |
- |
| rendersurfaceselector_p.h |
|
1510 |
- |
| rendertargetselectornode.cpp |
|
1231 |
- |
| rendertargetselectornode_p.h |
|
1116 |
- |
| setfence.cpp |
|
443 |
- |
| setfence_p.h |
|
867 |
- |
| sortcriterion.cpp |
|
1271 |
- |
| sortpolicy.cpp |
|
978 |
- |
| sortpolicy_p.h |
|
1081 |
- |
| statesetnode.cpp |
|
1542 |
- |
| statesetnode_p.h |
|
1251 |
- |
| subtreeenabler.cpp |
|
900 |
- |
| subtreeenabler_p.h |
|
1060 |
- |
| techniquefilternode.cpp |
|
1908 |
- |
| techniquefilternode_p.h |
|
1415 |
- |
| viewportnode.cpp |
|
2512 |
- |
| viewportnode_p.h |
|
1449 |
- |
| waitfence.cpp |
|
1711 |
- |
| waitfence_p.h |
|
1213 |
- |