Revision control
Copy as Markdown
// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <QtLottie/private/qlottierasterrenderer_p.h>
#include <QPainter>
#include <QRectF>
#include <QBrush>
#include <QTransform>
#include <QGradient>
#include <QPointer>
#include <QtLottie/private/qlottieshape_p.h>
#include <QtLottie/private/qlottiefill_p.h>
#include <QtLottie/private/qlottiegfill_p.h>
#include <QtLottie/private/qlottieimage_p.h>
#include <QtLottie/private/qlottiebasictransform_p.h>
#include <QtLottie/private/qlottieshapetransform_p.h>
#include <QtLottie/private/qlottierect_p.h>
#include <QtLottie/private/qlottieellipse_p.h>
#include <QtLottie/private/qlottiepolystar_p.h>
#include <QtLottie/private/qlottieround_p.h>
#include <QtLottie/private/qlottiefreeformshape_p.h>
#include <QtLottie/private/qlottietrimpath_p.h>
#include <QtLottie/private/qlottiefilleffect_p.h>
#include <QtLottie/private/qlottierepeater_p.h>
#include <QtLottie/private/qlottieflatlayers_p.h>
#include <QtLottie/private/qlottieprecomposition_p.h>
#include <QtLottie/private/qlottietextlayer_p.h>
QT_BEGIN_NAMESPACE
QLottieRasterRenderer::QLottieRasterRenderer(QPainter *painter)
: m_painter(painter)
{
m_painter->setPen(QPen(Qt::NoPen));
m_unitedPath.setCachingEnabled(true);
}
void QLottieRasterRenderer::saveState()
{
qCDebug(lcLottieQtLottieRender) << "Save painter state";
m_painter->save();
saveTrimmingState();
m_pathStack.push_back(m_unitedPath);
m_fillEffectStack.push_back(m_fillEffect);
m_inverseFillTransformStack.push(m_inverseFillTransform);
m_unitedPath.clear();
}
void QLottieRasterRenderer::restoreState()
{
qCDebug(lcLottieQtLottieRender) << "Restore painter state";
m_painter->restore();
restoreTrimmingState();
m_unitedPath = m_pathStack.pop();
m_renderPath.setFillRule(m_unitedPath.fillRule());
m_clipPath.setFillRule(m_unitedPath.fillRule());
m_fillEffect = m_fillEffectStack.pop();
m_inverseFillTransform = m_inverseFillTransformStack.pop();
}
void QLottieRasterRenderer::render(const QLottiePrecomposition &precomp)
{
Q_UNUSED(precomp);
// Nothing to do: no graphical properties at this level
}
void QLottieRasterRenderer::render(const QLottieLayer &layer)
{
qCDebug(lcLottieQtLottieRender) << "Layer:" << layer.name()
<< "is matte:" << layer.isMatteLayer()
<< "using matte:" << layer.isUsingMatteLayer();
if (layer.isMatteLayer())
m_buildingClipRegion = true;
else if (!m_clipPath.isEmpty()) {
QTransform inv = m_painter->transform().inverted();
if (layer.matteMode() == QLottieLayer::Alpha)
m_painter->setClipPath(inv.map(m_clipPath));
else if (layer.matteMode() == QLottieLayer::InvertedAlpha) {
QPainterPath screen;
screen.addRect(0, 0, m_painter->device()->width(),
m_painter->device()->height());
m_painter->setClipPath(inv.map(screen - m_clipPath));
}
else {
// Clipping is not applied to paths that have
// not setting clipping parameters
m_painter->setClipping(false);
}
m_buildingClipRegion = false;
m_clipPath = QPainterPath();
}
}
void QLottieRasterRenderer::render(const QLottieSolidLayer &layer)
{
render(static_cast<const QLottieLayer &>(layer));
m_painter->fillRect(QRect(QPoint(), layer.layerSize()), layer.color());
}
void QLottieRasterRenderer::render(const QLottieTextLayer &layer)
{
render(static_cast<const QLottieLayer &>(layer));
for (const QPainterPath &path : layer.buildGlyphPaths())
m_painter->fillPath(path, QBrush(layer.textDocument().fillColor));
}
void QLottieRasterRenderer::render(const QLottieRect &rect)
{
qCDebug(lcLottieQtLottieRender) << "Rect:" << rect.name()
<< rect.position() << rect.size();
m_renderPath.addPath(rect.path());
}
void QLottieRasterRenderer::render(const QLottieEllipse &ellipse)
{
qCDebug(lcLottieQtLottieRender) << "Ellipse:" << ellipse.name()
<< ellipse.position()
<< ellipse.size();
m_renderPath.addPath(ellipse.path());
}
void QLottieRasterRenderer::render(const QLottiePolyStar &star)
{
qCDebug(lcLottieQtLottieRender) << "PolyStar:" << star.name()
<< star.position() << star.pointCount()
<< star.outerRadius() << star.innerRadius();
m_renderPath.addPath(star.path());
}
void QLottieRasterRenderer::render(const QLottieImage &image)
{
const QImage img = image.image();
if (img.isNull())
return;
m_painter->save();
for (int i = 0; i < m_repeatCount; i++) {
qCDebug(lcLottieQtLottieRender) << "Image" << image.name();
applyRepeaterTransform(i);
m_painter->drawImage(QRectF(QPointF(), image.size()), img);
}
m_painter->restore();
}
void QLottieRasterRenderer::render(const QLottieRound &round)
{
Q_UNUSED(round);
// Rounded Corners modifier, not implemented
}
void QLottieRasterRenderer::render(const QLottieFill &fill)
{
qCDebug(lcLottieQtLottieRender) << "Fill:" <<fill.name()
<< fill.color();
if (m_fillEffect)
return;
float alpha = fill.color().alphaF() * fill.opacity() / 100.0f;
QColor color = fill.color();
color.setAlphaF(alpha);
m_painter->setBrush(color);
m_renderPath.setFillRule(fill.fillRule());
m_unitedPath.setFillRule(fill.fillRule());
m_clipPath.setFillRule(fill.fillRule());
}
void QLottieRasterRenderer::render(const QLottieGFill &gradient)
{
qCDebug(lcLottieQtLottieRender) << "Gradient:" << gradient.name()
<< gradient.value();
if (m_fillEffect)
return;
m_inverseFillTransform = QTransform();
if (gradient.value())
m_painter->setBrush(*gradient.value());
else
qCWarning(lcLottieQtLottieRender) << "Gradient:"
<< gradient.name()
<< "Cannot draw gradient fill";
m_renderPath.setFillRule(gradient.fillRule());
m_unitedPath.setFillRule(gradient.fillRule());
m_clipPath.setFillRule(gradient.fillRule());
}
void QLottieRasterRenderer::render(const QLottieStroke &stroke)
{
qCDebug(lcLottieQtLottieRender) << "Stroke:" << stroke.name()
<< stroke.pen() << stroke.pen().miterLimit();
if (m_fillEffect)
return;
m_painter->setPen(stroke.pen());
}
void QLottieRasterRenderer::render(const QLottieBasicTransform &transform)
{
QTransform t = m_painter->transform();
applyTransform(&t, transform);
m_painter->setTransform(t);
if (transform.hasLinkedLayerTransform())
m_painter->setOpacity(1.0);
m_painter->setOpacity(m_painter->opacity() * transform.opacity());
qCDebug(lcLottieQtLottieRender) << transform.name()
<< m_painter->transform()
<< "opacity:" << m_painter->opacity();
}
void QLottieRasterRenderer::render(const QLottieShapeTransform &transform)
{
qCDebug(lcLottieQtLottieRender) << "Shape transform:" << transform.name()
<< "of" << transform.parent()->name();
QTransform t = m_painter->transform();
applyTransform(&t, transform, true);
m_painter->setTransform(t);
m_painter->setOpacity(m_painter->opacity() * transform.opacity());
if (m_painter->brush().gradient())
applyTransform(&m_inverseFillTransform, transform, true);
qCDebug(lcLottieQtLottieRender) << transform.name()
<< m_painter->transform()
<< m_painter->opacity();
}
void QLottieRasterRenderer::render(const QLottieFreeFormShape &shape)
{
qCDebug(lcLottieQtLottieRender) << "Render shape:"
<< shape.name() << "of"
<< shape.parent()->name();
m_renderPath.addPath(shape.path());
}
void QLottieRasterRenderer::render(const QLottieTrimPath &trimPath)
{
// TODO: Move "Sequential" trimming to the prerendering thread
// Now it is done in the GUI thread
m_painter->save();
for (int i = 0; i < m_repeatCount; i ++) {
qCDebug(lcLottieQtLottieRender) << "Render shape:"
<< trimPath.name() << "of"
<< trimPath.parent()->name();
applyRepeaterTransform(i);
if (!trimPath.isParallel() && !qFuzzyCompare(qreal(0.0), m_unitedPath.length())) {
qCDebug(lcLottieQtLottieRender) << "Render trim path in the GUI thread";
QPainterPath tr = trimPath.trim(m_unitedPath);
// Do not use the applied transform, as the transform
// is already included in m_unitedPath
m_painter->setTransform(QTransform());
m_painter->drawPath(tr);
}
}
m_painter->restore();
}
void QLottieRasterRenderer::render(const QLottieFillEffect &effect)
{
qCDebug(lcLottieQtLottieRender) << "Fill:" <<effect.name()
<< effect.color();
m_fillEffect = &effect;
m_painter->setBrush(m_fillEffect->color());
m_painter->setOpacity(m_painter->opacity() * m_fillEffect->opacity());
}
void QLottieRasterRenderer::render(const QLottieRepeater &repeater)
{
qCDebug(lcLottieQtLottieRender) << "Repeater:" <<repeater.name()
<< "count:" << repeater.copies();
if (m_repeaterTransform) {
qCWarning(lcLottieQtLottieRender) << "Only one Repeater can be active at a time!";
return;
}
m_repeatCount = repeater.copies();
m_repeatOffset = repeater.offset();
// Can store pointer to transform, although the transform
// is managed by another thread. The object will be available
// until the frame has been rendered
m_repeaterTransform = &repeater.transform();
m_painter->translate(m_repeatOffset * m_repeaterTransform->position().x(),
m_repeatOffset * m_repeaterTransform->position().y());
}
void QLottieRasterRenderer::renderPathElements(const QList<QLottieBase *> &pathElements)
{
qCDebug(lcLottieQtLottieRender) << "PathElements: count:" << pathElements.size();
m_painter->save();
m_renderPath.clear();
for (const QLottieBase *element : pathElements)
element->render(*this); // Accumulates element paths in m_renderPath
for (int i = 0; i < m_repeatCount; i++) {
if (i > 0)
qCDebug(lcLottieQtLottieRender) << "Render repeated, combined path, iteration" << i + 1;
applyRepeaterTransform(i);
if (trimmingState() == QLottieRenderer::Sequential) {
QTransform t = m_painter->transform();
QPainterPath tp = t.map(m_renderPath);
tp.addPath(m_unitedPath);
m_unitedPath = tp;
} else if (m_buildingClipRegion) {
QTransform t = m_painter->transform();
QPainterPath tp = t.map(m_renderPath);
tp.addPath(m_clipPath);
m_clipPath = tp;
} else {
if (!m_inverseFillTransform.isIdentity() && m_painter->brush().gradient()) {
bool fill_ok = false;
const QTransform fillTransform = m_inverseFillTransform.inverted(&fill_ok);
if (fill_ok) {
QBrush adjustedBrush = m_painter->brush();
adjustedBrush.setTransform(fillTransform);
m_painter->save();
m_painter->setBrush(adjustedBrush);
m_painter->drawPath(m_renderPath);
m_painter->restore();
} else {
m_painter->drawPath(m_renderPath);
}
} else {
m_painter->drawPath(m_renderPath);
}
}
}
m_painter->restore();
}
void QLottieRasterRenderer::applyRepeaterTransform(int instance)
{
if (!m_repeaterTransform || instance == 0)
return;
QTransform t = m_painter->transform();
QPointF anchors = -m_repeaterTransform->anchorPoint();
QPointF position = m_repeaterTransform->position();
QPointF anchoredCenter = anchors + position;
t.translate(anchoredCenter.x(), anchoredCenter.y());
t.rotate(m_repeaterTransform->rotation());
t.scale(m_repeaterTransform->scale().x(),
m_repeaterTransform->scale().y());
m_painter->setTransform(t);
qreal o =m_repeaterTransform->opacityAtInstance(instance);
m_painter->setOpacity(m_painter->opacity() * o);
}
QT_END_NAMESPACE