// 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"
