/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtOpenGL module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qgl2pexvertexarray_p.h"

#include <private/qbezier_p.h>

QT_BEGIN_NAMESPACE

void QGL2PEXVertexArray::clear()

{

    vertexArray.reset();

    vertexArrayStops.clear();

    boundingRectDirty = true;

}

QGLRect QGL2PEXVertexArray::boundingRect() const

{

    if (boundingRectDirty)

        return QGLRect(0.0, 0.0, 0.0, 0.0);

    else

        return QGLRect(minX, minY, maxX, maxY);

}

void QGL2PEXVertexArray::addRect(const QRectF &rect)

{

    vertexArray << rect.topLeft() << rect.topRight() << rect.bottomRight()

                << rect.bottomRight() << rect.bottomLeft() << rect.topLeft();

}

void QGL2PEXVertexArray::addClosingLine(int index)

{

    if (QPointF(vertexArray.at(index)) != QPointF(vertexArray.last()))

        vertexArray.add(vertexArray.at(index));

}

void QGL2PEXVertexArray::addCentroid(const QVectorPath &path, int subPathIndex)

{

    const QPointF *const points = reinterpret_cast<const QPointF *>(path.points());

    const QPainterPath::ElementType *const elements = path.elements();

    QPointF sum = points[subPathIndex];

    int count = 1;

    for (int i = subPathIndex + 1; i < path.elementCount() && (!elements || elements[i] != QPainterPath::MoveToElement); ++i) {

        sum += points[i];

        ++count;

    }

    const QPointF centroid = sum / qreal(count);

    vertexArray.add(centroid);

}

void QGL2PEXVertexArray::addPath(const QVectorPath &path, GLfloat curveInverseScale, bool outline)

{

    const QPointF* const points = reinterpret_cast<const QPointF*>(path.points());

    const QPainterPath::ElementType* const elements = path.elements();

    if (boundingRectDirty) {

        minX = maxX = points[0].x();

        minY = maxY = points[0].y();

        boundingRectDirty = false;

    }

    if (!outline)

        addCentroid(path, 0);

    int lastMoveTo = vertexArray.size();

    vertexArray.add(points[0]); // The first element is always a moveTo

    do {

        if (!elements) {

//             qDebug("QVectorPath has no elements");

            // If the path has a null elements pointer, the elements implicitly

            // start with a moveTo (already added) and continue with lineTos:

            for (int i=1; i<path.elementCount(); ++i)

                lineToArray(points[i].x(), points[i].y());

            break;

        }

//         qDebug("QVectorPath has element types");

        for (int i=1; i<path.elementCount(); ++i) {

            const QPainterPath::ElementType elementType = elements[i];

            switch (elementType) {

            case QPainterPath::MoveToElement:

                if (!outline)

                    addClosingLine(lastMoveTo);

//                qDebug("element[%d] is a MoveToElement", i);

                vertexArrayStops.append(vertexArray.size());

                if (!outline) {

                    addCentroid(path, i);

                    lastMoveTo = vertexArray.size();

                }

                lineToArray(points[i].x(), points[i].y()); // Add the moveTo as a new vertex

                break;

            case QPainterPath::LineToElement:

//                qDebug("element[%d] is a LineToElement", i);

                lineToArray(points[i].x(), points[i].y());

                break;

            case QPainterPath::CurveToElement:

//                qDebug("element[%d] is a CurveToElement", i);

                curveToArray(points[i], points[i+1], points[i+2], curveInverseScale);

                i+=2;

                break;

            default:

                break;

            }

        }

    } while (0);

    if (!outline)

        addClosingLine(lastMoveTo);

    vertexArrayStops.append(vertexArray.size());

}

void QGL2PEXVertexArray::lineToArray(const GLfloat x, const GLfloat y)

{

    vertexArray.add(QGLPoint(x, y));

    if (x > maxX)

        maxX = x;

    else if (x < minX)

        minX = x;

    if (y > maxY)

        maxY = y;

    else if (y < minY)

        minY = y;

}

void QGL2PEXVertexArray::curveToArray(const QGLPoint &cp1, const QGLPoint &cp2, const QGLPoint &ep, GLfloat inverseScale)

{

    qreal inverseScaleHalf = inverseScale / 2;

    QBezier beziers[32];

    beziers[0] = QBezier::fromPoints(vertexArray.last(), cp1, cp2, ep);

    QBezier *b = beziers;

    while (b >= beziers) {

        // check if we can pop the top bezier curve from the stack

        qreal l = qAbs(b->x4 - b->x1) + qAbs(b->y4 - b->y1);

        qreal d;

        if (l > inverseScale) {

            d = qAbs( (b->x4 - b->x1)*(b->y1 - b->y2) - (b->y4 - b->y1)*(b->x1 - b->x2) )

                + qAbs( (b->x4 - b->x1)*(b->y1 - b->y3) - (b->y4 - b->y1)*(b->x1 - b->x3) );

            d /= l;

        } else {

            d = qAbs(b->x1 - b->x2) + qAbs(b->y1 - b->y2) +

                qAbs(b->x1 - b->x3) + qAbs(b->y1 - b->y3);

        }

        if (d < inverseScaleHalf || b == beziers + 31) {

            // good enough, we pop it off and add the endpoint

            lineToArray(b->x4, b->y4);

            --b;

        } else {

            // split, second half of the polygon goes lower into the stack

            b->split(b+1, b);

           ++b;

        }

    }

}

QT_END_NAMESPACE