AnimatedImageRenderer.h

/*
 * Copyright (C) 2014 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ANIMATEDIMAGERENDERER_H
#define ANIMATEDIMAGERENDERER_H

#include "ImageRenderer.h"

// TODO: Supporting grid layouts for texture sheets would allow larger animations to fit into the
// texture sheets within the size limitations of more hardware.
class AnimatedImageRenderer : public ImageRenderer {
    Q_OBJECT
    Q_PROPERTY(bool paused READ isPaused WRITE setPaused NOTIFY pausedChanged)
    Q_PROPERTY(bool looped READ isLooped WRITE setLooped NOTIFY loopedChanged)
    Q_PROPERTY(bool useGameTime READ isUseGameTime WRITE setUseGameTime NOTIFY useGameTimeChanged)
    Q_PROPERTY(float frameDelay READ getFrameDelay WRITE setFrameDelay NOTIFY frameDelayChanged)
    Q_PROPERTY(int frameCount READ getFrameCount WRITE setFrameCount NOTIFY frameCountChanged)
    Q_PROPERTY(int currentFrame READ getCurrentFrame WRITE setCurrentFrame)
    Q_PROPERTY(float currentPosition READ getCurrentPosition WRITE setCurrentPosition)
    Q_PROPERTY(bool pauseWhenHidden READ getPauseWhenHidden WRITE setPauseWhenHidden
            NOTIFY pauseWhenHiddenChanged)

public:
    explicit AnimatedImageRenderer(QQuickItem* parent = nullptr);

    bool isPaused() const { return mPaused; }
    void setPaused(bool value);
    bool isLooped() const { return mLooped; }
    void setLooped(bool value);
    bool isUseGameTime() const { return mUseGameTime; }
    void setUseGameTime(bool value);
    float getFrameDelay() const { return mFrameDelay; }
    void setFrameDelay(float value);
    int getFrameCount() const { return mFrameCount; }
    void setFrameCount(int value);
    int getCurrentFrame() const { return mCurrentFrame; }
    void setCurrentFrame(int value);
    float getCurrentPosition() const { return mCurrentPosition; }
    void setCurrentPosition(float value);
    bool getPauseWhenHidden() const { return mPauseWhenHidden; }
    void setPauseWhenHidden(bool value);

signals:
    void pausedChanged();
    void loopedChanged();
    void useGameTimeChanged();
    void frameDelayChanged();
    void frameCountChanged();
    void animationReachedEnd();
    void pauseWhenHiddenChanged();

protected:
    virtual void synchronizeForRendering(RenderList* renderList) override;
    virtual void computeDestTextureSize(QSizeF* textureSize) const override;
    virtual void computeSourceTextureRect(QRectF* textureSubRect) const override;

private:
    void moveCurrentFrame(int frame);
    void updateAnimation();

    bool mPaused = false;
    bool mLooped = true;
    bool mUseGameTime = true;
    bool mPauseWhenHidden = false;
    bool mAtEnd = false;
    float mFrameDelay = 0.0f;
    int mFrameCount = 0;
    float mNormalizedInvFrameCount = 1.0f;
    float mFrameTimer = 0.0f;
    int mCurrentFrame = 0;
    float mCurrentPosition = 0.0f;
};

#endif // ANIMATEDIMAGERENDERER_H