ImageRenderer.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 IMAGERENDERER_H
#define IMAGERENDERER_H

#include <memory>
#include "Graphic.h"
#include "renderer/RenderNode.h"
#include "renderer/Texture.h"

class Actor;
class Body;
class QSGTexture;

class ImageRenderer : public Graphic, public RenderableInterface {
    Q_OBJECT

    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
    Q_PROPERTY(float sizeScale READ getSizeScale WRITE setSizeScale NOTIFY sizeScaleChanged)
    Q_PROPERTY(float aspectRatio READ getAspectRatio WRITE setAspectRatio NOTIFY aspectRatioChanged)
    Q_PROPERTY(QString source READ getSource WRITE setSource NOTIFY sourceChanged)
    Q_PROPERTY(bool cacheRenderParams READ getCacheRenderParams WRITE setCacheRenderParams
            NOTIFY cacheRenderParamsChanged)
    Q_PROPERTY(bool cullingControlsBodyActive READ getCullingControlsBodyActive
            WRITE setCullingControlsBodyActive NOTIFY cullingControlsBodyActiveChanged)
public:
    explicit ImageRenderer(QQuickItem* parent = nullptr);
    virtual ~ImageRenderer();

    bool isVisible() const { return mVisible; }
    void setVisible(bool value);
    float getSizeScale() const { return mSizeScale; }
    void setSizeScale(float value);
    float getAspectRatio() const { return mAspectRatio; }
    void setAspectRatio(float value);
    const QString& getSource() const { return mSource; }
    void setSource(const QString& value);
    bool getCacheRenderParams() const { return mCacheRenderParams; }
    void setCacheRenderParams(bool value);
    bool getCullingControlsBodyActive() const { return mCullingControlsBodyActive; }
    void setCullingControlsBodyActive(bool value);

    bool isCulled() const { return mCulled; }

signals:
    void visibleChanged();
    void sizeScaleChanged();
    void aspectRatioChanged();
    void sourceChanged();
    void cacheRenderParamsChanged();
    void cullingControlsBodyActiveChanged();

protected:
    virtual void synchronizeForRendering(RenderList* renderList) override;
    virtual void render(RenderNode *node) override;
    virtual void componentComplete() override;
    virtual void computeDestTextureSize(QSizeF* textureSize) const;
    virtual void computeSourceTextureRect(QRectF* textureSubRect) const;
    void markSourceTextureRectDirty();

private:
    void reloadTexture();
    void updateLocalBoundingBox();
    void setCulled(bool value);
    void updateVisibility();
    void checkBody();

    bool mVisible = true;
    bool mWasVisible = true;
    bool mCacheRenderParams = false;
    bool mCullingControlsBodyActive = false;
    Actor* mActor = nullptr;
    Body* mBody = nullptr;
    float mSizeScale = 1.0f;
    float mAspectRatio = 1.0f;
    QRectF mLocalBoundingBox;
    float mTextureAspectRatio = 1.0f;
    QString mSource;
    bool mCulled = false;
    bool mSourceDirty = false;
    bool mTransformDirty = true;
    TexturePtr mTexture;
    bool mHasCachedRenderParams = false;
    RenderParameters mCachedRenderParams;
    // Double buffered data for threaded rendering.
    RenderNode mRenderNode;
    TexturePtr mRenderTexture;
    QPointF mRenderPos;
    QRectF mRenderTextureSubRect;
    QSizeF mRenderSize;
    float mRenderRotation = 0.0f;
    float mRenderOpacity = 1.0f;
};
Q_DECLARE_METATYPE(ImageRenderer*)

#endif // IMAGERENDERER_H