/****************************************************************************
**
** Copyright (C) 2008-2012 NVIDIA Corporation.
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Quick 3D.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QtQuick3DRender/private/qssgrendercontext_p.h>
#include <QtQuick3DRender/private/qssgrendertexturebase_p.h>

#include <limits>

QT_BEGIN_NAMESPACE

class QSSGRenderTextureSampler
{
public:
    QSSGRenderTextureMinifyingOp minFilter = QSSGRenderTextureMinifyingOp::Linear;
    QSSGRenderTextureMagnifyingOp magFilter = QSSGRenderTextureMagnifyingOp::Linear;
    QSSGRenderTextureCoordOp wrapS = QSSGRenderTextureCoordOp::ClampToEdge;
    QSSGRenderTextureCoordOp wrapT = QSSGRenderTextureCoordOp::ClampToEdge;
    QSSGRenderTextureCoordOp wrapR = QSSGRenderTextureCoordOp::ClampToEdge;
    QSSGRenderTextureSwizzleMode swizzleMode = QSSGRenderTextureSwizzleMode::NoSwizzle;
    float minLod = -1000.;
    float maxLod = 1000.;
    float lodBias = 0.;
    QSSGRenderTextureCompareMode compareMode = QSSGRenderTextureCompareMode::NoCompare;
    QSSGRenderTextureCompareOp compareOp = QSSGRenderTextureCompareOp::LessThanOrEqual;
    float m_anisotropy = 1.;

    /**
     * @brief constructor
     *
     * @param[in] context		Pointer to context
     * @param[in] fnd			Pointer to foundation
     * @param[in] minFilter		Texture min filter
     * @param[in] magFilter		Texture mag filter
     * @param[in] wrapS			Texture coord generation for S
     * @param[in] wrapT			Texture coord generation for T
     * @param[in] wrapR			Texture coord generation for R
     * @param[in] swizzleMode	Texture swizzle mode
     * @param[in] minLod		Texture min level of detail
     * @param[in] maxLod		Texture max level of detail
     * @param[in] lodBias		Texture level of detail bias (unused)
     * @param[in] compareMode	Texture compare mode
     * @param[in] compareFunc	Texture compare function
     * @param[in] anisoFilter	Aniso filter value [1.0, 16.0]
     * @param[in] borderColor	Texture border color float[4] (unused)
     *
     * @return No return.
     */
    explicit QSSGRenderTextureSampler(const QSSGRef<QSSGRenderContext> &context)
        : m_backend(context->backend())
        , m_handle(nullptr)
    {
        // create backend handle
        m_handle = m_backend->createSampler();
    }

    ~QSSGRenderTextureSampler()
    {
        if (m_handle)
            m_backend->releaseSampler(m_handle);
    }

    /**
     * @brief get the backend object handle
     *
     * @return the backend object handle.
     */
    QSSGRenderBackend::QSSGRenderBackendSamplerObject handle() const { return m_handle; }

private:
    QSSGRef<QSSGRenderBackend> m_backend; ///< pointer to backend
    QSSGRenderBackend::QSSGRenderBackendSamplerObject m_handle = nullptr;
};


QSSGRenderTextureBase::QSSGRenderTextureBase(const QSSGRef<QSSGRenderContext> &context,
                                                 QSSGRenderTextureTargetType texTarget,
                                                 bool ownsTexture)
    : m_context(context)
    , m_backend(context->backend())
    , m_handle(nullptr)
    , m_textureUnit(std::numeric_limits<qint32>::max())
    , m_samplerParamsDirty(true)
    , m_texStateDirty(false)
    , m_sampleCount(1)
    , m_format(QSSGRenderTextureFormat::Unknown)
    , m_texTarget(texTarget)
    , m_baseLevel(0)
    , m_maxLevel(1000)
    , m_maxMipLevel(0)
    , m_immutable(false)
    , m_ownsTexture(ownsTexture)
{
    if (m_ownsTexture)
        m_handle = m_backend->createTexture();
    m_sampler = new QSSGRenderTextureSampler(context);
}

QSSGRenderTextureBase::~QSSGRenderTextureBase()
{
    if (m_sampler)
        delete m_sampler;
    if (m_handle && m_ownsTexture)
        m_backend->releaseTexture(m_handle);
}

void QSSGRenderTextureBase::setBaseLevel(qint32 value)
{
    if (m_baseLevel != value) {
        m_baseLevel = value;
        m_texStateDirty = true;
    }
}

void QSSGRenderTextureBase::setMaxLevel(qint32 value)
{
    if (m_maxLevel != value) {
        m_maxLevel = value;
        m_texStateDirty = true;
    }
}

void QSSGRenderTextureBase::setMinFilter(QSSGRenderTextureMinifyingOp value)
{
    if (m_sampler->minFilter != value) {
        m_sampler->minFilter = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::setMagFilter(QSSGRenderTextureMagnifyingOp value)
{
    if (m_sampler->magFilter != value) {
        m_sampler->magFilter = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::setTextureWrapS(QSSGRenderTextureCoordOp value)
{
    if (m_sampler->wrapS != value) {
        m_sampler->wrapS = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::setTextureWrapT(QSSGRenderTextureCoordOp value)
{
    if (m_sampler->wrapT != value) {
        m_sampler->wrapT = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::setTextureCompareMode(QSSGRenderTextureCompareMode value)
{
    if (m_sampler->compareMode != value) {
        m_sampler->compareMode = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::setTextureCompareFunc(QSSGRenderTextureCompareOp value)
{
    if (m_sampler->compareOp != value) {
        m_sampler->compareOp = value;
        m_samplerParamsDirty = true;
    }
}

void QSSGRenderTextureBase::applyTexParams()
{
    if (m_samplerParamsDirty && m_texTarget != QSSGRenderTextureTargetType::Texture2D_MS) {
        m_backend->updateSampler(m_sampler->handle(),
                                 m_texTarget,
                                 m_sampler->minFilter,
                                 m_sampler->magFilter,
                                 m_sampler->wrapS,
                                 m_sampler->wrapT,
                                 m_sampler->wrapR,
                                 m_sampler->minLod,
                                 m_sampler->maxLod,
                                 m_sampler->lodBias,
                                 m_sampler->compareMode,
                                 m_sampler->compareOp);

        m_samplerParamsDirty = false;
    }

    if (m_texStateDirty) {
        m_backend->updateTextureObject(m_handle, m_texTarget, m_baseLevel, m_maxLevel);
        m_texStateDirty = false;
    }
}

void QSSGRenderTextureBase::applyTexSwizzle()
{
    QSSGRenderTextureSwizzleMode theSwizzleMode = m_backend->getTextureSwizzleMode(m_format);
    if (theSwizzleMode != m_sampler->swizzleMode) {
        m_sampler->swizzleMode = theSwizzleMode;
        m_backend->updateTextureSwizzle(m_handle, m_texTarget, theSwizzleMode);
    }
}
QT_END_NAMESPACE
