mirror of
https://github.com/thorvg/thorvg.git
synced 2025-06-13 19:44:28 +00:00
f757eb6a71
This change makes it possible to use Lottie animations that contain images from embedded/external resources.
460 lines
No EOL
16 KiB
C++
460 lines
No EOL
16 KiB
C++
/*
|
|
* Copyright (c) 2023 the ThorVG project. All rights reserved.
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "tvgMath.h"
|
|
#include "tvgShapeImpl.h"
|
|
#include "tvgLottieModel.h"
|
|
#include "tvgLottieBuilder.h"
|
|
|
|
|
|
/************************************************************************/
|
|
/* Internal Class Implementation */
|
|
/************************************************************************/
|
|
|
|
static void _updateChildren(LottieGroup* parent, int32_t frameNo, Shape* baseShape, bool reset);
|
|
static void _updateLayer(LottieLayer* root, LottieLayer* layer, int32_t frameNo, bool reset);
|
|
static bool _buildPrecomp(LottieComposition* comp, LottieGroup* parent);
|
|
|
|
static bool _invisible(LottieGroup* group, int32_t frameNo)
|
|
{
|
|
auto opacity = group->opacity(frameNo);
|
|
if (group->scene) group->scene->opacity(opacity);
|
|
if (opacity == 0) return true;
|
|
else return false;
|
|
}
|
|
|
|
|
|
static bool _updateTransform(LottieTransform* transform, int32_t frameNo, bool autoOrient, Matrix& matrix, uint8_t& opacity)
|
|
{
|
|
if (!transform) return false;
|
|
|
|
mathIdentity(&matrix);
|
|
|
|
if (transform->coords) {
|
|
mathTranslate(&matrix, transform->coords->x(frameNo), transform->coords->y(frameNo));
|
|
} else {
|
|
auto position = transform->position(frameNo);
|
|
mathTranslate(&matrix, position.x, position.y);
|
|
}
|
|
|
|
auto scale = transform->scale(frameNo);
|
|
mathScale(&matrix, scale.x * 0.01f, scale.y * 0.01f);
|
|
|
|
auto angle = 0.0f;
|
|
if (autoOrient) angle = transform->position.angle(frameNo);
|
|
mathRotate(&matrix, transform->rotation(frameNo) + angle);
|
|
|
|
//Lottie specific anchor transform.
|
|
auto anchor = transform->anchor(frameNo);
|
|
matrix.e13 -= (anchor.x * matrix.e11 + anchor.y * matrix.e12);
|
|
matrix.e23 -= (anchor.x * matrix.e21 + anchor.y * matrix.e22);
|
|
|
|
opacity = transform->opacity(frameNo);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static void _updateTransform(LottieLayer* layer, int32_t frameNo)
|
|
{
|
|
if (!layer || layer->cache.frameNo == frameNo) return;
|
|
|
|
auto transform = layer->transform;
|
|
auto parent = layer->parent;
|
|
|
|
if (parent) _updateTransform(parent, parent->remap(frameNo));
|
|
|
|
auto& matrix = layer->cache.matrix;
|
|
uint8_t opacity;
|
|
_updateTransform(transform, layer->remap(frameNo), layer->autoOrient, matrix, opacity);
|
|
|
|
if (parent) {
|
|
layer->cache.matrix = mathMultiply(&parent->cache.matrix, &matrix);
|
|
layer->cache.opacity = MULTIPLY(opacity, parent->cache.opacity);
|
|
}
|
|
layer->cache.opacity = opacity;
|
|
layer->cache.frameNo = frameNo;
|
|
}
|
|
|
|
|
|
static Shape* _updateTransform(Paint* paint, LottieTransform* transform, int32_t frameNo)
|
|
{
|
|
if (!transform) return nullptr;
|
|
|
|
Matrix matrix;
|
|
uint8_t opacity;
|
|
if (!_updateTransform(transform, frameNo, false, matrix, opacity)) return nullptr;
|
|
|
|
auto pmatrix = paint->transform();
|
|
paint->transform(mathMultiply(&pmatrix, &matrix));
|
|
paint->opacity(opacity);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateGroup(LottieGroup* parent, LottieGroup* group, int32_t frameNo, Shape* baseShape, bool reset)
|
|
{
|
|
//Prepare render data
|
|
if (reset || !group->scene) {
|
|
auto scene = Scene::gen();
|
|
group->scene = scene.get();
|
|
static_cast<Scene*>(parent->scene)->push(std::move(scene));
|
|
} else {
|
|
static_cast<Scene*>(group->scene)->clear();
|
|
reset = true;
|
|
}
|
|
|
|
if (_invisible(group, frameNo)) return nullptr;
|
|
|
|
if (group->transform) {
|
|
Matrix matrix;
|
|
uint8_t opacity;
|
|
_updateTransform(group->transform, frameNo, false, matrix, opacity);
|
|
group->scene->transform(matrix);
|
|
group->scene->opacity(opacity);
|
|
}
|
|
_updateChildren(group, frameNo, baseShape, reset);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateFill(LottieSolidFill* fill, int32_t frameNo, Shape* baseShape)
|
|
{
|
|
if (fill->disabled) return nullptr;
|
|
auto color = fill->color(frameNo);
|
|
baseShape->fill(color.rgb[0], color.rgb[1], color.rgb[2], fill->opacity(frameNo));
|
|
baseShape->fill(fill->rule);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateStroke(LottieSolidStroke* stroke, int32_t frameNo, Shape* baseShape)
|
|
{
|
|
if (stroke->disabled) return nullptr;
|
|
baseShape->stroke(stroke->width(frameNo));
|
|
auto color = stroke->color(frameNo);
|
|
baseShape->stroke(color.rgb[0], color.rgb[1], color.rgb[2], stroke->opacity(frameNo));
|
|
baseShape->stroke(stroke->cap);
|
|
baseShape->stroke(stroke->join);
|
|
baseShape->strokeMiterlimit(stroke->miterLimit);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateFill(LottieGradientFill* fill, int32_t frameNo, Shape* baseShape)
|
|
{
|
|
baseShape->opacity(fill->opacity(frameNo));
|
|
//TODO: reuse the fill instance?
|
|
baseShape->fill(unique_ptr<Fill>(fill->fill(frameNo)));
|
|
baseShape->fill(fill->rule);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateStroke(LottieGradientStroke* stroke, int32_t frameNo, Shape* baseShape)
|
|
{
|
|
baseShape->opacity(stroke->opacity(frameNo));
|
|
baseShape->stroke(stroke->width(frameNo));
|
|
baseShape->stroke(unique_ptr<Fill>(stroke->fill(frameNo)));
|
|
baseShape->stroke(stroke->cap);
|
|
baseShape->stroke(stroke->join);
|
|
baseShape->strokeMiterlimit(stroke->miterLimit);
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
static Shape* _updateRect(LottieGroup* parent, LottieRect* rect, int32_t frameNo, Shape* baseShape, Shape* mergingShape)
|
|
{
|
|
auto position = rect->position(frameNo);
|
|
auto size = rect->size(frameNo);
|
|
auto roundness = rect->roundness(frameNo);
|
|
if (roundness != 0) {
|
|
if (roundness > size.x * 0.5f) roundness = size.x * 0.5f;
|
|
if (roundness > size.y * 0.5f) roundness = size.y * 0.5f;
|
|
}
|
|
if (!mergingShape) {
|
|
auto newShape = cast<Shape>(baseShape->duplicate());
|
|
mergingShape = newShape.get();
|
|
static_cast<Scene*>(parent->scene)->push(std::move(newShape));
|
|
}
|
|
mergingShape->appendRect(position.x - size.x * 0.5f, position.y - size.y * 0.5f, size.x, size.y, roundness, roundness);
|
|
return mergingShape;
|
|
}
|
|
|
|
|
|
static Shape* _updateEllipse(LottieGroup* parent, LottieEllipse* ellipse, int32_t frameNo, Shape* baseShape, Shape* mergingShape)
|
|
{
|
|
auto position = ellipse->position(frameNo);
|
|
auto size = ellipse->size(frameNo);
|
|
if (!mergingShape) {
|
|
auto newShape = cast<Shape>(baseShape->duplicate());
|
|
mergingShape = newShape.get();
|
|
static_cast<Scene*>(parent->scene)->push(std::move(newShape));
|
|
}
|
|
mergingShape->appendCircle(position.x, position.y, size.x * 0.5f, size.y * 0.5f);
|
|
return mergingShape;
|
|
}
|
|
|
|
|
|
static Shape* _updatePath(LottieGroup* parent, LottiePath* path, int32_t frameNo, Shape* baseShape, Shape* mergingShape)
|
|
{
|
|
if (!mergingShape) {
|
|
auto newShape = cast<Shape>(baseShape->duplicate());
|
|
mergingShape = newShape.get();
|
|
static_cast<Scene*>(parent->scene)->push(std::move(newShape));
|
|
}
|
|
if (path->pathset(frameNo, mergingShape->pImpl->rs.path.cmds, mergingShape->pImpl->rs.path.pts)) {
|
|
mergingShape->pImpl->update(RenderUpdateFlag::Path);
|
|
}
|
|
return mergingShape;
|
|
}
|
|
|
|
|
|
static void _updateImage(LottieGroup* parent, LottieImage* image, int32_t frameNo, Shape* baseShape)
|
|
{
|
|
auto picture = Picture::gen();
|
|
|
|
if (image->size > 0) picture->load((const char*)image->b64Data, image->size, image->mimeType, false);
|
|
else picture->load(image->path);
|
|
|
|
if (baseShape) {
|
|
picture->transform(baseShape->transform());
|
|
picture->opacity(baseShape->opacity());
|
|
}
|
|
parent->scene->push(std::move(picture));
|
|
}
|
|
|
|
static void _updateChildren(LottieGroup* parent, int32_t frameNo, Shape* baseShape, bool reset)
|
|
{
|
|
if (parent->children.empty()) return;
|
|
|
|
//inherits the parent's shape properties.
|
|
baseShape = baseShape ? static_cast<Shape*>(baseShape->duplicate()) : Shape::gen().release();
|
|
|
|
//merge shapes if they are continuously appended?
|
|
Shape* mergingShape = nullptr;
|
|
|
|
//Draw the parent shapes first
|
|
for (auto child = parent->children.end() - 1; child >= parent->children.data; --child) {
|
|
switch ((*child)->type) {
|
|
case LottieObject::Group: {
|
|
mergingShape = _updateGroup(parent, static_cast<LottieGroup*>(*child), frameNo, baseShape, reset);
|
|
break;
|
|
}
|
|
case LottieObject::Transform: {
|
|
mergingShape = _updateTransform(baseShape, static_cast<LottieTransform*>(*child), frameNo);
|
|
break;
|
|
}
|
|
case LottieObject::SolidFill: {
|
|
mergingShape = _updateFill(static_cast<LottieSolidFill*>(*child), frameNo, baseShape);
|
|
break;
|
|
}
|
|
case LottieObject::SolidStroke: {
|
|
mergingShape = _updateStroke(static_cast<LottieSolidStroke*>(*child), frameNo, baseShape);
|
|
break;
|
|
}
|
|
case LottieObject::GradientFill: {
|
|
mergingShape = _updateFill(static_cast<LottieGradientFill*>(*child), frameNo, baseShape);
|
|
break;
|
|
}
|
|
case LottieObject::GradientStroke: {
|
|
mergingShape = _updateStroke(static_cast<LottieGradientStroke*>(*child), frameNo, baseShape);
|
|
break;
|
|
}
|
|
case LottieObject::Rect: {
|
|
mergingShape = _updateRect(parent, static_cast<LottieRect*>(*child), frameNo, baseShape, mergingShape);
|
|
break;
|
|
}
|
|
case LottieObject::Ellipse: {
|
|
mergingShape = _updateEllipse(parent, static_cast<LottieEllipse*>(*child), frameNo, baseShape, mergingShape);
|
|
break;
|
|
}
|
|
case LottieObject::Path: {
|
|
mergingShape = _updatePath(parent, static_cast<LottiePath*>(*child), frameNo, baseShape, mergingShape);
|
|
break;
|
|
}
|
|
case LottieObject::Polystar: {
|
|
TVGERR("LOTTIE", "TODO: update Polystar");
|
|
break;
|
|
}
|
|
case LottieObject::RoundedCorner: {
|
|
TVGERR("LOTTIE", "TODO: update Round Corner");
|
|
break;
|
|
}
|
|
case LottieObject::Image: {
|
|
_updateImage(parent, static_cast<LottieImage*>(*child), frameNo, baseShape);
|
|
break;
|
|
}
|
|
default: {
|
|
TVGERR("LOTTIE", "TODO: Missing type??");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
delete(baseShape);
|
|
}
|
|
|
|
static void _updatePrecomp(LottieLayer* precomp, int32_t frameNo, bool reset)
|
|
{
|
|
//TODO: skip if the layer is static.
|
|
for (auto child = precomp->children.end() - 1; child >= precomp->children.data; --child) {
|
|
_updateLayer(precomp, static_cast<LottieLayer*>(*child), frameNo, reset);
|
|
}
|
|
}
|
|
|
|
|
|
static void _updateLayer(LottieLayer* root, LottieLayer* layer, int32_t frameNo, bool reset)
|
|
{
|
|
//Prepare render data
|
|
if (reset || !layer->scene) {
|
|
auto scene = Scene::gen();
|
|
layer->scene = scene.get();
|
|
static_cast<Scene*>(root->scene)->push(std::move(scene));
|
|
}
|
|
//else if (layer->statical) return; //FIXME: rendering is skipped due to no update?
|
|
else {
|
|
static_cast<Scene*>(layer->scene)->clear();
|
|
reset = true;
|
|
}
|
|
|
|
if (_invisible(layer, frameNo)) return;
|
|
|
|
_updateTransform(layer, frameNo);
|
|
|
|
layer->scene->transform(layer->cache.matrix);
|
|
|
|
//FIXME: Ignore opacity when Null layer?
|
|
if (layer->type != LottieLayer::Null) {
|
|
layer->scene->opacity(layer->cache.opacity);
|
|
}
|
|
|
|
frameNo = layer->remap(frameNo);
|
|
|
|
switch (layer->type) {
|
|
case LottieLayer::Precomp: {
|
|
_updatePrecomp(layer, frameNo, reset);
|
|
break;
|
|
}
|
|
case LottieLayer::Solid: {
|
|
TVGERR("LOTTIE", "TODO: update Solid Layer");
|
|
break;
|
|
}
|
|
default: {
|
|
_updateChildren(layer, frameNo, nullptr, reset);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void _buildReference(LottieComposition* comp, LottieLayer* layer)
|
|
{
|
|
for (auto asset = comp->assets.data; asset < comp->assets.end(); ++asset) {
|
|
if (strcmp(layer->refId, (*asset)->name)) continue;
|
|
auto assetLayer = static_cast<LottieLayer*>(*asset);
|
|
if (layer->type == LottieLayer::Precomp) {
|
|
if (_buildPrecomp(comp, assetLayer)) {
|
|
layer->children = assetLayer->children;
|
|
}
|
|
} else if (layer->type == LottieLayer::Image) {
|
|
layer->children.push(*asset);
|
|
}
|
|
layer->statical &= assetLayer->statical;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static bool _buildPrecomp(LottieComposition* comp, LottieGroup* parent)
|
|
{
|
|
if (parent->children.count == 0) return false;
|
|
|
|
for (auto c = parent->children.data; c < parent->children.end(); ++c) {
|
|
auto child = static_cast<LottieLayer*>(*c);
|
|
//attach the referencing layer.
|
|
if (child->refId) _buildReference(comp, child);
|
|
|
|
if (child->pid == -1) continue;
|
|
|
|
//parenting
|
|
for (auto p = parent->children.data; p < parent->children.end(); ++p) {
|
|
if (c == p) continue;
|
|
auto parent = static_cast<LottieLayer*>(*p);
|
|
if (child->pid == parent->id) {
|
|
child->parent = parent;
|
|
parent->statical &= child->statical;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
/* External Class Implementation */
|
|
/************************************************************************/
|
|
|
|
bool LottieBuilder::update(LottieComposition* comp, int32_t frameNo)
|
|
{
|
|
frameNo += comp->startFrame;
|
|
if (frameNo < comp->startFrame) frameNo = comp->startFrame;
|
|
if (frameNo > comp->endFrame) frameNo = comp->endFrame;
|
|
|
|
//Update root layer
|
|
auto root = comp->root;
|
|
if (!root) return false;
|
|
|
|
//Prepare render data
|
|
if (!root->scene) {
|
|
auto scene = Scene::gen();
|
|
root->scene = scene.get();
|
|
comp->scene->push(std::move(scene));
|
|
}
|
|
|
|
//update children layers
|
|
//TODO: skip if the layer is static.
|
|
for (auto child = root->children.end() - 1; child >= root->children.data; --child) {
|
|
_updateLayer(root, static_cast<LottieLayer*>(*child), frameNo, false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void LottieBuilder::build(LottieComposition* comp)
|
|
{
|
|
if (comp->scene) return;
|
|
|
|
comp->scene = Scene::gen().release();
|
|
if (!comp->scene) return;
|
|
|
|
_buildPrecomp(comp, comp->root);
|
|
|
|
//TODO: Process repeater objects?
|
|
|
|
if (!update(comp, 0)) return;
|
|
|
|
//viewport clip
|
|
auto clip = Shape::gen();
|
|
clip->appendRect(0, 0, static_cast<float>(comp->w), static_cast<float>(comp->h));
|
|
comp->scene->composite(std::move(clip), CompositeMethod::ClipPath);
|
|
} |