Say hello to QtQuick module

This change moves the QtQuick 2 types and C++ API (including
SceneGraph) to a new module (AKA library), QtQuick.

99% of this change is moving files from src/declarative to
src/quick, and from tests/auto/declarative to
tests/auto/qtquick2.

The loading of QtQuick 2 ("import QtQuick 2.0") is now delegated to
a plugin, src/imports/qtquick2, just like it's done for QtQuick 1.

All tools, examples, and tests that use QtQuick C++ API have gotten
"QT += quick" or "QT += quick-private" added to their .pro file.

A few additional internal QtDeclarative classes had to be exported
(via Q_DECLARATIVE_PRIVATE_EXPORT) since they're needed by the
QtQuick 2 implementation.

The old header locations (e.g. QtDeclarative/qquickitem.h) will
still be supported for some time, but will produce compile-time
warnings. (To avoid the QtQuick implementation using the
compatibility headers (since QtDeclarative's includepath comes
first), a few include statements were modified, e.g. from
"#include <qsgnode.h>" to "#include <QtQuick/qsgnode.h>".)

There's a change in qtbase that automatically adds QtQuick to the
module list if QtDeclarative is used. Together with the compatibility
headers, this should help reduce the migration pain for existing
projects.

In theory, simply getting an existing QtDeclarative-based project
to compile and link shouldn't require any changes for now -- but
porting to the new scheme is of course recommended, and will
eventually become mandatory.

Task-number: QTBUG-22889
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Change-Id: Ia52be9373172ba2f37e7623231ecb060316c96a7
Reviewed-by: Kent Hansen <kent.hansen@nokia.com>
Reviewed-by: Sergio Ahumada <sergio.ahumada@nokia.com>

1 files changed, 455 insertions, 0 deletions

diff --git a/src/quick/items/qquickspriteimage.cpp b/src/quick/items/qquickspriteimage.cpp
new file mode 100644
index 0000000000..1da46f2ae8
--- /dev/null
+++ b/src/quick/items/qquickspriteimage.cpp
@@ -0,0 +1,455 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Declarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qquickspriteimage_p.h"
+#include "qquicksprite_p.h"
+#include "qquickspriteengine_p.h"
+#include <QtQuick/private/qsgcontext_p.h>
+#include <private/qsgadaptationlayer_p.h>
+#include <QtQuick/qsgnode.h>
+#include <QtQuick/qsgengine.h>
+#include <QtQuick/qsgtexturematerial.h>
+#include <QtQuick/qsgtexture.h>
+#include <QtQuick/qquickcanvas.h>
+#include <QFile>
+#include <cmath>
+#include <qmath.h>
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+static const char vertexShaderCode[] =
+    "attribute highp vec2 vTex;\n"
+    "uniform highp vec4 animData;// interpolate(bool), duration, frameCount (this anim), timestamp (this anim)\n"
+    "uniform highp vec4 animPos;//sheet x,y, width/height of this anim\n"
+    "uniform highp vec4 animSheetSize; //width/height of whole sheet, width/height of element\n"
+    "\n"
+    "uniform highp mat4 qt_Matrix;\n"
+    "uniform highp float timestamp;\n"
+    "\n"
+    "varying highp vec4 fTexS;\n"
+    "varying lowp float progress;\n"
+    "\n"
+    "\n"
+    "void main() {\n"
+    "    //Calculate frame location in texture\n"
+    "    highp float frameIndex = mod((((timestamp - animData.w)*1000.)/animData.y),animData.z);\n"
+    "    progress = mod((timestamp - animData.w)*1000., animData.y) / animData.y;\n"
+    "\n"
+    "    frameIndex = floor(frameIndex);\n"
+    "    fTexS.xy = vec2(((frameIndex + vTex.x) * animPos.z / animSheetSize.x), ((animPos.y + vTex.y * animPos.w) / animSheetSize.y));\n"
+    "\n"
+    "    //Next frame is also passed, for interpolation\n"
+    "    //### Should the next anim be precalculated to allow for interpolation there?\n"
+    "    if (animData.x == 1.0 && frameIndex != animData.z - 1.)//Can't do it for the last frame though, this anim may not loop\n"
+    "        frameIndex = mod(frameIndex+1., animData.z);\n"
+    "    fTexS.zw = vec2(((frameIndex + vTex.x) * animPos.z / animSheetSize.x), ((animPos.y + vTex.y * animPos.w) / animSheetSize.y));\n"
+    "\n"
+    "    gl_Position = qt_Matrix * vec4(animSheetSize.z * vTex.x, animSheetSize.w * vTex.y, 0, 1);\n"
+    "}\n";
+
+static const char fragmentShaderCode[] =
+    "uniform sampler2D texture;\n"
+    "uniform lowp float qt_Opacity;\n"
+    "\n"
+    "varying highp vec4 fTexS;\n"
+    "varying lowp float progress;\n"
+    "\n"
+    "void main() {\n"
+    "    gl_FragColor = mix(texture2D(texture, fTexS.xy), texture2D(texture, fTexS.zw), progress) * qt_Opacity;\n"
+    "}\n";
+
+class QQuickSpriteMaterial : public QSGMaterial
+{
+public:
+    QQuickSpriteMaterial();
+    virtual ~QQuickSpriteMaterial();
+    virtual QSGMaterialType *type() const { static QSGMaterialType type; return &type; }
+    virtual QSGMaterialShader *createShader() const;
+    virtual int compare(const QSGMaterial *other) const
+    {
+        return this - static_cast<const QQuickSpriteMaterial *>(other);
+    }
+
+    QSGTexture *texture;
+
+    qreal timestamp;
+    float interpolate;
+    float frameDuration;
+    float frameCount;
+    float animT;
+    float animX;
+    float animY;
+    float animWidth;
+    float animHeight;
+    float sheetWidth;
+    float sheetHeight;
+    float elementWidth;
+    float elementHeight;
+};
+
+QQuickSpriteMaterial::QQuickSpriteMaterial()
+    : timestamp(0)
+    , interpolate(1.0f)
+    , frameDuration(1.0f)
+    , frameCount(1.0f)
+    , animT(0.0f)
+    , animX(0.0f)
+    , animY(0.0f)
+    , animWidth(1.0f)
+    , animHeight(1.0f)
+    , sheetWidth(1.0f)
+    , sheetHeight(1.0f)
+    , elementWidth(1.0f)
+    , elementHeight(1.0f)
+{
+    setFlag(Blending, true);
+}
+
+QQuickSpriteMaterial::~QQuickSpriteMaterial()
+{
+    delete texture;
+}
+
+class SpriteMaterialData : public QSGMaterialShader
+{
+public:
+    SpriteMaterialData(const char * /* vertexFile */ = 0, const char * /* fragmentFile */ = 0)
+    {
+    }
+
+    void deactivate() {
+        QSGMaterialShader::deactivate();
+
+        for (int i=0; i<8; ++i) {
+            program()->setAttributeArray(i, GL_FLOAT, chunkOfBytes, 1, 0);
+        }
+    }
+
+    virtual void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *)
+    {
+        QQuickSpriteMaterial *m = static_cast<QQuickSpriteMaterial *>(newEffect);
+        m->texture->bind();
+
+        program()->setUniformValue(m_opacity_id, state.opacity());
+        program()->setUniformValue(m_timestamp_id, (float) m->timestamp);
+        program()->setUniformValue(m_animData_id, m->interpolate, m->frameDuration, m->frameCount, m->animT);
+        program()->setUniformValue(m_animPos_id, m->animX, m->animY, m->animWidth, m->animHeight);
+        program()->setUniformValue(m_animSheetSize_id, m->sheetWidth, m->sheetHeight, m->elementWidth, m->elementHeight);
+
+        if (state.isMatrixDirty())
+            program()->setUniformValue(m_matrix_id, state.combinedMatrix());
+    }
+
+    virtual void initialize() {
+        m_matrix_id = program()->uniformLocation("qt_Matrix");
+        m_opacity_id = program()->uniformLocation("qt_Opacity");
+        m_timestamp_id = program()->uniformLocation("timestamp");
+        m_animData_id = program()->uniformLocation("animData");
+        m_animPos_id = program()->uniformLocation("animPos");
+        m_animSheetSize_id = program()->uniformLocation("animSheetSize");
+    }
+
+    virtual const char *vertexShader() const { return vertexShaderCode; }
+    virtual const char *fragmentShader() const { return fragmentShaderCode; }
+
+    virtual char const *const *attributeNames() const {
+        static const char *attr[] = {
+           "vTex",
+            0
+        };
+        return attr;
+    }
+
+    int m_matrix_id;
+    int m_opacity_id;
+    int m_timestamp_id;
+    int m_animData_id;
+    int m_animPos_id;
+    int m_animSheetSize_id;
+
+    static float chunkOfBytes[1024];
+};
+
+float SpriteMaterialData::chunkOfBytes[1024];
+
+QSGMaterialShader *QQuickSpriteMaterial::createShader() const
+{
+    return new SpriteMaterialData;
+}
+
+struct SpriteVertex {
+    float tx;
+    float ty;
+};
+
+struct SpriteVertices {
+    SpriteVertex v1;
+    SpriteVertex v2;
+    SpriteVertex v3;
+    SpriteVertex v4;
+};
+
+/*!
+    \qmlclass SpriteImage QQuickSpriteImage
+    \inqmlmodule QtQuick 2
+    \inherits Item
+    \brief The SpriteImage element draws a sprite animation
+
+*/
+/*!
+    \qmlproperty bool QtQuick2::SpriteImage::running
+
+    Whether the sprite is animating or not.
+
+    Default is true
+*/
+/*!
+    \qmlproperty bool QtQuick2::SpriteImage::interpolate
+
+    If true, interpolation will occur between sprite frames to make the
+    animation appear smoother.
+
+    Default is true.
+*/
+/*!
+    \qmlproperty string QtQuick2::SpriteImage::goalState
+
+    The name of the Sprite which the animation should move to.
+
+    Sprite states have defined durations and transitions between them, setting goalState
+    will cause it to disregard any path weightings (including 0) and head down the path
+    which will reach the goalState quickest (fewest animations). It will pass through
+    intermediate states on that path, and animate them for their duration.
+
+    If it is possible to return to the goalState from the starting point of the goalState
+    it will continue to do so until goalState is set to "" or an unreachable state.
+*/
+/*! \qmlmethod void QtQuick2::SpriteImage::jumpTo(string sprite)
+
+    This function causes the sprite to jump to the specified state immediately, intermediate
+    states are not played.
+*/
+/*!
+    \qmlproperty list<Sprite> QtQuick2::SpriteImage::sprites
+
+    The sprite or sprites to draw. Sprites will be scaled to the size of this element.
+*/
+
+//TODO: Implicitly size element to size of first sprite?
+QQuickSpriteImage::QQuickSpriteImage(QQuickItem *parent) :
+    QQuickItem(parent)
+    , m_node(0)
+    , m_material(0)
+    , m_spriteEngine(0)
+    , m_pleaseReset(false)
+    , m_running(true)
+    , m_interpolate(true)
+{
+    setFlag(ItemHasContents);
+    connect(this, SIGNAL(runningChanged(bool)),
+            this, SLOT(update()));
+}
+
+void QQuickSpriteImage::jumpTo(const QString &sprite)
+{
+    if (!m_spriteEngine)
+        return;
+    m_spriteEngine->setGoal(m_spriteEngine->stateIndex(sprite), 0, true);
+}
+
+void QQuickSpriteImage::setGoalState(const QString &sprite)
+{
+    if (m_goalState != sprite){
+        m_goalState = sprite;
+        emit goalStateChanged(sprite);
+        m_spriteEngine->setGoal(m_spriteEngine->stateIndex(sprite));
+    }
+}
+
+QDeclarativeListProperty<QQuickSprite> QQuickSpriteImage::sprites()
+{
+    return QDeclarativeListProperty<QQuickSprite>(this, &m_sprites, spriteAppend, spriteCount, spriteAt, spriteClear);
+}
+
+void QQuickSpriteImage::createEngine()
+{
+    //TODO: delay until component complete
+    if (m_spriteEngine)
+        delete m_spriteEngine;
+    if (m_sprites.count())
+        m_spriteEngine = new QQuickSpriteEngine(m_sprites, this);
+    else
+        m_spriteEngine = 0;
+    reset();
+}
+
+static QSGGeometry::Attribute SpriteImage_Attributes[] = {
+    QSGGeometry::Attribute::create(0, 2, GL_FLOAT),         // tex
+};
+
+static QSGGeometry::AttributeSet SpriteImage_AttributeSet =
+{
+    1, // Attribute Count
+    2 * sizeof(float),
+    SpriteImage_Attributes
+};
+
+QSGGeometryNode* QQuickSpriteImage::buildNode()
+{
+    if (!m_spriteEngine) {
+        qWarning() << "SpriteImage: No sprite engine...";
+        return 0;
+    }
+
+    m_material = new QQuickSpriteMaterial();
+
+    QImage image = m_spriteEngine->assembledImage();
+    if (image.isNull())
+        return 0;
+    m_material->texture = canvas()->createTextureFromImage(image);
+    m_material->texture->setFiltering(QSGTexture::Linear);
+    m_spriteEngine->start(0);
+    m_material->interpolate = m_interpolate ? 1.0 : 0.0;
+    m_material->frameCount = m_spriteEngine->spriteFrames();
+    m_material->frameDuration = m_spriteEngine->spriteDuration();
+    m_material->animT = 0;
+    m_material->animX = m_spriteEngine->spriteX();
+    m_material->animY = m_spriteEngine->spriteY();
+    m_material->animWidth = m_spriteEngine->spriteWidth();
+    m_material->animHeight = m_spriteEngine->spriteHeight();
+    m_material->sheetWidth = image.width();
+    m_material->sheetHeight = image.height();
+    m_material->elementWidth = width();
+    m_material->elementHeight = height();
+
+    int vCount = 4;
+    int iCount = 6;
+    QSGGeometry *g = new QSGGeometry(SpriteImage_AttributeSet, vCount, iCount);
+    g->setDrawingMode(GL_TRIANGLES);
+
+    SpriteVertices *p = (SpriteVertices *) g->vertexData();
+
+    p->v1.tx = 0;
+    p->v1.ty = 0;
+
+    p->v2.tx = 1.0;
+    p->v2.ty = 0;
+
+    p->v3.tx = 0;
+    p->v3.ty = 1.0;
+
+    p->v4.tx = 1.0;
+    p->v4.ty = 1.0;
+
+    quint16 *indices = g->indexDataAsUShort();
+    indices[0] = 0;
+    indices[1] = 1;
+    indices[2] = 2;
+    indices[3] = 1;
+    indices[4] = 3;
+    indices[5] = 2;
+
+
+    m_timestamp.start();
+    m_node = new QSGGeometryNode();
+    m_node->setGeometry(g);
+    m_node->setMaterial(m_material);
+    m_node->setFlag(QSGGeometryNode::OwnsMaterial);
+    return m_node;
+}
+
+void QQuickSpriteImage::reset()
+{
+    m_pleaseReset = true;
+}
+
+QSGNode *QQuickSpriteImage::updatePaintNode(QSGNode *, UpdatePaintNodeData *)
+{
+    if (m_pleaseReset) {
+        delete m_node;
+        delete m_material;
+
+        m_node = 0;
+        m_material = 0;
+        m_pleaseReset = false;
+    }
+
+    prepareNextFrame();
+
+    if (m_running) {
+        update();
+        if (m_node)
+            m_node->markDirty(QSGNode::DirtyMaterial);
+    }
+
+    return m_node;
+}
+
+void QQuickSpriteImage::prepareNextFrame()
+{
+    if (m_node == 0)
+        m_node = buildNode();
+    if (m_node == 0) //error creating node
+        return;
+
+    uint timeInt = m_timestamp.elapsed();
+    qreal time =  timeInt / 1000.;
+    m_material->timestamp = time;
+    m_material->elementHeight = height();
+    m_material->elementWidth = width();
+    m_material->interpolate = m_interpolate;
+
+    //Advance State
+    m_spriteEngine->updateSprites(timeInt);
+    int curY = m_spriteEngine->spriteY();
+    if (curY != m_material->animY){
+        m_material->animT = m_spriteEngine->spriteStart()/1000.0;
+        m_material->frameCount = m_spriteEngine->spriteFrames();
+        m_material->frameDuration = m_spriteEngine->spriteDuration();
+        m_material->animX = m_spriteEngine->spriteX();
+        m_material->animY = m_spriteEngine->spriteY();
+        m_material->animWidth = m_spriteEngine->spriteWidth();
+        m_material->animHeight = m_spriteEngine->spriteHeight();
+    }
+}
+
+QT_END_NAMESPACE