Source code
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 "qforwardrenderer.h"
#include "qforwardrenderer_p.h"
#include <Qt3DCore/qentity.h>
#include <Qt3DRender/qviewport.h>
#include <Qt3DRender/qcameraselector.h>
#include <Qt3DRender/qclearbuffers.h>
#include <Qt3DRender/qfilterkey.h>
#include <Qt3DRender/qfrustumculling.h>
#include <Qt3DRender/qrendersurfaceselector.h>
#include <Qt3DRender/qdebugoverlay.h>
static void initResources()
{
#ifdef QT_STATIC
Q_INIT_RESOURCE(extras);
#endif
}
QT_BEGIN_NAMESPACE
namespace Qt3DExtras {
using namespace Qt3DRender;
QForwardRendererPrivate::QForwardRendererPrivate()
: QTechniqueFilterPrivate()
, m_surfaceSelector(new QRenderSurfaceSelector)
, m_viewport(new QViewport())
, m_cameraSelector(new QCameraSelector())
, m_clearBuffer(new QClearBuffers())
, m_frustumCulling(new QFrustumCulling())
, m_debugOverlay(new QDebugOverlay())
{
}
void QForwardRendererPrivate::init()
{
Q_Q(QForwardRenderer);
initResources();
m_debugOverlay->setParent(m_frustumCulling);
m_debugOverlay->setEnabled(false);
m_frustumCulling->setParent(m_clearBuffer);
m_clearBuffer->setParent(m_cameraSelector);
m_cameraSelector->setParent(m_viewport);
m_viewport->setParent(m_surfaceSelector);
m_surfaceSelector->setParent(q);
m_viewport->setNormalizedRect(QRectF(0.0, 0.0, 1.0, 1.0));
m_clearBuffer->setClearColor(Qt::white);
m_clearBuffer->setBuffers(QClearBuffers::ColorDepthBuffer);
QFilterKey *forwardRenderingStyle = new QFilterKey(q);
forwardRenderingStyle->setName(QStringLiteral("renderingStyle"));
forwardRenderingStyle->setValue(QStringLiteral("forward"));
q->addMatch(forwardRenderingStyle);
}
/*!
\class Qt3DExtras::QForwardRenderer
\brief The QForwardRenderer provides a default \l{Qt 3D Render Framegraph}{FrameGraph}
implementation of a forward renderer.
\inmodule Qt3DExtras
\since 5.7
\inherits Qt3DRender::QTechniqueFilter
Forward rendering is what OpenGL traditionally uses. It renders directly to the backbuffer
one object at a time shading each one as it goes.
QForwardRenderer is a single leaf \l{Qt 3D Render Framegraph}{FrameGraph} tree which contains
a Qt3DRender::QViewport, a Qt3DRender::QCameraSelector, and a Qt3DRender::QClearBuffers.
The QForwardRenderer has a default requirement filter key whose name is "renderingStyle" and
value "forward".
If you need to filter out your techniques, you should do so based on that filter key.
By default the viewport occupies the whole screen and the clear color is white.
Frustum culling is also enabled.
*/
/*!
\qmltype ForwardRenderer
\brief The ForwardRenderer provides a default \l{Qt 3D Render Framegraph}{FrameGraph}
implementation of a forward renderer.
\since 5.7
\inqmlmodule Qt3D.Extras
\nativetype Qt3DExtras::QForwardRenderer
Forward rendering is what OpenGL traditionally uses. It renders directly to the backbuffer
one object at a time shading each one as it goes.
ForwardRenderer is a single leaf \l{Qt 3D Render Framegraph}{FrameGraph} tree which contains
a Viewport, a CameraSelector, and a ClearBuffers.
The ForwardRenderer has a default requirement filter key whose name is "renderingStyle" and
value "forward".
If you need to filter out your techniques, you should do so based on that filter key.
By default the viewport occupies the whole screen and the clear color is white.
Frustum culling is also enabled.
*/
QForwardRenderer::QForwardRenderer(QNode *parent)
: QTechniqueFilter(*new QForwardRendererPrivate, parent)
{
Q_D(QForwardRenderer);
QObject::connect(d->m_clearBuffer, &QClearBuffers::clearColorChanged, this, &QForwardRenderer::clearColorChanged);
QObject::connect(d->m_clearBuffer, &QClearBuffers::buffersChanged, this, &QForwardRenderer::buffersToClearChanged);
QObject::connect(d->m_viewport, &QViewport::normalizedRectChanged, this, &QForwardRenderer::viewportRectChanged);
QObject::connect(d->m_cameraSelector, &QCameraSelector::cameraChanged, this, &QForwardRenderer::cameraChanged);
QObject::connect(d->m_surfaceSelector, &QRenderSurfaceSelector::surfaceChanged, this, &QForwardRenderer::surfaceChanged);
QObject::connect(d->m_surfaceSelector, &QRenderSurfaceSelector::externalRenderTargetSizeChanged, this, &QForwardRenderer::externalRenderTargetSizeChanged);
QObject::connect(d->m_frustumCulling, &QFrustumCulling::enabledChanged, this, &QForwardRenderer::frustumCullingEnabledChanged);
QObject::connect(d->m_viewport, &QViewport::gammaChanged, this, &QForwardRenderer::gammaChanged);
QObject::connect(d->m_debugOverlay, &QDebugOverlay::enabledChanged, this, &QForwardRenderer::showDebugOverlayChanged);
d->init();
}
QForwardRenderer::~QForwardRenderer()
{
}
void QForwardRenderer::setViewportRect(const QRectF &viewportRect)
{
Q_D(QForwardRenderer);
d->m_viewport->setNormalizedRect(viewportRect);
}
void QForwardRenderer::setClearColor(const QColor &clearColor)
{
Q_D(QForwardRenderer);
d->m_clearBuffer->setClearColor(clearColor);
}
void QForwardRenderer::setBuffersToClear(QClearBuffers::BufferType buffers)
{
Q_D(QForwardRenderer);
d->m_clearBuffer->setBuffers(buffers);
}
void QForwardRenderer::setCamera(Qt3DCore::QEntity *camera)
{
Q_D(QForwardRenderer);
d->m_cameraSelector->setCamera(camera);
}
void QForwardRenderer::setSurface(QObject *surface)
{
Q_D(QForwardRenderer);
d->m_surfaceSelector->setSurface(surface);
}
void QForwardRenderer::setExternalRenderTargetSize(const QSize &size)
{
Q_D(QForwardRenderer);
d->m_surfaceSelector->setExternalRenderTargetSize(size);
}
void QForwardRenderer::setFrustumCullingEnabled(bool enabled)
{
Q_D(QForwardRenderer);
d->m_frustumCulling->setEnabled(enabled);
}
void QForwardRenderer::setGamma(float gamma)
{
Q_D(QForwardRenderer);
d->m_viewport->setGamma(gamma);
}
void QForwardRenderer::setShowDebugOverlay(bool showDebugOverlay)
{
Q_D(QForwardRenderer);
d->m_debugOverlay->setEnabled(showDebugOverlay);
}
/*!
\qmlproperty rect ForwardRenderer::viewportRect
Holds the current normalized viewport rectangle.
*/
/*!
\property Qt3DExtras::QForwardRenderer::viewportRect
Holds the current normalized viewport rectangle.
*/
QRectF QForwardRenderer::viewportRect() const
{
Q_D(const QForwardRenderer);
return d->m_viewport->normalizedRect();
}
/*!
\qmlproperty color ForwardRenderer::clearColor
Holds the current clear color of the scene. The frame buffer is initialized to the clear color
before rendering.
*/
/*!
\property Qt3DExtras::QForwardRenderer::clearColor
Holds the current clear color of the scene. The frame buffer is initialized to the clear color
before rendering.
*/
QColor QForwardRenderer::clearColor() const
{
Q_D(const QForwardRenderer);
return d->m_clearBuffer->clearColor();
}
/*!
\qmlproperty color ForwardRenderer::buffersToClear
Holds the current buffers to be cleared. Default value is ColorDepthBuffer
\since 5.14
*/
/*!
\property Qt3DExtras::QForwardRenderer::buffersToClear
Holds the current buffers to be cleared. Default value is ColorDepthBuffer
\since 5.14
*/
QClearBuffers::BufferType QForwardRenderer::buffersToClear() const
{
Q_D(const QForwardRenderer);
return d->m_clearBuffer->buffers();
}
/*!
\qmlproperty Entity ForwardRenderer::camera
Holds the current camera entity used to render the scene.
\note A camera is an Entity that has a CameraLens as one of its components.
*/
/*!
\property Qt3DExtras::QForwardRenderer::camera
Holds the current camera entity used to render the scene.
\note A camera is a QEntity that has a QCameraLens as one of its components.
*/
Qt3DCore::QEntity *QForwardRenderer::camera() const
{
Q_D(const QForwardRenderer);
return d->m_cameraSelector->camera();
}
/*!
\qmlproperty QtObject ForwardRenderer::window
Holds the current render surface.
\deprecated
*/
/*!
\property Qt3DExtras::QForwardRenderer::window
Holds the current render surface.
\deprecated
*/
/*!
\qmlproperty QtObject ForwardRenderer::surface
Holds the current render surface.
*/
/*!
\property Qt3DExtras::QForwardRenderer::surface
Holds the current render surface.
*/
QObject *QForwardRenderer::surface() const
{
Q_D(const QForwardRenderer);
return d->m_surfaceSelector->surface();
}
/*!
\qmlproperty size ForwardRenderer::externalRenderTargetSize
Contains the size of the external render target. External render
targets are relevant when rendering does not target a window
surface (as set in \l {surface}).
*/
/*!
\property Qt3DExtras::QForwardRenderer::externalRenderTargetSize
Contains the size of the external render target. External render
targets are relevant when rendering does not target a window
surface (as set in \l {surface}).
*/
QSize QForwardRenderer::externalRenderTargetSize() const
{
Q_D(const QForwardRenderer);
return d->m_surfaceSelector->externalRenderTargetSize();
}
/*!
\qmlproperty bool ForwardRenderer::frustumCulling
Indicates if the renderer applies frustum culling to the scene.
*/
/*!
\property Qt3DExtras::QForwardRenderer::frustumCulling
Indicates if the renderer applies frustum culling to the scene.
*/
bool QForwardRenderer::isFrustumCullingEnabled() const
{
Q_D(const QForwardRenderer);
return d->m_frustumCulling->isEnabled();
}
/*!
\qmlproperty real ForwardRenderer::gamma
Holds the gamma value the renderer applies to the scene.
*/
/*!
\property Qt3DExtras::QForwardRenderer::gamma
Holds the gamma value the renderer applies to the scene.
*/
float QForwardRenderer::gamma() const
{
Q_D(const QForwardRenderer);
return d->m_viewport->gamma();
}
/*!
\qmlproperty bool ForwardRenderer::showDebugOverlay
If true, a debug overlay will be rendered over the scene. It will show
detailed information about the runtime rendering state, let the user
turn logging on and off, etc.
\since 5.15
*/
/*!
\property Qt3DExtras::QForwardRenderer::showDebugOverlay
If true, a debug overlay will be rendered over the scene. It will show
detailed information about the runtime rendering state, let the user
turn logging on and off, etc.
\since 5.15
*/
bool QForwardRenderer::showDebugOverlay() const
{
Q_D(const QForwardRenderer);
return d->m_debugOverlay->isEnabled();
}
} // namespace Qt3DExtras
QT_END_NAMESPACE
#include "moc_qforwardrenderer.cpp"