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

**

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

** All rights reserved.

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

**

** This file is part of the demonstration applications 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 "roundedbox.h"

//============================================================================//

//                                P3T2N3Vertex                                //

//============================================================================//

VertexDescription P3T2N3Vertex::description[] = {

    {VertexDescription::Position, GL_FLOAT, SIZE_OF_MEMBER(P3T2N3Vertex, position) / sizeof(float), 0, 0},

    {VertexDescription::TexCoord, GL_FLOAT, SIZE_OF_MEMBER(P3T2N3Vertex, texCoord) / sizeof(float), sizeof(QVector3D), 0},

    {VertexDescription::Normal, GL_FLOAT, SIZE_OF_MEMBER(P3T2N3Vertex, normal) / sizeof(float), sizeof(QVector3D) + sizeof(QVector2D), 0},

    {VertexDescription::Null, 0, 0, 0, 0},

};

//============================================================================//

//                                GLRoundedBox                                //

//============================================================================//

float lerp(float a, float b, float t)

{

    return a * (1.0f - t) + b * t;

}

GLRoundedBox::GLRoundedBox(float r, float scale, int n)

    : GLTriangleMesh<P3T2N3Vertex, unsigned short>((n+2)*(n+3)*4, (n+1)*(n+1)*24+36+72*(n+1))

{

    int vidx = 0, iidx = 0;

    int vertexCountPerCorner = (n + 2) * (n + 3) / 2;

    P3T2N3Vertex *vp = m_vb.lock();

    unsigned short *ip = m_ib.lock();

    if (!vp || !ip) {

        qWarning("GLRoundedBox::GLRoundedBox: Failed to lock vertex buffer and/or index buffer.");

        m_ib.unlock();

        m_vb.unlock();

        return;

    }

    for (int corner = 0; corner < 8; ++corner) {

        QVector3D centre(corner & 1 ? 1.0f : -1.0f,

                corner & 2 ? 1.0f : -1.0f,

                corner & 4 ? 1.0f : -1.0f);

        int winding = (corner & 1) ^ ((corner >> 1) & 1) ^ (corner >> 2);

        int offsX = ((corner ^ 1) - corner) * vertexCountPerCorner;

        int offsY = ((corner ^ 2) - corner) * vertexCountPerCorner;

        int offsZ = ((corner ^ 4) - corner) * vertexCountPerCorner;

        // Face polygons

        if (winding) {

            ip[iidx++] = vidx;

            ip[iidx++] = vidx + offsX;

            ip[iidx++] = vidx + offsY;

            ip[iidx++] = vidx + vertexCountPerCorner - n - 2;

            ip[iidx++] = vidx + vertexCountPerCorner - n - 2 + offsY;

            ip[iidx++] = vidx + vertexCountPerCorner - n - 2 + offsZ;

            ip[iidx++] = vidx + vertexCountPerCorner - 1;

            ip[iidx++] = vidx + vertexCountPerCorner - 1 + offsZ;

            ip[iidx++] = vidx + vertexCountPerCorner - 1 + offsX;

        }

        for (int i = 0; i < n + 2; ++i) {

            // Edge polygons

            if (winding && i < n + 1) {

                ip[iidx++] = vidx + i + 1;

                ip[iidx++] = vidx;

                ip[iidx++] = vidx + offsY + i + 1;

                ip[iidx++] = vidx + offsY;

                ip[iidx++] = vidx + offsY + i + 1;

                ip[iidx++] = vidx;

                ip[iidx++] = vidx + i;

                ip[iidx++] = vidx + 2 * i + 2;

                ip[iidx++] = vidx + i + offsX;

                ip[iidx++] = vidx + 2 * i + offsX + 2;

                ip[iidx++] = vidx + i + offsX;

                ip[iidx++] = vidx + 2 * i + 2;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 1 - i;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 2 - i;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 1 - i + offsZ;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 2 - i + offsZ;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 1 - i + offsZ;

                ip[iidx++] = (corner + 1) * vertexCountPerCorner - 2 - i;

            }

            for (int j = 0; j <= i; ++j) {

                QVector3D normal = QVector3D(i - j, j, n + 1 - i).normalized();

                QVector3D offset(0.5f - r, 0.5f - r, 0.5f - r);

                QVector3D pos = centre * (offset + r * normal);

                vp[vidx].position = scale * pos;

                vp[vidx].normal = centre * normal;

                vp[vidx].texCoord = QVector2D(pos.x() + 0.5f, pos.y() + 0.5f);

                // Corner polygons

                if (i < n + 1) {

                    ip[iidx++] = vidx;

                    ip[iidx++] = vidx + i + 2 - winding;

                    ip[iidx++] = vidx + i + 1 + winding;

                }

                if (i < n) {

                    ip[iidx++] = vidx + i + 1 + winding;

                    ip[iidx++] = vidx + i + 2 - winding;

                    ip[iidx++] = vidx + 2 * i + 4;

                }

                ++vidx;

            }

        }

    }

    m_ib.unlock();

    m_vb.unlock();

}