Add QSGSpriteNode to the Scenegraph Adaptation Layer

Most core Qt Quick items use one of the nodes provided by the Scenegraph
Adaptation Layer, however the two items that provide support for Sprites
created their own custom nodes.  There was significant redundancy in
this, and it made it only possible to use the OpenGL adaptation.  The
AnimatedSprite and SpriteSequence items have been cleaned up, and now
use the new QSGSpriteNode.

Change-Id: Idc20b9c5da9dc1c94f6368021785382cdf7cec5a
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

1 files changed, 393 insertions, 299 deletions

diff --git a/src/quick/items/qquickanimatedsprite.cpp b/src/quick/items/qquickanimatedsprite.cpp
index aaa0487afd..991ca8519f 100644
--- a/src/quick/items/qquickanimatedsprite.cpp
+++ b/src/quick/items/qquickanimatedsprite.cpp
@@ -38,6 +38,7 @@
 ****************************************************************************/
 
 #include "qquickanimatedsprite_p.h"
+#include "qquickanimatedsprite_p_p.h"
 #include "qquicksprite_p.h"
 #include "qquickspriteengine_p.h"
 #include <QtQuick/private/qsgcontext_p.h>
@@ -55,117 +56,6 @@
 
 QT_BEGIN_NAMESPACE
 
-class QQuickAnimatedSpriteMaterial : public QSGMaterial
-{
-public:
-    QQuickAnimatedSpriteMaterial();
-    ~QQuickAnimatedSpriteMaterial();
-    QSGMaterialType *type() const Q_DECL_OVERRIDE { static QSGMaterialType type; return &type; }
-    QSGMaterialShader *createShader() const Q_DECL_OVERRIDE;
-    int compare(const QSGMaterial *other) const Q_DECL_OVERRIDE
-    {
-        return this - static_cast<const QQuickAnimatedSpriteMaterial *>(other);
-    }
-
-    QSGTexture *texture;
-
-    float animT;
-    float animX1;
-    float animY1;
-    float animX2;
-    float animY2;
-    float animW;
-    float animH;
-};
-
-QQuickAnimatedSpriteMaterial::QQuickAnimatedSpriteMaterial()
-    : texture(0)
-    , animT(0.0f)
-    , animX1(0.0f)
-    , animY1(0.0f)
-    , animX2(0.0f)
-    , animY2(0.0f)
-    , animW(1.0f)
-    , animH(1.0f)
-{
-    setFlag(Blending, true);
-}
-
-QQuickAnimatedSpriteMaterial::~QQuickAnimatedSpriteMaterial()
-{
-    delete texture;
-}
-
-#ifndef QT_NO_OPENGL
-class AnimatedSpriteMaterialData : public QSGMaterialShader
-{
-public:
-    AnimatedSpriteMaterialData()
-        : QSGMaterialShader()
-    {
-        setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/qt-project.org/items/shaders/sprite.vert"));
-        setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/qt-project.org/items/shaders/sprite.frag"));
-    }
-
-    void updateState(const RenderState &state, QSGMaterial *newEffect, QSGMaterial *) Q_DECL_OVERRIDE
-    {
-        QQuickAnimatedSpriteMaterial *m = static_cast<QQuickAnimatedSpriteMaterial *>(newEffect);
-        m->texture->bind();
-
-        program()->setUniformValue(m_opacity_id, state.opacity());
-        program()->setUniformValue(m_animData_id, m->animW, m->animH, m->animT);
-        program()->setUniformValue(m_animPos_id, m->animX1, m->animY1, m->animX2, m->animY2);
-
-        if (state.isMatrixDirty())
-            program()->setUniformValue(m_matrix_id, state.combinedMatrix());
-    }
-
-    void initialize() Q_DECL_OVERRIDE {
-        m_matrix_id = program()->uniformLocation("qt_Matrix");
-        m_opacity_id = program()->uniformLocation("qt_Opacity");
-        m_animData_id = program()->uniformLocation("animData");
-        m_animPos_id = program()->uniformLocation("animPos");
-    }
-
-    char const *const *attributeNames() const Q_DECL_OVERRIDE {
-        static const char *attr[] = {
-           "vPos",
-           "vTex",
-            0
-        };
-        return attr;
-    }
-
-    int m_matrix_id;
-    int m_opacity_id;
-    int m_animData_id;
-    int m_animPos_id;
-};
-#endif
-
-QSGMaterialShader *QQuickAnimatedSpriteMaterial::createShader() const
-{
-#ifndef QT_NO_OPENGL
-    return new AnimatedSpriteMaterialData;
-#else
-    return nullptr;
-#endif
-}
-
-struct AnimatedSpriteVertex {
-    float x;
-    float y;
-    float tx;
-    float ty;
-};
-
-struct AnimatedSpriteVertices {
-    AnimatedSpriteVertex v1;
-    AnimatedSpriteVertex v2;
-    AnimatedSpriteVertex v3;
-    AnimatedSpriteVertex v4;
-};
-
 /*!
     \qmltype AnimatedSprite
     \instantiates QQuickAnimatedSprite
@@ -321,18 +211,11 @@ struct AnimatedSpriteVertices {
 
 //TODO: Implicitly size element to size of sprite
 QQuickAnimatedSprite::QQuickAnimatedSprite(QQuickItem *parent) :
-    QQuickItem(parent)
-    , m_sprite(new QQuickSprite(this))
-    , m_spriteEngine(0)
-    , m_curFrame(0)
-    , m_pleaseReset(false)
-    , m_running(true)
-    , m_paused(false)
-    , m_interpolate(true)
-    , m_loops(-1)
-    , m_curLoop(0)
-    , m_pauseOffset(0)
+    QQuickItem(*(new QQuickAnimatedSpritePrivate), parent)
 {
+    Q_D(QQuickAnimatedSprite);
+    d->m_sprite = new QQuickSprite(this);
+
     setFlag(ItemHasContents);
     connect(this, SIGNAL(widthChanged()),
             this, SLOT(reset()));
@@ -340,6 +223,96 @@ QQuickAnimatedSprite::QQuickAnimatedSprite(QQuickItem *parent) :
             this, SLOT(reset()));
 }
 
+bool QQuickAnimatedSprite::running() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_running;
+}
+
+bool QQuickAnimatedSprite::interpolate() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_interpolate;
+}
+
+QUrl QQuickAnimatedSprite::source() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->source();
+}
+
+bool QQuickAnimatedSprite::reverse() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->reverse();
+}
+
+bool QQuickAnimatedSprite::frameSync() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameSync();
+}
+
+int QQuickAnimatedSprite::frameCount() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frames();
+}
+
+int QQuickAnimatedSprite::frameHeight() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameHeight();
+}
+
+int QQuickAnimatedSprite::frameWidth() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameWidth();
+}
+
+int QQuickAnimatedSprite::frameX() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameX();
+}
+
+int QQuickAnimatedSprite::frameY() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameY();
+}
+
+qreal QQuickAnimatedSprite::frameRate() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameRate();
+}
+
+int QQuickAnimatedSprite::frameDuration() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_sprite->frameDuration();
+}
+
+int QQuickAnimatedSprite::loops() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_loops;
+}
+
+bool QQuickAnimatedSprite::paused() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_paused;
+}
+
+int QQuickAnimatedSprite::currentFrame() const
+{
+    Q_D(const QQuickAnimatedSprite);
+    return d->m_curFrame;
+}
+
 bool QQuickAnimatedSprite::isCurrentFrameChangedConnected()
 {
     IS_SIGNAL_CONNECTED(this, QQuickAnimatedSprite, currentFrameChanged, (int));
@@ -354,23 +327,25 @@ void QQuickAnimatedSprite::reloadImage()
 
 void QQuickAnimatedSprite::componentComplete()
 {
+    Q_D(const QQuickAnimatedSprite);
     createEngine();
     QQuickItem::componentComplete();
-    if (m_running)
+    if (d->m_running)
         start();
 }
 
 void QQuickAnimatedSprite::start()
 {
-    m_running = true;
+    Q_D(QQuickAnimatedSprite);
+    d->m_running = true;
     if (!isComponentComplete())
         return;
-    m_curLoop = 0;
-    m_timestamp.start();
-    if (m_spriteEngine) {
-        m_spriteEngine->stop(0);
-        m_spriteEngine->updateSprites(0);
-        m_spriteEngine->start(0);
+    d->m_curLoop = 0;
+    d->m_timestamp.start();
+    if (d->m_spriteEngine) {
+        d->m_spriteEngine->stop(0);
+        d->m_spriteEngine->updateSprites(0);
+        d->m_spriteEngine->start(0);
     }
     emit currentFrameChanged(0);
     emit runningChanged(true);
@@ -379,10 +354,11 @@ void QQuickAnimatedSprite::start()
 
 void QQuickAnimatedSprite::stop()
 {
-    m_running = false;
+    Q_D(QQuickAnimatedSprite);
+    d->m_running = false;
     if (!isComponentComplete())
         return;
-    m_pauseOffset = 0;
+    d->m_pauseOffset = 0;
     emit runningChanged(false);
     update();
 }
@@ -394,14 +370,15 @@ void QQuickAnimatedSprite::stop()
 */
 void QQuickAnimatedSprite::advance(int frames)
 {
+    Q_D(QQuickAnimatedSprite);
     if (!frames)
         return;
     //TODO-C: May not work when running - only when paused
-    m_curFrame += frames;
-    while (m_curFrame < 0)
-        m_curFrame += m_spriteEngine->maxFrames();
-    m_curFrame = m_curFrame % m_spriteEngine->maxFrames();
-    emit currentFrameChanged(m_curFrame);
+    d->m_curFrame += frames;
+    while (d->m_curFrame < 0)
+        d->m_curFrame += d->m_spriteEngine->maxFrames();
+    d->m_curFrame = d->m_curFrame % d->m_spriteEngine->maxFrames();
+    emit currentFrameChanged(d->m_curFrame);
     update();
 }
 
@@ -415,10 +392,12 @@ void QQuickAnimatedSprite::advance(int frames)
 */
 void QQuickAnimatedSprite::pause()
 {
-    if (m_paused)
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_paused)
         return;
-    m_pauseOffset = m_timestamp.elapsed();
-    m_paused = true;
+    d->m_pauseOffset = d->m_timestamp.elapsed();
+    d->m_paused = true;
     emit pausedChanged(true);
     update();
 }
@@ -433,246 +412,363 @@ void QQuickAnimatedSprite::pause()
 */
 void QQuickAnimatedSprite::resume()
 {
-    if (!m_paused)
+    Q_D(QQuickAnimatedSprite);
+
+    if (!d->m_paused)
         return;
-    m_pauseOffset = m_pauseOffset - m_timestamp.elapsed();
-    m_paused = false;
+    d->m_pauseOffset = d->m_pauseOffset - d->m_timestamp.elapsed();
+    d->m_paused = false;
     emit pausedChanged(false);
     update();
 }
 
-void QQuickAnimatedSprite::createEngine()
+void QQuickAnimatedSprite::setRunning(bool arg)
 {
-    if (m_spriteEngine)
-        delete m_spriteEngine;
-    QList<QQuickSprite*> spriteList;
-    spriteList << m_sprite;
-    m_spriteEngine = new QQuickSpriteEngine(QList<QQuickSprite*>(spriteList), this);
-    m_spriteEngine->startAssemblingImage();
-    reset();
-    update();
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_running != arg) {
+        if (d->m_running)
+            stop();
+        else
+            start();
+    }
 }
 
-static QSGGeometry::Attribute AnimatedSprite_Attributes[] = {
-    QSGGeometry::Attribute::create(0, 2, QSGGeometry::TypeFloat, true),   // pos
-    QSGGeometry::Attribute::create(1, 2, QSGGeometry::TypeFloat),         // tex
-};
+void QQuickAnimatedSprite::setPaused(bool arg)
+{
+    Q_D(const QQuickAnimatedSprite);
 
-static QSGGeometry::AttributeSet AnimatedSprite_AttributeSet =
+    if (d->m_paused != arg) {
+        if (d->m_paused)
+            resume();
+        else
+            pause();
+    }
+}
+
+void QQuickAnimatedSprite::setInterpolate(bool arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_interpolate != arg) {
+        d->m_interpolate = arg;
+        Q_EMIT interpolateChanged(arg);
+    }
+}
+
+void QQuickAnimatedSprite::setSource(QUrl arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_source != arg) {
+        d->m_sprite->setSource(arg);
+        Q_EMIT sourceChanged(arg);
+        reloadImage();
+    }
+}
+
+void QQuickAnimatedSprite::setReverse(bool arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_reverse != arg) {
+        d->m_sprite->setReverse(arg);
+        Q_EMIT reverseChanged(arg);
+    }
+}
+
+void QQuickAnimatedSprite::setFrameSync(bool arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frameSync != arg) {
+        d->m_sprite->setFrameSync(arg);
+        Q_EMIT frameSyncChanged(arg);
+        if (d->m_running)
+            restart();
+    }
+}
+
+void QQuickAnimatedSprite::setFrameCount(int arg)
 {
-    2, // Attribute Count
-    (2+2) * sizeof(float),
-    AnimatedSprite_Attributes
-};
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frames != arg) {
+        d->m_sprite->setFrameCount(arg);
+        Q_EMIT frameCountChanged(arg);
+        reloadImage();
+    }
+}
 
-void QQuickAnimatedSprite::sizeVertices(QSGGeometryNode *node)
+void QQuickAnimatedSprite::setFrameHeight(int arg)
 {
-    AnimatedSpriteVertices *p = (AnimatedSpriteVertices *) node->geometry()->vertexData();
-    p->v1.x = 0;
-    p->v1.y = 0;
+    Q_D(QQuickAnimatedSprite);
 
-    p->v2.x = width();
-    p->v2.y = 0;
+    if (d->m_sprite->m_frameHeight != arg) {
+        d->m_sprite->setFrameHeight(arg);
+        Q_EMIT frameHeightChanged(arg);
+        reloadImage();
+    }
+}
 
-    p->v3.x = 0;
-    p->v3.y = height();
+void QQuickAnimatedSprite::setFrameWidth(int arg)
+{
+    Q_D(QQuickAnimatedSprite);
 
-    p->v4.x = width();
-    p->v4.y = height();
+    if (d->m_sprite->m_frameWidth != arg) {
+        d->m_sprite->setFrameWidth(arg);
+        Q_EMIT frameWidthChanged(arg);
+        reloadImage();
+    }
 }
 
-QSGGeometryNode* QQuickAnimatedSprite::buildNode()
+void QQuickAnimatedSprite::setFrameX(int arg)
 {
-    if (!m_spriteEngine) {
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frameX != arg) {
+        d->m_sprite->setFrameX(arg);
+        Q_EMIT frameXChanged(arg);
+        reloadImage();
+    }
+}
+
+void QQuickAnimatedSprite::setFrameY(int arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frameY != arg) {
+        d->m_sprite->setFrameY(arg);
+        Q_EMIT frameYChanged(arg);
+        reloadImage();
+    }
+}
+
+void QQuickAnimatedSprite::setFrameRate(qreal arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frameRate != arg) {
+        d->m_sprite->setFrameRate(arg);
+        Q_EMIT frameRateChanged(arg);
+        if (d->m_running)
+            restart();
+    }
+}
+
+void QQuickAnimatedSprite::setFrameDuration(int arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_sprite->m_frameDuration != arg) {
+        d->m_sprite->setFrameDuration(arg);
+        Q_EMIT frameDurationChanged(arg);
+        if (d->m_running)
+            restart();
+    }
+}
+
+void QQuickAnimatedSprite::resetFrameRate()
+{
+    setFrameRate(-1.0);
+}
+
+void QQuickAnimatedSprite::resetFrameDuration()
+{
+    setFrameDuration(-1);
+}
+
+void QQuickAnimatedSprite::setLoops(int arg)
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_loops != arg) {
+        d->m_loops = arg;
+        Q_EMIT loopsChanged(arg);
+    }
+}
+
+void QQuickAnimatedSprite::setCurrentFrame(int arg) //TODO-C: Probably only works when paused
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_curFrame != arg) {
+        d->m_curFrame = arg;
+        Q_EMIT currentFrameChanged(arg); //TODO-C Only emitted on manual advance!
+        update();
+    }
+}
+
+void QQuickAnimatedSprite::createEngine()
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_spriteEngine)
+        delete d->m_spriteEngine;
+    QList<QQuickSprite*> spriteList;
+    spriteList << d->m_sprite;
+    d->m_spriteEngine = new QQuickSpriteEngine(QList<QQuickSprite*>(spriteList), this);
+    d->m_spriteEngine->startAssemblingImage();
+    reset();
+    update();
+}
+
+QSGSpriteNode* QQuickAnimatedSprite::initNode()
+{
+    Q_D(QQuickAnimatedSprite);
+
+    if (!d->m_spriteEngine) {
         qmlInfo(this) << "No sprite engine...";
-        return 0;
-    } else if (m_spriteEngine->status() == QQuickPixmap::Null) {
-        m_spriteEngine->startAssemblingImage();
+        return nullptr;
+    } else if (d->m_spriteEngine->status() == QQuickPixmap::Null) {
+        d->m_spriteEngine->startAssemblingImage();
         update();//Schedule another update, where we will check again
-        return 0;
-    } else if (m_spriteEngine->status() == QQuickPixmap::Loading) {
+        return nullptr;
+    } else if (d->m_spriteEngine->status() == QQuickPixmap::Loading) {
         update();//Schedule another update, where we will check again
-        return 0;
+        return nullptr;
     }
 
-    QQuickAnimatedSpriteMaterial *material = new QQuickAnimatedSpriteMaterial();
-
-    QImage image = m_spriteEngine->assembledImage(); //Engine prints errors if there are any
+    QImage image = d->m_spriteEngine->assembledImage(d->sceneGraphRenderContext()->maxTextureSize()); //Engine prints errors if there are any
     if (image.isNull())
-        return 0;
-    m_sheetSize = QSizeF(image.size());
-    material->texture = window()->createTextureFromImage(image);
-    m_spriteEngine->start(0);
-    material->animT = 0;
-    material->animX1 = m_spriteEngine->spriteX() / m_sheetSize.width();
-    material->animY1 = m_spriteEngine->spriteY() / m_sheetSize.height();
-    material->animX2 = material->animX1;
-    material->animY2 = material->animY1;
-    material->animW = m_spriteEngine->spriteWidth() / m_sheetSize.width();
-    material->animH = m_spriteEngine->spriteHeight() / m_sheetSize.height();
-
-    int vCount = 4;
-    int iCount = 6;
-    QSGGeometry *g = new QSGGeometry(AnimatedSprite_AttributeSet, vCount, iCount);
-    g->setDrawingMode(QSGGeometry::DrawTriangles);
-
-    AnimatedSpriteVertices *p = (AnimatedSpriteVertices *) g->vertexData();
-
-    QRectF texRect = material->texture->normalizedTextureSubRect();
-
-    p->v1.tx = texRect.topLeft().x();
-    p->v1.ty = texRect.topLeft().y();
-
-    p->v2.tx = texRect.topRight().x();
-    p->v2.ty = texRect.topRight().y();
-
-    p->v3.tx = texRect.bottomLeft().x();
-    p->v3.ty = texRect.bottomLeft().y();
-
-    p->v4.tx = texRect.bottomRight().x();
-    p->v4.ty = texRect.bottomRight().y();
-
-    quint16 *indices = g->indexDataAsUShort();
-    indices[0] = 0;
-    indices[1] = 1;
-    indices[2] = 2;
-    indices[3] = 1;
-    indices[4] = 3;
-    indices[5] = 2;
-
-
-    QSGGeometryNode *node = new QSGGeometryNode();
-    node->setGeometry(g);
-    node->setMaterial(material);
-    node->setFlag(QSGGeometryNode::OwnsMaterial);
-    node->setFlag(QSGGeometryNode::OwnsGeometry);
-    sizeVertices(node);
+        return nullptr;
+
+    QSGSpriteNode *node = d->sceneGraphContext()->createSpriteNode();
+
+    d->m_sheetSize = QSize(image.size());
+    node->setTexture(window()->createTextureFromImage(image));
+    d->m_spriteEngine->start(0);
+    node->setTime(0.0f);
+    node->setSourceA(QPoint(d->m_spriteEngine->spriteX(), d->m_spriteEngine->spriteY()));
+    node->setSourceB(QPoint(d->m_spriteEngine->spriteX(), d->m_spriteEngine->spriteY()));
+    node->setSpriteSize(QSize(d->m_spriteEngine->spriteWidth(), d->m_spriteEngine->spriteHeight()));
+    node->setSheetSize(d->m_sheetSize);
+    node->setSize(QSizeF(width(), height()));
     return node;
 }
 
 void QQuickAnimatedSprite::reset()
 {
-    m_pleaseReset = true;
+    Q_D(QQuickAnimatedSprite);
+    d->m_pleaseReset = true;
     update();
 }
 
 QSGNode *QQuickAnimatedSprite::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
 {
-    if (m_pleaseReset) {
+    Q_D(QQuickAnimatedSprite);
+
+    if (d->m_pleaseReset) {
         delete oldNode;
 
-        oldNode = 0;
-        m_pleaseReset = false;
+        oldNode = nullptr;
+        d->m_pleaseReset = false;
     }
 
-    QSGGeometryNode *node = static_cast<QSGGeometryNode *>(oldNode);
+    QSGSpriteNode *node = static_cast<QSGSpriteNode *>(oldNode);
     if (!node)
-        node = buildNode();
+        node = initNode();
 
     if (node)
         prepareNextFrame(node);
 
-    if (m_running) {
-        if (!m_paused)
-            update();
-
-        if (node) {
-            node->markDirty(QSGNode::DirtyMaterial);
-        }
-    }
+    if (d->m_running && !d->m_paused)
+        update();
 
     return node;
 }
 
-void QQuickAnimatedSprite::prepareNextFrame(QSGGeometryNode *node)
+void QQuickAnimatedSprite::prepareNextFrame(QSGSpriteNode *node)
 {
-    int timeInt = m_timestamp.elapsed() + m_pauseOffset;
+    Q_D(QQuickAnimatedSprite);
+
+    int timeInt = d->m_timestamp.elapsed() + d->m_pauseOffset;
     qreal time =  timeInt / 1000.;
 
     int frameAt;
     qreal progress = 0.0;
-    int lastFrame = m_curFrame;
-    if (m_running && !m_paused) {
-        const int nColumns = int(m_sheetSize.width()) / m_spriteEngine->spriteWidth();
+    int lastFrame = d->m_curFrame;
+    if (d->m_running && !d->m_paused) {
+        const int nColumns = d->m_sheetSize.width() / d->m_spriteEngine->spriteWidth();
         //Advance State (keeps time for psuedostates)
-        m_spriteEngine->updateSprites(timeInt);
+        d->m_spriteEngine->updateSprites(timeInt);
 
         //Advance AnimatedSprite
-        qreal animT = m_spriteEngine->spriteStart()/1000.0;
-        const int frameCountInRow = m_spriteEngine->spriteFrames();
-        const qreal frameDuration = m_spriteEngine->spriteDuration()/frameCountInRow;
+        qreal animT = d->m_spriteEngine->spriteStart()/1000.0;
+        const int frameCountInRow = d->m_spriteEngine->spriteFrames();
+        const qreal frameDuration = d->m_spriteEngine->spriteDuration() / frameCountInRow;
         if (frameDuration > 0) {
             qreal frame = (time - animT)/(frameDuration / 1000.0);
-            bool lastLoop = m_loops > 0 && m_curLoop == m_loops-1;
+            bool lastLoop = d->m_loops > 0 && d->m_curLoop == d->m_loops-1;
             //don't visually interpolate for the last frame of the last loop
             const int max = lastLoop ? frameCountInRow - 1 : frameCountInRow;
             frame = qBound(qreal(0.0), frame, qreal(max));
             double intpart;
             progress = std::modf(frame,&intpart);
             frameAt = (int)intpart;
-            const int rowIndex = m_spriteEngine->spriteY()/frameHeight();
+            const int rowIndex = d->m_spriteEngine->spriteY()/frameHeight();
             const int newFrame = rowIndex * nColumns + frameAt;
-            if (m_curFrame > newFrame) //went around
-                m_curLoop++;
-            m_curFrame = newFrame;
+            if (d->m_curFrame > newFrame) //went around
+                d->m_curLoop++;
+            d->m_curFrame = newFrame;
         } else {
-            m_curFrame++;
-            if (m_curFrame >= m_spriteEngine->maxFrames()) {    // maxFrames: total number of frames including all rows
-                m_curFrame = 0;
-                m_curLoop++;
+            d->m_curFrame++;
+            if (d->m_curFrame >= d->m_spriteEngine->maxFrames()) {    // maxFrames: total number of frames including all rows
+                d->m_curFrame = 0;
+                d->m_curLoop++;
             }
-            frameAt = m_curFrame % nColumns;
+            frameAt = d->m_curFrame % nColumns;
             if (frameAt == 0)
-                m_spriteEngine->advance();
+                d->m_spriteEngine->advance();
             progress = 0;
         }
-        if (m_loops > 0 && m_curLoop >= m_loops) {
+        if (d->m_loops > 0 && d->m_curLoop >= d->m_loops) {
             frameAt = 0;
-            m_running = false;
+            d->m_running = false;
             emit runningChanged(false);
             update();
         }
     } else {
-        frameAt = m_curFrame;
+        frameAt = d->m_curFrame;
     }
-    if (m_curFrame != lastFrame) {
+    if (d->m_curFrame != lastFrame) {
         if (isCurrentFrameChangedConnected())
-            emit currentFrameChanged(m_curFrame);
+            emit currentFrameChanged(d->m_curFrame);
         update();
     }
 
-    qreal frameCount = m_spriteEngine->spriteFrames();
-    bool reverse = m_spriteEngine->sprite()->reverse();
+    qreal frameCount = d->m_spriteEngine->spriteFrames();
+    bool reverse = d->m_spriteEngine->sprite()->reverse();
     if (reverse)
         frameAt = (frameCount - 1) - frameAt;
 
-    qreal w = m_spriteEngine->spriteWidth() / m_sheetSize.width();
-    qreal h = m_spriteEngine->spriteHeight() / m_sheetSize.height();
-    qreal x1;
-    qreal y1;
-    if (m_paused) {
-        int spriteY = m_spriteEngine->spriteY();
+    int w = d->m_spriteEngine->spriteWidth();
+    int h = d->m_spriteEngine->spriteHeight();
+    int x1;
+    int y1;
+    if (d->m_paused) {
+        int spriteY = d->m_spriteEngine->spriteY();
         if (reverse) {
-            int rows = m_spriteEngine->maxFrames() * m_spriteEngine->spriteWidth() / m_sheetSize.width();
-            spriteY -= rows * m_spriteEngine->spriteHeight();
+            int rows = d->m_spriteEngine->maxFrames() * d->m_spriteEngine->spriteWidth() / d->m_sheetSize.width();
+            spriteY -= rows * d->m_spriteEngine->spriteHeight();
             frameAt = (frameCount - 1) - frameAt;
         }
 
-        int position = frameAt * m_spriteEngine->spriteWidth() + m_spriteEngine->spriteX();
-        int row = position / m_sheetSize.width();
+        int position = frameAt * d->m_spriteEngine->spriteWidth() + d->m_spriteEngine->spriteX();
+        int row = position / d->m_sheetSize.width();
 
-        x1 = (position - (row * m_sheetSize.width())) / m_sheetSize.width();
-        y1 = (row * m_spriteEngine->spriteHeight() + spriteY) / m_sheetSize.height();
+        x1 = (position - (row * d->m_sheetSize.width()));
+        y1 = (row * d->m_spriteEngine->spriteHeight() + spriteY);
     } else {
-        x1 = m_spriteEngine->spriteX() / m_sheetSize.width() + frameAt * w;
-        y1 = m_spriteEngine->spriteY() / m_sheetSize.height();
+        x1 = d->m_spriteEngine->spriteX() + frameAt * w;
+        y1 = d->m_spriteEngine->spriteY();
     }
 
     //### hard-coded 0/1 work because we are the only
     // images in the sprite sheet (without this we cannot assume
     // where in the sheet we begin/end).
-    qreal x2;
-    qreal y2;
+    int x2;
+    int y2;
     if (reverse) {
         if (frameAt > 0) {
             x2 = x1 - w;
@@ -682,9 +778,9 @@ void QQuickAnimatedSprite::prepareNextFrame(QSGGeometryNode *node)
             y2 = y1 - h;
             if (y2 < 0.0) {
                 //the last row may not fill the entire width
-                int maxRowFrames = m_sheetSize.width() / m_spriteEngine->spriteWidth();
-                if (m_spriteEngine->maxFrames() % maxRowFrames)
-                    x2 = ((m_spriteEngine->maxFrames() % maxRowFrames) - 1) * w;
+                int maxRowFrames = d->m_sheetSize.width() / d->m_spriteEngine->spriteWidth();
+                if (d->m_spriteEngine->maxFrames() % maxRowFrames)
+                    x2 = ((d->m_spriteEngine->maxFrames() % maxRowFrames) - 1) * w;
 
                 y2 = 1.0 - h;
             }
@@ -701,15 +797,13 @@ void QQuickAnimatedSprite::prepareNextFrame(QSGGeometryNode *node)
         }
     }
 
-    QQuickAnimatedSpriteMaterial *material = static_cast<QQuickAnimatedSpriteMaterial *>(node->material());
-    material->animX1 = x1;
-    material->animY1 = y1;
-    material->animX2 = x2;
-    material->animY2 = y2;
-    material->animW = w;
-    material->animH = h;
-    material->animT = m_interpolate ? progress : 0.0;
-    material->texture->setFiltering(smooth() ? QSGTexture::Linear : QSGTexture::Nearest);
+    node->setSourceA(QPoint(x1, y1));
+    node->setSourceB(QPoint(x2, y2));
+    node->setSpriteSize(QSize(w, h));
+    node->setTime(d->m_interpolate ? progress : 0.0);
+    node->setSize(QSizeF(width(), height()));
+    node->setFiltering(smooth() ? QSGTexture::Linear : QSGTexture::Nearest);
+    node->update();
 }
 
 QT_END_NAMESPACE