Revision control
Copy as Markdown
// Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qgeometryrenderer.h"
#include "qgeometryrenderer_p.h"
#include <private/qcomponent_p.h>
QT_BEGIN_NAMESPACE
namespace Qt3DRender {
using namespace Qt3DCore;
QGeometryRendererPrivate::QGeometryRendererPrivate()
: Qt3DCore::QBoundingVolumePrivate()
, m_instanceCount(1)
, m_vertexCount(0)
, m_indexOffset(0)
, m_firstInstance(0)
, m_firstVertex(0)
, m_indexBufferByteOffset(0)
, m_restartIndexValue(-1)
, m_verticesPerPatch(0)
, m_primitiveRestart(false)
, m_geometry(nullptr)
, m_primitiveType(QGeometryRenderer::Triangles)
, m_sortIndex(-1.f)
{
m_primaryProvider = false;
}
QGeometryRendererPrivate::~QGeometryRendererPrivate()
{
}
void QGeometryRendererPrivate::setView(QGeometryView *view)
{
Q_Q(QGeometryRenderer);
if (m_view == view)
return;
if (m_view)
m_view->disconnect(q);
QBoundingVolumePrivate::setView(view);
// Ensures proper bookkeeping
if (m_view) {
QObject::connect(view, &QGeometryView::instanceCountChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::vertexCountChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::indexOffsetChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::firstInstanceChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::firstVertexChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::indexBufferByteOffsetChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::restartIndexValueChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::verticesPerPatchChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::primitiveRestartEnabledChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::geometryChanged, q, [this]() { update(); });
QObject::connect(view, &QGeometryView::primitiveTypeChanged, q, [this]() { update(); });
}
}
/*!
\qmltype GeometryRenderer
\nativetype Qt3DRender::QGeometryRenderer
\inqmlmodule Qt3D.Render
\inherits BoundingVolume
\since 5.7
\brief Encapsulates geometry rendering.
A GeometryRenderer holds all the information necessary to draw
a Geometry. A Geometry holds the coordinates of the geometry data -
GeometryRenderer specifies how to interpret that data.
*/
/*!
\class Qt3DRender::QGeometryRenderer
\inmodule Qt3DRender
\since 5.7
\brief Encapsulates geometry rendering.
A Qt3DRender::QGeometryRenderer holds all the information necessary to draw
a Qt3DCore::QGeometry. A QGeometry holds the coordinates of the geometry data -
QGeometryRenderer specifies how to interpret that data.
*/
/*!
\enum Qt3DRender::QGeometryRenderer::PrimitiveType
The type of the primitive.
\value Points List of points
\value Lines List of lines
\value LineLoop Connected group of lines connected at ends forming a loop
\value LineStrip Connected group of lines
\value Triangles List of triangles
\value TriangleStrip List of connected triangles
\value TriangleFan List of connected triagles where all triangles share the first vertex
\value LinesAdjacency Allows geometry shader to access adjacent lines in a line list
\value TrianglesAdjacency Allows geometry shader to access adjacent triangles in a triangle list
\value LineStripAdjacency Allows geometry shader to access adjacent lines in a line strip
\value TriangleStripAdjacency Allows geometry shader to access adjacent triangles in a triangle strip
\value Patches Only primitive type accepted by tesselation shader where a patch consists of arbitrary number of vertices
*/
/*!
\qmlproperty int GeometryRenderer::instanceCount
Holds the instance count.
*/
/*!
\qmlproperty int GeometryRenderer::vertexCount
Holds the vertex count.
*/
/*!
\qmlproperty int GeometryRenderer::indexOffset
Holds the base vertex.
*/
/*!
\qmlproperty int GeometryRenderer::firstInstance
Holds the base instance.
*/
/*!
\qmlproperty int GeometryRenderer::firstVertex
Holds the first vertex.
*/
/*!
\qmlproperty int GeometryRenderer::indexBufferByteOffset
Holds the byte offset into the index buffer.
*/
/*!
\qmlproperty int GeometryRenderer::restartIndexValue
Holds the restart index.
*/
/*!
\qmlproperty int GeometryRenderer::verticesPerPatch
Holds vertices per patch.
*/
/*!
\qmlproperty bool GeometryRenderer::primitiveRestartEnabled
Holds the primitive restart flag.
*/
/*!
\qmlproperty Geometry GeometryRenderer::geometry
Holds the geometry.
*/
/*!
\qmlproperty enumeration GeometryRenderer::primitiveType
Holds the primitive type.
\list
\li QGeometryRenderer.Points
\li QGeometryRenderer.Lines
\li QGeometryRenderer.LineLoop
\li QGeometryRenderer.LineStrip
\li QGeometryRenderer.Triangles
\li QGeometryRenderer.TriangleStrip
\li QGeometryRenderer.TriangleFan
\li QGeometryRenderer.LinesAdjacency
\li QGeometryRenderer.TrianglesAdjacency
\li QGeometryRenderer.LineStripAdjacency
\li QGeometryRenderer.TriangleStripAdjacency
\li QGeometryRenderer.Patches
\endlist
\sa Qt3DRender::QGeometryRenderer::PrimitiveType
*/
/*!
\qmlproperty real GeometryRenderer::sortIndex
\since 6.0
Overrides the sorting index when depth sorting is enabled.
If depth sorting is enabled on the frame graph, the renderer will sort
objects based on how far the center of the bounding volume is from
the camera and render objects from the furthest to the closest.
This property can be used to override the depth index and precisely
control the order in which objects are rendered. This is useful when
all objects are at the same physical distance from the camera.
The actual values are not significant, only that they define an order
to sort the objects. These are sorted such as the object with the
smallest value is drawn first, then the second smallest, and so on.
\note Setting this to -1.f will disable the explicit sorting for this
entity and revert to using the distance from the center of the bounding
volume.
\sa SortPolicy
*/
/*!
Constructs a new QGeometryRenderer with \a parent.
*/
QGeometryRenderer::QGeometryRenderer(QNode *parent)
: Qt3DCore::QBoundingVolume(*new QGeometryRendererPrivate(), parent)
{
Q_UNUSED(m_sortIndex)
}
/*!
\internal
*/
QGeometryRenderer::~QGeometryRenderer()
{
}
/*!
\internal
*/
QGeometryRenderer::QGeometryRenderer(QGeometryRendererPrivate &dd, QNode *parent)
: Qt3DCore::QBoundingVolume(dd, parent)
{
}
/*!
\property Qt3DRender::QGeometryRenderer::instanceCount
Holds the instance count.
*/
int QGeometryRenderer::instanceCount() const
{
Q_D(const QGeometryRenderer);
return d->m_instanceCount;
}
/*!
\property Qt3DRender::QGeometryRenderer::vertexCount
Holds the primitive count.
*/
int QGeometryRenderer::vertexCount() const
{
Q_D(const QGeometryRenderer);
return d->m_vertexCount;
}
/*!
\property Qt3DRender::QGeometryRenderer::indexOffset
Holds the base vertex.
*/
int QGeometryRenderer::indexOffset() const
{
Q_D(const QGeometryRenderer);
return d->m_indexOffset;
}
/*!
\property Qt3DRender::QGeometryRenderer::firstInstance
Holds the base instance.
*/
int QGeometryRenderer::firstInstance() const
{
Q_D(const QGeometryRenderer);
return d->m_firstInstance;
}
/*!
\property Qt3DRender::QGeometryRenderer::firstVertex
Holds the base vertex.
*/
int QGeometryRenderer::firstVertex() const
{
Q_D(const QGeometryRenderer);
return d->m_firstVertex;
}
/*!
\property Qt3DRender::QGeometryRenderer::indexBufferByteOffset
Holds the byte offset into the index buffer.
*/
int QGeometryRenderer::indexBufferByteOffset() const
{
Q_D(const QGeometryRenderer);
return d->m_indexBufferByteOffset;
}
/*!
\property Qt3DRender::QGeometryRenderer::restartIndexValue
Holds the restart index.
*/
int QGeometryRenderer::restartIndexValue() const
{
Q_D(const QGeometryRenderer);
return d->m_restartIndexValue;
}
/*!
\property Qt3DRender::QGeometryRenderer::verticesPerPatch
Holds vertices per patch.
*/
int QGeometryRenderer::verticesPerPatch() const
{
Q_D(const QGeometryRenderer);
return d->m_verticesPerPatch;
}
/*!
\property Qt3DRender::QGeometryRenderer::primitiveRestartEnabled
Holds the primitive restart flag.
*/
bool QGeometryRenderer::primitiveRestartEnabled() const
{
Q_D(const QGeometryRenderer);
return d->m_primitiveRestart;
}
/*!
\property Qt3DRender::QGeometryRenderer::geometry
Holds the geometry.
*/
QGeometry *QGeometryRenderer::geometry() const
{
Q_D(const QGeometryRenderer);
return d->m_geometry;
}
/*!
\property Qt3DRender::QGeometryRenderer::primitiveType
Holds the primitive type.
*/
QGeometryRenderer::PrimitiveType QGeometryRenderer::primitiveType() const
{
Q_D(const QGeometryRenderer);
return d->m_primitiveType;
}
/*!
\property Qt3DRender::QGeometryRenderer::sortIndex
\since 6.0
Overrides the sorting index when depth sorting is enabled.
If depth sorting is enabled on the frame graph, the renderer will sort
objects based on how far the center of the bounding volume is from
the camera and render objects from the furthest to the closest.
This property can be used to override the depth index and precisely
control the order in which objects are rendered. This is useful when
all objects are at the same physical distance from the camera.
The actual values are not significant, only that they define an order
to sort the objects. These are sorted such as the object with the
smallest value is drawn first, then the second smallest, and so on.
\note Setting this to -1.f will disable the explicit sorting for this
entity and revert to using the distance from the center of the bounding
volume.
\sa Qt3DRender::QSortPolicy
*/
float QGeometryRenderer::sortIndex() const
{
Q_D(const QGeometryRenderer);
return d->m_sortIndex;
}
void QGeometryRenderer::setInstanceCount(int instanceCount)
{
Q_D(QGeometryRenderer);
if (d->m_instanceCount == instanceCount)
return;
d->m_instanceCount = instanceCount;
emit instanceCountChanged(instanceCount);
}
void QGeometryRenderer::setVertexCount(int vertexCount)
{
Q_D(QGeometryRenderer);
if (d->m_vertexCount == vertexCount)
return;
d->m_vertexCount = vertexCount;
emit vertexCountChanged(vertexCount);
}
void QGeometryRenderer::setIndexOffset(int indexOffset)
{
Q_D(QGeometryRenderer);
if (d->m_indexOffset == indexOffset)
return;
d->m_indexOffset = indexOffset;
emit indexOffsetChanged(indexOffset);
}
void QGeometryRenderer::setFirstInstance(int firstInstance)
{
Q_D(QGeometryRenderer);
if (d->m_firstInstance == firstInstance)
return;
d->m_firstInstance = firstInstance;
emit firstInstanceChanged(firstInstance);
}
void QGeometryRenderer::setFirstVertex(int firstVertex)
{
Q_D(QGeometryRenderer);
if (d->m_firstVertex == firstVertex)
return;
d->m_firstVertex = firstVertex;
emit firstVertexChanged(firstVertex);
}
void QGeometryRenderer::setIndexBufferByteOffset(int offset)
{
Q_D(QGeometryRenderer);
if (d->m_indexBufferByteOffset == offset)
return;
d->m_indexBufferByteOffset = offset;
emit indexBufferByteOffsetChanged(offset);
}
void QGeometryRenderer::setRestartIndexValue(int index)
{
Q_D(QGeometryRenderer);
if (index == d->m_restartIndexValue)
return;
d->m_restartIndexValue = index;
emit restartIndexValueChanged(index);
}
void QGeometryRenderer::setVerticesPerPatch(int verticesPerPatch)
{
Q_D(QGeometryRenderer);
if (d->m_verticesPerPatch != verticesPerPatch) {
d->m_verticesPerPatch = verticesPerPatch;
emit verticesPerPatchChanged(verticesPerPatch);
}
}
void QGeometryRenderer::setPrimitiveRestartEnabled(bool enabled)
{
Q_D(QGeometryRenderer);
if (enabled == d->m_primitiveRestart)
return;
d->m_primitiveRestart = enabled;
emit primitiveRestartEnabledChanged(enabled);
}
void QGeometryRenderer::setGeometry(QGeometry *geometry)
{
Q_D(QGeometryRenderer);
if (d->m_geometry == geometry)
return;
if (d->m_geometry)
d->unregisterDestructionHelper(d->m_geometry);
if (geometry && !geometry->parent())
geometry->setParent(this);
d->m_geometry = geometry;
// Ensures proper bookkeeping
if (d->m_geometry)
d->registerDestructionHelper(d->m_geometry, &QGeometryRenderer::setGeometry, d->m_geometry);
emit geometryChanged(geometry);
}
void QGeometryRenderer::setPrimitiveType(QGeometryRenderer::PrimitiveType primitiveType)
{
Q_D(QGeometryRenderer);
if (d->m_primitiveType == primitiveType)
return;
d->m_primitiveType = primitiveType;
emit primitiveTypeChanged(primitiveType);
}
void QGeometryRenderer::setSortIndex(float sortIndex)
{
Q_D(QGeometryRenderer);
if (qFuzzyCompare(d->m_sortIndex, sortIndex))
return;
d->m_sortIndex = sortIndex;
emit sortIndexChanged(d->m_sortIndex);
}
} // namespace Qt3DRender
QT_END_NAMESPACE
#include "moc_qgeometryrenderer.cpp"